blob: 916fc11b560de656749ed627ce52a506863dd6a3 [file] [log] [blame]
Chris Lattner5ba61f02006-10-14 07:39:34 +00001//===--- Targets.cpp - Implement -arch option and targets -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner5ba61f02006-10-14 07:39:34 +00007//
8//===----------------------------------------------------------------------===//
9//
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000010// This file implements construction of a TargetInfo object from a
Ted Kremenek6f6ff372007-12-12 18:05:32 +000011// target triple.
Chris Lattner5ba61f02006-10-14 07:39:34 +000012//
13//===----------------------------------------------------------------------===//
14
Chris Lattner5ba61f02006-10-14 07:39:34 +000015#include "clang/Basic/TargetInfo.h"
Daniel Dunbarb9bbd542009-11-15 06:48:46 +000016#include "clang/Basic/Builtins.h"
17#include "clang/Basic/Diagnostic.h"
Chris Lattnerc7c6dd42008-12-04 22:54:33 +000018#include "clang/Basic/LangOptions.h"
Chandler Carruth26b29a02010-01-20 06:13:02 +000019#include "clang/Basic/MacroBuilder.h"
Daniel Dunbarb9bbd542009-11-15 06:48:46 +000020#include "clang/Basic/TargetBuiltins.h"
21#include "clang/Basic/TargetOptions.h"
Eli Friedman7cef49e2008-05-20 14:27:34 +000022#include "llvm/ADT/APFloat.h"
Daniel Dunbar979586e2009-11-11 09:38:56 +000023#include "llvm/ADT/STLExtras.h"
Daniel Dunbar58bc48c2009-08-19 20:04:03 +000024#include "llvm/ADT/StringRef.h"
Daniel Dunbar979586e2009-11-11 09:38:56 +000025#include "llvm/ADT/StringSwitch.h"
Chris Lattner859c37a2009-08-12 06:24:27 +000026#include "llvm/ADT/Triple.h"
Chandler Carruthffd55512013-01-02 11:45:17 +000027#include "llvm/IR/Type.h"
Chris Lattner30ba6742009-08-10 19:03:04 +000028#include "llvm/MC/MCSectionMachO.h"
David Blaikie76bd3c82011-09-23 05:35:21 +000029#include "llvm/Support/ErrorHandling.h"
Benjamin Kramerdc2f0062010-01-09 18:20:57 +000030#include <algorithm>
Ahmed Charlesdfca6f92014-03-09 11:36:40 +000031#include <memory>
Chris Lattner5ba61f02006-10-14 07:39:34 +000032using namespace clang;
33
Chris Lattner5ba61f02006-10-14 07:39:34 +000034//===----------------------------------------------------------------------===//
Chris Lattner1f5ad112006-10-14 18:32:12 +000035// Common code shared among targets.
Chris Lattner5ba61f02006-10-14 07:39:34 +000036//===----------------------------------------------------------------------===//
37
Chris Lattner1e1c0b92009-03-20 16:06:38 +000038/// DefineStd - Define a macro name and standard variants. For example if
39/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
40/// when in GNU mode.
Chris Lattner0e62c1c2011-07-23 10:55:15 +000041static void DefineStd(MacroBuilder &Builder, StringRef MacroName,
Chris Lattner1e1c0b92009-03-20 16:06:38 +000042 const LangOptions &Opts) {
43 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000044
Chris Lattner1e1c0b92009-03-20 16:06:38 +000045 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
46 // in the user's namespace.
47 if (Opts.GNUMode)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000048 Builder.defineMacro(MacroName);
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000049
Chris Lattner1e1c0b92009-03-20 16:06:38 +000050 // Define __unix.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000051 Builder.defineMacro("__" + MacroName);
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000052
Chris Lattner1e1c0b92009-03-20 16:06:38 +000053 // Define __unix__.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000054 Builder.defineMacro("__" + MacroName + "__");
Chris Lattner1e1c0b92009-03-20 16:06:38 +000055}
56
Benjamin Kramere3b442d2012-01-10 11:50:09 +000057static void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName,
58 bool Tuning = true) {
59 Builder.defineMacro("__" + CPUName);
60 Builder.defineMacro("__" + CPUName + "__");
61 if (Tuning)
62 Builder.defineMacro("__tune_" + CPUName + "__");
63}
64
Chris Lattner09d98f52008-10-05 21:50:58 +000065//===----------------------------------------------------------------------===//
66// Defines specific to certain operating systems.
67//===----------------------------------------------------------------------===//
Chris Lattner30ba6742009-08-10 19:03:04 +000068
Torok Edwinb2b37c62009-06-30 17:10:35 +000069namespace {
Douglas Gregorc05d2a12009-07-01 15:12:53 +000070template<typename TgtInfo>
71class OSTargetInfo : public TgtInfo {
Torok Edwinb2b37c62009-06-30 17:10:35 +000072protected:
Daniel Dunbar40165182009-08-24 09:10:05 +000073 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000074 MacroBuilder &Builder) const=0;
Torok Edwinb2b37c62009-06-30 17:10:35 +000075public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +000076 OSTargetInfo(const llvm::Triple &Triple) : TgtInfo(Triple) {}
Craig Topper3164f332014-03-11 03:39:26 +000077 void getTargetDefines(const LangOptions &Opts,
78 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000079 TgtInfo::getTargetDefines(Opts, Builder);
80 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Torok Edwin4e054162009-06-30 17:00:25 +000081 }
Torok Edwinb2b37c62009-06-30 17:10:35 +000082
83};
Chris Lattner859c37a2009-08-12 06:24:27 +000084} // end anonymous namespace
Torok Edwin4e054162009-06-30 17:00:25 +000085
Chris Lattner30ba6742009-08-10 19:03:04 +000086
Daniel Dunbard86666f2010-01-26 01:44:04 +000087static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +000088 const llvm::Triple &Triple,
Chris Lattner0e62c1c2011-07-23 10:55:15 +000089 StringRef &PlatformName,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +000090 VersionTuple &PlatformMinVersion) {
Bob Wilson834400b2013-08-19 20:23:37 +000091 Builder.defineMacro("__APPLE_CC__", "6000");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000092 Builder.defineMacro("__APPLE__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000093 Builder.defineMacro("OBJC_NEW_PROPERTIES");
Alexander Potapenkob4f81902012-09-20 10:10:01 +000094 // AddressSanitizer doesn't play well with source fortification, which is on
95 // by default on Darwin.
Will Dietzf54319c2013-01-18 11:30:38 +000096 if (Opts.Sanitize.Address) Builder.defineMacro("_FORTIFY_SOURCE", "0");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000097
John McCall5d36a8c2011-06-16 00:03:19 +000098 if (!Opts.ObjCAutoRefCount) {
John McCall31168b02011-06-15 23:02:42 +000099 // __weak is always defined, for use in blocks and with objc pointers.
100 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000101
John McCall31168b02011-06-15 23:02:42 +0000102 // Darwin defines __strong even in C mode (just to nothing).
Douglas Gregor79a91412011-09-13 17:21:33 +0000103 if (Opts.getGC() != LangOptions::NonGC)
John McCall31168b02011-06-15 23:02:42 +0000104 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
105 else
106 Builder.defineMacro("__strong", "");
Eric Christopher0c912c52011-07-07 22:55:26 +0000107
John McCall31168b02011-06-15 23:02:42 +0000108 // __unsafe_unretained is defined to nothing in non-ARC mode. We even
109 // allow this in C, since one might have block pointers in structs that
110 // are used in pure C code and in Objective-C ARC.
111 Builder.defineMacro("__unsafe_unretained", "");
John McCall31168b02011-06-15 23:02:42 +0000112 }
Eric Christopher0c912c52011-07-07 22:55:26 +0000113
Eli Friedmanfd4b1552009-06-04 23:00:29 +0000114 if (Opts.Static)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000115 Builder.defineMacro("__STATIC__");
Eli Friedmanfd4b1552009-06-04 23:00:29 +0000116 else
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000117 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000118
119 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000120 Builder.defineMacro("_REENTRANT");
Daniel Dunbar497ff132009-04-10 19:52:24 +0000121
Daniel Dunbarecf13562011-04-19 21:40:34 +0000122 // Get the platform type and version number from the triple.
Daniel Dunbar497ff132009-04-10 19:52:24 +0000123 unsigned Maj, Min, Rev;
Bob Wilson8e5acc52012-01-31 23:52:58 +0000124 if (Triple.isMacOSX()) {
125 Triple.getMacOSXVersion(Maj, Min, Rev);
Daniel Dunbarecf13562011-04-19 21:40:34 +0000126 PlatformName = "macosx";
Daniel Dunbarecf13562011-04-19 21:40:34 +0000127 } else {
Bob Wilson8e5acc52012-01-31 23:52:58 +0000128 Triple.getOSVersion(Maj, Min, Rev);
129 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbarecf13562011-04-19 21:40:34 +0000130 }
Daniel Dunbard86666f2010-01-26 01:44:04 +0000131
Sebastian Pop422377c2012-01-20 22:01:23 +0000132 // If -target arch-pc-win32-macho option specified, we're
Eric Christopherb081ba62011-07-29 21:20:35 +0000133 // generating code for Win32 ABI. No need to emit
Chad Rosierb90e4022011-07-19 20:00:06 +0000134 // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
135 if (PlatformName == "win32") {
136 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
137 return;
138 }
139
Evan Cheng31dd9a62014-01-26 23:12:43 +0000140 // Set the appropriate OS version define.
141 if (Triple.isiOS()) {
142 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
143 char Str[6];
144 Str[0] = '0' + Maj;
145 Str[1] = '0' + (Min / 10);
146 Str[2] = '0' + (Min % 10);
147 Str[3] = '0' + (Rev / 10);
148 Str[4] = '0' + (Rev % 10);
149 Str[5] = '\0';
150 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__",
151 Str);
152 } else if (Triple.isMacOSX()) {
153 // Note that the Driver allows versions which aren't representable in the
154 // define (because we only get a single digit for the minor and micro
155 // revision numbers). So, we limit them to the maximum representable
156 // version.
157 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Bob Wilson2a3710e2014-08-08 21:45:53 +0000158 char Str[7];
159 if (Maj < 10 || (Maj == 10 && Min < 10)) {
160 Str[0] = '0' + (Maj / 10);
161 Str[1] = '0' + (Maj % 10);
162 Str[2] = '0' + std::min(Min, 9U);
163 Str[3] = '0' + std::min(Rev, 9U);
164 Str[4] = '\0';
165 } else {
166 // Handle versions > 10.9.
167 Str[0] = '0' + (Maj / 10);
168 Str[1] = '0' + (Maj % 10);
169 Str[2] = '0' + (Min / 10);
170 Str[3] = '0' + (Min % 10);
171 Str[4] = '0' + (Rev / 10);
172 Str[5] = '0' + (Rev % 10);
173 Str[6] = '\0';
174 }
Evan Cheng31dd9a62014-01-26 23:12:43 +0000175 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar497ff132009-04-10 19:52:24 +0000176 }
Daniel Dunbarecf13562011-04-19 21:40:34 +0000177
Tim Northover157d9112014-01-16 08:48:16 +0000178 // Tell users about the kernel if there is one.
179 if (Triple.isOSDarwin())
180 Builder.defineMacro("__MACH__");
181
Daniel Dunbarecf13562011-04-19 21:40:34 +0000182 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman3fd920a2008-08-20 02:34:37 +0000183}
Chris Lattner5ba61f02006-10-14 07:39:34 +0000184
Chris Lattner30ba6742009-08-10 19:03:04 +0000185namespace {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000186template<typename Target>
187class DarwinTargetInfo : public OSTargetInfo<Target> {
188protected:
Craig Topper3164f332014-03-11 03:39:26 +0000189 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
190 MacroBuilder &Builder) const override {
Eric Christopher0c912c52011-07-07 22:55:26 +0000191 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000192 this->PlatformMinVersion);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000193 }
Mike Stump11289f42009-09-09 15:08:12 +0000194
Torok Edwinb2b37c62009-06-30 17:10:35 +0000195public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000196 DarwinTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
197 this->TLSSupported = Triple.isMacOSX() && !Triple.isMacOSXVersionLT(10, 7);
198 this->MCountName = "\01mcount";
199 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000200
Craig Topper3164f332014-03-11 03:39:26 +0000201 std::string isValidSectionSpecifier(StringRef SR) const override {
Chris Lattner30ba6742009-08-10 19:03:04 +0000202 // Let MCSectionMachO validate this.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000203 StringRef Segment, Section;
Chris Lattner30ba6742009-08-10 19:03:04 +0000204 unsigned TAA, StubSize;
Daniel Dunbar75942372011-03-19 02:06:21 +0000205 bool HasTAA;
Chris Lattner30ba6742009-08-10 19:03:04 +0000206 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar75942372011-03-19 02:06:21 +0000207 TAA, HasTAA, StubSize);
Chris Lattner30ba6742009-08-10 19:03:04 +0000208 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000209
Craig Topper3164f332014-03-11 03:39:26 +0000210 const char *getStaticInitSectionSpecifier() const override {
Anders Carlsson851318a2010-06-08 22:47:50 +0000211 // FIXME: We should return 0 when building kexts.
212 return "__TEXT,__StaticInit,regular,pure_instructions";
213 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000214
John McCalleed64c72012-01-29 01:20:30 +0000215 /// Darwin does not support protected visibility. Darwin's "default"
216 /// is very similar to ELF's "protected"; Darwin requires a "weak"
217 /// attribute on declarations that can be dynamically replaced.
Craig Topper3164f332014-03-11 03:39:26 +0000218 bool hasProtectedVisibility() const override {
John McCalleed64c72012-01-29 01:20:30 +0000219 return false;
220 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000221};
222
Chris Lattner30ba6742009-08-10 19:03:04 +0000223
Torok Edwinb2b37c62009-06-30 17:10:35 +0000224// DragonFlyBSD Target
225template<typename Target>
226class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
227protected:
Craig Topper3164f332014-03-11 03:39:26 +0000228 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
229 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000230 // DragonFly defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000231 Builder.defineMacro("__DragonFly__");
232 Builder.defineMacro("__DragonFly_cc_version", "100001");
233 Builder.defineMacro("__ELF__");
234 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
235 Builder.defineMacro("__tune_i386__");
236 DefineStd(Builder, "unix", Opts);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000237 }
238public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000239 DragonFlyBSDTargetInfo(const llvm::Triple &Triple)
240 : OSTargetInfo<Target>(Triple) {
241 this->UserLabelPrefix = "";
Eli Friedman4286fba2012-02-10 23:02:29 +0000242
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000243 switch (Triple.getArch()) {
244 default:
245 case llvm::Triple::x86:
246 case llvm::Triple::x86_64:
247 this->MCountName = ".mcount";
248 break;
249 }
Eli Friedman4286fba2012-02-10 23:02:29 +0000250 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000251};
252
253// FreeBSD Target
254template<typename Target>
255class FreeBSDTargetInfo : public OSTargetInfo<Target> {
256protected:
Craig Topper3164f332014-03-11 03:39:26 +0000257 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
258 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000259 // FreeBSD defines; list based off of gcc output
260
Benjamin Kramer80ca4072011-10-18 10:10:08 +0000261 unsigned Release = Triple.getOSMajorVersion();
262 if (Release == 0U)
263 Release = 8;
Torok Edwinb2b37c62009-06-30 17:10:35 +0000264
Benjamin Kramer80ca4072011-10-18 10:10:08 +0000265 Builder.defineMacro("__FreeBSD__", Twine(Release));
266 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000267 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
268 DefineStd(Builder, "unix", Opts);
269 Builder.defineMacro("__ELF__");
Ed Schoutend0621462013-09-29 07:54:52 +0000270
271 // On FreeBSD, wchar_t contains the number of the code point as
272 // used by the character set of the locale. These character sets are
273 // not necessarily a superset of ASCII.
274 Builder.defineMacro("__STDC_MB_MIGHT_NEQ_WC__", "1");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000275 }
276public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000277 FreeBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
278 this->UserLabelPrefix = "";
Roman Divacky178e01602011-02-10 16:52:03 +0000279
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000280 switch (Triple.getArch()) {
281 default:
282 case llvm::Triple::x86:
283 case llvm::Triple::x86_64:
284 this->MCountName = ".mcount";
285 break;
286 case llvm::Triple::mips:
287 case llvm::Triple::mipsel:
288 case llvm::Triple::ppc:
289 case llvm::Triple::ppc64:
Bill Schmidt778d3872013-07-26 01:36:11 +0000290 case llvm::Triple::ppc64le:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000291 this->MCountName = "_mcount";
292 break;
293 case llvm::Triple::arm:
294 this->MCountName = "__mcount";
295 break;
Duncan Sands9cb27e92009-07-08 13:55:08 +0000296 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000297 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000298};
299
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +0000300// GNU/kFreeBSD Target
301template<typename Target>
302class KFreeBSDTargetInfo : public OSTargetInfo<Target> {
303protected:
Craig Topper3164f332014-03-11 03:39:26 +0000304 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
305 MacroBuilder &Builder) const override {
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +0000306 // GNU/kFreeBSD defines; list based off of gcc output
307
308 DefineStd(Builder, "unix", Opts);
309 Builder.defineMacro("__FreeBSD_kernel__");
310 Builder.defineMacro("__GLIBC__");
311 Builder.defineMacro("__ELF__");
312 if (Opts.POSIXThreads)
313 Builder.defineMacro("_REENTRANT");
314 if (Opts.CPlusPlus)
315 Builder.defineMacro("_GNU_SOURCE");
316 }
317public:
Sylvestre Ledru15832282013-09-05 13:58:07 +0000318 KFreeBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +0000319 this->UserLabelPrefix = "";
320 }
321};
322
Chris Lattner3e2ee142010-07-07 16:01:42 +0000323// Minix Target
324template<typename Target>
325class MinixTargetInfo : public OSTargetInfo<Target> {
326protected:
Craig Topper3164f332014-03-11 03:39:26 +0000327 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
328 MacroBuilder &Builder) const override {
Chris Lattner3e2ee142010-07-07 16:01:42 +0000329 // Minix defines
330
331 Builder.defineMacro("__minix", "3");
332 Builder.defineMacro("_EM_WSIZE", "4");
333 Builder.defineMacro("_EM_PSIZE", "4");
334 Builder.defineMacro("_EM_SSIZE", "2");
335 Builder.defineMacro("_EM_LSIZE", "4");
336 Builder.defineMacro("_EM_FSIZE", "4");
337 Builder.defineMacro("_EM_DSIZE", "8");
Eli Friedman83de5132011-12-08 23:54:21 +0000338 Builder.defineMacro("__ELF__");
Chris Lattner3e2ee142010-07-07 16:01:42 +0000339 DefineStd(Builder, "unix", Opts);
340 }
341public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000342 MinixTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
343 this->UserLabelPrefix = "";
344 }
Chris Lattner3e2ee142010-07-07 16:01:42 +0000345};
346
Torok Edwinb2b37c62009-06-30 17:10:35 +0000347// Linux target
348template<typename Target>
349class LinuxTargetInfo : public OSTargetInfo<Target> {
350protected:
Craig Topper3164f332014-03-11 03:39:26 +0000351 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
352 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000353 // Linux defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000354 DefineStd(Builder, "unix", Opts);
355 DefineStd(Builder, "linux", Opts);
356 Builder.defineMacro("__gnu_linux__");
357 Builder.defineMacro("__ELF__");
Logan Chienc6fd8202012-09-02 09:30:11 +0000358 if (Triple.getEnvironment() == llvm::Triple::Android)
Evgeniy Stepanov94dc4c92012-04-26 12:08:09 +0000359 Builder.defineMacro("__ANDROID__", "1");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000360 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000361 Builder.defineMacro("_REENTRANT");
Douglas Gregor3ecc6652010-04-21 05:52:38 +0000362 if (Opts.CPlusPlus)
363 Builder.defineMacro("_GNU_SOURCE");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000364 }
365public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000366 LinuxTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000367 this->UserLabelPrefix = "";
Douglas Gregore6d6e512011-01-12 21:19:25 +0000368 this->WIntType = TargetInfo::UnsignedInt;
Hal Finkelecdb4542014-03-30 13:00:06 +0000369
370 switch (Triple.getArch()) {
371 default:
372 break;
373 case llvm::Triple::ppc:
374 case llvm::Triple::ppc64:
375 case llvm::Triple::ppc64le:
376 this->MCountName = "_mcount";
377 break;
378 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000379 }
Benjamin Kramera518b222011-10-15 17:53:33 +0000380
Craig Topper3164f332014-03-11 03:39:26 +0000381 const char *getStaticInitSectionSpecifier() const override {
Benjamin Kramera518b222011-10-15 17:53:33 +0000382 return ".text.startup";
383 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000384};
385
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000386// NetBSD Target
387template<typename Target>
388class NetBSDTargetInfo : public OSTargetInfo<Target> {
389protected:
Craig Topper3164f332014-03-11 03:39:26 +0000390 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
391 MacroBuilder &Builder) const override {
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000392 // NetBSD defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000393 Builder.defineMacro("__NetBSD__");
394 Builder.defineMacro("__unix__");
395 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000396 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000397 Builder.defineMacro("_POSIX_THREADS");
Joerg Sonnenbergercc1edb52014-05-13 18:58:36 +0000398
399 switch (Triple.getArch()) {
400 default:
401 break;
402 case llvm::Triple::arm:
403 case llvm::Triple::armeb:
404 case llvm::Triple::thumb:
405 case llvm::Triple::thumbeb:
406 Builder.defineMacro("__ARM_DWARF_EH__");
407 break;
408 }
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000409 }
410public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000411 NetBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
412 this->UserLabelPrefix = "";
413 }
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000414};
415
Torok Edwinb2b37c62009-06-30 17:10:35 +0000416// OpenBSD Target
417template<typename Target>
418class OpenBSDTargetInfo : public OSTargetInfo<Target> {
419protected:
Craig Topper3164f332014-03-11 03:39:26 +0000420 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
421 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000422 // OpenBSD defines; list based off of gcc output
423
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000424 Builder.defineMacro("__OpenBSD__");
425 DefineStd(Builder, "unix", Opts);
426 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000427 if (Opts.POSIXThreads)
Chris Lattner024e12d2012-04-25 06:12:24 +0000428 Builder.defineMacro("_REENTRANT");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000429 }
430public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000431 OpenBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
432 this->UserLabelPrefix = "";
433 this->TLSSupported = false;
Eli Friedman3715d1f2011-12-15 02:15:56 +0000434
Eli Friedman3715d1f2011-12-15 02:15:56 +0000435 switch (Triple.getArch()) {
436 default:
437 case llvm::Triple::x86:
438 case llvm::Triple::x86_64:
439 case llvm::Triple::arm:
Eric Christopherfd081ca2012-11-14 22:08:59 +0000440 case llvm::Triple::sparc:
Eli Friedman3715d1f2011-12-15 02:15:56 +0000441 this->MCountName = "__mcount";
442 break;
443 case llvm::Triple::mips64:
444 case llvm::Triple::mips64el:
445 case llvm::Triple::ppc:
Eric Christopherfd081ca2012-11-14 22:08:59 +0000446 case llvm::Triple::sparcv9:
Eli Friedman3715d1f2011-12-15 02:15:56 +0000447 this->MCountName = "_mcount";
448 break;
449 }
450 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000451};
452
Eli Friedman9fa28852012-08-08 23:57:20 +0000453// Bitrig Target
454template<typename Target>
455class BitrigTargetInfo : public OSTargetInfo<Target> {
456protected:
Craig Topper3164f332014-03-11 03:39:26 +0000457 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
458 MacroBuilder &Builder) const override {
Eli Friedman9fa28852012-08-08 23:57:20 +0000459 // Bitrig defines; list based off of gcc output
460
461 Builder.defineMacro("__Bitrig__");
462 DefineStd(Builder, "unix", Opts);
463 Builder.defineMacro("__ELF__");
464 if (Opts.POSIXThreads)
465 Builder.defineMacro("_REENTRANT");
466 }
467public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000468 BitrigTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
469 this->UserLabelPrefix = "";
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000470 this->MCountName = "__mcount";
Eli Friedman9fa28852012-08-08 23:57:20 +0000471 }
472};
473
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000474// PSP Target
475template<typename Target>
476class PSPTargetInfo : public OSTargetInfo<Target> {
477protected:
Craig Topper3164f332014-03-11 03:39:26 +0000478 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
479 MacroBuilder &Builder) const override {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000480 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000481 Builder.defineMacro("PSP");
482 Builder.defineMacro("_PSP");
483 Builder.defineMacro("__psp__");
484 Builder.defineMacro("__ELF__");
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000485 }
486public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000487 PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000488 this->UserLabelPrefix = "";
489 }
490};
491
John Thompsone467e192009-11-19 17:18:50 +0000492// PS3 PPU Target
493template<typename Target>
494class PS3PPUTargetInfo : public OSTargetInfo<Target> {
495protected:
Craig Topper3164f332014-03-11 03:39:26 +0000496 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
497 MacroBuilder &Builder) const override {
John Thompsone467e192009-11-19 17:18:50 +0000498 // PS3 PPU defines.
John Thompson957816f2010-03-25 16:18:32 +0000499 Builder.defineMacro("__PPC__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000500 Builder.defineMacro("__PPU__");
501 Builder.defineMacro("__CELLOS_LV2__");
502 Builder.defineMacro("__ELF__");
503 Builder.defineMacro("__LP32__");
John Thompson07a61a42010-06-24 22:44:13 +0000504 Builder.defineMacro("_ARCH_PPC64");
505 Builder.defineMacro("__powerpc64__");
John Thompsone467e192009-11-19 17:18:50 +0000506 }
507public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000508 PS3PPUTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
John Thompsone467e192009-11-19 17:18:50 +0000509 this->UserLabelPrefix = "";
Nick Lewyckyc0a61732011-12-16 22:32:39 +0000510 this->LongWidth = this->LongAlign = 32;
511 this->PointerWidth = this->PointerAlign = 32;
John Thompson07a61a42010-06-24 22:44:13 +0000512 this->IntMaxType = TargetInfo::SignedLongLong;
John Thompson07a61a42010-06-24 22:44:13 +0000513 this->Int64Type = TargetInfo::SignedLongLong;
John Thompson6f8dba72009-12-18 14:21:08 +0000514 this->SizeType = TargetInfo::UnsignedInt;
Rafael Espindolac418ae92014-01-03 19:22:05 +0000515 this->DescriptionString = "E-m:e-p:32:32-i64:64-n32:64";
John Thompsone467e192009-11-19 17:18:50 +0000516 }
517};
518
Torok Edwinb2b37c62009-06-30 17:10:35 +0000519// Solaris target
520template<typename Target>
521class SolarisTargetInfo : public OSTargetInfo<Target> {
522protected:
Craig Topper3164f332014-03-11 03:39:26 +0000523 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
524 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000525 DefineStd(Builder, "sun", Opts);
526 DefineStd(Builder, "unix", Opts);
527 Builder.defineMacro("__ELF__");
528 Builder.defineMacro("__svr4__");
529 Builder.defineMacro("__SVR4");
David Chisnall0c52c0f2012-02-28 17:10:04 +0000530 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
531 // newer, but to 500 for everything else. feature_test.h has a check to
532 // ensure that you are not using C99 with an old version of X/Open or C89
533 // with a new version.
534 if (Opts.C99 || Opts.C11)
535 Builder.defineMacro("_XOPEN_SOURCE", "600");
536 else
537 Builder.defineMacro("_XOPEN_SOURCE", "500");
David Chisnalle04307e2012-03-02 10:49:52 +0000538 if (Opts.CPlusPlus)
David Chisnall0c52c0f2012-02-28 17:10:04 +0000539 Builder.defineMacro("__C99FEATURES__");
David Chisnall0c1941cb2012-02-17 18:35:11 +0000540 Builder.defineMacro("_LARGEFILE_SOURCE");
541 Builder.defineMacro("_LARGEFILE64_SOURCE");
542 Builder.defineMacro("__EXTENSIONS__");
David Chisnall0c52c0f2012-02-28 17:10:04 +0000543 Builder.defineMacro("_REENTRANT");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000544 }
545public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000546 SolarisTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000547 this->UserLabelPrefix = "";
David Chisnallb526e932012-03-28 18:04:14 +0000548 this->WCharType = this->SignedInt;
Torok Edwinb2b37c62009-06-30 17:10:35 +0000549 // FIXME: WIntType should be SignedLong
550 }
551};
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000552
553// Windows target
554template<typename Target>
555class WindowsTargetInfo : public OSTargetInfo<Target> {
556protected:
Craig Topper3164f332014-03-11 03:39:26 +0000557 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
558 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +0000559 Builder.defineMacro("_WIN32");
560 }
561 void getVisualStudioDefines(const LangOptions &Opts,
562 MacroBuilder &Builder) const {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000563 if (Opts.CPlusPlus) {
David Majnemerf6072342014-07-01 22:24:56 +0000564 if (Opts.RTTIData)
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000565 Builder.defineMacro("_CPPRTTI");
566
567 if (Opts.Exceptions)
568 Builder.defineMacro("_CPPUNWIND");
569 }
570
571 if (!Opts.CharIsSigned)
572 Builder.defineMacro("_CHAR_UNSIGNED");
573
574 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
575 // but it works for now.
576 if (Opts.POSIXThreads)
577 Builder.defineMacro("_MT");
Michael J. Spencer54bf3c32010-10-21 08:22:51 +0000578
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +0000579 if (Opts.MSCompatibilityVersion) {
580 Builder.defineMacro("_MSC_VER",
581 Twine(Opts.MSCompatibilityVersion / 100000));
582 Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion));
Saleem Abdulrasool9d45e772014-06-20 22:58:35 +0000583 // FIXME We cannot encode the revision information into 32-bits
584 Builder.defineMacro("_MSC_BUILD", Twine(1));
585 }
Reid Kleckner6f6e76d2014-04-16 20:10:16 +0000586
587 if (Opts.MicrosoftExt) {
588 Builder.defineMacro("_MSC_EXTENSIONS");
589
590 if (Opts.CPlusPlus11) {
591 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
592 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
593 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
594 }
595 }
596
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000597 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000598 }
599
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000600public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000601 WindowsTargetInfo(const llvm::Triple &Triple)
602 : OSTargetInfo<Target>(Triple) {}
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000603};
604
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000605template <typename Target>
606class NaClTargetInfo : public OSTargetInfo<Target> {
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000607protected:
Craig Topper3164f332014-03-11 03:39:26 +0000608 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
609 MacroBuilder &Builder) const override {
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000610 if (Opts.POSIXThreads)
611 Builder.defineMacro("_REENTRANT");
612 if (Opts.CPlusPlus)
613 Builder.defineMacro("_GNU_SOURCE");
614
615 DefineStd(Builder, "unix", Opts);
616 Builder.defineMacro("__ELF__");
617 Builder.defineMacro("__native_client__");
618 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000619
620public:
621 NaClTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000622 this->UserLabelPrefix = "";
623 this->LongAlign = 32;
624 this->LongWidth = 32;
625 this->PointerAlign = 32;
626 this->PointerWidth = 32;
627 this->IntMaxType = TargetInfo::SignedLongLong;
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000628 this->Int64Type = TargetInfo::SignedLongLong;
629 this->DoubleAlign = 64;
630 this->LongDoubleWidth = 64;
631 this->LongDoubleAlign = 64;
Jan Wen Voung1f9c4ee2014-01-15 21:42:41 +0000632 this->LongLongWidth = 64;
633 this->LongLongAlign = 64;
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000634 this->SizeType = TargetInfo::UnsignedInt;
635 this->PtrDiffType = TargetInfo::SignedInt;
636 this->IntPtrType = TargetInfo::SignedInt;
Eli Bendersky4f6791c2013-04-08 21:31:01 +0000637 // RegParmMax is inherited from the underlying architecture
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000638 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Rafael Espindola1c09b262013-12-18 23:41:04 +0000639 if (Triple.getArch() == llvm::Triple::arm) {
Rafael Espindolac418ae92014-01-03 19:22:05 +0000640 this->DescriptionString = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S128";
Rafael Espindola1c09b262013-12-18 23:41:04 +0000641 } else if (Triple.getArch() == llvm::Triple::x86) {
Rafael Espindolac418ae92014-01-03 19:22:05 +0000642 this->DescriptionString = "e-m:e-p:32:32-i64:64-n8:16:32-S128";
Rafael Espindola1c09b262013-12-18 23:41:04 +0000643 } else if (Triple.getArch() == llvm::Triple::x86_64) {
Rafael Espindolac418ae92014-01-03 19:22:05 +0000644 this->DescriptionString = "e-m:e-p:32:32-i64:64-n8:16:32:64-S128";
Rafael Espindola1c09b262013-12-18 23:41:04 +0000645 } else if (Triple.getArch() == llvm::Triple::mipsel) {
646 // Handled on mips' setDescriptionString.
647 } else {
648 assert(Triple.getArch() == llvm::Triple::le32);
649 this->DescriptionString = "e-p:32:32-i64:64";
650 }
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000651 }
Craig Topper3164f332014-03-11 03:39:26 +0000652 typename Target::CallingConvCheckResult checkCallingConvention(
653 CallingConv CC) const override {
Derek Schuffa2020962012-10-16 22:30:41 +0000654 return CC == CC_PnaclCall ? Target::CCCR_OK :
655 Target::checkCallingConvention(CC);
656 }
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000657};
Mike Stump11289f42009-09-09 15:08:12 +0000658} // end anonymous namespace.
Torok Edwinb2b37c62009-06-30 17:10:35 +0000659
Chris Lattner09d98f52008-10-05 21:50:58 +0000660//===----------------------------------------------------------------------===//
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000661// Specific target implementations.
662//===----------------------------------------------------------------------===//
Anders Carlssona7408e72007-10-13 00:45:48 +0000663
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000664namespace {
665// PPC abstract base class
666class PPCTargetInfo : public TargetInfo {
667 static const Builtin::Info BuiltinInfo[];
668 static const char * const GCCRegNames[];
669 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Hal Finkel8eb59282012-06-11 22:35:19 +0000670 std::string CPU;
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000671
672 // Target cpu features.
673 bool HasVSX;
674
Ulrich Weigand8afad612014-07-28 13:17:52 +0000675protected:
676 std::string ABI;
677
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000678public:
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000679 PPCTargetInfo(const llvm::Triple &Triple)
680 : TargetInfo(Triple), HasVSX(false) {
Bill Schmidt778d3872013-07-26 01:36:11 +0000681 BigEndian = (Triple.getArch() != llvm::Triple::ppc64le);
Nico Weber3435ede2012-01-31 02:07:33 +0000682 LongDoubleWidth = LongDoubleAlign = 128;
683 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
684 }
Eli Friedman9ffd4a92009-06-05 07:05:05 +0000685
Hal Finkel6b984f02012-07-03 16:51:04 +0000686 /// \brief Flags for architecture specific defines.
687 typedef enum {
688 ArchDefineNone = 0,
689 ArchDefineName = 1 << 0, // <name> is substituted for arch name.
690 ArchDefinePpcgr = 1 << 1,
691 ArchDefinePpcsq = 1 << 2,
692 ArchDefine440 = 1 << 3,
693 ArchDefine603 = 1 << 4,
694 ArchDefine604 = 1 << 5,
695 ArchDefinePwr4 = 1 << 6,
Bill Schmidt38378a02013-02-01 20:23:10 +0000696 ArchDefinePwr5 = 1 << 7,
697 ArchDefinePwr5x = 1 << 8,
698 ArchDefinePwr6 = 1 << 9,
699 ArchDefinePwr6x = 1 << 10,
700 ArchDefinePwr7 = 1 << 11,
Will Schmidtf0487512014-06-26 13:34:10 +0000701 ArchDefinePwr8 = 1 << 12,
702 ArchDefineA2 = 1 << 13,
703 ArchDefineA2q = 1 << 14
Hal Finkel6b984f02012-07-03 16:51:04 +0000704 } ArchDefineTypes;
705
Bill Schmidt38378a02013-02-01 20:23:10 +0000706 // Note: GCC recognizes the following additional cpus:
707 // 401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801,
708 // 821, 823, 8540, 8548, e300c2, e300c3, e500mc64, e6500, 860, cell,
709 // titan, rs64.
Craig Topper3164f332014-03-11 03:39:26 +0000710 bool setCPU(const std::string &Name) override {
Hal Finkel8eb59282012-06-11 22:35:19 +0000711 bool CPUKnown = llvm::StringSwitch<bool>(Name)
712 .Case("generic", true)
713 .Case("440", true)
714 .Case("450", true)
715 .Case("601", true)
716 .Case("602", true)
717 .Case("603", true)
718 .Case("603e", true)
719 .Case("603ev", true)
720 .Case("604", true)
721 .Case("604e", true)
722 .Case("620", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000723 .Case("630", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000724 .Case("g3", true)
725 .Case("7400", true)
726 .Case("g4", true)
727 .Case("7450", true)
728 .Case("g4+", true)
729 .Case("750", true)
730 .Case("970", true)
731 .Case("g5", true)
732 .Case("a2", true)
Hal Finkeldf1e4bf2013-02-01 05:53:33 +0000733 .Case("a2q", true)
Hal Finkelf6d6cb02012-09-18 22:25:03 +0000734 .Case("e500mc", true)
735 .Case("e5500", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000736 .Case("power3", true)
737 .Case("pwr3", true)
738 .Case("power4", true)
739 .Case("pwr4", true)
740 .Case("power5", true)
741 .Case("pwr5", true)
742 .Case("power5x", true)
743 .Case("pwr5x", true)
744 .Case("power6", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000745 .Case("pwr6", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000746 .Case("power6x", true)
747 .Case("pwr6x", true)
748 .Case("power7", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000749 .Case("pwr7", true)
Will Schmidtf0487512014-06-26 13:34:10 +0000750 .Case("power8", true)
751 .Case("pwr8", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000752 .Case("powerpc", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000753 .Case("ppc", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000754 .Case("powerpc64", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000755 .Case("ppc64", true)
Bill Schmidt778d3872013-07-26 01:36:11 +0000756 .Case("powerpc64le", true)
757 .Case("ppc64le", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000758 .Default(false);
759
760 if (CPUKnown)
761 CPU = Name;
762
763 return CPUKnown;
764 }
765
Ulrich Weigand8afad612014-07-28 13:17:52 +0000766
767 StringRef getABI() const override { return ABI; }
768
Craig Topper3164f332014-03-11 03:39:26 +0000769 void getTargetBuiltins(const Builtin::Info *&Records,
770 unsigned &NumRecords) const override {
Chris Lattner10a5b382007-01-29 05:24:35 +0000771 Records = BuiltinInfo;
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000772 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner10a5b382007-01-29 05:24:35 +0000773 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000774
Craig Topper3164f332014-03-11 03:39:26 +0000775 bool isCLZForZeroUndef() const override { return false; }
Bob Wilson19a2f2b2012-01-28 18:02:29 +0000776
Craig Topper3164f332014-03-11 03:39:26 +0000777 void getTargetDefines(const LangOptions &Opts,
778 MacroBuilder &Builder) const override;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000779
Craig Topper3164f332014-03-11 03:39:26 +0000780 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override;
Bill Schmidt2fe4c672013-02-01 02:14:03 +0000781
Craig Topper3164f332014-03-11 03:39:26 +0000782 bool handleTargetFeatures(std::vector<std::string> &Features,
783 DiagnosticsEngine &Diags) override;
784 bool hasFeature(StringRef Feature) const override;
785
786 void getGCCRegNames(const char * const *&Names,
787 unsigned &NumNames) const override;
788 void getGCCRegAliases(const GCCRegAlias *&Aliases,
789 unsigned &NumAliases) const override;
790 bool validateAsmConstraint(const char *&Name,
791 TargetInfo::ConstraintInfo &Info) const override {
Anders Carlsson58436352009-02-28 17:11:49 +0000792 switch (*Name) {
Anders Carlssonf511f642007-11-27 04:11:28 +0000793 default: return false;
794 case 'O': // Zero
John Thompson07a61a42010-06-24 22:44:13 +0000795 break;
Anders Carlssonf511f642007-11-27 04:11:28 +0000796 case 'b': // Base register
797 case 'f': // Floating point register
Chris Lattnerd9725f72009-04-26 07:16:29 +0000798 Info.setAllowsRegister();
John Thompson07a61a42010-06-24 22:44:13 +0000799 break;
800 // FIXME: The following are added to allow parsing.
801 // I just took a guess at what the actions should be.
802 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000803 case 'd': // Floating point register (containing 64-bit value)
John Thompson07a61a42010-06-24 22:44:13 +0000804 case 'v': // Altivec vector register
805 Info.setAllowsRegister();
806 break;
807 case 'w':
808 switch (Name[1]) {
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000809 case 'd':// VSX vector register to hold vector double data
810 case 'f':// VSX vector register to hold vector float data
811 case 's':// VSX vector register to hold scalar float data
812 case 'a':// Any VSX register
Hal Finkelf7a07a52014-03-02 18:24:18 +0000813 case 'c':// An individual CR bit
John Thompson07a61a42010-06-24 22:44:13 +0000814 break;
815 default:
816 return false;
817 }
818 Info.setAllowsRegister();
819 Name++; // Skip over 'w'.
820 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000821 case 'h': // `MQ', `CTR', or `LINK' register
822 case 'q': // `MQ' register
823 case 'c': // `CTR' register
824 case 'l': // `LINK' register
825 case 'x': // `CR' register (condition register) number 0
826 case 'y': // `CR' register (condition register)
827 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson07a61a42010-06-24 22:44:13 +0000828 Info.setAllowsRegister();
829 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000830 case 'I': // Signed 16-bit constant
John Thompson07a61a42010-06-24 22:44:13 +0000831 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000832 // (use `L' instead for SImode constants)
833 case 'K': // Unsigned 16-bit constant
834 case 'L': // Signed 16-bit constant shifted left 16 bits
835 case 'M': // Constant larger than 31
836 case 'N': // Exact power of 2
837 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson07a61a42010-06-24 22:44:13 +0000838 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000839 // register with one instruction per word
John Thompson07a61a42010-06-24 22:44:13 +0000840 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000841 // into a register using three instructions
John Thompson07a61a42010-06-24 22:44:13 +0000842 break;
843 case 'm': // Memory operand. Note that on PowerPC targets, m can
844 // include addresses that update the base register. It
845 // is therefore only safe to use `m' in an asm statement
846 // if that asm statement accesses the operand exactly once.
847 // The asm statement must also use `%U<opno>' as a
Sebastian Redldd008712010-08-17 22:42:34 +0000848 // placeholder for the "update" flag in the corresponding
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000849 // load or store instruction. For example:
John Thompson07a61a42010-06-24 22:44:13 +0000850 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000851 // is correct but:
John Thompson07a61a42010-06-24 22:44:13 +0000852 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
853 // is not. Use es rather than m if you don't want the base
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000854 // register to be updated.
855 case 'e':
John Thompsonceebdf12010-06-25 00:02:05 +0000856 if (Name[1] != 's')
857 return false;
Sebastian Redldd008712010-08-17 22:42:34 +0000858 // es: A "stable" memory operand; that is, one which does not
John Thompson07a61a42010-06-24 22:44:13 +0000859 // include any automodification of the base register. Unlike
860 // `m', this constraint can be used in asm statements that
861 // might access the operand several times, or that might not
John Thompsonceebdf12010-06-25 00:02:05 +0000862 // access it at all.
John Thompson07a61a42010-06-24 22:44:13 +0000863 Info.setAllowsMemory();
John Thompsonceebdf12010-06-25 00:02:05 +0000864 Name++; // Skip over 'e'.
John Thompson07a61a42010-06-24 22:44:13 +0000865 break;
866 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000867 // usually better to use `m' or `es' in asm statements)
John Thompson07a61a42010-06-24 22:44:13 +0000868 case 'Z': // Memory operand that is an indexed or indirect from a
869 // register (it is usually better to use `m' or `es' in
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000870 // asm statements)
John Thompson07a61a42010-06-24 22:44:13 +0000871 Info.setAllowsMemory();
872 Info.setAllowsRegister();
873 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000874 case 'R': // AIX TOC entry
John Thompson07a61a42010-06-24 22:44:13 +0000875 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000876 // register (`p' is preferable for asm statements)
877 case 'S': // Constant suitable as a 64-bit mask operand
878 case 'T': // Constant suitable as a 32-bit mask operand
879 case 'U': // System V Release 4 small data area reference
John Thompson07a61a42010-06-24 22:44:13 +0000880 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000881 // instructions
882 case 'W': // Vector constant that does not require memory
883 case 'j': // Vector constant that is all zeros.
John Thompson07a61a42010-06-24 22:44:13 +0000884 break;
885 // End FIXME.
Anders Carlssonf511f642007-11-27 04:11:28 +0000886 }
John Thompson07a61a42010-06-24 22:44:13 +0000887 return true;
Anders Carlssonf511f642007-11-27 04:11:28 +0000888 }
Craig Topper3164f332014-03-11 03:39:26 +0000889 std::string convertConstraint(const char *&Constraint) const override {
Hal Finkelf7a07a52014-03-02 18:24:18 +0000890 std::string R;
891 switch (*Constraint) {
892 case 'e':
893 case 'w':
894 // Two-character constraint; add "^" hint for later parsing.
895 R = std::string("^") + std::string(Constraint, 2);
896 Constraint++;
897 break;
898 default:
899 return TargetInfo::convertConstraint(Constraint);
900 }
901 return R;
902 }
Craig Topper3164f332014-03-11 03:39:26 +0000903 const char *getClobbers() const override {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000904 return "";
Anders Carlssonf511f642007-11-27 04:11:28 +0000905 }
Craig Topper3164f332014-03-11 03:39:26 +0000906 int getEHDataRegisterNumber(unsigned RegNo) const override {
Adhemerval Zanella5d874ae2013-01-22 20:02:45 +0000907 if (RegNo == 0) return 3;
908 if (RegNo == 1) return 4;
909 return -1;
910 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000911};
Anders Carlssonf511f642007-11-27 04:11:28 +0000912
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000913const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000914#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +0000915#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000916 ALL_LANGUAGES },
Chris Lattner5abdec72009-06-14 01:05:48 +0000917#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000918};
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000919
Eric Christopher3ff21b32013-10-16 21:26:26 +0000920 /// handleTargetFeatures - Perform initialization based on the user
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000921/// configured set of features.
Eric Christopher3ff21b32013-10-16 21:26:26 +0000922bool PPCTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000923 DiagnosticsEngine &Diags) {
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000924 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
925 // Ignore disabled features.
926 if (Features[i][0] == '-')
927 continue;
928
929 StringRef Feature = StringRef(Features[i]).substr(1);
930
931 if (Feature == "vsx") {
932 HasVSX = true;
933 continue;
934 }
935
936 // TODO: Finish this list and add an assert that we've handled them
937 // all.
938 }
939
940 return true;
941}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000942
Chris Lattnerecd49032009-03-02 22:27:17 +0000943/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
944/// #defines that are not tied to a specific subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000945void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000946 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +0000947 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000948 Builder.defineMacro("__ppc__");
Chandler Carruth6aa92ad2013-06-25 11:13:47 +0000949 Builder.defineMacro("__PPC__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000950 Builder.defineMacro("_ARCH_PPC");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000951 Builder.defineMacro("__powerpc__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000952 Builder.defineMacro("__POWERPC__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000953 if (PointerWidth == 64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000954 Builder.defineMacro("_ARCH_PPC64");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000955 Builder.defineMacro("__powerpc64__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000956 Builder.defineMacro("__ppc64__");
Chandler Carruth6aa92ad2013-06-25 11:13:47 +0000957 Builder.defineMacro("__PPC64__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000958 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000959
Chris Lattnerecd49032009-03-02 22:27:17 +0000960 // Target properties.
Bill Schmidt778d3872013-07-26 01:36:11 +0000961 if (getTriple().getArch() == llvm::Triple::ppc64le) {
962 Builder.defineMacro("_LITTLE_ENDIAN");
Bill Schmidt778d3872013-07-26 01:36:11 +0000963 } else {
964 if (getTriple().getOS() != llvm::Triple::NetBSD &&
965 getTriple().getOS() != llvm::Triple::OpenBSD)
966 Builder.defineMacro("_BIG_ENDIAN");
Bill Schmidt778d3872013-07-26 01:36:11 +0000967 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000968
Ulrich Weigand8afad612014-07-28 13:17:52 +0000969 // ABI options.
970 if (ABI == "elfv1")
971 Builder.defineMacro("_CALL_ELF", "1");
972 if (ABI == "elfv2")
973 Builder.defineMacro("_CALL_ELF", "2");
974
Chris Lattnerecd49032009-03-02 22:27:17 +0000975 // Subtarget options.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000976 Builder.defineMacro("__NATURAL_ALIGNMENT__");
977 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000978
Chris Lattnerecd49032009-03-02 22:27:17 +0000979 // FIXME: Should be controlled by command line option.
Roman Divacky13b586f2013-07-03 19:45:54 +0000980 if (LongDoubleWidth == 128)
981 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000982
John Thompsone467e192009-11-19 17:18:50 +0000983 if (Opts.AltiVec) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000984 Builder.defineMacro("__VEC__", "10206");
985 Builder.defineMacro("__ALTIVEC__");
John Thompsone467e192009-11-19 17:18:50 +0000986 }
Hal Finkel8eb59282012-06-11 22:35:19 +0000987
988 // CPU identification.
Hal Finkel6b984f02012-07-03 16:51:04 +0000989 ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
990 .Case("440", ArchDefineName)
991 .Case("450", ArchDefineName | ArchDefine440)
992 .Case("601", ArchDefineName)
993 .Case("602", ArchDefineName | ArchDefinePpcgr)
994 .Case("603", ArchDefineName | ArchDefinePpcgr)
995 .Case("603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
996 .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
997 .Case("604", ArchDefineName | ArchDefinePpcgr)
998 .Case("604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
999 .Case("620", ArchDefineName | ArchDefinePpcgr)
Bill Schmidt38378a02013-02-01 20:23:10 +00001000 .Case("630", ArchDefineName | ArchDefinePpcgr)
Hal Finkel6b984f02012-07-03 16:51:04 +00001001 .Case("7400", ArchDefineName | ArchDefinePpcgr)
1002 .Case("7450", ArchDefineName | ArchDefinePpcgr)
1003 .Case("750", ArchDefineName | ArchDefinePpcgr)
1004 .Case("970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
1005 | ArchDefinePpcsq)
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001006 .Case("a2", ArchDefineA2)
1007 .Case("a2q", ArchDefineName | ArchDefineA2 | ArchDefineA2q)
Bill Schmidt38378a02013-02-01 20:23:10 +00001008 .Case("pwr3", ArchDefinePpcgr)
1009 .Case("pwr4", ArchDefineName | ArchDefinePpcgr | ArchDefinePpcsq)
1010 .Case("pwr5", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
1011 | ArchDefinePpcsq)
1012 .Case("pwr5x", ArchDefineName | ArchDefinePwr5 | ArchDefinePwr4
1013 | ArchDefinePpcgr | ArchDefinePpcsq)
1014 .Case("pwr6", ArchDefineName | ArchDefinePwr5x | ArchDefinePwr5
1015 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1016 .Case("pwr6x", ArchDefineName | ArchDefinePwr6 | ArchDefinePwr5x
1017 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1018 | ArchDefinePpcsq)
1019 .Case("pwr7", ArchDefineName | ArchDefinePwr6x | ArchDefinePwr6
1020 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
Will Schmidtf0487512014-06-26 13:34:10 +00001021 | ArchDefinePpcgr | ArchDefinePpcsq)
1022 .Case("pwr8", ArchDefineName | ArchDefinePwr7 | ArchDefinePwr6x
1023 | ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1024 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
Bill Schmidt38378a02013-02-01 20:23:10 +00001025 .Case("power3", ArchDefinePpcgr)
1026 .Case("power4", ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1027 .Case("power5", ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1028 | ArchDefinePpcsq)
1029 .Case("power5x", ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
1030 | ArchDefinePpcgr | ArchDefinePpcsq)
1031 .Case("power6", ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1032 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1033 .Case("power6x", ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x
1034 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1035 | ArchDefinePpcsq)
1036 .Case("power7", ArchDefinePwr7 | ArchDefinePwr6x | ArchDefinePwr6
1037 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
Will Schmidtf0487512014-06-26 13:34:10 +00001038 | ArchDefinePpcgr | ArchDefinePpcsq)
1039 .Case("power8", ArchDefinePwr8 | ArchDefinePwr7 | ArchDefinePwr6x
1040 | ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1041 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
Hal Finkel6b984f02012-07-03 16:51:04 +00001042 .Default(ArchDefineNone);
1043
1044 if (defs & ArchDefineName)
1045 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
1046 if (defs & ArchDefinePpcgr)
1047 Builder.defineMacro("_ARCH_PPCGR");
1048 if (defs & ArchDefinePpcsq)
1049 Builder.defineMacro("_ARCH_PPCSQ");
1050 if (defs & ArchDefine440)
Hal Finkel8eb59282012-06-11 22:35:19 +00001051 Builder.defineMacro("_ARCH_440");
Hal Finkel6b984f02012-07-03 16:51:04 +00001052 if (defs & ArchDefine603)
1053 Builder.defineMacro("_ARCH_603");
1054 if (defs & ArchDefine604)
1055 Builder.defineMacro("_ARCH_604");
Bill Schmidt38378a02013-02-01 20:23:10 +00001056 if (defs & ArchDefinePwr4)
Hal Finkel6b984f02012-07-03 16:51:04 +00001057 Builder.defineMacro("_ARCH_PWR4");
Bill Schmidt38378a02013-02-01 20:23:10 +00001058 if (defs & ArchDefinePwr5)
Hal Finkel6b984f02012-07-03 16:51:04 +00001059 Builder.defineMacro("_ARCH_PWR5");
Bill Schmidt38378a02013-02-01 20:23:10 +00001060 if (defs & ArchDefinePwr5x)
1061 Builder.defineMacro("_ARCH_PWR5X");
1062 if (defs & ArchDefinePwr6)
Hal Finkel8eb59282012-06-11 22:35:19 +00001063 Builder.defineMacro("_ARCH_PWR6");
Bill Schmidt38378a02013-02-01 20:23:10 +00001064 if (defs & ArchDefinePwr6x)
1065 Builder.defineMacro("_ARCH_PWR6X");
1066 if (defs & ArchDefinePwr7)
1067 Builder.defineMacro("_ARCH_PWR7");
Will Schmidtf0487512014-06-26 13:34:10 +00001068 if (defs & ArchDefinePwr8)
1069 Builder.defineMacro("_ARCH_PWR8");
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001070 if (defs & ArchDefineA2)
1071 Builder.defineMacro("_ARCH_A2");
1072 if (defs & ArchDefineA2q) {
1073 Builder.defineMacro("_ARCH_A2Q");
1074 Builder.defineMacro("_ARCH_QP");
1075 }
1076
1077 if (getTriple().getVendor() == llvm::Triple::BGQ) {
1078 Builder.defineMacro("__bg__");
1079 Builder.defineMacro("__THW_BLUEGENE__");
1080 Builder.defineMacro("__bgq__");
1081 Builder.defineMacro("__TOS_BGQ__");
1082 }
Bill Schmidt38378a02013-02-01 20:23:10 +00001083
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001084 if (HasVSX)
1085 Builder.defineMacro("__VSX__");
1086
Bill Schmidt38378a02013-02-01 20:23:10 +00001087 // FIXME: The following are not yet generated here by Clang, but are
1088 // generated by GCC:
1089 //
1090 // _SOFT_FLOAT_
1091 // __RECIP_PRECISION__
1092 // __APPLE_ALTIVEC__
Bill Schmidt38378a02013-02-01 20:23:10 +00001093 // __RECIP__
1094 // __RECIPF__
1095 // __RSQRTE__
1096 // __RSQRTEF__
1097 // _SOFT_DOUBLE_
1098 // __NO_LWSYNC__
1099 // __HAVE_BSWAP__
1100 // __LONGDOUBLE128
1101 // __CMODEL_MEDIUM__
1102 // __CMODEL_LARGE__
1103 // _CALL_SYSV
1104 // _CALL_DARWIN
1105 // __NO_FPRS__
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001106}
1107
1108void PPCTargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
1109 Features["altivec"] = llvm::StringSwitch<bool>(CPU)
1110 .Case("7400", true)
1111 .Case("g4", true)
1112 .Case("7450", true)
1113 .Case("g4+", true)
1114 .Case("970", true)
1115 .Case("g5", true)
1116 .Case("pwr6", true)
1117 .Case("pwr7", true)
Will Schmidtf0487512014-06-26 13:34:10 +00001118 .Case("pwr8", true)
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001119 .Case("ppc64", true)
Bill Schmidt778d3872013-07-26 01:36:11 +00001120 .Case("ppc64le", true)
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001121 .Default(false);
Hal Finkelb58ce852013-02-01 18:44:19 +00001122
1123 Features["qpx"] = (CPU == "a2q");
Ulrich Weigand8afad612014-07-28 13:17:52 +00001124
1125 if (!ABI.empty())
1126 Features[ABI] = true;
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001127}
1128
Douglas Gregor0070c0b2012-01-30 06:38:25 +00001129bool PPCTargetInfo::hasFeature(StringRef Feature) const {
1130 return Feature == "powerpc";
1131}
Chris Lattner17df24e2008-04-21 18:56:49 +00001132
Douglas Gregor0070c0b2012-01-30 06:38:25 +00001133
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001134const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnerf7ff53d2009-09-16 05:05:27 +00001135 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1136 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1137 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1138 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1139 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
1140 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
1141 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
1142 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001143 "mq", "lr", "ctr", "ap",
Chris Lattnerf7ff53d2009-09-16 05:05:27 +00001144 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001145 "xer",
Chris Lattnerf7ff53d2009-09-16 05:05:27 +00001146 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1147 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
1148 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
1149 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001150 "vrsave", "vscr",
1151 "spe_acc", "spefscr",
1152 "sfp"
1153};
Chris Lattner10a5b382007-01-29 05:24:35 +00001154
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001155void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001156 unsigned &NumNames) const {
1157 Names = GCCRegNames;
1158 NumNames = llvm::array_lengthof(GCCRegNames);
1159}
Chris Lattner5ba61f02006-10-14 07:39:34 +00001160
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001161const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
1162 // While some of these aliases do map to different registers
1163 // they still share the same register name.
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001164 { { "0" }, "r0" },
1165 { { "1"}, "r1" },
1166 { { "2" }, "r2" },
1167 { { "3" }, "r3" },
1168 { { "4" }, "r4" },
1169 { { "5" }, "r5" },
1170 { { "6" }, "r6" },
1171 { { "7" }, "r7" },
1172 { { "8" }, "r8" },
1173 { { "9" }, "r9" },
1174 { { "10" }, "r10" },
1175 { { "11" }, "r11" },
1176 { { "12" }, "r12" },
1177 { { "13" }, "r13" },
1178 { { "14" }, "r14" },
1179 { { "15" }, "r15" },
1180 { { "16" }, "r16" },
1181 { { "17" }, "r17" },
1182 { { "18" }, "r18" },
1183 { { "19" }, "r19" },
1184 { { "20" }, "r20" },
1185 { { "21" }, "r21" },
1186 { { "22" }, "r22" },
1187 { { "23" }, "r23" },
1188 { { "24" }, "r24" },
1189 { { "25" }, "r25" },
1190 { { "26" }, "r26" },
1191 { { "27" }, "r27" },
1192 { { "28" }, "r28" },
1193 { { "29" }, "r29" },
1194 { { "30" }, "r30" },
1195 { { "31" }, "r31" },
1196 { { "fr0" }, "f0" },
1197 { { "fr1" }, "f1" },
1198 { { "fr2" }, "f2" },
1199 { { "fr3" }, "f3" },
1200 { { "fr4" }, "f4" },
1201 { { "fr5" }, "f5" },
1202 { { "fr6" }, "f6" },
1203 { { "fr7" }, "f7" },
1204 { { "fr8" }, "f8" },
1205 { { "fr9" }, "f9" },
Mike Stumpfaacf012009-09-17 21:15:00 +00001206 { { "fr10" }, "f10" },
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001207 { { "fr11" }, "f11" },
1208 { { "fr12" }, "f12" },
1209 { { "fr13" }, "f13" },
1210 { { "fr14" }, "f14" },
1211 { { "fr15" }, "f15" },
1212 { { "fr16" }, "f16" },
1213 { { "fr17" }, "f17" },
1214 { { "fr18" }, "f18" },
1215 { { "fr19" }, "f19" },
1216 { { "fr20" }, "f20" },
1217 { { "fr21" }, "f21" },
1218 { { "fr22" }, "f22" },
1219 { { "fr23" }, "f23" },
1220 { { "fr24" }, "f24" },
1221 { { "fr25" }, "f25" },
1222 { { "fr26" }, "f26" },
1223 { { "fr27" }, "f27" },
1224 { { "fr28" }, "f28" },
1225 { { "fr29" }, "f29" },
1226 { { "fr30" }, "f30" },
1227 { { "fr31" }, "f31" },
1228 { { "cc" }, "cr0" },
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001229};
1230
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001231void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001232 unsigned &NumAliases) const {
1233 Aliases = GCCRegAliases;
1234 NumAliases = llvm::array_lengthof(GCCRegAliases);
1235}
1236} // end anonymous namespace.
Chris Lattner02dffbd2006-10-14 07:50:21 +00001237
Chris Lattner5ba61f02006-10-14 07:39:34 +00001238namespace {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001239class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00001240public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001241 PPC32TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Rafael Espindolac418ae92014-01-03 19:22:05 +00001242 DescriptionString = "E-m:e-p:32:32-i64:64-n32";
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00001243
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +00001244 switch (getTriple().getOS()) {
Nico Weber3435ede2012-01-31 02:07:33 +00001245 case llvm::Triple::Linux:
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +00001246 case llvm::Triple::FreeBSD:
1247 case llvm::Triple::NetBSD:
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +00001248 SizeType = UnsignedInt;
Hal Finkel26908382012-03-02 20:54:36 +00001249 PtrDiffType = SignedInt;
1250 IntPtrType = SignedInt;
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +00001251 break;
Joerg Sonnenbergerf031fd92011-07-04 23:11:58 +00001252 default:
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +00001253 break;
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +00001254 }
Roman Divacky816dcd12012-03-13 16:53:54 +00001255
Roman Divacky3ffe7462012-03-13 19:20:17 +00001256 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1257 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divacky816dcd12012-03-13 16:53:54 +00001258 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divacky3ffe7462012-03-13 19:20:17 +00001259 }
Benjamin Kramer37196de2012-11-17 17:30:55 +00001260
1261 // PPC32 supports atomics up to 4 bytes.
1262 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Roman Divacky965b0b72011-01-06 08:27:10 +00001263 }
1264
Craig Topper3164f332014-03-11 03:39:26 +00001265 BuiltinVaListKind getBuiltinVaListKind() const override {
Roman Divacky965b0b72011-01-06 08:27:10 +00001266 // This is the ELF definition, and is overridden by the Darwin sub-target
Meador Inge5d3fb222012-06-16 03:34:49 +00001267 return TargetInfo::PowerABIBuiltinVaList;
Eli Friedman873f65a2008-08-21 00:13:15 +00001268 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00001269};
1270} // end anonymous namespace.
1271
Bill Schmidt778d3872013-07-26 01:36:11 +00001272// Note: ABI differences may eventually require us to have a separate
1273// TargetInfo for little endian.
Chris Lattner5ba61f02006-10-14 07:39:34 +00001274namespace {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001275class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00001276public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001277 PPC64TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Chris Lattnerba7a6c12008-05-09 06:17:04 +00001278 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman2857ccb2009-07-01 03:36:11 +00001279 IntMaxType = SignedLong;
Eli Friedman2857ccb2009-07-01 03:36:11 +00001280 Int64Type = SignedLong;
Roman Divacky816dcd12012-03-13 16:53:54 +00001281
Roman Divacky3ffe7462012-03-13 19:20:17 +00001282 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1283 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divacky816dcd12012-03-13 16:53:54 +00001284 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Rafael Espindolac418ae92014-01-03 19:22:05 +00001285 DescriptionString = "E-m:e-i64:64-n32:64";
Will Schmidt0c67b7e2014-03-24 15:48:02 +00001286 } else {
1287 if ((Triple.getArch() == llvm::Triple::ppc64le)) {
1288 DescriptionString = "e-m:e-i64:64-n32:64";
Ulrich Weigand8afad612014-07-28 13:17:52 +00001289 ABI = "elfv2";
Will Schmidt0c67b7e2014-03-24 15:48:02 +00001290 } else {
1291 DescriptionString = "E-m:e-i64:64-n32:64";
Ulrich Weigand8afad612014-07-28 13:17:52 +00001292 ABI = "elfv1";
Will Schmidt0c67b7e2014-03-24 15:48:02 +00001293 }
Ulrich Weigand8afad612014-07-28 13:17:52 +00001294 }
Benjamin Kramer37196de2012-11-17 17:30:55 +00001295
1296 // PPC64 supports atomics up to 8 bytes.
1297 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Chris Lattnerba7a6c12008-05-09 06:17:04 +00001298 }
Craig Topper3164f332014-03-11 03:39:26 +00001299 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00001300 return TargetInfo::CharPtrBuiltinVaList;
Roman Divacky965b0b72011-01-06 08:27:10 +00001301 }
Ulrich Weigand8afad612014-07-28 13:17:52 +00001302 // PPC64 Linux-specifc ABI options.
1303 bool setABI(const std::string &Name) override {
1304 if (Name == "elfv1" || Name == "elfv2") {
1305 ABI = Name;
1306 return true;
1307 }
1308 return false;
1309 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001310};
1311} // end anonymous namespace.
1312
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001313
1314namespace {
Roman Divacky965b0b72011-01-06 08:27:10 +00001315class DarwinPPC32TargetInfo :
1316 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001317public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001318 DarwinPPC32TargetInfo(const llvm::Triple &Triple)
1319 : DarwinTargetInfo<PPC32TargetInfo>(Triple) {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001320 HasAlignMac68kSupport = true;
Roman Divacky965b0b72011-01-06 08:27:10 +00001321 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
Eric Christopherc04fe092013-10-16 21:19:19 +00001322 PtrDiffType = SignedInt; // for http://llvm.org/bugs/show_bug.cgi?id=15726
Anton Yartsev68d773c2012-01-17 22:40:00 +00001323 LongLongAlign = 32;
Nick Lewyckyf243e0d2011-12-21 04:25:47 +00001324 SuitableAlign = 128;
Rafael Espindolac418ae92014-01-03 19:22:05 +00001325 DescriptionString = "E-m:o-p:32:32-f64:32:64-n32";
Roman Divacky965b0b72011-01-06 08:27:10 +00001326 }
Craig Topper3164f332014-03-11 03:39:26 +00001327 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00001328 return TargetInfo::CharPtrBuiltinVaList;
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001329 }
1330};
1331
1332class DarwinPPC64TargetInfo :
1333 public DarwinTargetInfo<PPC64TargetInfo> {
1334public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001335 DarwinPPC64TargetInfo(const llvm::Triple &Triple)
1336 : DarwinTargetInfo<PPC64TargetInfo>(Triple) {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001337 HasAlignMac68kSupport = true;
Nick Lewyckyf243e0d2011-12-21 04:25:47 +00001338 SuitableAlign = 128;
Rafael Espindolac418ae92014-01-03 19:22:05 +00001339 DescriptionString = "E-m:o-i64:64-n32:64";
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001340 }
1341};
1342} // end anonymous namespace.
1343
Chris Lattner5ba61f02006-10-14 07:39:34 +00001344namespace {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001345 static const unsigned NVPTXAddrSpaceMap[] = {
1346 1, // opencl_global
1347 3, // opencl_local
1348 4, // opencl_constant
1349 1, // cuda_device
1350 4, // cuda_constant
1351 3, // cuda_shared
1352 };
1353 class NVPTXTargetInfo : public TargetInfo {
1354 static const char * const GCCRegNames[];
Justin Holewinski83e96682012-05-24 17:43:12 +00001355 static const Builtin::Info BuiltinInfo[];
Peter Collingbournec947aae2012-05-20 23:28:41 +00001356 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001357 NVPTXTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001358 BigEndian = false;
1359 TLSSupported = false;
1360 LongWidth = LongAlign = 64;
1361 AddrSpaceMap = &NVPTXAddrSpaceMap;
David Tweed31d09b02013-09-13 12:04:22 +00001362 UseAddrSpaceMapMangling = true;
Justin Holewinski83e96682012-05-24 17:43:12 +00001363 // Define available target features
1364 // These must be defined in sorted order!
Justin Holewinski5fafdd92012-07-11 15:34:55 +00001365 NoAsmVariants = true;
Peter Collingbournec947aae2012-05-20 23:28:41 +00001366 }
Craig Topper3164f332014-03-11 03:39:26 +00001367 void getTargetDefines(const LangOptions &Opts,
1368 MacroBuilder &Builder) const override {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001369 Builder.defineMacro("__PTX__");
Justin Holewinski83e96682012-05-24 17:43:12 +00001370 Builder.defineMacro("__NVPTX__");
Peter Collingbournec947aae2012-05-20 23:28:41 +00001371 }
Craig Topper3164f332014-03-11 03:39:26 +00001372 void getTargetBuiltins(const Builtin::Info *&Records,
1373 unsigned &NumRecords) const override {
Justin Holewinski83e96682012-05-24 17:43:12 +00001374 Records = BuiltinInfo;
1375 NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
Peter Collingbournec947aae2012-05-20 23:28:41 +00001376 }
Craig Topper3164f332014-03-11 03:39:26 +00001377 bool hasFeature(StringRef Feature) const override {
Justin Holewinski83e96682012-05-24 17:43:12 +00001378 return Feature == "ptx" || Feature == "nvptx";
Peter Collingbournec947aae2012-05-20 23:28:41 +00001379 }
Craig Topper3164f332014-03-11 03:39:26 +00001380
1381 void getGCCRegNames(const char * const *&Names,
1382 unsigned &NumNames) const override;
1383 void getGCCRegAliases(const GCCRegAlias *&Aliases,
1384 unsigned &NumAliases) const override {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001385 // No aliases.
Craig Topperf1186c52014-05-08 06:41:40 +00001386 Aliases = nullptr;
Peter Collingbournec947aae2012-05-20 23:28:41 +00001387 NumAliases = 0;
1388 }
Craig Topper3164f332014-03-11 03:39:26 +00001389 bool validateAsmConstraint(const char *&Name,
1390 TargetInfo::ConstraintInfo &Info) const override {
Justin Holewinski7ceab3a892013-06-21 18:51:24 +00001391 switch (*Name) {
1392 default: return false;
1393 case 'c':
1394 case 'h':
1395 case 'r':
1396 case 'l':
1397 case 'f':
1398 case 'd':
1399 Info.setAllowsRegister();
1400 return true;
1401 }
Peter Collingbournec947aae2012-05-20 23:28:41 +00001402 }
Craig Topper3164f332014-03-11 03:39:26 +00001403 const char *getClobbers() const override {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001404 // FIXME: Is this really right?
1405 return "";
1406 }
Craig Topper3164f332014-03-11 03:39:26 +00001407 BuiltinVaListKind getBuiltinVaListKind() const override {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001408 // FIXME: implement
Meador Inge5d3fb222012-06-16 03:34:49 +00001409 return TargetInfo::CharPtrBuiltinVaList;
Peter Collingbournec947aae2012-05-20 23:28:41 +00001410 }
Craig Topper3164f332014-03-11 03:39:26 +00001411 bool setCPU(const std::string &Name) override {
Justin Holewinski91203e82013-03-30 14:38:26 +00001412 bool Valid = llvm::StringSwitch<bool>(Name)
1413 .Case("sm_20", true)
1414 .Case("sm_21", true)
1415 .Case("sm_30", true)
1416 .Case("sm_35", true)
1417 .Default(false);
1418
1419 return Valid;
Peter Collingbournec947aae2012-05-20 23:28:41 +00001420 }
Justin Holewinski83e96682012-05-24 17:43:12 +00001421 };
1422
1423 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1424#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1425#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1426 ALL_LANGUAGES },
1427#include "clang/Basic/BuiltinsNVPTX.def"
Peter Collingbournec947aae2012-05-20 23:28:41 +00001428 };
1429
1430 const char * const NVPTXTargetInfo::GCCRegNames[] = {
1431 "r0"
1432 };
1433
1434 void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names,
1435 unsigned &NumNames) const {
1436 Names = GCCRegNames;
1437 NumNames = llvm::array_lengthof(GCCRegNames);
1438 }
1439
1440 class NVPTX32TargetInfo : public NVPTXTargetInfo {
1441 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001442 NVPTX32TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001443 PointerWidth = PointerAlign = 32;
Joerg Sonnenberger3809a7a2014-07-14 20:40:56 +00001444 SizeType = PtrDiffType = TargetInfo::UnsignedInt;
1445 IntPtrType = TargetInfo::SignedInt;
Rafael Espindola29db13a2014-01-03 18:13:17 +00001446 DescriptionString = "e-p:32:32-i64:64-v16:16-v32:32-n16:32:64";
Justin Holewinski83e96682012-05-24 17:43:12 +00001447 }
Peter Collingbournec947aae2012-05-20 23:28:41 +00001448 };
1449
1450 class NVPTX64TargetInfo : public NVPTXTargetInfo {
1451 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001452 NVPTX64TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001453 PointerWidth = PointerAlign = 64;
Joerg Sonnenberger3809a7a2014-07-14 20:40:56 +00001454 SizeType = PtrDiffType = TargetInfo::UnsignedLongLong;
1455 IntPtrType = TargetInfo::SignedLongLong;
Rafael Espindola29db13a2014-01-03 18:13:17 +00001456 DescriptionString = "e-i64:64-v16:16-v32:32-n16:32:64";
Justin Holewinski83e96682012-05-24 17:43:12 +00001457 }
Peter Collingbournec947aae2012-05-20 23:28:41 +00001458 };
1459}
1460
1461namespace {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001462
1463static const unsigned R600AddrSpaceMap[] = {
1464 1, // opencl_global
1465 3, // opencl_local
1466 2, // opencl_constant
1467 1, // cuda_device
1468 2, // cuda_constant
1469 3 // cuda_shared
1470};
1471
Tom Stellarda96344b2014-08-21 13:58:40 +00001472// If you edit the description strings, make sure you update
1473// getPointerWidthV().
1474
Tom Stellardc74b1e02013-03-04 17:40:53 +00001475static const char *DescriptionStringR600 =
Rafael Espindola29db13a2014-01-03 18:13:17 +00001476 "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1477 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
Tom Stellardc74b1e02013-03-04 17:40:53 +00001478
1479static const char *DescriptionStringR600DoubleOps =
Rafael Espindola29db13a2014-01-03 18:13:17 +00001480 "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1481 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
Tom Stellardc74b1e02013-03-04 17:40:53 +00001482
1483static const char *DescriptionStringSI =
Matt Arsenault23e7b082014-05-22 18:33:55 +00001484 "e-p:32:32-p1:64:64-p2:64:64-p3:32:32-p4:64:64-p5:32:32-p24:64:64"
Rafael Espindola29db13a2014-01-03 18:13:17 +00001485 "-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1486 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
Tom Stellardc74b1e02013-03-04 17:40:53 +00001487
Eli Friedmand13b41e2012-10-12 23:32:00 +00001488class R600TargetInfo : public TargetInfo {
Matt Arsenault56f008d2014-06-24 20:45:01 +00001489 static const Builtin::Info BuiltinInfo[];
1490
Tom Stellardc74b1e02013-03-04 17:40:53 +00001491 /// \brief The GPU profiles supported by the R600 target.
1492 enum GPUKind {
1493 GK_NONE,
1494 GK_R600,
1495 GK_R600_DOUBLE_OPS,
1496 GK_R700,
1497 GK_R700_DOUBLE_OPS,
1498 GK_EVERGREEN,
1499 GK_EVERGREEN_DOUBLE_OPS,
1500 GK_NORTHERN_ISLANDS,
1501 GK_CAYMAN,
Tom Stellard08ded122013-10-29 16:38:29 +00001502 GK_SOUTHERN_ISLANDS,
1503 GK_SEA_ISLANDS
Tom Stellardc74b1e02013-03-04 17:40:53 +00001504 } GPU;
1505
Eli Friedmand13b41e2012-10-12 23:32:00 +00001506public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001507 R600TargetInfo(const llvm::Triple &Triple)
1508 : TargetInfo(Triple), GPU(GK_R600) {
Tom Stellardc74b1e02013-03-04 17:40:53 +00001509 DescriptionString = DescriptionStringR600;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001510 AddrSpaceMap = &R600AddrSpaceMap;
David Tweed31d09b02013-09-13 12:04:22 +00001511 UseAddrSpaceMapMangling = true;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001512 }
1513
Tom Stellarda96344b2014-08-21 13:58:40 +00001514 uint64_t getPointerWidthV(unsigned AddrSpace) const override {
1515 if (GPU <= GK_CAYMAN)
1516 return 32;
1517
1518 switch(AddrSpace) {
1519 default:
1520 return 64;
1521 case 0:
1522 case 3:
1523 case 5:
1524 return 32;
1525 }
1526 }
1527
Craig Topper3164f332014-03-11 03:39:26 +00001528 const char * getClobbers() const override {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001529 return "";
1530 }
1531
Craig Topper3164f332014-03-11 03:39:26 +00001532 void getGCCRegNames(const char * const *&Names,
1533 unsigned &numNames) const override {
Craig Topperf1186c52014-05-08 06:41:40 +00001534 Names = nullptr;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001535 numNames = 0;
1536 }
1537
Craig Topper3164f332014-03-11 03:39:26 +00001538 void getGCCRegAliases(const GCCRegAlias *&Aliases,
1539 unsigned &NumAliases) const override {
Craig Topperf1186c52014-05-08 06:41:40 +00001540 Aliases = nullptr;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001541 NumAliases = 0;
1542 }
1543
Craig Topper3164f332014-03-11 03:39:26 +00001544 bool validateAsmConstraint(const char *&Name,
1545 TargetInfo::ConstraintInfo &info) const override {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001546 return true;
1547 }
1548
Craig Topper3164f332014-03-11 03:39:26 +00001549 void getTargetBuiltins(const Builtin::Info *&Records,
1550 unsigned &NumRecords) const override {
Matt Arsenault56f008d2014-06-24 20:45:01 +00001551 Records = BuiltinInfo;
1552 NumRecords = clang::R600::LastTSBuiltin - Builtin::FirstTSBuiltin;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001553 }
1554
Craig Topper3164f332014-03-11 03:39:26 +00001555 void getTargetDefines(const LangOptions &Opts,
1556 MacroBuilder &Builder) const override {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001557 Builder.defineMacro("__R600__");
1558 }
1559
Craig Topper3164f332014-03-11 03:39:26 +00001560 BuiltinVaListKind getBuiltinVaListKind() const override {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001561 return TargetInfo::CharPtrBuiltinVaList;
1562 }
1563
Craig Topper3164f332014-03-11 03:39:26 +00001564 bool setCPU(const std::string &Name) override {
Tom Stellardc74b1e02013-03-04 17:40:53 +00001565 GPU = llvm::StringSwitch<GPUKind>(Name)
1566 .Case("r600" , GK_R600)
1567 .Case("rv610", GK_R600)
1568 .Case("rv620", GK_R600)
1569 .Case("rv630", GK_R600)
1570 .Case("rv635", GK_R600)
1571 .Case("rs780", GK_R600)
1572 .Case("rs880", GK_R600)
1573 .Case("rv670", GK_R600_DOUBLE_OPS)
1574 .Case("rv710", GK_R700)
1575 .Case("rv730", GK_R700)
1576 .Case("rv740", GK_R700_DOUBLE_OPS)
1577 .Case("rv770", GK_R700_DOUBLE_OPS)
1578 .Case("palm", GK_EVERGREEN)
1579 .Case("cedar", GK_EVERGREEN)
1580 .Case("sumo", GK_EVERGREEN)
1581 .Case("sumo2", GK_EVERGREEN)
1582 .Case("redwood", GK_EVERGREEN)
1583 .Case("juniper", GK_EVERGREEN)
1584 .Case("hemlock", GK_EVERGREEN_DOUBLE_OPS)
1585 .Case("cypress", GK_EVERGREEN_DOUBLE_OPS)
1586 .Case("barts", GK_NORTHERN_ISLANDS)
1587 .Case("turks", GK_NORTHERN_ISLANDS)
1588 .Case("caicos", GK_NORTHERN_ISLANDS)
1589 .Case("cayman", GK_CAYMAN)
1590 .Case("aruba", GK_CAYMAN)
Tom Stellard785699322013-04-01 20:56:49 +00001591 .Case("tahiti", GK_SOUTHERN_ISLANDS)
Tom Stellardc74b1e02013-03-04 17:40:53 +00001592 .Case("pitcairn", GK_SOUTHERN_ISLANDS)
1593 .Case("verde", GK_SOUTHERN_ISLANDS)
1594 .Case("oland", GK_SOUTHERN_ISLANDS)
Tom Stellard9affba42014-08-21 13:58:38 +00001595 .Case("hainan", GK_SOUTHERN_ISLANDS)
Tom Stellard08ded122013-10-29 16:38:29 +00001596 .Case("bonaire", GK_SEA_ISLANDS)
1597 .Case("kabini", GK_SEA_ISLANDS)
1598 .Case("kaveri", GK_SEA_ISLANDS)
Tom Stellard55583042013-11-14 23:45:53 +00001599 .Case("hawaii", GK_SEA_ISLANDS)
Tom Stellard14e03962014-07-26 01:05:20 +00001600 .Case("mullins", GK_SEA_ISLANDS)
Tom Stellardc74b1e02013-03-04 17:40:53 +00001601 .Default(GK_NONE);
1602
1603 if (GPU == GK_NONE) {
1604 return false;
1605 }
1606
1607 // Set the correct data layout
1608 switch (GPU) {
1609 case GK_NONE:
1610 case GK_R600:
1611 case GK_R700:
1612 case GK_EVERGREEN:
1613 case GK_NORTHERN_ISLANDS:
1614 DescriptionString = DescriptionStringR600;
1615 break;
1616 case GK_R600_DOUBLE_OPS:
1617 case GK_R700_DOUBLE_OPS:
1618 case GK_EVERGREEN_DOUBLE_OPS:
1619 case GK_CAYMAN:
1620 DescriptionString = DescriptionStringR600DoubleOps;
1621 break;
1622 case GK_SOUTHERN_ISLANDS:
Tom Stellard08ded122013-10-29 16:38:29 +00001623 case GK_SEA_ISLANDS:
Tom Stellardc74b1e02013-03-04 17:40:53 +00001624 DescriptionString = DescriptionStringSI;
1625 break;
1626 }
1627
1628 return true;
1629 }
Eli Friedmand13b41e2012-10-12 23:32:00 +00001630};
1631
Matt Arsenault56f008d2014-06-24 20:45:01 +00001632const Builtin::Info R600TargetInfo::BuiltinInfo[] = {
1633#define BUILTIN(ID, TYPE, ATTRS) \
1634 { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1635#include "clang/Basic/BuiltinsR600.def"
1636};
1637
Eli Friedmand13b41e2012-10-12 23:32:00 +00001638} // end anonymous namespace
1639
1640namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001641// Namespace for x86 abstract base class
1642const Builtin::Info BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00001643#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +00001644#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00001645 ALL_LANGUAGES },
Chris Lattner5abdec72009-06-14 01:05:48 +00001646#include "clang/Basic/BuiltinsX86.def"
Eli Friedman3fd920a2008-08-20 02:34:37 +00001647};
Eli Friedmanb5366062008-05-20 14:21:01 +00001648
Nuno Lopescfca1f02009-12-23 17:49:57 +00001649static const char* const GCCRegNames[] = {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001650 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1651 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher0c912c52011-07-07 22:55:26 +00001652 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman3fd920a2008-08-20 02:34:37 +00001653 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1654 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1655 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercdd36352011-06-21 00:05:20 +00001656 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopheraf643102011-12-02 02:12:16 +00001657 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1658 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman3fd920a2008-08-20 02:34:37 +00001659};
1660
Eric Christophercdd36352011-06-21 00:05:20 +00001661const TargetInfo::AddlRegName AddlRegNames[] = {
1662 { { "al", "ah", "eax", "rax" }, 0 },
1663 { { "bl", "bh", "ebx", "rbx" }, 3 },
1664 { { "cl", "ch", "ecx", "rcx" }, 2 },
1665 { { "dl", "dh", "edx", "rdx" }, 1 },
1666 { { "esi", "rsi" }, 4 },
1667 { { "edi", "rdi" }, 5 },
1668 { { "esp", "rsp" }, 7 },
1669 { { "ebp", "rbp" }, 6 },
Eli Friedman3fd920a2008-08-20 02:34:37 +00001670};
1671
1672// X86 target abstract base class; x86-32 and x86-64 are very close, so
1673// most of the implementation can be shared.
1674class X86TargetInfo : public TargetInfo {
Chris Lattner96e43572009-03-02 22:40:39 +00001675 enum X86SSEEnum {
Craig Topper9c4d17f2013-08-21 03:59:22 +00001676 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2, AVX512F
Chris Lattner96e43572009-03-02 22:40:39 +00001677 } SSELevel;
Eli Friedman33465822011-07-08 23:31:17 +00001678 enum MMX3DNowEnum {
1679 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1680 } MMX3DNowLevel;
Rafael Espindolae62e2792013-08-20 13:44:29 +00001681 enum XOPEnum {
1682 NoXOP,
1683 SSE4A,
1684 FMA4,
1685 XOP
1686 } XOPLevel;
Anders Carlssone437c682010-01-27 03:47:49 +00001687
Eric Christophere1ddaf92010-04-02 23:50:19 +00001688 bool HasAES;
Craig Topper3f122a72012-05-31 05:18:48 +00001689 bool HasPCLMUL;
Craig Topper22967d42011-12-25 05:06:45 +00001690 bool HasLZCNT;
Benjamin Kramer1e250392012-07-07 09:39:18 +00001691 bool HasRDRND;
Craig Topper22967d42011-12-25 05:06:45 +00001692 bool HasBMI;
1693 bool HasBMI2;
Craig Topper1de83482011-12-29 16:10:46 +00001694 bool HasPOPCNT;
Michael Liao625a8752012-11-10 05:17:46 +00001695 bool HasRTM;
Michael Liao74f4eaf2013-03-26 17:52:08 +00001696 bool HasPRFCHW;
Michael Liaoffaae352013-03-29 05:17:55 +00001697 bool HasRDSEED;
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00001698 bool HasTBM;
Craig Topperbba778b2012-06-03 21:46:30 +00001699 bool HasFMA;
Manman Rena45358c2012-10-11 00:59:55 +00001700 bool HasF16C;
Robert Khasanov3b6616c2014-07-30 13:53:40 +00001701 bool HasAVX512CD, HasAVX512ER, HasAVX512PF, HasAVX512DQ, HasAVX512BW, HasAVX512VL;
Ben Langmuir58078d02013-09-19 13:22:04 +00001702 bool HasSHA;
Nick Lewycky50e8f482013-10-05 20:14:27 +00001703 bool HasCX16;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001704
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001705 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1706 ///
1707 /// Each enumeration represents a particular CPU supported by Clang. These
1708 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1709 enum CPUKind {
1710 CK_Generic,
1711
1712 /// \name i386
1713 /// i386-generation processors.
1714 //@{
1715 CK_i386,
1716 //@}
1717
1718 /// \name i486
1719 /// i486-generation processors.
1720 //@{
1721 CK_i486,
1722 CK_WinChipC6,
1723 CK_WinChip2,
1724 CK_C3,
1725 //@}
1726
1727 /// \name i586
1728 /// i586-generation processors, P5 microarchitecture based.
1729 //@{
1730 CK_i586,
1731 CK_Pentium,
1732 CK_PentiumMMX,
1733 //@}
1734
1735 /// \name i686
1736 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1737 //@{
1738 CK_i686,
1739 CK_PentiumPro,
1740 CK_Pentium2,
1741 CK_Pentium3,
1742 CK_Pentium3M,
1743 CK_PentiumM,
1744 CK_C3_2,
1745
1746 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1747 /// Clang however has some logic to suport this.
1748 // FIXME: Warn, deprecate, and potentially remove this.
1749 CK_Yonah,
1750 //@}
1751
1752 /// \name Netburst
Chandler Carruth3270e262011-09-28 18:17:30 +00001753 /// Netburst microarchitecture based processors.
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001754 //@{
1755 CK_Pentium4,
1756 CK_Pentium4M,
1757 CK_Prescott,
1758 CK_Nocona,
1759 //@}
1760
1761 /// \name Core
1762 /// Core microarchitecture based processors.
1763 //@{
1764 CK_Core2,
1765
1766 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1767 /// codename which GCC no longer accepts as an option to -march, but Clang
1768 /// has some logic for recognizing it.
1769 // FIXME: Warn, deprecate, and potentially remove this.
1770 CK_Penryn,
1771 //@}
1772
1773 /// \name Atom
1774 /// Atom processors
1775 //@{
1776 CK_Atom,
Preston Gurda3c58c02013-09-13 19:27:17 +00001777 CK_Silvermont,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001778 //@}
1779
1780 /// \name Nehalem
1781 /// Nehalem microarchitecture based processors.
1782 //@{
1783 CK_Corei7,
1784 CK_Corei7AVX,
Chandler Carruth212334f2011-09-28 08:55:37 +00001785 CK_CoreAVXi,
Craig Topper865fff52011-12-17 19:55:21 +00001786 CK_CoreAVX2,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001787 //@}
1788
Craig Topper449314e2013-08-20 07:09:39 +00001789 /// \name Knights Landing
1790 /// Knights Landing processor.
1791 CK_KNL,
1792
Robert Khasanov3b6616c2014-07-30 13:53:40 +00001793 /// \name Skylake Server
1794 /// Skylake server processor.
1795 CK_SKX,
1796
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001797 /// \name K6
1798 /// K6 architecture processors.
1799 //@{
1800 CK_K6,
1801 CK_K6_2,
1802 CK_K6_3,
1803 //@}
1804
1805 /// \name K7
1806 /// K7 architecture processors.
1807 //@{
1808 CK_Athlon,
1809 CK_AthlonThunderbird,
1810 CK_Athlon4,
1811 CK_AthlonXP,
1812 CK_AthlonMP,
1813 //@}
1814
1815 /// \name K8
1816 /// K8 architecture processors.
1817 //@{
1818 CK_Athlon64,
1819 CK_Athlon64SSE3,
1820 CK_AthlonFX,
1821 CK_K8,
Chandler Carruth212334f2011-09-28 08:55:37 +00001822 CK_K8SSE3,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001823 CK_Opteron,
1824 CK_OpteronSSE3,
Roman Divacky43eb6f82011-10-30 07:48:46 +00001825 CK_AMDFAM10,
Benjamin Kramer569f2152012-01-10 11:50:18 +00001826 //@}
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001827
Benjamin Kramer569f2152012-01-10 11:50:18 +00001828 /// \name Bobcat
1829 /// Bobcat architecture processors.
1830 //@{
1831 CK_BTVER1,
Benjamin Kramer914d7e02013-05-03 10:47:15 +00001832 CK_BTVER2,
Benjamin Kramer569f2152012-01-10 11:50:18 +00001833 //@}
1834
1835 /// \name Bulldozer
1836 /// Bulldozer architecture processors.
Benjamin Kramer6bd51592011-12-01 18:23:59 +00001837 //@{
1838 CK_BDVER1,
1839 CK_BDVER2,
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00001840 CK_BDVER3,
Benjamin Kramer56c58222014-05-02 15:47:51 +00001841 CK_BDVER4,
Benjamin Kramer569f2152012-01-10 11:50:18 +00001842 //@}
Benjamin Kramer6bd51592011-12-01 18:23:59 +00001843
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001844 /// This specification is deprecated and will be removed in the future.
1845 /// Users should prefer \see CK_K8.
1846 // FIXME: Warn on this when the CPU is set to it.
1847 CK_x86_64,
1848 //@}
1849
1850 /// \name Geode
1851 /// Geode processors.
1852 //@{
1853 CK_Geode
1854 //@}
Chandler Carruth212334f2011-09-28 08:55:37 +00001855 } CPU;
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001856
Rafael Espindolaeb265472013-08-21 21:59:03 +00001857 enum FPMathKind {
1858 FP_Default,
1859 FP_SSE,
1860 FP_387
1861 } FPMath;
1862
Eli Friedman3fd920a2008-08-20 02:34:37 +00001863public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001864 X86TargetInfo(const llvm::Triple &Triple)
1865 : TargetInfo(Triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Rafael Espindolae62e2792013-08-20 13:44:29 +00001866 XOPLevel(NoXOP), HasAES(false), HasPCLMUL(false), HasLZCNT(false),
1867 HasRDRND(false), HasBMI(false), HasBMI2(false), HasPOPCNT(false),
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00001868 HasRTM(false), HasPRFCHW(false), HasRDSEED(false), HasTBM(false),
1869 HasFMA(false), HasF16C(false), HasAVX512CD(false), HasAVX512ER(false),
Robert Khasanov3b6616c2014-07-30 13:53:40 +00001870 HasAVX512PF(false), HasAVX512DQ(false), HasAVX512BW(false), HasAVX512VL(false),
1871 HasSHA(false), HasCX16(false), CPU(CK_Generic),
Nick Lewycky50e8f482013-10-05 20:14:27 +00001872 FPMath(FP_Default) {
Eli Friedman803acb32011-12-22 03:51:45 +00001873 BigEndian = false;
Eli Friedman3fd920a2008-08-20 02:34:37 +00001874 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner1f5ad112006-10-14 18:32:12 +00001875 }
Craig Topper3164f332014-03-11 03:39:26 +00001876 unsigned getFloatEvalMethod() const override {
Benjamin Kramercf501472011-12-28 15:47:06 +00001877 // X87 evaluates with 80 bits "long double" precision.
1878 return SSELevel == NoSSE ? 2 : 0;
1879 }
Craig Topper3164f332014-03-11 03:39:26 +00001880 void getTargetBuiltins(const Builtin::Info *&Records,
1881 unsigned &NumRecords) const override {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001882 Records = BuiltinInfo;
1883 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner10a5b382007-01-29 05:24:35 +00001884 }
Craig Topper3164f332014-03-11 03:39:26 +00001885 void getGCCRegNames(const char * const *&Names,
1886 unsigned &NumNames) const override {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001887 Names = GCCRegNames;
1888 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson5fa3f342007-11-24 23:38:12 +00001889 }
Craig Topper3164f332014-03-11 03:39:26 +00001890 void getGCCRegAliases(const GCCRegAlias *&Aliases,
1891 unsigned &NumAliases) const override {
Craig Topperf1186c52014-05-08 06:41:40 +00001892 Aliases = nullptr;
Eric Christophercdd36352011-06-21 00:05:20 +00001893 NumAliases = 0;
1894 }
Craig Topper3164f332014-03-11 03:39:26 +00001895 void getGCCAddlRegNames(const AddlRegName *&Names,
1896 unsigned &NumNames) const override {
Eric Christophercdd36352011-06-21 00:05:20 +00001897 Names = AddlRegNames;
1898 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssona7408e72007-10-13 00:45:48 +00001899 }
Craig Topper3164f332014-03-11 03:39:26 +00001900 bool validateAsmConstraint(const char *&Name,
1901 TargetInfo::ConstraintInfo &info) const override;
1902 std::string convertConstraint(const char *&Constraint) const override;
1903 const char *getClobbers() const override {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001904 return "~{dirflag},~{fpsr},~{flags}";
1905 }
Craig Topper3164f332014-03-11 03:39:26 +00001906 void getTargetDefines(const LangOptions &Opts,
1907 MacroBuilder &Builder) const override;
Craig Topper13f61a62013-09-17 04:12:55 +00001908 static void setSSELevel(llvm::StringMap<bool> &Features, X86SSEEnum Level,
1909 bool Enabled);
1910 static void setMMXLevel(llvm::StringMap<bool> &Features, MMX3DNowEnum Level,
1911 bool Enabled);
1912 static void setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
1913 bool Enabled);
Craig Topper3164f332014-03-11 03:39:26 +00001914 void setFeatureEnabled(llvm::StringMap<bool> &Features,
1915 StringRef Name, bool Enabled) const override {
Craig Topper86d79ef2013-09-17 04:51:29 +00001916 setFeatureEnabledImpl(Features, Name, Enabled);
1917 }
1918 // This exists purely to cut down on the number of virtual calls in
1919 // getDefaultFeatures which calls this repeatedly.
1920 static void setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
1921 StringRef Name, bool Enabled);
Craig Topper3164f332014-03-11 03:39:26 +00001922 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override;
1923 bool hasFeature(StringRef Feature) const override;
1924 bool handleTargetFeatures(std::vector<std::string> &Features,
1925 DiagnosticsEngine &Diags) override;
Alp Toker4925ba72014-06-07 23:30:42 +00001926 StringRef getABI() const override {
Derek Schuffc7dd7222012-10-11 15:52:22 +00001927 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
Eli Friedmanbfd5add2011-12-02 00:11:43 +00001928 return "avx";
Derek Schuffc7dd7222012-10-11 15:52:22 +00001929 else if (getTriple().getArch() == llvm::Triple::x86 &&
1930 MMX3DNowLevel == NoMMX3DNow)
Eli Friedmanbfd5add2011-12-02 00:11:43 +00001931 return "no-mmx";
1932 return "";
Eli Friedman33465822011-07-08 23:31:17 +00001933 }
Craig Topper3164f332014-03-11 03:39:26 +00001934 bool setCPU(const std::string &Name) override {
Chandler Carruth212334f2011-09-28 08:55:37 +00001935 CPU = llvm::StringSwitch<CPUKind>(Name)
1936 .Case("i386", CK_i386)
1937 .Case("i486", CK_i486)
1938 .Case("winchip-c6", CK_WinChipC6)
1939 .Case("winchip2", CK_WinChip2)
1940 .Case("c3", CK_C3)
1941 .Case("i586", CK_i586)
1942 .Case("pentium", CK_Pentium)
1943 .Case("pentium-mmx", CK_PentiumMMX)
1944 .Case("i686", CK_i686)
1945 .Case("pentiumpro", CK_PentiumPro)
1946 .Case("pentium2", CK_Pentium2)
1947 .Case("pentium3", CK_Pentium3)
1948 .Case("pentium3m", CK_Pentium3M)
1949 .Case("pentium-m", CK_PentiumM)
1950 .Case("c3-2", CK_C3_2)
1951 .Case("yonah", CK_Yonah)
1952 .Case("pentium4", CK_Pentium4)
1953 .Case("pentium4m", CK_Pentium4M)
1954 .Case("prescott", CK_Prescott)
1955 .Case("nocona", CK_Nocona)
1956 .Case("core2", CK_Core2)
1957 .Case("penryn", CK_Penryn)
1958 .Case("atom", CK_Atom)
Preston Gurda3c58c02013-09-13 19:27:17 +00001959 .Case("slm", CK_Silvermont)
Chandler Carruth212334f2011-09-28 08:55:37 +00001960 .Case("corei7", CK_Corei7)
1961 .Case("corei7-avx", CK_Corei7AVX)
1962 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper865fff52011-12-17 19:55:21 +00001963 .Case("core-avx2", CK_CoreAVX2)
Craig Topper449314e2013-08-20 07:09:39 +00001964 .Case("knl", CK_KNL)
Robert Khasanov3b6616c2014-07-30 13:53:40 +00001965 .Case("skx", CK_SKX)
Chandler Carruth212334f2011-09-28 08:55:37 +00001966 .Case("k6", CK_K6)
1967 .Case("k6-2", CK_K6_2)
1968 .Case("k6-3", CK_K6_3)
1969 .Case("athlon", CK_Athlon)
1970 .Case("athlon-tbird", CK_AthlonThunderbird)
1971 .Case("athlon-4", CK_Athlon4)
1972 .Case("athlon-xp", CK_AthlonXP)
1973 .Case("athlon-mp", CK_AthlonMP)
1974 .Case("athlon64", CK_Athlon64)
1975 .Case("athlon64-sse3", CK_Athlon64SSE3)
1976 .Case("athlon-fx", CK_AthlonFX)
1977 .Case("k8", CK_K8)
1978 .Case("k8-sse3", CK_K8SSE3)
1979 .Case("opteron", CK_Opteron)
1980 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky43eb6f82011-10-30 07:48:46 +00001981 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer569f2152012-01-10 11:50:18 +00001982 .Case("btver1", CK_BTVER1)
Benjamin Kramer914d7e02013-05-03 10:47:15 +00001983 .Case("btver2", CK_BTVER2)
Benjamin Kramer6bd51592011-12-01 18:23:59 +00001984 .Case("bdver1", CK_BDVER1)
1985 .Case("bdver2", CK_BDVER2)
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00001986 .Case("bdver3", CK_BDVER3)
Benjamin Kramer56c58222014-05-02 15:47:51 +00001987 .Case("bdver4", CK_BDVER4)
Chandler Carruth212334f2011-09-28 08:55:37 +00001988 .Case("x86-64", CK_x86_64)
1989 .Case("geode", CK_Geode)
1990 .Default(CK_Generic);
1991
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00001992 // Perform any per-CPU checks necessary to determine if this CPU is
1993 // acceptable.
1994 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1995 // invalid without explaining *why*.
1996 switch (CPU) {
1997 case CK_Generic:
1998 // No processor selected!
1999 return false;
2000
2001 case CK_i386:
2002 case CK_i486:
2003 case CK_WinChipC6:
2004 case CK_WinChip2:
2005 case CK_C3:
2006 case CK_i586:
2007 case CK_Pentium:
2008 case CK_PentiumMMX:
2009 case CK_i686:
2010 case CK_PentiumPro:
2011 case CK_Pentium2:
2012 case CK_Pentium3:
2013 case CK_Pentium3M:
2014 case CK_PentiumM:
2015 case CK_Yonah:
2016 case CK_C3_2:
2017 case CK_Pentium4:
2018 case CK_Pentium4M:
2019 case CK_Prescott:
2020 case CK_K6:
2021 case CK_K6_2:
2022 case CK_K6_3:
2023 case CK_Athlon:
2024 case CK_AthlonThunderbird:
2025 case CK_Athlon4:
2026 case CK_AthlonXP:
2027 case CK_AthlonMP:
2028 case CK_Geode:
2029 // Only accept certain architectures when compiling in 32-bit mode.
Derek Schuffc7dd7222012-10-11 15:52:22 +00002030 if (getTriple().getArch() != llvm::Triple::x86)
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00002031 return false;
2032
2033 // Fallthrough
2034 case CK_Nocona:
2035 case CK_Core2:
2036 case CK_Penryn:
2037 case CK_Atom:
Preston Gurda3c58c02013-09-13 19:27:17 +00002038 case CK_Silvermont:
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00002039 case CK_Corei7:
2040 case CK_Corei7AVX:
2041 case CK_CoreAVXi:
Craig Topper865fff52011-12-17 19:55:21 +00002042 case CK_CoreAVX2:
Craig Topper449314e2013-08-20 07:09:39 +00002043 case CK_KNL:
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002044 case CK_SKX:
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00002045 case CK_Athlon64:
2046 case CK_Athlon64SSE3:
2047 case CK_AthlonFX:
2048 case CK_K8:
2049 case CK_K8SSE3:
2050 case CK_Opteron:
2051 case CK_OpteronSSE3:
Roman Divacky43eb6f82011-10-30 07:48:46 +00002052 case CK_AMDFAM10:
Benjamin Kramer569f2152012-01-10 11:50:18 +00002053 case CK_BTVER1:
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002054 case CK_BTVER2:
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002055 case CK_BDVER1:
2056 case CK_BDVER2:
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00002057 case CK_BDVER3:
Benjamin Kramer56c58222014-05-02 15:47:51 +00002058 case CK_BDVER4:
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00002059 case CK_x86_64:
2060 return true;
2061 }
Chandler Carruth7d8241c2011-09-28 10:49:06 +00002062 llvm_unreachable("Unhandled CPU kind");
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002063 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00002064
Craig Topper3164f332014-03-11 03:39:26 +00002065 bool setFPMath(StringRef Name) override;
Rafael Espindolaeb265472013-08-21 21:59:03 +00002066
Craig Topper3164f332014-03-11 03:39:26 +00002067 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Aaron Ballmane91c6be2012-10-02 14:26:08 +00002068 // We accept all non-ARM calling conventions
2069 return (CC == CC_X86ThisCall ||
2070 CC == CC_X86FastCall ||
Peter Collingbourne47f9f2d2013-02-23 00:06:18 +00002071 CC == CC_X86StdCall ||
2072 CC == CC_C ||
Guy Benyeif0a014b2012-12-25 08:53:55 +00002073 CC == CC_X86Pascal ||
2074 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00002075 }
2076
Craig Topper3164f332014-03-11 03:39:26 +00002077 CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
Aaron Ballman02df2e02012-12-09 17:45:41 +00002078 return MT == CCMT_Member ? CC_X86ThisCall : CC_C;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00002079 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00002080};
Chris Lattnerc25d8a72009-03-02 22:20:04 +00002081
Rafael Espindolaeb265472013-08-21 21:59:03 +00002082bool X86TargetInfo::setFPMath(StringRef Name) {
2083 if (Name == "387") {
2084 FPMath = FP_387;
2085 return true;
2086 }
2087 if (Name == "sse") {
2088 FPMath = FP_SSE;
2089 return true;
2090 }
2091 return false;
2092}
2093
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00002094void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002095 // FIXME: This *really* should not be here.
2096
2097 // X86_64 always has SSE2.
Derek Schuffc7dd7222012-10-11 15:52:22 +00002098 if (getTriple().getArch() == llvm::Triple::x86_64)
Craig Topper86d79ef2013-09-17 04:51:29 +00002099 setFeatureEnabledImpl(Features, "sse2", true);
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002100
Chandler Carruth212334f2011-09-28 08:55:37 +00002101 switch (CPU) {
2102 case CK_Generic:
2103 case CK_i386:
2104 case CK_i486:
2105 case CK_i586:
2106 case CK_Pentium:
2107 case CK_i686:
2108 case CK_PentiumPro:
Chandler Carruth212334f2011-09-28 08:55:37 +00002109 break;
2110 case CK_PentiumMMX:
2111 case CK_Pentium2:
Craig Topper86d79ef2013-09-17 04:51:29 +00002112 setFeatureEnabledImpl(Features, "mmx", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002113 break;
2114 case CK_Pentium3:
2115 case CK_Pentium3M:
Craig Topper86d79ef2013-09-17 04:51:29 +00002116 setFeatureEnabledImpl(Features, "sse", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002117 break;
2118 case CK_PentiumM:
2119 case CK_Pentium4:
2120 case CK_Pentium4M:
2121 case CK_x86_64:
Craig Topper86d79ef2013-09-17 04:51:29 +00002122 setFeatureEnabledImpl(Features, "sse2", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002123 break;
2124 case CK_Yonah:
2125 case CK_Prescott:
2126 case CK_Nocona:
Craig Topper86d79ef2013-09-17 04:51:29 +00002127 setFeatureEnabledImpl(Features, "sse3", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002128 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002129 break;
2130 case CK_Core2:
Craig Topper86d79ef2013-09-17 04:51:29 +00002131 setFeatureEnabledImpl(Features, "ssse3", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002132 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002133 break;
2134 case CK_Penryn:
Craig Topper86d79ef2013-09-17 04:51:29 +00002135 setFeatureEnabledImpl(Features, "sse4.1", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002136 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002137 break;
2138 case CK_Atom:
Craig Topper86d79ef2013-09-17 04:51:29 +00002139 setFeatureEnabledImpl(Features, "ssse3", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002140 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002141 break;
Preston Gurda3c58c02013-09-13 19:27:17 +00002142 case CK_Silvermont:
Craig Topper86d79ef2013-09-17 04:51:29 +00002143 setFeatureEnabledImpl(Features, "sse4.2", true);
2144 setFeatureEnabledImpl(Features, "aes", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002145 setFeatureEnabledImpl(Features, "cx16", true);
Craig Topper86d79ef2013-09-17 04:51:29 +00002146 setFeatureEnabledImpl(Features, "pclmul", true);
Preston Gurda3c58c02013-09-13 19:27:17 +00002147 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002148 case CK_Corei7:
Craig Topper86d79ef2013-09-17 04:51:29 +00002149 setFeatureEnabledImpl(Features, "sse4.2", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002150 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002151 break;
2152 case CK_Corei7AVX:
Craig Topper86d79ef2013-09-17 04:51:29 +00002153 setFeatureEnabledImpl(Features, "avx", true);
2154 setFeatureEnabledImpl(Features, "aes", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002155 setFeatureEnabledImpl(Features, "cx16", true);
Craig Topper86d79ef2013-09-17 04:51:29 +00002156 setFeatureEnabledImpl(Features, "pclmul", true);
Benjamin Kramer1e250392012-07-07 09:39:18 +00002157 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002158 case CK_CoreAVXi:
Craig Topper86d79ef2013-09-17 04:51:29 +00002159 setFeatureEnabledImpl(Features, "avx", true);
2160 setFeatureEnabledImpl(Features, "aes", true);
2161 setFeatureEnabledImpl(Features, "pclmul", true);
2162 setFeatureEnabledImpl(Features, "rdrnd", true);
2163 setFeatureEnabledImpl(Features, "f16c", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002164 break;
Craig Topper865fff52011-12-17 19:55:21 +00002165 case CK_CoreAVX2:
Craig Topper86d79ef2013-09-17 04:51:29 +00002166 setFeatureEnabledImpl(Features, "avx2", true);
2167 setFeatureEnabledImpl(Features, "aes", true);
2168 setFeatureEnabledImpl(Features, "pclmul", true);
2169 setFeatureEnabledImpl(Features, "lzcnt", true);
2170 setFeatureEnabledImpl(Features, "rdrnd", true);
2171 setFeatureEnabledImpl(Features, "f16c", true);
2172 setFeatureEnabledImpl(Features, "bmi", true);
2173 setFeatureEnabledImpl(Features, "bmi2", true);
2174 setFeatureEnabledImpl(Features, "rtm", true);
2175 setFeatureEnabledImpl(Features, "fma", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002176 setFeatureEnabledImpl(Features, "cx16", true);
Craig Topper865fff52011-12-17 19:55:21 +00002177 break;
Craig Topper449314e2013-08-20 07:09:39 +00002178 case CK_KNL:
Craig Topper86d79ef2013-09-17 04:51:29 +00002179 setFeatureEnabledImpl(Features, "avx512f", true);
2180 setFeatureEnabledImpl(Features, "avx512cd", true);
2181 setFeatureEnabledImpl(Features, "avx512er", true);
2182 setFeatureEnabledImpl(Features, "avx512pf", true);
2183 setFeatureEnabledImpl(Features, "aes", true);
2184 setFeatureEnabledImpl(Features, "pclmul", true);
2185 setFeatureEnabledImpl(Features, "lzcnt", true);
2186 setFeatureEnabledImpl(Features, "rdrnd", true);
2187 setFeatureEnabledImpl(Features, "f16c", true);
2188 setFeatureEnabledImpl(Features, "bmi", true);
2189 setFeatureEnabledImpl(Features, "bmi2", true);
2190 setFeatureEnabledImpl(Features, "rtm", true);
2191 setFeatureEnabledImpl(Features, "fma", true);
Craig Topper449314e2013-08-20 07:09:39 +00002192 break;
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002193 case CK_SKX:
2194 setFeatureEnabledImpl(Features, "avx512f", true);
2195 setFeatureEnabledImpl(Features, "avx512cd", true);
2196 setFeatureEnabledImpl(Features, "avx512dq", true);
2197 setFeatureEnabledImpl(Features, "avx512bw", true);
2198 setFeatureEnabledImpl(Features, "avx512vl", true);
2199 setFeatureEnabledImpl(Features, "aes", true);
2200 setFeatureEnabledImpl(Features, "pclmul", true);
2201 setFeatureEnabledImpl(Features, "lzcnt", true);
2202 setFeatureEnabledImpl(Features, "rdrnd", true);
2203 setFeatureEnabledImpl(Features, "f16c", true);
2204 setFeatureEnabledImpl(Features, "bmi", true);
2205 setFeatureEnabledImpl(Features, "bmi2", true);
2206 setFeatureEnabledImpl(Features, "rtm", true);
2207 setFeatureEnabledImpl(Features, "fma", true);
2208 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002209 case CK_K6:
2210 case CK_WinChipC6:
Craig Topper86d79ef2013-09-17 04:51:29 +00002211 setFeatureEnabledImpl(Features, "mmx", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002212 break;
2213 case CK_K6_2:
2214 case CK_K6_3:
Chandler Carruth212334f2011-09-28 08:55:37 +00002215 case CK_WinChip2:
2216 case CK_C3:
Craig Topper86d79ef2013-09-17 04:51:29 +00002217 setFeatureEnabledImpl(Features, "3dnow", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002218 break;
Chandler Carruthcd99bad2011-09-28 10:36:46 +00002219 case CK_Athlon:
2220 case CK_AthlonThunderbird:
2221 case CK_Geode:
Craig Topper86d79ef2013-09-17 04:51:29 +00002222 setFeatureEnabledImpl(Features, "3dnowa", true);
Chandler Carruthcd99bad2011-09-28 10:36:46 +00002223 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002224 case CK_Athlon4:
2225 case CK_AthlonXP:
2226 case CK_AthlonMP:
Craig Topper86d79ef2013-09-17 04:51:29 +00002227 setFeatureEnabledImpl(Features, "sse", true);
2228 setFeatureEnabledImpl(Features, "3dnowa", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002229 break;
2230 case CK_K8:
2231 case CK_Opteron:
2232 case CK_Athlon64:
2233 case CK_AthlonFX:
Craig Topper86d79ef2013-09-17 04:51:29 +00002234 setFeatureEnabledImpl(Features, "sse2", true);
2235 setFeatureEnabledImpl(Features, "3dnowa", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002236 break;
2237 case CK_K8SSE3:
2238 case CK_OpteronSSE3:
2239 case CK_Athlon64SSE3:
Craig Topper86d79ef2013-09-17 04:51:29 +00002240 setFeatureEnabledImpl(Features, "sse3", true);
2241 setFeatureEnabledImpl(Features, "3dnowa", true);
Roman Divackyce253d82011-10-30 13:47:56 +00002242 break;
Roman Divacky43eb6f82011-10-30 07:48:46 +00002243 case CK_AMDFAM10:
Craig Topper86d79ef2013-09-17 04:51:29 +00002244 setFeatureEnabledImpl(Features, "sse3", true);
2245 setFeatureEnabledImpl(Features, "sse4a", true);
2246 setFeatureEnabledImpl(Features, "3dnowa", true);
2247 setFeatureEnabledImpl(Features, "lzcnt", true);
2248 setFeatureEnabledImpl(Features, "popcnt", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002249 break;
Benjamin Kramer569f2152012-01-10 11:50:18 +00002250 case CK_BTVER1:
Craig Topper86d79ef2013-09-17 04:51:29 +00002251 setFeatureEnabledImpl(Features, "ssse3", true);
2252 setFeatureEnabledImpl(Features, "sse4a", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002253 setFeatureEnabledImpl(Features, "cx16", true);
Craig Topper86d79ef2013-09-17 04:51:29 +00002254 setFeatureEnabledImpl(Features, "lzcnt", true);
2255 setFeatureEnabledImpl(Features, "popcnt", true);
Yunzhong Gao61089362013-10-16 19:07:02 +00002256 setFeatureEnabledImpl(Features, "prfchw", true);
Craig Topper9ee12502012-05-30 05:54:54 +00002257 break;
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002258 case CK_BTVER2:
Craig Topper86d79ef2013-09-17 04:51:29 +00002259 setFeatureEnabledImpl(Features, "avx", true);
2260 setFeatureEnabledImpl(Features, "sse4a", true);
2261 setFeatureEnabledImpl(Features, "lzcnt", true);
2262 setFeatureEnabledImpl(Features, "aes", true);
2263 setFeatureEnabledImpl(Features, "pclmul", true);
Yunzhong Gao61089362013-10-16 19:07:02 +00002264 setFeatureEnabledImpl(Features, "prfchw", true);
Craig Topper86d79ef2013-09-17 04:51:29 +00002265 setFeatureEnabledImpl(Features, "bmi", true);
2266 setFeatureEnabledImpl(Features, "f16c", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002267 setFeatureEnabledImpl(Features, "cx16", true);
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002268 break;
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002269 case CK_BDVER1:
Craig Topper86d79ef2013-09-17 04:51:29 +00002270 setFeatureEnabledImpl(Features, "xop", true);
2271 setFeatureEnabledImpl(Features, "lzcnt", true);
2272 setFeatureEnabledImpl(Features, "aes", true);
2273 setFeatureEnabledImpl(Features, "pclmul", true);
Yunzhong Gao61089362013-10-16 19:07:02 +00002274 setFeatureEnabledImpl(Features, "prfchw", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002275 setFeatureEnabledImpl(Features, "cx16", true);
Eli Friedman102dc4e2012-11-26 21:57:28 +00002276 break;
Benjamin Kramer56c58222014-05-02 15:47:51 +00002277 case CK_BDVER4:
2278 setFeatureEnabledImpl(Features, "avx2", true);
2279 setFeatureEnabledImpl(Features, "bmi2", true);
2280 // FALLTHROUGH
Eli Friedman3e94f572012-11-17 01:43:10 +00002281 case CK_BDVER2:
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00002282 case CK_BDVER3:
Craig Topper86d79ef2013-09-17 04:51:29 +00002283 setFeatureEnabledImpl(Features, "xop", true);
2284 setFeatureEnabledImpl(Features, "lzcnt", true);
2285 setFeatureEnabledImpl(Features, "aes", true);
2286 setFeatureEnabledImpl(Features, "pclmul", true);
Yunzhong Gao61089362013-10-16 19:07:02 +00002287 setFeatureEnabledImpl(Features, "prfchw", true);
Craig Topper86d79ef2013-09-17 04:51:29 +00002288 setFeatureEnabledImpl(Features, "bmi", true);
2289 setFeatureEnabledImpl(Features, "fma", true);
2290 setFeatureEnabledImpl(Features, "f16c", true);
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00002291 setFeatureEnabledImpl(Features, "tbm", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002292 setFeatureEnabledImpl(Features, "cx16", true);
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002293 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002294 case CK_C3_2:
Craig Topper86d79ef2013-09-17 04:51:29 +00002295 setFeatureEnabledImpl(Features, "sse", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002296 break;
Eli Friedman33465822011-07-08 23:31:17 +00002297 }
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002298}
2299
Rafael Espindolae62e2792013-08-20 13:44:29 +00002300void X86TargetInfo::setSSELevel(llvm::StringMap<bool> &Features,
Craig Topper13f61a62013-09-17 04:12:55 +00002301 X86SSEEnum Level, bool Enabled) {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002302 if (Enabled) {
2303 switch (Level) {
Craig Topper9c4d17f2013-08-21 03:59:22 +00002304 case AVX512F:
2305 Features["avx512f"] = true;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002306 case AVX2:
2307 Features["avx2"] = true;
2308 case AVX:
2309 Features["avx"] = true;
2310 case SSE42:
Craig Topper7481d8a2013-09-10 06:55:47 +00002311 Features["sse4.2"] = true;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002312 case SSE41:
Rafael Espindola89049822013-08-23 20:21:37 +00002313 Features["sse4.1"] = true;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002314 case SSSE3:
2315 Features["ssse3"] = true;
2316 case SSE3:
2317 Features["sse3"] = true;
2318 case SSE2:
2319 Features["sse2"] = true;
2320 case SSE1:
Rafael Espindolae62e2792013-08-20 13:44:29 +00002321 Features["sse"] = true;
2322 case NoSSE:
2323 break;
2324 }
2325 return;
2326 }
2327
2328 switch (Level) {
2329 case NoSSE:
2330 case SSE1:
2331 Features["sse"] = false;
2332 case SSE2:
Ben Langmuir58078d02013-09-19 13:22:04 +00002333 Features["sse2"] = Features["pclmul"] = Features["aes"] =
2334 Features["sha"] = false;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002335 case SSE3:
2336 Features["sse3"] = false;
2337 setXOPLevel(Features, NoXOP, false);
2338 case SSSE3:
2339 Features["ssse3"] = false;
2340 case SSE41:
Rafael Espindola89049822013-08-23 20:21:37 +00002341 Features["sse4.1"] = false;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002342 case SSE42:
Craig Topper7481d8a2013-09-10 06:55:47 +00002343 Features["sse4.2"] = false;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002344 case AVX:
Craig Topper31db3a22013-09-16 04:54:13 +00002345 Features["fma"] = Features["avx"] = Features["f16c"] = false;
Rafael Espindola0221d862013-08-21 13:28:02 +00002346 setXOPLevel(Features, FMA4, false);
Rafael Espindolae62e2792013-08-20 13:44:29 +00002347 case AVX2:
2348 Features["avx2"] = false;
Craig Topper9c4d17f2013-08-21 03:59:22 +00002349 case AVX512F:
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002350 Features["avx512f"] = Features["avx512cd"] = Features["avx512er"] = Features["avx512pf"] =
2351 Features["avx512dq"] = Features["avx512bw"] = Features["avx512vl"] = false;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002352 }
2353}
2354
2355void X86TargetInfo::setMMXLevel(llvm::StringMap<bool> &Features,
Craig Topper13f61a62013-09-17 04:12:55 +00002356 MMX3DNowEnum Level, bool Enabled) {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002357 if (Enabled) {
2358 switch (Level) {
2359 case AMD3DNowAthlon:
2360 Features["3dnowa"] = true;
2361 case AMD3DNow:
2362 Features["3dnow"] = true;
2363 case MMX:
2364 Features["mmx"] = true;
2365 case NoMMX3DNow:
2366 break;
2367 }
2368 return;
2369 }
2370
2371 switch (Level) {
2372 case NoMMX3DNow:
2373 case MMX:
2374 Features["mmx"] = false;
2375 case AMD3DNow:
2376 Features["3dnow"] = false;
2377 case AMD3DNowAthlon:
2378 Features["3dnowa"] = false;
2379 }
2380}
2381
2382void X86TargetInfo::setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
Craig Topper13f61a62013-09-17 04:12:55 +00002383 bool Enabled) {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002384 if (Enabled) {
2385 switch (Level) {
2386 case XOP:
2387 Features["xop"] = true;
2388 case FMA4:
2389 Features["fma4"] = true;
2390 setSSELevel(Features, AVX, true);
2391 case SSE4A:
2392 Features["sse4a"] = true;
2393 setSSELevel(Features, SSE3, true);
2394 case NoXOP:
2395 break;
2396 }
2397 return;
2398 }
2399
2400 switch (Level) {
2401 case NoXOP:
2402 case SSE4A:
2403 Features["sse4a"] = false;
2404 case FMA4:
2405 Features["fma4"] = false;
2406 case XOP:
2407 Features["xop"] = false;
2408 }
2409}
2410
Craig Topper86d79ef2013-09-17 04:51:29 +00002411void X86TargetInfo::setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
2412 StringRef Name, bool Enabled) {
Eric Christopher399ffa52010-03-04 02:26:37 +00002413 // FIXME: This *really* should not be here. We need some way of translating
2414 // options into llvm subtarget features.
Rafael Espindola89049822013-08-23 20:21:37 +00002415 if (Name == "sse4")
2416 Name = "sse4.2";
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00002417
Rafael Espindolae62e2792013-08-20 13:44:29 +00002418 Features[Name] = Enabled;
Rafael Espindolaa6416a72011-11-27 20:00:43 +00002419
Craig Topper29561122013-09-19 01:13:07 +00002420 if (Name == "mmx") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002421 setMMXLevel(Features, MMX, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002422 } else if (Name == "sse") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002423 setSSELevel(Features, SSE1, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002424 } else if (Name == "sse2") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002425 setSSELevel(Features, SSE2, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002426 } else if (Name == "sse3") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002427 setSSELevel(Features, SSE3, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002428 } else if (Name == "ssse3") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002429 setSSELevel(Features, SSSE3, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002430 } else if (Name == "sse4.2") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002431 setSSELevel(Features, SSE42, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002432 } else if (Name == "sse4.1") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002433 setSSELevel(Features, SSE41, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002434 } else if (Name == "3dnow") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002435 setMMXLevel(Features, AMD3DNow, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002436 } else if (Name == "3dnowa") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002437 setMMXLevel(Features, AMD3DNowAthlon, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002438 } else if (Name == "aes") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002439 if (Enabled)
2440 setSSELevel(Features, SSE2, Enabled);
2441 } else if (Name == "pclmul") {
2442 if (Enabled)
2443 setSSELevel(Features, SSE2, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002444 } else if (Name == "avx") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002445 setSSELevel(Features, AVX, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002446 } else if (Name == "avx2") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002447 setSSELevel(Features, AVX2, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002448 } else if (Name == "avx512f") {
Craig Topper9c4d17f2013-08-21 03:59:22 +00002449 setSSELevel(Features, AVX512F, Enabled);
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002450 } else if (Name == "avx512cd" || Name == "avx512er" || Name == "avx512pf"
2451 || Name == "avx512dq" || Name == "avx512bw" || Name == "avx512vl") {
Craig Topper679b53a2013-08-21 05:29:10 +00002452 if (Enabled)
2453 setSSELevel(Features, AVX512F, Enabled);
2454 } else if (Name == "fma") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002455 if (Enabled)
2456 setSSELevel(Features, AVX, Enabled);
2457 } else if (Name == "fma4") {
2458 setXOPLevel(Features, FMA4, Enabled);
2459 } else if (Name == "xop") {
2460 setXOPLevel(Features, XOP, Enabled);
2461 } else if (Name == "sse4a") {
2462 setXOPLevel(Features, SSE4A, Enabled);
Craig Topper31db3a22013-09-16 04:54:13 +00002463 } else if (Name == "f16c") {
2464 if (Enabled)
2465 setSSELevel(Features, AVX, Enabled);
Ben Langmuir58078d02013-09-19 13:22:04 +00002466 } else if (Name == "sha") {
2467 if (Enabled)
2468 setSSELevel(Features, SSE2, Enabled);
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00002469 }
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00002470}
2471
Eric Christopher3ff21b32013-10-16 21:26:26 +00002472/// handleTargetFeatures - Perform initialization based on the user
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002473/// configured set of features.
Eric Christopher3ff21b32013-10-16 21:26:26 +00002474bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
Rafael Espindolaeb265472013-08-21 21:59:03 +00002475 DiagnosticsEngine &Diags) {
Daniel Dunbar979586e2009-11-11 09:38:56 +00002476 // Remember the maximum enabled sselevel.
2477 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
2478 // Ignore disabled features.
2479 if (Features[i][0] == '-')
2480 continue;
2481
Benjamin Kramer27402c62012-03-05 15:10:44 +00002482 StringRef Feature = StringRef(Features[i]).substr(1);
2483
2484 if (Feature == "aes") {
Eric Christophere1ddaf92010-04-02 23:50:19 +00002485 HasAES = true;
2486 continue;
2487 }
2488
Craig Topper3f122a72012-05-31 05:18:48 +00002489 if (Feature == "pclmul") {
2490 HasPCLMUL = true;
2491 continue;
2492 }
2493
Benjamin Kramer27402c62012-03-05 15:10:44 +00002494 if (Feature == "lzcnt") {
Craig Topper22967d42011-12-25 05:06:45 +00002495 HasLZCNT = true;
2496 continue;
2497 }
2498
Rafael Espindola89049822013-08-23 20:21:37 +00002499 if (Feature == "rdrnd") {
Benjamin Kramer1e250392012-07-07 09:39:18 +00002500 HasRDRND = true;
2501 continue;
2502 }
2503
Benjamin Kramer27402c62012-03-05 15:10:44 +00002504 if (Feature == "bmi") {
Craig Topper22967d42011-12-25 05:06:45 +00002505 HasBMI = true;
2506 continue;
2507 }
2508
Benjamin Kramer27402c62012-03-05 15:10:44 +00002509 if (Feature == "bmi2") {
Craig Topper22967d42011-12-25 05:06:45 +00002510 HasBMI2 = true;
2511 continue;
2512 }
2513
Benjamin Kramer27402c62012-03-05 15:10:44 +00002514 if (Feature == "popcnt") {
Craig Topper1de83482011-12-29 16:10:46 +00002515 HasPOPCNT = true;
2516 continue;
2517 }
2518
Michael Liao625a8752012-11-10 05:17:46 +00002519 if (Feature == "rtm") {
2520 HasRTM = true;
2521 continue;
2522 }
2523
Michael Liao74f4eaf2013-03-26 17:52:08 +00002524 if (Feature == "prfchw") {
2525 HasPRFCHW = true;
2526 continue;
2527 }
2528
Michael Liaoffaae352013-03-29 05:17:55 +00002529 if (Feature == "rdseed") {
2530 HasRDSEED = true;
2531 continue;
2532 }
2533
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00002534 if (Feature == "tbm") {
2535 HasTBM = true;
2536 continue;
2537 }
2538
Craig Topperbba778b2012-06-03 21:46:30 +00002539 if (Feature == "fma") {
2540 HasFMA = true;
2541 continue;
2542 }
2543
Manman Rena45358c2012-10-11 00:59:55 +00002544 if (Feature == "f16c") {
2545 HasF16C = true;
2546 continue;
2547 }
2548
Craig Topper679b53a2013-08-21 05:29:10 +00002549 if (Feature == "avx512cd") {
2550 HasAVX512CD = true;
2551 continue;
2552 }
2553
2554 if (Feature == "avx512er") {
2555 HasAVX512ER = true;
2556 continue;
2557 }
2558
2559 if (Feature == "avx512pf") {
2560 HasAVX512PF = true;
2561 continue;
2562 }
2563
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002564 if (Feature == "avx512dq") {
2565 HasAVX512DQ = true;
2566 continue;
2567 }
2568
2569 if (Feature == "avx512bw") {
2570 HasAVX512BW = true;
2571 continue;
2572 }
2573
2574 if (Feature == "avx512vl") {
2575 HasAVX512VL = true;
2576 continue;
2577 }
2578
Ben Langmuir58078d02013-09-19 13:22:04 +00002579 if (Feature == "sha") {
2580 HasSHA = true;
2581 continue;
2582 }
2583
Nick Lewycky50e8f482013-10-05 20:14:27 +00002584 if (Feature == "cx16") {
2585 HasCX16 = true;
2586 continue;
2587 }
2588
Daniel Dunbar979586e2009-11-11 09:38:56 +00002589 assert(Features[i][0] == '+' && "Invalid target feature!");
Benjamin Kramer27402c62012-03-05 15:10:44 +00002590 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Craig Topper679b53a2013-08-21 05:29:10 +00002591 .Case("avx512f", AVX512F)
Craig Topper23b92192012-01-09 09:19:09 +00002592 .Case("avx2", AVX2)
2593 .Case("avx", AVX)
Rafael Espindola89049822013-08-23 20:21:37 +00002594 .Case("sse4.2", SSE42)
2595 .Case("sse4.1", SSE41)
Daniel Dunbar979586e2009-11-11 09:38:56 +00002596 .Case("ssse3", SSSE3)
Nuno Lopes4cbc8bd2010-03-12 10:20:09 +00002597 .Case("sse3", SSE3)
Daniel Dunbar979586e2009-11-11 09:38:56 +00002598 .Case("sse2", SSE2)
2599 .Case("sse", SSE1)
Eli Friedman33465822011-07-08 23:31:17 +00002600 .Default(NoSSE);
Daniel Dunbar979586e2009-11-11 09:38:56 +00002601 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002602
Eli Friedman33465822011-07-08 23:31:17 +00002603 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer27402c62012-03-05 15:10:44 +00002604 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Anders Carlssone437c682010-01-27 03:47:49 +00002605 .Case("3dnowa", AMD3DNowAthlon)
2606 .Case("3dnow", AMD3DNow)
Eli Friedman33465822011-07-08 23:31:17 +00002607 .Case("mmx", MMX)
2608 .Default(NoMMX3DNow);
Eli Friedman33465822011-07-08 23:31:17 +00002609 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Rafael Espindolae62e2792013-08-20 13:44:29 +00002610
2611 XOPEnum XLevel = llvm::StringSwitch<XOPEnum>(Feature)
2612 .Case("xop", XOP)
2613 .Case("fma4", FMA4)
2614 .Case("sse4a", SSE4A)
2615 .Default(NoXOP);
2616 XOPLevel = std::max(XOPLevel, XLevel);
Daniel Dunbar979586e2009-11-11 09:38:56 +00002617 }
Eli Friedman33465822011-07-08 23:31:17 +00002618
Craig Topper7481d8a2013-09-10 06:55:47 +00002619 // Enable popcnt if sse4.2 is enabled and popcnt is not explicitly disabled.
2620 // Can't do this earlier because we need to be able to explicitly enable
2621 // popcnt and still disable sse4.2.
2622 if (!HasPOPCNT && SSELevel >= SSE42 &&
2623 std::find(Features.begin(), Features.end(), "-popcnt") == Features.end()){
2624 HasPOPCNT = true;
2625 Features.push_back("+popcnt");
2626 }
2627
Yunzhong Gao61089362013-10-16 19:07:02 +00002628 // Enable prfchw if 3DNow! is enabled and prfchw is not explicitly disabled.
2629 if (!HasPRFCHW && MMX3DNowLevel >= AMD3DNow &&
2630 std::find(Features.begin(), Features.end(), "-prfchw") == Features.end()){
2631 HasPRFCHW = true;
2632 Features.push_back("+prfchw");
2633 }
2634
Rafael Espindolaeb265472013-08-21 21:59:03 +00002635 // LLVM doesn't have a separate switch for fpmath, so only accept it if it
2636 // matches the selected sse level.
2637 if (FPMath == FP_SSE && SSELevel < SSE1) {
2638 Diags.Report(diag::err_target_unsupported_fpmath) << "sse";
2639 return false;
2640 } else if (FPMath == FP_387 && SSELevel >= SSE1) {
2641 Diags.Report(diag::err_target_unsupported_fpmath) << "387";
2642 return false;
2643 }
2644
Eli Friedman33465822011-07-08 23:31:17 +00002645 // Don't tell the backend if we're turning off mmx; it will end up disabling
2646 // SSE, which we don't want.
Craig Topperc0070a42013-09-11 06:48:53 +00002647 // Additionally, if SSE is enabled and mmx is not explicitly disabled,
2648 // then enable MMX.
Eli Friedman33465822011-07-08 23:31:17 +00002649 std::vector<std::string>::iterator it;
2650 it = std::find(Features.begin(), Features.end(), "-mmx");
2651 if (it != Features.end())
2652 Features.erase(it);
Craig Topperc0070a42013-09-11 06:48:53 +00002653 else if (SSELevel > NoSSE)
2654 MMX3DNowLevel = std::max(MMX3DNowLevel, MMX);
Rafael Espindolaeb265472013-08-21 21:59:03 +00002655 return true;
Chris Lattnerc25d8a72009-03-02 22:20:04 +00002656}
Chris Lattnerecd49032009-03-02 22:27:17 +00002657
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002658/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
2659/// definitions for this particular subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +00002660void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002661 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +00002662 // Target identification.
Derek Schuffc7dd7222012-10-11 15:52:22 +00002663 if (getTriple().getArch() == llvm::Triple::x86_64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002664 Builder.defineMacro("__amd64__");
2665 Builder.defineMacro("__amd64");
2666 Builder.defineMacro("__x86_64");
2667 Builder.defineMacro("__x86_64__");
Bob Wilsona2acb1e2014-08-08 23:46:28 +00002668 if (getTriple().getArchName() == "x86_64h") {
2669 Builder.defineMacro("__x86_64h");
2670 Builder.defineMacro("__x86_64h__");
2671 }
Chris Lattnerecd49032009-03-02 22:27:17 +00002672 } else {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002673 DefineStd(Builder, "i386", Opts);
Chris Lattnerecd49032009-03-02 22:27:17 +00002674 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002675
Chris Lattnerecd49032009-03-02 22:27:17 +00002676 // Subtarget options.
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002677 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
2678 // truly should be based on -mtune options.
Chandler Carruth212334f2011-09-28 08:55:37 +00002679 switch (CPU) {
2680 case CK_Generic:
2681 break;
2682 case CK_i386:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002683 // The rest are coming from the i386 define above.
2684 Builder.defineMacro("__tune_i386__");
Chandler Carruth212334f2011-09-28 08:55:37 +00002685 break;
2686 case CK_i486:
2687 case CK_WinChipC6:
2688 case CK_WinChip2:
2689 case CK_C3:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002690 defineCPUMacros(Builder, "i486");
Chandler Carruth212334f2011-09-28 08:55:37 +00002691 break;
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002692 case CK_PentiumMMX:
2693 Builder.defineMacro("__pentium_mmx__");
2694 Builder.defineMacro("__tune_pentium_mmx__");
2695 // Fallthrough
Chandler Carruth212334f2011-09-28 08:55:37 +00002696 case CK_i586:
2697 case CK_Pentium:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002698 defineCPUMacros(Builder, "i586");
2699 defineCPUMacros(Builder, "pentium");
Chandler Carruth212334f2011-09-28 08:55:37 +00002700 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002701 case CK_Pentium3:
2702 case CK_Pentium3M:
2703 case CK_PentiumM:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002704 Builder.defineMacro("__tune_pentium3__");
2705 // Fallthrough
2706 case CK_Pentium2:
Chandler Carruth212334f2011-09-28 08:55:37 +00002707 case CK_C3_2:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002708 Builder.defineMacro("__tune_pentium2__");
2709 // Fallthrough
2710 case CK_PentiumPro:
2711 Builder.defineMacro("__tune_i686__");
2712 Builder.defineMacro("__tune_pentiumpro__");
2713 // Fallthrough
2714 case CK_i686:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002715 Builder.defineMacro("__i686");
2716 Builder.defineMacro("__i686__");
2717 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
2718 Builder.defineMacro("__pentiumpro");
2719 Builder.defineMacro("__pentiumpro__");
Chandler Carruth212334f2011-09-28 08:55:37 +00002720 break;
2721 case CK_Pentium4:
2722 case CK_Pentium4M:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002723 defineCPUMacros(Builder, "pentium4");
Chandler Carruth212334f2011-09-28 08:55:37 +00002724 break;
2725 case CK_Yonah:
2726 case CK_Prescott:
2727 case CK_Nocona:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002728 defineCPUMacros(Builder, "nocona");
Chandler Carruth212334f2011-09-28 08:55:37 +00002729 break;
2730 case CK_Core2:
2731 case CK_Penryn:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002732 defineCPUMacros(Builder, "core2");
Chandler Carruth212334f2011-09-28 08:55:37 +00002733 break;
2734 case CK_Atom:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002735 defineCPUMacros(Builder, "atom");
Chandler Carruth212334f2011-09-28 08:55:37 +00002736 break;
Preston Gurda3c58c02013-09-13 19:27:17 +00002737 case CK_Silvermont:
Benjamin Kramerffecc842013-08-30 14:05:34 +00002738 defineCPUMacros(Builder, "slm");
2739 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002740 case CK_Corei7:
2741 case CK_Corei7AVX:
2742 case CK_CoreAVXi:
Craig Topper865fff52011-12-17 19:55:21 +00002743 case CK_CoreAVX2:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002744 defineCPUMacros(Builder, "corei7");
Chandler Carruth212334f2011-09-28 08:55:37 +00002745 break;
Craig Topper449314e2013-08-20 07:09:39 +00002746 case CK_KNL:
2747 defineCPUMacros(Builder, "knl");
2748 break;
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002749 case CK_SKX:
2750 defineCPUMacros(Builder, "skx");
2751 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002752 case CK_K6_2:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002753 Builder.defineMacro("__k6_2__");
2754 Builder.defineMacro("__tune_k6_2__");
2755 // Fallthrough
Chandler Carruth212334f2011-09-28 08:55:37 +00002756 case CK_K6_3:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002757 if (CPU != CK_K6_2) { // In case of fallthrough
2758 // FIXME: GCC may be enabling these in cases where some other k6
2759 // architecture is specified but -m3dnow is explicitly provided. The
2760 // exact semantics need to be determined and emulated here.
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002761 Builder.defineMacro("__k6_3__");
2762 Builder.defineMacro("__tune_k6_3__");
2763 }
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002764 // Fallthrough
2765 case CK_K6:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002766 defineCPUMacros(Builder, "k6");
Chandler Carruth212334f2011-09-28 08:55:37 +00002767 break;
2768 case CK_Athlon:
2769 case CK_AthlonThunderbird:
2770 case CK_Athlon4:
2771 case CK_AthlonXP:
2772 case CK_AthlonMP:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002773 defineCPUMacros(Builder, "athlon");
Chandler Carruth5d0feef2011-09-28 09:54:11 +00002774 if (SSELevel != NoSSE) {
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002775 Builder.defineMacro("__athlon_sse__");
Chandler Carruth5d0feef2011-09-28 09:54:11 +00002776 Builder.defineMacro("__tune_athlon_sse__");
2777 }
Chandler Carruth212334f2011-09-28 08:55:37 +00002778 break;
2779 case CK_K8:
2780 case CK_K8SSE3:
2781 case CK_x86_64:
2782 case CK_Opteron:
2783 case CK_OpteronSSE3:
2784 case CK_Athlon64:
2785 case CK_Athlon64SSE3:
2786 case CK_AthlonFX:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002787 defineCPUMacros(Builder, "k8");
Chandler Carruth212334f2011-09-28 08:55:37 +00002788 break;
Roman Divacky43eb6f82011-10-30 07:48:46 +00002789 case CK_AMDFAM10:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002790 defineCPUMacros(Builder, "amdfam10");
Roman Divacky43eb6f82011-10-30 07:48:46 +00002791 break;
Benjamin Kramer569f2152012-01-10 11:50:18 +00002792 case CK_BTVER1:
2793 defineCPUMacros(Builder, "btver1");
2794 break;
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002795 case CK_BTVER2:
2796 defineCPUMacros(Builder, "btver2");
2797 break;
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002798 case CK_BDVER1:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002799 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002800 break;
2801 case CK_BDVER2:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002802 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002803 break;
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00002804 case CK_BDVER3:
2805 defineCPUMacros(Builder, "bdver3");
2806 break;
Benjamin Kramer56c58222014-05-02 15:47:51 +00002807 case CK_BDVER4:
2808 defineCPUMacros(Builder, "bdver4");
2809 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002810 case CK_Geode:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002811 defineCPUMacros(Builder, "geode");
Chandler Carruth212334f2011-09-28 08:55:37 +00002812 break;
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002813 }
Chris Lattner96e43572009-03-02 22:40:39 +00002814
Chandler Carruth3f7ed952011-09-28 09:54:07 +00002815 // Target properties.
Chandler Carruth3f7ed952011-09-28 09:54:07 +00002816 Builder.defineMacro("__REGISTER_PREFIX__", "");
2817
Chris Lattner6df41af2009-04-19 17:32:33 +00002818 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2819 // functions in glibc header files that use FP Stack inline asm which the
2820 // backend can't deal with (PR879).
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002821 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002822
Chandler Carruth3f7ed952011-09-28 09:54:07 +00002823 if (HasAES)
2824 Builder.defineMacro("__AES__");
2825
Craig Topper3f122a72012-05-31 05:18:48 +00002826 if (HasPCLMUL)
2827 Builder.defineMacro("__PCLMUL__");
2828
Craig Topper22967d42011-12-25 05:06:45 +00002829 if (HasLZCNT)
2830 Builder.defineMacro("__LZCNT__");
2831
Benjamin Kramer1e250392012-07-07 09:39:18 +00002832 if (HasRDRND)
2833 Builder.defineMacro("__RDRND__");
2834
Craig Topper22967d42011-12-25 05:06:45 +00002835 if (HasBMI)
2836 Builder.defineMacro("__BMI__");
2837
2838 if (HasBMI2)
2839 Builder.defineMacro("__BMI2__");
2840
Craig Topper1de83482011-12-29 16:10:46 +00002841 if (HasPOPCNT)
2842 Builder.defineMacro("__POPCNT__");
2843
Michael Liao625a8752012-11-10 05:17:46 +00002844 if (HasRTM)
2845 Builder.defineMacro("__RTM__");
2846
Michael Liao74f4eaf2013-03-26 17:52:08 +00002847 if (HasPRFCHW)
2848 Builder.defineMacro("__PRFCHW__");
2849
Michael Liaoffaae352013-03-29 05:17:55 +00002850 if (HasRDSEED)
2851 Builder.defineMacro("__RDSEED__");
2852
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00002853 if (HasTBM)
2854 Builder.defineMacro("__TBM__");
2855
Rafael Espindolae62e2792013-08-20 13:44:29 +00002856 switch (XOPLevel) {
2857 case XOP:
2858 Builder.defineMacro("__XOP__");
2859 case FMA4:
Craig Topperffdb46c2011-12-30 07:33:42 +00002860 Builder.defineMacro("__FMA4__");
Rafael Espindolae62e2792013-08-20 13:44:29 +00002861 case SSE4A:
2862 Builder.defineMacro("__SSE4A__");
2863 case NoXOP:
2864 break;
2865 }
Craig Topperffdb46c2011-12-30 07:33:42 +00002866
Craig Topperbba778b2012-06-03 21:46:30 +00002867 if (HasFMA)
2868 Builder.defineMacro("__FMA__");
2869
Manman Rena45358c2012-10-11 00:59:55 +00002870 if (HasF16C)
2871 Builder.defineMacro("__F16C__");
2872
Craig Topper679b53a2013-08-21 05:29:10 +00002873 if (HasAVX512CD)
2874 Builder.defineMacro("__AVX512CD__");
2875 if (HasAVX512ER)
2876 Builder.defineMacro("__AVX512ER__");
2877 if (HasAVX512PF)
2878 Builder.defineMacro("__AVX512PF__");
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002879 if (HasAVX512DQ)
2880 Builder.defineMacro("__AVX512DQ__");
2881 if (HasAVX512BW)
2882 Builder.defineMacro("__AVX512BW__");
2883 if (HasAVX512VL)
2884 Builder.defineMacro("__AVX512VL__");
Craig Topper679b53a2013-08-21 05:29:10 +00002885
Ben Langmuir58078d02013-09-19 13:22:04 +00002886 if (HasSHA)
2887 Builder.defineMacro("__SHA__");
2888
Nick Lewycky50e8f482013-10-05 20:14:27 +00002889 if (HasCX16)
2890 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
2891
Chris Lattner96e43572009-03-02 22:40:39 +00002892 // Each case falls through to the previous one here.
2893 switch (SSELevel) {
Craig Topper9c4d17f2013-08-21 03:59:22 +00002894 case AVX512F:
Craig Topper007b0592013-08-20 07:39:54 +00002895 Builder.defineMacro("__AVX512F__");
Craig Topper23b92192012-01-09 09:19:09 +00002896 case AVX2:
2897 Builder.defineMacro("__AVX2__");
2898 case AVX:
2899 Builder.defineMacro("__AVX__");
Chris Lattner96e43572009-03-02 22:40:39 +00002900 case SSE42:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002901 Builder.defineMacro("__SSE4_2__");
Chris Lattner96e43572009-03-02 22:40:39 +00002902 case SSE41:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002903 Builder.defineMacro("__SSE4_1__");
Chris Lattner96e43572009-03-02 22:40:39 +00002904 case SSSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002905 Builder.defineMacro("__SSSE3__");
Chris Lattner96e43572009-03-02 22:40:39 +00002906 case SSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002907 Builder.defineMacro("__SSE3__");
Chris Lattner96e43572009-03-02 22:40:39 +00002908 case SSE2:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002909 Builder.defineMacro("__SSE2__");
2910 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner96e43572009-03-02 22:40:39 +00002911 case SSE1:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002912 Builder.defineMacro("__SSE__");
2913 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedman33465822011-07-08 23:31:17 +00002914 case NoSSE:
Chris Lattner96e43572009-03-02 22:40:39 +00002915 break;
2916 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00002917
Derek Schuffc7dd7222012-10-11 15:52:22 +00002918 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002919 switch (SSELevel) {
Craig Topper9c4d17f2013-08-21 03:59:22 +00002920 case AVX512F:
Craig Topper23b92192012-01-09 09:19:09 +00002921 case AVX2:
2922 case AVX:
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002923 case SSE42:
2924 case SSE41:
2925 case SSSE3:
2926 case SSE3:
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002927 case SSE2:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002928 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002929 break;
2930 case SSE1:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002931 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002932 break;
2933 default:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002934 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002935 }
2936 }
2937
Anders Carlssone437c682010-01-27 03:47:49 +00002938 // Each case falls through to the previous one here.
Eli Friedman33465822011-07-08 23:31:17 +00002939 switch (MMX3DNowLevel) {
Anders Carlssone437c682010-01-27 03:47:49 +00002940 case AMD3DNowAthlon:
2941 Builder.defineMacro("__3dNOW_A__");
2942 case AMD3DNow:
2943 Builder.defineMacro("__3dNOW__");
Eli Friedman33465822011-07-08 23:31:17 +00002944 case MMX:
2945 Builder.defineMacro("__MMX__");
2946 case NoMMX3DNow:
Anders Carlssone437c682010-01-27 03:47:49 +00002947 break;
2948 }
Michael J. Spencera0d5eb3a2013-04-04 23:53:43 +00002949
2950 if (CPU >= CK_i486) {
2951 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
2952 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
2953 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
2954 }
2955 if (CPU >= CK_i586)
2956 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Chris Lattnerecd49032009-03-02 22:27:17 +00002957}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002958
Douglas Gregor0070c0b2012-01-30 06:38:25 +00002959bool X86TargetInfo::hasFeature(StringRef Feature) const {
2960 return llvm::StringSwitch<bool>(Feature)
2961 .Case("aes", HasAES)
2962 .Case("avx", SSELevel >= AVX)
2963 .Case("avx2", SSELevel >= AVX2)
Craig Topper9c4d17f2013-08-21 03:59:22 +00002964 .Case("avx512f", SSELevel >= AVX512F)
Craig Topper679b53a2013-08-21 05:29:10 +00002965 .Case("avx512cd", HasAVX512CD)
2966 .Case("avx512er", HasAVX512ER)
2967 .Case("avx512pf", HasAVX512PF)
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002968 .Case("avx512dq", HasAVX512DQ)
2969 .Case("avx512bw", HasAVX512BW)
2970 .Case("avx512vl", HasAVX512VL)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00002971 .Case("bmi", HasBMI)
2972 .Case("bmi2", HasBMI2)
Nick Lewycky50e8f482013-10-05 20:14:27 +00002973 .Case("cx16", HasCX16)
2974 .Case("f16c", HasF16C)
Craig Topperbba778b2012-06-03 21:46:30 +00002975 .Case("fma", HasFMA)
Rafael Espindolae62e2792013-08-20 13:44:29 +00002976 .Case("fma4", XOPLevel >= FMA4)
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00002977 .Case("tbm", HasTBM)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00002978 .Case("lzcnt", HasLZCNT)
Benjamin Kramer1e250392012-07-07 09:39:18 +00002979 .Case("rdrnd", HasRDRND)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00002980 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
2981 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
2982 .Case("mmx", MMX3DNowLevel >= MMX)
Craig Topper3f122a72012-05-31 05:18:48 +00002983 .Case("pclmul", HasPCLMUL)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00002984 .Case("popcnt", HasPOPCNT)
Michael Liao625a8752012-11-10 05:17:46 +00002985 .Case("rtm", HasRTM)
Michael Liao74f4eaf2013-03-26 17:52:08 +00002986 .Case("prfchw", HasPRFCHW)
Michael Liaoffaae352013-03-29 05:17:55 +00002987 .Case("rdseed", HasRDSEED)
Ben Langmuir58078d02013-09-19 13:22:04 +00002988 .Case("sha", HasSHA)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00002989 .Case("sse", SSELevel >= SSE1)
2990 .Case("sse2", SSELevel >= SSE2)
2991 .Case("sse3", SSELevel >= SSE3)
2992 .Case("ssse3", SSELevel >= SSSE3)
Rafael Espindola89049822013-08-23 20:21:37 +00002993 .Case("sse4.1", SSELevel >= SSE41)
2994 .Case("sse4.2", SSELevel >= SSE42)
Rafael Espindolae62e2792013-08-20 13:44:29 +00002995 .Case("sse4a", XOPLevel >= SSE4A)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00002996 .Case("x86", true)
Derek Schuffc7dd7222012-10-11 15:52:22 +00002997 .Case("x86_32", getTriple().getArch() == llvm::Triple::x86)
2998 .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64)
Rafael Espindolae62e2792013-08-20 13:44:29 +00002999 .Case("xop", XOPLevel >= XOP)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003000 .Default(false);
3001}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003002
Eli Friedman3fd920a2008-08-20 02:34:37 +00003003bool
Anders Carlsson58436352009-02-28 17:11:49 +00003004X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +00003005 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson58436352009-02-28 17:11:49 +00003006 switch (*Name) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003007 default: return false;
Dale Johannesen46742a42010-08-24 22:33:12 +00003008 case 'Y': // first letter of a pair:
3009 switch (*(Name+1)) {
3010 default: return false;
3011 case '0': // First SSE register.
3012 case 't': // Any SSE register, when SSE2 is enabled.
3013 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
3014 case 'm': // any MMX register, when inter-unit moves enabled.
3015 break; // falls through to setAllowsRegister.
3016 }
Akira Hatanaka88ef7282014-07-18 23:30:30 +00003017 case 'f': // any x87 floating point stack register.
3018 // Constraint 'f' cannot be used for output operands.
3019 if (Info.ConstraintStr[0] == '=')
3020 return false;
3021
3022 Info.setAllowsRegister();
3023 return true;
Eli Friedman3fd920a2008-08-20 02:34:37 +00003024 case 'a': // eax.
3025 case 'b': // ebx.
3026 case 'c': // ecx.
3027 case 'd': // edx.
3028 case 'S': // esi.
3029 case 'D': // edi.
3030 case 'A': // edx:eax.
3031 case 't': // top of floating point stack.
3032 case 'u': // second from top of floating point stack.
3033 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson83661ac2008-10-06 00:41:45 +00003034 case 'y': // Any MMX register.
Anders Carlsson5f7ee682008-10-06 19:17:39 +00003035 case 'x': // Any SSE register.
Eli Friedman3fd920a2008-08-20 02:34:37 +00003036 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen46742a42010-08-24 22:33:12 +00003037 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
3038 case 'l': // "Index" registers: any general register that can be used as an
3039 // index in a base+index memory access.
3040 Info.setAllowsRegister();
3041 return true;
3042 case 'C': // SSE floating point constant.
3043 case 'G': // x87 floating point constant.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003044 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssona0b89212009-01-24 18:03:09 +00003045 // x86_64 instructions.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003046 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssona0b89212009-01-24 18:03:09 +00003047 // x86_64 instructions.
Eli Friedman3fd920a2008-08-20 02:34:37 +00003048 return true;
3049 }
3050}
3051
Dale Johannesen7d3dfc02010-10-29 23:12:32 +00003052
Eli Friedman3fd920a2008-08-20 02:34:37 +00003053std::string
Stuart Hastings7fdc6702011-06-07 23:45:05 +00003054X86TargetInfo::convertConstraint(const char *&Constraint) const {
3055 switch (*Constraint) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003056 case 'a': return std::string("{ax}");
3057 case 'b': return std::string("{bx}");
3058 case 'c': return std::string("{cx}");
3059 case 'd': return std::string("{dx}");
3060 case 'S': return std::string("{si}");
3061 case 'D': return std::string("{di}");
Dale Johannesen70f564e2010-10-22 21:07:10 +00003062 case 'p': // address
3063 return std::string("im");
Eli Friedman3fd920a2008-08-20 02:34:37 +00003064 case 't': // top of floating point stack.
3065 return std::string("{st}");
3066 case 'u': // second from top of floating point stack.
3067 return std::string("{st(1)}"); // second from top of floating point stack.
3068 default:
Stuart Hastings7fdc6702011-06-07 23:45:05 +00003069 return std::string(1, *Constraint);
Eli Friedman3fd920a2008-08-20 02:34:37 +00003070 }
3071}
Eli Friedman3fd920a2008-08-20 02:34:37 +00003072} // end anonymous namespace
Chris Lattner5ba61f02006-10-14 07:39:34 +00003073
3074namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003075// X86-32 generic target
3076class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00003077public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003078 X86_32TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003079 DoubleAlign = LongLongAlign = 32;
3080 LongDoubleWidth = 96;
3081 LongDoubleAlign = 32;
Nick Lewyckyf243e0d2011-12-21 04:25:47 +00003082 SuitableAlign = 128;
Rafael Espindolac418ae92014-01-03 19:22:05 +00003083 DescriptionString = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128";
Eli Friedman32ca82a2009-03-29 20:31:09 +00003084 SizeType = UnsignedInt;
3085 PtrDiffType = SignedInt;
3086 IntPtrType = SignedInt;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00003087 RegParmMax = 3;
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00003088
3089 // Use fpret for all types.
3090 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
3091 (1 << TargetInfo::Double) |
3092 (1 << TargetInfo::LongDouble));
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003093
3094 // x86-32 has atomics up to 8 bytes
3095 // FIXME: Check that we actually have cmpxchg8b before setting
3096 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
3097 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman3fd920a2008-08-20 02:34:37 +00003098 }
Craig Topper3164f332014-03-11 03:39:26 +00003099 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00003100 return TargetInfo::CharPtrBuiltinVaList;
Eli Friedman3fd920a2008-08-20 02:34:37 +00003101 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003102
Craig Topper3164f332014-03-11 03:39:26 +00003103 int getEHDataRegisterNumber(unsigned RegNo) const override {
Chris Lattnerd545ad12009-09-23 06:06:36 +00003104 if (RegNo == 0) return 0;
3105 if (RegNo == 1) return 2;
3106 return -1;
3107 }
Craig Topper3164f332014-03-11 03:39:26 +00003108 bool validateInputSize(StringRef Constraint,
3109 unsigned Size) const override {
Bill Wendling887b4852012-11-12 06:42:51 +00003110 switch (Constraint[0]) {
3111 default: break;
3112 case 'a':
3113 case 'b':
3114 case 'c':
3115 case 'd':
Bill Wendling3c7fed82012-11-12 18:52:32 +00003116 return Size <= 32;
Bill Wendling887b4852012-11-12 06:42:51 +00003117 }
3118
3119 return true;
3120 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00003121};
3122} // end anonymous namespace
3123
3124namespace {
Joerg Sonnenberger16237142012-01-06 18:32:26 +00003125class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
3126public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003127 NetBSDI386TargetInfo(const llvm::Triple &Triple)
3128 : NetBSDTargetInfo<X86_32TargetInfo>(Triple) {}
Joerg Sonnenberger16237142012-01-06 18:32:26 +00003129
Craig Topper3164f332014-03-11 03:39:26 +00003130 unsigned getFloatEvalMethod() const override {
Joerg Sonnenberger0e921f22013-11-11 14:00:37 +00003131 unsigned Major, Minor, Micro;
3132 getTriple().getOSVersion(Major, Minor, Micro);
3133 // New NetBSD uses the default rounding mode.
3134 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 26) || Major == 0)
3135 return X86_32TargetInfo::getFloatEvalMethod();
3136 // NetBSD before 6.99.26 defaults to "double" rounding.
Joerg Sonnenberger16237142012-01-06 18:32:26 +00003137 return 1;
3138 }
3139};
3140} // end anonymous namespace
3141
3142namespace {
Eli Friedmane3aa4542009-07-05 18:47:56 +00003143class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
3144public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003145 OpenBSDI386TargetInfo(const llvm::Triple &Triple)
3146 : OpenBSDTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedmane3aa4542009-07-05 18:47:56 +00003147 SizeType = UnsignedLong;
3148 IntPtrType = SignedLong;
Eli Friedman245f2292009-07-05 22:31:18 +00003149 PtrDiffType = SignedLong;
Eli Friedmane3aa4542009-07-05 18:47:56 +00003150 }
3151};
3152} // end anonymous namespace
3153
3154namespace {
Eli Friedman9fa28852012-08-08 23:57:20 +00003155class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
3156public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003157 BitrigI386TargetInfo(const llvm::Triple &Triple)
3158 : BitrigTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman9fa28852012-08-08 23:57:20 +00003159 SizeType = UnsignedLong;
3160 IntPtrType = SignedLong;
3161 PtrDiffType = SignedLong;
3162 }
3163};
3164} // end anonymous namespace
3165
3166namespace {
Torok Edwinb2b37c62009-06-30 17:10:35 +00003167class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003168public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003169 DarwinI386TargetInfo(const llvm::Triple &Triple)
3170 : DarwinTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003171 LongDoubleWidth = 128;
3172 LongDoubleAlign = 128;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00003173 SuitableAlign = 128;
Chad Rosiercc40ea72012-07-13 23:57:43 +00003174 MaxVectorAlign = 256;
Eli Friedman32ca82a2009-03-29 20:31:09 +00003175 SizeType = UnsignedLong;
3176 IntPtrType = SignedLong;
Rafael Espindolac418ae92014-01-03 19:22:05 +00003177 DescriptionString = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128";
Daniel Dunbarbd606522010-05-27 00:35:16 +00003178 HasAlignMac68kSupport = true;
Torok Edwin4e054162009-06-30 17:00:25 +00003179 }
3180
Eli Friedman3fd920a2008-08-20 02:34:37 +00003181};
Daniel Dunbar10de9e62009-06-29 20:52:51 +00003182} // end anonymous namespace
3183
3184namespace {
Eli Friedmanc968a6a2008-08-21 01:40:19 +00003185// x86-32 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003186class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedmanc968a6a2008-08-21 01:40:19 +00003187public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003188 WindowsX86_32TargetInfo(const llvm::Triple &Triple)
3189 : WindowsTargetInfo<X86_32TargetInfo>(Triple) {
Chris Lattner46be2e12009-06-24 17:12:15 +00003190 WCharType = UnsignedShort;
Eli Friedmanebb9e4d2009-06-08 21:16:17 +00003191 DoubleAlign = LongLongAlign = 64;
Rafael Espindola26d0f7c2014-01-10 13:42:17 +00003192 DescriptionString = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32";
Eli Friedmanc968a6a2008-08-21 01:40:19 +00003193 }
Craig Topper3164f332014-03-11 03:39:26 +00003194 void getTargetDefines(const LangOptions &Opts,
3195 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003196 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
3197 }
3198};
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003199
3200// x86-32 Windows Visual Studio target
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00003201class MicrosoftX86_32TargetInfo : public WindowsX86_32TargetInfo {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003202public:
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00003203 MicrosoftX86_32TargetInfo(const llvm::Triple &Triple)
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003204 : WindowsX86_32TargetInfo(Triple) {
Eli Friedman015d6282011-03-22 21:25:11 +00003205 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003206 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
3207 }
Craig Topper3164f332014-03-11 03:39:26 +00003208 void getTargetDefines(const LangOptions &Opts,
3209 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003210 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
3211 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
3212 // The value of the following reflects processor type.
3213 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
3214 // We lost the original triple, so we use the default.
3215 Builder.defineMacro("_M_IX86", "600");
3216 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003217};
3218} // end anonymous namespace
3219
Reid Kleckner47606832014-04-21 20:58:00 +00003220static void addMinGWDefines(const LangOptions &Opts, MacroBuilder &Builder) {
3221 Builder.defineMacro("__MSVCRT__");
3222 Builder.defineMacro("__MINGW32__");
3223
3224 // Mingw defines __declspec(a) to __attribute__((a)). Clang supports
3225 // __declspec natively under -fms-extensions, but we define a no-op __declspec
3226 // macro anyway for pre-processor compatibility.
3227 if (Opts.MicrosoftExt)
3228 Builder.defineMacro("__declspec", "__declspec");
3229 else
3230 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
3231
3232 if (!Opts.MicrosoftExt) {
3233 // Provide macros for all the calling convention keywords. Provide both
3234 // single and double underscore prefixed variants. These are available on
3235 // x64 as well as x86, even though they have no effect.
3236 const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"};
3237 for (const char *CC : CCs) {
Reid Kleckner70cfa662014-04-21 22:29:45 +00003238 std::string GCCSpelling = "__attribute__((__";
3239 GCCSpelling += CC;
3240 GCCSpelling += "__))";
Reid Kleckner47606832014-04-21 20:58:00 +00003241 Builder.defineMacro(Twine("_") + CC, GCCSpelling);
3242 Builder.defineMacro(Twine("__") + CC, GCCSpelling);
3243 }
3244 }
3245}
3246
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003247namespace {
3248// x86-32 MinGW target
3249class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
3250public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003251 MinGWX86_32TargetInfo(const llvm::Triple &Triple)
3252 : WindowsX86_32TargetInfo(Triple) {}
Craig Topper3164f332014-03-11 03:39:26 +00003253 void getTargetDefines(const LangOptions &Opts,
3254 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003255 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003256 DefineStd(Builder, "WIN32", Opts);
3257 DefineStd(Builder, "WINNT", Opts);
3258 Builder.defineMacro("_X86_");
Reid Kleckner47606832014-04-21 20:58:00 +00003259 addMinGWDefines(Opts, Builder);
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003260 }
3261};
3262} // end anonymous namespace
3263
3264namespace {
3265// x86-32 Cygwin target
3266class CygwinX86_32TargetInfo : public X86_32TargetInfo {
3267public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003268 CygwinX86_32TargetInfo(const llvm::Triple &Triple)
3269 : X86_32TargetInfo(Triple) {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003270 TLSSupported = false;
3271 WCharType = UnsignedShort;
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003272 DoubleAlign = LongLongAlign = 64;
Rafael Espindola26d0f7c2014-01-10 13:42:17 +00003273 DescriptionString = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32";
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003274 }
Craig Topper3164f332014-03-11 03:39:26 +00003275 void getTargetDefines(const LangOptions &Opts,
3276 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003277 X86_32TargetInfo::getTargetDefines(Opts, Builder);
NAKAMURA Takumi02f43952012-12-14 10:17:26 +00003278 Builder.defineMacro("_X86_");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003279 Builder.defineMacro("__CYGWIN__");
3280 Builder.defineMacro("__CYGWIN32__");
3281 DefineStd(Builder, "unix", Opts);
Douglas Gregor3ecc6652010-04-21 05:52:38 +00003282 if (Opts.CPlusPlus)
3283 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanaa27a872009-06-08 06:11:14 +00003284 }
Eli Friedmanc968a6a2008-08-21 01:40:19 +00003285};
3286} // end anonymous namespace
3287
3288namespace {
Chris Lattnerb986aba2010-04-11 19:29:39 +00003289// x86-32 Haiku target
3290class HaikuX86_32TargetInfo : public X86_32TargetInfo {
3291public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003292 HaikuX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Chris Lattnerb986aba2010-04-11 19:29:39 +00003293 SizeType = UnsignedLong;
Chris Lattner8b290212010-04-22 17:48:00 +00003294 IntPtrType = SignedLong;
3295 PtrDiffType = SignedLong;
Eli Friedman4e91899e2012-11-27 02:58:24 +00003296 ProcessIDType = SignedLong;
Rafael Espindolac55be6d2010-11-09 16:41:02 +00003297 this->UserLabelPrefix = "";
Benjamin Kramerd0b9f092012-11-08 12:59:15 +00003298 this->TLSSupported = false;
Eli Friedman04831922010-08-22 01:00:03 +00003299 }
Craig Topper3164f332014-03-11 03:39:26 +00003300 void getTargetDefines(const LangOptions &Opts,
3301 MacroBuilder &Builder) const override {
Chris Lattnerb986aba2010-04-11 19:29:39 +00003302 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3303 Builder.defineMacro("__INTEL__");
3304 Builder.defineMacro("__HAIKU__");
3305 }
3306};
3307} // end anonymous namespace
3308
Douglas Gregor9fabd852011-07-01 22:41:14 +00003309// RTEMS Target
3310template<typename Target>
3311class RTEMSTargetInfo : public OSTargetInfo<Target> {
3312protected:
Craig Topper3164f332014-03-11 03:39:26 +00003313 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
3314 MacroBuilder &Builder) const override {
Douglas Gregor9fabd852011-07-01 22:41:14 +00003315 // RTEMS defines; list based off of gcc output
3316
Douglas Gregor9fabd852011-07-01 22:41:14 +00003317 Builder.defineMacro("__rtems__");
3318 Builder.defineMacro("__ELF__");
3319 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003320
Douglas Gregor9fabd852011-07-01 22:41:14 +00003321public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003322 RTEMSTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
3323 this->UserLabelPrefix = "";
Douglas Gregor9fabd852011-07-01 22:41:14 +00003324
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003325 switch (Triple.getArch()) {
3326 default:
3327 case llvm::Triple::x86:
3328 // this->MCountName = ".mcount";
3329 break;
3330 case llvm::Triple::mips:
3331 case llvm::Triple::mipsel:
3332 case llvm::Triple::ppc:
3333 case llvm::Triple::ppc64:
Bill Schmidt778d3872013-07-26 01:36:11 +00003334 case llvm::Triple::ppc64le:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003335 // this->MCountName = "_mcount";
3336 break;
3337 case llvm::Triple::arm:
3338 // this->MCountName = "__mcount";
3339 break;
Douglas Gregor9fabd852011-07-01 22:41:14 +00003340 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003341 }
Douglas Gregor9fabd852011-07-01 22:41:14 +00003342};
3343
3344namespace {
3345// x86-32 RTEMS target
3346class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
3347public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003348 RTEMSX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Douglas Gregor9fabd852011-07-01 22:41:14 +00003349 SizeType = UnsignedLong;
3350 IntPtrType = SignedLong;
3351 PtrDiffType = SignedLong;
3352 this->UserLabelPrefix = "";
3353 }
Craig Topper3164f332014-03-11 03:39:26 +00003354 void getTargetDefines(const LangOptions &Opts,
3355 MacroBuilder &Builder) const override {
Douglas Gregor9fabd852011-07-01 22:41:14 +00003356 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3357 Builder.defineMacro("__INTEL__");
3358 Builder.defineMacro("__rtems__");
3359 }
3360};
3361} // end anonymous namespace
3362
Chris Lattnerb986aba2010-04-11 19:29:39 +00003363namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003364// x86-64 generic target
3365class X86_64TargetInfo : public X86TargetInfo {
3366public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003367 X86_64TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
David Blaikie40f842d2014-07-10 18:46:15 +00003368 const bool IsX32 = getTriple().getEnvironment() == llvm::Triple::GNUX32;
Zinovy Nis1db95732014-07-10 15:27:19 +00003369 LongWidth = LongAlign = PointerWidth = PointerAlign = IsX32 ? 32 : 64;
Eli Friedmanb5366062008-05-20 14:21:01 +00003370 LongDoubleWidth = 128;
3371 LongDoubleAlign = 128;
Rafael Espindolae971b9a2010-06-04 23:15:27 +00003372 LargeArrayMinWidth = 128;
3373 LargeArrayAlign = 128;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00003374 SuitableAlign = 128;
Zinovy Nis1db95732014-07-10 15:27:19 +00003375 SizeType = IsX32 ? UnsignedInt : UnsignedLong;
3376 PtrDiffType = IsX32 ? SignedInt : SignedLong;
3377 IntPtrType = IsX32 ? SignedInt : SignedLong;
3378 IntMaxType = IsX32 ? SignedLongLong : SignedLong;
Zinovy Nis1db95732014-07-10 15:27:19 +00003379 Int64Type = IsX32 ? SignedLongLong : SignedLong;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00003380 RegParmMax = 6;
Chris Lattnerd0a79b22009-02-05 07:32:46 +00003381
Zinovy Nis1db95732014-07-10 15:27:19 +00003382 DescriptionString = (IsX32)
3383 ? "e-m:e-" "p:32:32-" "i64:64-f80:128-n8:16:32:64-S128"
3384 : "e-m:e-" "i64:64-f80:128-n8:16:32:64-S128";
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00003385
3386 // Use fpret only for long double.
3387 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003388
Anders Carlsson2f1a6c32011-10-31 16:27:11 +00003389 // Use fp2ret for _Complex long double.
3390 ComplexLongDoubleUsesFP2Ret = true;
3391
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003392 // x86-64 has atomics up to 16 bytes.
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003393 MaxAtomicPromoteWidth = 128;
Tim Northover1471cb12014-07-02 10:25:45 +00003394 MaxAtomicInlineWidth = 128;
Chris Lattner10a5b382007-01-29 05:24:35 +00003395 }
Craig Topper3164f332014-03-11 03:39:26 +00003396 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00003397 return TargetInfo::X86_64ABIBuiltinVaList;
Anders Carlsson5fa3f342007-11-24 23:38:12 +00003398 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00003399
Craig Topper3164f332014-03-11 03:39:26 +00003400 int getEHDataRegisterNumber(unsigned RegNo) const override {
Chris Lattnerd545ad12009-09-23 06:06:36 +00003401 if (RegNo == 0) return 0;
3402 if (RegNo == 1) return 1;
3403 return -1;
3404 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00003405
Craig Topper3164f332014-03-11 03:39:26 +00003406 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Charles Davisb5a214e2013-08-30 04:39:01 +00003407 return (CC == CC_C ||
3408 CC == CC_IntelOclBicc ||
3409 CC == CC_X86_64Win64) ? CCCR_OK : CCCR_Warning;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00003410 }
3411
Craig Topper3164f332014-03-11 03:39:26 +00003412 CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
Aaron Ballman02df2e02012-12-09 17:45:41 +00003413 return CC_C;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00003414 }
3415
Pavel Chupinfd223e12014-08-04 12:39:43 +00003416 // for x32 we need it here explicitly
3417 bool hasInt128Type() const override { return true; }
Eli Friedman3fd920a2008-08-20 02:34:37 +00003418};
3419} // end anonymous namespace
3420
3421namespace {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003422// x86-64 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003423class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003424public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003425 WindowsX86_64TargetInfo(const llvm::Triple &Triple)
3426 : WindowsTargetInfo<X86_64TargetInfo>(Triple) {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003427 WCharType = UnsignedShort;
Mike Stumpaf9afe92009-10-08 23:00:00 +00003428 LongWidth = LongAlign = 32;
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00003429 DoubleAlign = LongLongAlign = 64;
Nate Begeman6e8865a2010-07-21 02:02:56 +00003430 IntMaxType = SignedLongLong;
Nate Begeman6e8865a2010-07-21 02:02:56 +00003431 Int64Type = SignedLongLong;
Cameron Esfahanieb856502010-09-15 00:28:12 +00003432 SizeType = UnsignedLongLong;
3433 PtrDiffType = SignedLongLong;
3434 IntPtrType = SignedLongLong;
NAKAMURA Takumif7c30222011-01-17 22:56:08 +00003435 this->UserLabelPrefix = "";
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003436 }
Craig Topper3164f332014-03-11 03:39:26 +00003437 void getTargetDefines(const LangOptions &Opts,
3438 MacroBuilder &Builder) const override {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003439 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003440 Builder.defineMacro("_WIN64");
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003441 }
Craig Topper3164f332014-03-11 03:39:26 +00003442 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00003443 return TargetInfo::CharPtrBuiltinVaList;
NAKAMURA Takumia2e468c2011-01-17 22:56:23 +00003444 }
Craig Topper3164f332014-03-11 03:39:26 +00003445 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Charles Davisb5a214e2013-08-30 04:39:01 +00003446 return (CC == CC_C ||
3447 CC == CC_IntelOclBicc ||
3448 CC == CC_X86_64SysV) ? CCCR_OK : CCCR_Warning;
3449 }
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003450};
3451} // end anonymous namespace
3452
3453namespace {
3454// x86-64 Windows Visual Studio target
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00003455class MicrosoftX86_64TargetInfo : public WindowsX86_64TargetInfo {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003456public:
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00003457 MicrosoftX86_64TargetInfo(const llvm::Triple &Triple)
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003458 : WindowsX86_64TargetInfo(Triple) {
Eli Friedman015d6282011-03-22 21:25:11 +00003459 LongDoubleWidth = LongDoubleAlign = 64;
3460 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003461 }
Craig Topper3164f332014-03-11 03:39:26 +00003462 void getTargetDefines(const LangOptions &Opts,
3463 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003464 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
3465 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003466 Builder.defineMacro("_M_X64");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003467 Builder.defineMacro("_M_AMD64");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003468 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003469};
3470} // end anonymous namespace
3471
3472namespace {
3473// x86-64 MinGW target
3474class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
3475public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003476 MinGWX86_64TargetInfo(const llvm::Triple &Triple)
3477 : WindowsX86_64TargetInfo(Triple) {}
Craig Topper3164f332014-03-11 03:39:26 +00003478 void getTargetDefines(const LangOptions &Opts,
3479 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003480 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003481 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003482 Builder.defineMacro("__MINGW64__");
Reid Kleckner47606832014-04-21 20:58:00 +00003483 addMinGWDefines(Opts, Builder);
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003484 }
3485};
3486} // end anonymous namespace
3487
3488namespace {
Eli Friedman2857ccb2009-07-01 03:36:11 +00003489class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
3490public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003491 DarwinX86_64TargetInfo(const llvm::Triple &Triple)
3492 : DarwinTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman2857ccb2009-07-01 03:36:11 +00003493 Int64Type = SignedLongLong;
Chad Rosiercc40ea72012-07-13 23:57:43 +00003494 MaxVectorAlign = 256;
Tim Northovera2ee4332014-03-29 15:09:45 +00003495 // The 64-bit iOS simulator uses the builtin bool type for Objective-C.
3496 llvm::Triple T = llvm::Triple(Triple);
3497 if (T.getOS() == llvm::Triple::IOS)
3498 UseSignedCharForObjCBool = false;
Rafael Espindolac418ae92014-01-03 19:22:05 +00003499 DescriptionString = "e-m:o-i64:64-f80:128-n8:16:32:64-S128";
Eli Friedman2857ccb2009-07-01 03:36:11 +00003500 }
3501};
3502} // end anonymous namespace
3503
3504namespace {
Eli Friedman245f2292009-07-05 22:31:18 +00003505class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
3506public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003507 OpenBSDX86_64TargetInfo(const llvm::Triple &Triple)
3508 : OpenBSDTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman245f2292009-07-05 22:31:18 +00003509 IntMaxType = SignedLongLong;
Eli Friedman245f2292009-07-05 22:31:18 +00003510 Int64Type = SignedLongLong;
3511 }
3512};
3513} // end anonymous namespace
3514
3515namespace {
Eli Friedman9fa28852012-08-08 23:57:20 +00003516class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
3517public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003518 BitrigX86_64TargetInfo(const llvm::Triple &Triple)
3519 : BitrigTargetInfo<X86_64TargetInfo>(Triple) {
3520 IntMaxType = SignedLongLong;
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003521 Int64Type = SignedLongLong;
Eli Friedman9fa28852012-08-08 23:57:20 +00003522 }
3523};
Tim Northover9bb857a2013-01-31 12:13:10 +00003524}
3525
Eli Friedman9fa28852012-08-08 23:57:20 +00003526
3527namespace {
Eli Friedmanf05b7722008-08-20 07:44:10 +00003528class ARMTargetInfo : public TargetInfo {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003529 // Possible FPU choices.
3530 enum FPUMode {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00003531 VFP2FPU = (1 << 0),
3532 VFP3FPU = (1 << 1),
3533 VFP4FPU = (1 << 2),
Bernard Ogdenda13af32013-10-24 18:32:51 +00003534 NeonFPU = (1 << 3),
3535 FPARMV8 = (1 << 4)
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003536 };
3537
Silviu Barangaf9671dd2013-10-21 10:54:53 +00003538 // Possible HWDiv features.
3539 enum HWDivMode {
3540 HWDivThumb = (1 << 0),
3541 HWDivARM = (1 << 1)
3542 };
3543
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003544 static bool FPUModeIsVFP(FPUMode Mode) {
Bernard Ogdenda13af32013-10-24 18:32:51 +00003545 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU | FPARMV8);
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003546 }
3547
3548 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3549 static const char * const GCCRegNames[];
Daniel Dunbar1da76c42009-09-17 07:03:19 +00003550
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003551 std::string ABI, CPU;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003552
Rafael Espindolaeb265472013-08-21 21:59:03 +00003553 enum {
3554 FP_Default,
3555 FP_VFP,
3556 FP_Neon
3557 } FPMath;
3558
Bernard Ogdenda13af32013-10-24 18:32:51 +00003559 unsigned FPU : 5;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003560
Logan Chien57086ce2012-10-10 06:56:20 +00003561 unsigned IsAAPCS : 1;
Daniel Dunbar893d4752009-12-19 04:15:38 +00003562 unsigned IsThumb : 1;
Silviu Barangaf9671dd2013-10-21 10:54:53 +00003563 unsigned HWDiv : 2;
Daniel Dunbar893d4752009-12-19 04:15:38 +00003564
3565 // Initialized via features.
3566 unsigned SoftFloat : 1;
3567 unsigned SoftFloatABI : 1;
Daniel Dunbarb4091a92009-09-14 00:35:03 +00003568
Bernard Ogden18b57012013-10-29 09:47:51 +00003569 unsigned CRC : 1;
Tim Northover02e38602014-02-03 17:28:04 +00003570 unsigned Crypto : 1;
Bernard Ogden18b57012013-10-29 09:47:51 +00003571
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003572 // ACLE 6.5.1 Hardware floating point
3573 enum {
3574 HW_FP_HP = (1 << 1), /// half (16-bit)
3575 HW_FP_SP = (1 << 2), /// single (32-bit)
3576 HW_FP_DP = (1 << 3), /// double (64-bit)
3577 };
3578 uint32_t HW_FP;
3579
Chris Lattner5cc15e02010-03-03 19:03:45 +00003580 static const Builtin::Info BuiltinInfo[];
3581
Rafael Espindola101d5b92013-05-13 20:09:47 +00003582 static bool shouldUseInlineAtomic(const llvm::Triple &T) {
Rafael Espindola101d5b92013-05-13 20:09:47 +00003583 StringRef ArchName = T.getArchName();
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003584 if (T.getArch() == llvm::Triple::arm ||
3585 T.getArch() == llvm::Triple::armeb) {
3586 StringRef VersionStr;
3587 if (ArchName.startswith("armv"))
Tim Northovere8c37212014-07-09 09:24:43 +00003588 VersionStr = ArchName.substr(4, 1);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003589 else if (ArchName.startswith("armebv"))
Tim Northovere8c37212014-07-09 09:24:43 +00003590 VersionStr = ArchName.substr(6, 1);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003591 else
Rafael Espindola92dbc312013-05-14 00:44:24 +00003592 return false;
Rafael Espindola92dbc312013-05-14 00:44:24 +00003593 unsigned Version;
3594 if (VersionStr.getAsInteger(10, Version))
3595 return false;
3596 return Version >= 6;
3597 }
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003598 assert(T.getArch() == llvm::Triple::thumb ||
3599 T.getArch() == llvm::Triple::thumbeb);
3600 StringRef VersionStr;
3601 if (ArchName.startswith("thumbv"))
Tim Northovere8c37212014-07-09 09:24:43 +00003602 VersionStr = ArchName.substr(6, 1);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003603 else if (ArchName.startswith("thumbebv"))
Tim Northovere8c37212014-07-09 09:24:43 +00003604 VersionStr = ArchName.substr(8, 1);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003605 else
Rafael Espindola92dbc312013-05-14 00:44:24 +00003606 return false;
Rafael Espindola92dbc312013-05-14 00:44:24 +00003607 unsigned Version;
3608 if (VersionStr.getAsInteger(10, Version))
3609 return false;
3610 return Version >= 7;
Rafael Espindola101d5b92013-05-13 20:09:47 +00003611 }
3612
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003613 void setABIAAPCS() {
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003614 IsAAPCS = true;
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003615
3616 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 64;
Rafael Espindolac418ae92014-01-03 19:22:05 +00003617 const llvm::Triple &T = getTriple();
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003618
Tim Northover00853e52014-08-05 11:07:26 +00003619 // size_t is unsigned long on MachO-derived environments and NetBSD.
3620 if (T.isOSBinFormatMachO() || T.getOS() == llvm::Triple::NetBSD)
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003621 SizeType = UnsignedLong;
3622 else
3623 SizeType = UnsignedInt;
3624
Saleem Abdulrasool6323a2d2014-05-04 01:56:04 +00003625 switch (T.getOS()) {
3626 case llvm::Triple::NetBSD:
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003627 WCharType = SignedInt;
Saleem Abdulrasool6323a2d2014-05-04 01:56:04 +00003628 break;
3629 case llvm::Triple::Win32:
3630 WCharType = UnsignedShort;
3631 break;
3632 case llvm::Triple::Linux:
3633 default:
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003634 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
3635 WCharType = UnsignedInt;
Saleem Abdulrasool6323a2d2014-05-04 01:56:04 +00003636 break;
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003637 }
3638
3639 UseBitFieldTypeAlignment = true;
3640
3641 ZeroLengthBitfieldBoundary = 0;
3642
3643 if (IsThumb) {
3644 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3645 // so set preferred for small types to 32.
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00003646 if (T.isOSBinFormatMachO()) {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003647 DescriptionString = BigEndian ?
3648 "E-m:o-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:64-"
3649 "v128:64:128-a:0:32-n32-S64" :
3650 "e-m:o-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:64-"
3651 "v128:64:128-a:0:32-n32-S64";
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00003652 } else if (T.isOSWindows()) {
3653 // FIXME: this is invalid for WindowsCE
3654 assert(!BigEndian && "Windows on ARM does not support big endian");
3655 DescriptionString = "e"
3656 "-m:e"
3657 "-p:32:32"
3658 "-i1:8:32-i8:8:32-i16:16:32-i64:64"
3659 "-v128:64:128"
3660 "-a:0:32"
3661 "-n32"
3662 "-S64";
3663 } else {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003664 DescriptionString = BigEndian ?
3665 "E-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:64-"
3666 "v128:64:128-a:0:32-n32-S64" :
3667 "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:64-"
3668 "v128:64:128-a:0:32-n32-S64";
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00003669 }
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003670 } else {
Rafael Espindolac418ae92014-01-03 19:22:05 +00003671 if (T.isOSBinFormatMachO())
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003672 DescriptionString = BigEndian ?
3673 "E-m:o-p:32:32-i64:64-v128:64:128-n32-S64" :
3674 "e-m:o-p:32:32-i64:64-v128:64:128-n32-S64";
Rafael Espindolac418ae92014-01-03 19:22:05 +00003675 else
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003676 DescriptionString = BigEndian ?
3677 "E-m:e-p:32:32-i64:64-v128:64:128-n32-S64" :
3678 "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64";
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003679 }
3680
3681 // FIXME: Enumerated types are variable width in straight AAPCS.
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003682 }
3683
3684 void setABIAPCS() {
Rafael Espindolac418ae92014-01-03 19:22:05 +00003685 const llvm::Triple &T = getTriple();
3686
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003687 IsAAPCS = false;
3688
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003689 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003690
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003691 // size_t is unsigned int on FreeBSD.
Rafael Espindolac418ae92014-01-03 19:22:05 +00003692 if (T.getOS() == llvm::Triple::FreeBSD)
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003693 SizeType = UnsignedInt;
3694 else
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003695 SizeType = UnsignedLong;
3696
3697 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
3698 WCharType = SignedInt;
3699
3700 // Do not respect the alignment of bit-field types when laying out
3701 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
3702 UseBitFieldTypeAlignment = false;
3703
3704 /// gcc forces the alignment to 4 bytes, regardless of the type of the
3705 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
3706 /// gcc.
3707 ZeroLengthBitfieldBoundary = 32;
3708
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003709 if (IsThumb) {
3710 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3711 // so set preferred for small types to 32.
Rafael Espindolac418ae92014-01-03 19:22:05 +00003712 if (T.isOSBinFormatMachO())
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003713 DescriptionString = BigEndian ?
3714 "E-m:o-p:32:32-i1:8:32-i8:8:32-i16:16:32-f64:32:64"
3715 "-v64:32:64-v128:32:128-a:0:32-n32-S32" :
3716 "e-m:o-p:32:32-i1:8:32-i8:8:32-i16:16:32-f64:32:64"
3717 "-v64:32:64-v128:32:128-a:0:32-n32-S32";
Rafael Espindolac418ae92014-01-03 19:22:05 +00003718 else
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003719 DescriptionString = BigEndian ?
3720 "E-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-f64:32:64"
3721 "-v64:32:64-v128:32:128-a:0:32-n32-S32" :
3722 "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-f64:32:64"
3723 "-v64:32:64-v128:32:128-a:0:32-n32-S32";
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003724 } else {
Rafael Espindolac418ae92014-01-03 19:22:05 +00003725 if (T.isOSBinFormatMachO())
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003726 DescriptionString = BigEndian ?
3727 "E-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32" :
Rafael Espindolac418ae92014-01-03 19:22:05 +00003728 "e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32";
3729 else
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003730 DescriptionString = BigEndian ?
3731 "E-m:e-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32" :
Rafael Espindolac418ae92014-01-03 19:22:05 +00003732 "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 +00003733 }
3734
3735 // FIXME: Override "preferred align" for double and long long.
3736 }
3737
Chris Lattner17df24e2008-04-21 18:56:49 +00003738public:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003739 ARMTargetInfo(const llvm::Triple &Triple, bool IsBigEndian)
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003740 : TargetInfo(Triple), CPU("arm1136j-s"), FPMath(FP_Default),
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003741 IsAAPCS(true), HW_FP(0) {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003742 BigEndian = IsBigEndian;
3743
Joerg Sonnenberger84c7ca82013-11-30 00:38:16 +00003744 switch (getTriple().getOS()) {
3745 case llvm::Triple::NetBSD:
Joerg Sonnenberger7c7fcec2013-12-02 16:09:34 +00003746 PtrDiffType = SignedLong;
Joerg Sonnenberger84c7ca82013-11-30 00:38:16 +00003747 break;
3748 default:
Joerg Sonnenberger7c7fcec2013-12-02 16:09:34 +00003749 PtrDiffType = SignedInt;
Joerg Sonnenberger84c7ca82013-11-30 00:38:16 +00003750 break;
3751 }
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00003752
Chris Lattner1a8f3942010-04-23 16:29:58 +00003753 // {} in inline assembly are neon specifiers, not assembly variant
3754 // specifiers.
3755 NoAsmVariants = true;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003756
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003757 // FIXME: Should we just treat this as a feature?
Daniel Dunbarc454ecf2009-12-18 19:57:13 +00003758 IsThumb = getTriple().getArchName().startswith("thumb");
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003759
3760 setABI("aapcs-linux");
John McCall86353412010-08-21 22:46:04 +00003761
3762 // ARM targets default to using the ARM C++ ABI.
John McCall359b8852013-01-25 22:30:49 +00003763 TheCXXABI.set(TargetCXXABI::GenericARM);
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003764
3765 // ARM has atomics up to 8 bytes
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003766 MaxAtomicPromoteWidth = 64;
Rafael Espindola101d5b92013-05-13 20:09:47 +00003767 if (shouldUseInlineAtomic(getTriple()))
3768 MaxAtomicInlineWidth = 64;
James Molloya7139222012-03-12 09:14:10 +00003769
3770 // Do force alignment of members that follow zero length bitfields. If
3771 // the alignment of the zero-length bitfield is greater than the member
3772 // that follows it, `bar', `bar' will be aligned as the type of the
3773 // zero length bitfield.
3774 UseZeroLengthBitfieldAlignment = true;
Eli Friedmanb5366062008-05-20 14:21:01 +00003775 }
Alp Toker4925ba72014-06-07 23:30:42 +00003776 StringRef getABI() const override { return ABI; }
Craig Topper3164f332014-03-11 03:39:26 +00003777 bool setABI(const std::string &Name) override {
Daniel Dunbarb4091a92009-09-14 00:35:03 +00003778 ABI = Name;
3779
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00003780 // The defaults (above) are for AAPCS, check if we need to change them.
3781 //
3782 // FIXME: We need support for -meabi... we could just mangle it into the
3783 // name.
3784 if (Name == "apcs-gnu") {
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003785 setABIAPCS();
3786 return true;
3787 }
3788 if (Name == "aapcs" || Name == "aapcs-vfp" || Name == "aapcs-linux") {
3789 setABIAAPCS();
3790 return true;
3791 }
3792 return false;
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00003793 }
Daniel Dunbar893d4752009-12-19 04:15:38 +00003794
Craig Topper3164f332014-03-11 03:39:26 +00003795 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override {
Rafael Espindolad8da90b2014-01-02 13:57:18 +00003796 if (IsAAPCS)
3797 Features["aapcs"] = true;
3798 else
3799 Features["apcs"] = true;
3800
Silviu Barangae5690462013-10-21 10:59:33 +00003801 StringRef ArchName = getTriple().getArchName();
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003802 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
3803 Features["vfp2"] = true;
Renato Golineefb5772013-09-13 17:02:45 +00003804 else if (CPU == "cortex-a8" || CPU == "cortex-a9" ||
3805 CPU == "cortex-a9-mp") {
3806 Features["vfp3"] = true;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003807 Features["neon"] = true;
Silviu Barangae5690462013-10-21 10:59:33 +00003808 }
3809 else if (CPU == "cortex-a5") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00003810 Features["vfp4"] = true;
3811 Features["neon"] = true;
Ana Pazosdd6068d2013-12-06 22:43:17 +00003812 } else if (CPU == "swift" || CPU == "cortex-a7" ||
3813 CPU == "cortex-a12" || CPU == "cortex-a15" ||
3814 CPU == "krait") {
Silviu Barangae5690462013-10-21 10:59:33 +00003815 Features["vfp4"] = true;
3816 Features["neon"] = true;
3817 Features["hwdiv"] = true;
3818 Features["hwdiv-arm"] = true;
Tim Northovera2ee4332014-03-29 15:09:45 +00003819 } else if (CPU == "cyclone") {
3820 Features["v8fp"] = true;
3821 Features["neon"] = true;
3822 Features["hwdiv"] = true;
3823 Features["hwdiv-arm"] = true;
Bernard Ogdenda13af32013-10-24 18:32:51 +00003824 } else if (CPU == "cortex-a53" || CPU == "cortex-a57") {
3825 Features["fp-armv8"] = true;
3826 Features["neon"] = true;
3827 Features["hwdiv"] = true;
3828 Features["hwdiv-arm"] = true;
Bernard Ogden18b57012013-10-29 09:47:51 +00003829 Features["crc"] = true;
Tim Northover02e38602014-02-03 17:28:04 +00003830 Features["crypto"] = true;
Artyom Skrobove72a6f72014-01-29 09:43:07 +00003831 } else if (CPU == "cortex-r5" ||
Silviu Barangae5690462013-10-21 10:59:33 +00003832 // Enable the hwdiv extension for all v8a AArch32 cores by
3833 // default.
3834 ArchName == "armv8a" || ArchName == "armv8" ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003835 ArchName == "armebv8a" || ArchName == "armebv8" ||
3836 ArchName == "thumbv8a" || ArchName == "thumbv8" ||
3837 ArchName == "thumbebv8a" || ArchName == "thumbebv8") {
Silviu Barangae5690462013-10-21 10:59:33 +00003838 Features["hwdiv"] = true;
3839 Features["hwdiv-arm"] = true;
Artyom Skrobove72a6f72014-01-29 09:43:07 +00003840 } else if (CPU == "cortex-m3" || CPU == "cortex-m4") {
3841 Features["hwdiv"] = true;
Bob Wilson6fc8fb82012-09-29 23:52:52 +00003842 }
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003843 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003844
Craig Topper3164f332014-03-11 03:39:26 +00003845 bool handleTargetFeatures(std::vector<std::string> &Features,
3846 DiagnosticsEngine &Diags) override {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00003847 FPU = 0;
Bernard Ogden18b57012013-10-29 09:47:51 +00003848 CRC = 0;
Tim Northover02e38602014-02-03 17:28:04 +00003849 Crypto = 0;
Daniel Dunbar893d4752009-12-19 04:15:38 +00003850 SoftFloat = SoftFloatABI = false;
Silviu Barangaf9671dd2013-10-21 10:54:53 +00003851 HWDiv = 0;
Saleem Abdulrasool0f691c62014-09-17 14:50:23 +00003852
3853 for (const auto &Feature : Features) {
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003854 if (Feature == "+soft-float") {
Daniel Dunbar893d4752009-12-19 04:15:38 +00003855 SoftFloat = true;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003856 } else if (Feature == "+soft-float-abi") {
Daniel Dunbar893d4752009-12-19 04:15:38 +00003857 SoftFloatABI = true;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003858 } else if (Feature == "+vfp2") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00003859 FPU |= VFP2FPU;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003860 HW_FP = HW_FP_SP | HW_FP_DP;
3861 } else if (Feature == "+vfp3") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00003862 FPU |= VFP3FPU;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003863 HW_FP = HW_FP_SP | HW_FP_DP;
3864 } else if (Feature == "+vfp4") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00003865 FPU |= VFP4FPU;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003866 HW_FP = HW_FP_SP | HW_FP_DP | HW_FP_HP;
3867 } else if (Feature == "+fp-armv8") {
Bernard Ogdenda13af32013-10-24 18:32:51 +00003868 FPU |= FPARMV8;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003869 HW_FP = HW_FP_SP | HW_FP_DP | HW_FP_HP;
3870 } else if (Feature == "+neon") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00003871 FPU |= NeonFPU;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003872 HW_FP = HW_FP_SP | HW_FP_DP;
3873 } else if (Feature == "+hwdiv") {
Silviu Barangaf9671dd2013-10-21 10:54:53 +00003874 HWDiv |= HWDivThumb;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003875 } else if (Feature == "+hwdiv-arm") {
Silviu Barangaf9671dd2013-10-21 10:54:53 +00003876 HWDiv |= HWDivARM;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003877 } else if (Feature == "+crc") {
Bernard Ogden18b57012013-10-29 09:47:51 +00003878 CRC = 1;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003879 } else if (Feature == "+crypto") {
Tim Northover02e38602014-02-03 17:28:04 +00003880 Crypto = 1;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003881 } else if (Feature == "+fp-only-sp") {
3882 HW_FP &= ~HW_FP_DP;
3883 }
Daniel Dunbar893d4752009-12-19 04:15:38 +00003884 }
3885
Rafael Espindolaeb265472013-08-21 21:59:03 +00003886 if (!(FPU & NeonFPU) && FPMath == FP_Neon) {
3887 Diags.Report(diag::err_target_unsupported_fpmath) << "neon";
3888 return false;
3889 }
3890
3891 if (FPMath == FP_Neon)
3892 Features.push_back("+neonfp");
3893 else if (FPMath == FP_VFP)
3894 Features.push_back("-neonfp");
3895
Daniel Dunbar893d4752009-12-19 04:15:38 +00003896 // Remove front-end specific options which the backend handles differently.
Saleem Abdulrasool0f691c62014-09-17 14:50:23 +00003897 const StringRef FrontEndFeatures[] = { "+soft-float", "+soft-float-abi" };
3898 for (const auto &FEFeature : FrontEndFeatures) {
3899 auto Feature = std::find(Features.begin(), Features.end(), FEFeature);
3900 if (Feature != Features.end())
3901 Features.erase(Feature);
3902 }
3903
Rafael Espindolaeb265472013-08-21 21:59:03 +00003904 return true;
Daniel Dunbar893d4752009-12-19 04:15:38 +00003905 }
3906
Craig Topper3164f332014-03-11 03:39:26 +00003907 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003908 return llvm::StringSwitch<bool>(Feature)
3909 .Case("arm", true)
3910 .Case("softfloat", SoftFloat)
3911 .Case("thumb", IsThumb)
Amara Emerson8c3de542013-09-16 18:07:35 +00003912 .Case("neon", (FPU & NeonFPU) && !SoftFloat)
Silviu Barangaf9671dd2013-10-21 10:54:53 +00003913 .Case("hwdiv", HWDiv & HWDivThumb)
3914 .Case("hwdiv-arm", HWDiv & HWDivARM)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003915 .Default(false);
3916 }
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00003917 // FIXME: Should we actually have some table instead of these switches?
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003918 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003919 return llvm::StringSwitch<const char*>(Name)
3920 .Cases("arm8", "arm810", "4")
3921 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
3922 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
3923 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
3924 .Case("ep9312", "4T")
3925 .Cases("arm10tdmi", "arm1020t", "5T")
3926 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
3927 .Case("arm926ej-s", "5TEJ")
3928 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
3929 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003930 .Case("arm1136j-s", "6J")
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003931 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003932 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003933 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
Bob Wilsonb767d152014-01-15 21:43:40 +00003934 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "cortex-a9-mp", "7A")
Ana Pazosdd6068d2013-12-06 22:43:17 +00003935 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "krait", "7A")
Renato Golin1a04f222013-09-13 17:02:54 +00003936 .Cases("cortex-r4", "cortex-r5", "7R")
Bob Wilsond7cf1042012-09-29 23:52:50 +00003937 .Case("swift", "7S")
Tim Northovera2ee4332014-03-29 15:09:45 +00003938 .Case("cyclone", "8A")
Jim Grosbachbe83cb82014-06-26 17:24:16 +00003939 .Case("cortex-m3", "7M")
3940 .Case("cortex-m4", "7EM")
Bob Wilson87ba1d32011-03-21 21:55:25 +00003941 .Case("cortex-m0", "6M")
Bernard Ogden021d7da2013-10-24 18:32:36 +00003942 .Cases("cortex-a53", "cortex-a57", "8A")
Craig Topperf1186c52014-05-08 06:41:40 +00003943 .Default(nullptr);
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003944 }
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00003945 static const char *getCPUProfile(StringRef Name) {
3946 return llvm::StringSwitch<const char*>(Name)
Renato Golin1a04f222013-09-13 17:02:54 +00003947 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "A")
Ana Pazosdd6068d2013-12-06 22:43:17 +00003948 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "krait", "A")
Bernard Ogden021d7da2013-10-24 18:32:36 +00003949 .Cases("cortex-a53", "cortex-a57", "A")
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00003950 .Cases("cortex-m3", "cortex-m4", "cortex-m0", "M")
Renato Golin1a04f222013-09-13 17:02:54 +00003951 .Cases("cortex-r4", "cortex-r5", "R")
Anton Korobeynikov26b13882012-09-08 08:22:13 +00003952 .Default("");
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00003953 }
Craig Topper3164f332014-03-11 03:39:26 +00003954 bool setCPU(const std::string &Name) override {
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003955 if (!getCPUDefineSuffix(Name))
3956 return false;
3957
Tim Northovere8c37212014-07-09 09:24:43 +00003958 // Cortex M does not support 8 byte atomics, while general Thumb2 does.
3959 StringRef Profile = getCPUProfile(Name);
3960 if (Profile == "M" && MaxAtomicInlineWidth) {
3961 MaxAtomicPromoteWidth = 32;
3962 MaxAtomicInlineWidth = 32;
3963 }
3964
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003965 CPU = Name;
3966 return true;
3967 }
Craig Topper3164f332014-03-11 03:39:26 +00003968 bool setFPMath(StringRef Name) override;
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00003969 bool supportsThumb(StringRef ArchName, StringRef CPUArch,
3970 unsigned CPUArchVer) const {
3971 return CPUArchVer >= 7 || (CPUArch.find('T') != StringRef::npos) ||
3972 (CPUArch.find('M') != StringRef::npos);
3973 }
3974 bool supportsThumb2(StringRef ArchName, StringRef CPUArch,
3975 unsigned CPUArchVer) const {
3976 // We check both CPUArchVer and ArchName because when only triple is
3977 // specified, the default CPU is arm1136j-s.
3978 return ArchName.endswith("v6t2") || ArchName.endswith("v7") ||
3979 ArchName.endswith("v8") || CPUArch == "6T2" || CPUArchVer >= 7;
3980 }
Craig Topper3164f332014-03-11 03:39:26 +00003981 void getTargetDefines(const LangOptions &Opts,
3982 MacroBuilder &Builder) const override {
Chris Lattnerecd49032009-03-02 22:27:17 +00003983 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003984 Builder.defineMacro("__arm");
3985 Builder.defineMacro("__arm__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003986
Chris Lattnerecd49032009-03-02 22:27:17 +00003987 // Target properties.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003988 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003989
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003990 StringRef CPUArch = getCPUDefineSuffix(CPU);
Bernard Ogden58a05cf2013-10-24 18:32:44 +00003991 unsigned int CPUArchVer;
Saleem Abdulrasool820e9272014-09-17 14:50:19 +00003992 if (CPUArch.substr(0, 1).getAsInteger<unsigned int>(10, CPUArchVer))
Bernard Ogden58a05cf2013-10-24 18:32:44 +00003993 llvm_unreachable("Invalid char for architecture version number");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003994 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00003995
3996 // ACLE 6.4.1 ARM/Thumb instruction set architecture
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00003997 StringRef CPUProfile = getCPUProfile(CPU);
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00003998 StringRef ArchName = getTriple().getArchName();
3999
4000 // __ARM_ARCH is defined as an integer value indicating the current ARM ISA
4001 Builder.defineMacro("__ARM_ARCH", CPUArch.substr(0, 1));
James Molloy0ffb0932014-09-15 11:25:38 +00004002 if (CPUArch[0] >= '8') {
4003 Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN");
4004 Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING");
4005 }
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004006
4007 // __ARM_ARCH_ISA_ARM is defined to 1 if the core supports the ARM ISA. It
4008 // is not defined for the M-profile.
4009 // NOTE that the deffault profile is assumed to be 'A'
4010 if (CPUProfile.empty() || CPUProfile != "M")
4011 Builder.defineMacro("__ARM_ARCH_ISA_ARM", "1");
4012
4013 // __ARM_ARCH_ISA_THUMB is defined to 1 if the core supporst the original
4014 // Thumb ISA (including v6-M). It is set to 2 if the core supports the
4015 // Thumb-2 ISA as found in the v6T2 architecture and all v7 architecture.
4016 if (supportsThumb2(ArchName, CPUArch, CPUArchVer))
4017 Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "2");
4018 else if (supportsThumb(ArchName, CPUArch, CPUArchVer))
4019 Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "1");
4020
4021 // __ARM_32BIT_STATE is defined to 1 if code is being generated for a 32-bit
4022 // instruction set such as ARM or Thumb.
4023 Builder.defineMacro("__ARM_32BIT_STATE", "1");
4024
4025 // ACLE 6.4.2 Architectural Profile (A, R, M or pre-Cortex)
4026
4027 // __ARM_ARCH_PROFILE is defined as 'A', 'R', 'M' or 'S', or unset.
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004028 if (!CPUProfile.empty())
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004029 Builder.defineMacro("__ARM_ARCH_PROFILE", "'" + CPUProfile + "'");
Weiming Zhaofb5c21a2014-01-22 18:42:13 +00004030
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004031 // ACLE 6.5.1 Hardware Floating Point
4032 if (HW_FP)
4033 Builder.defineMacro("__ARM_FP", std::to_string(HW_FP));
4034
Yi Konga44c4d72014-06-27 21:25:42 +00004035 // ACLE predefines.
4036 Builder.defineMacro("__ARM_ACLE", "200");
4037
Mike Stump9d54bd72009-04-08 02:07:04 +00004038 // Subtarget options.
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00004039
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004040 // FIXME: It's more complicated than this and we don't really support
4041 // interworking.
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004042 // Windows on ARM does not "support" interworking
4043 if (5 <= CPUArchVer && CPUArchVer <= 8 && !getTriple().isOSWindows())
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004044 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004045
David Tweed8f676532012-10-25 13:33:01 +00004046 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
Tim Northovere77f78c2013-11-11 19:11:22 +00004047 // Embedded targets on Darwin follow AAPCS, but not EABI.
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004048 // Windows on ARM follows AAPCS VFP, but does not conform to EABI.
4049 if (!getTriple().isOSDarwin() && !getTriple().isOSWindows())
Daniel Dunbarf7124da2012-10-22 18:51:13 +00004050 Builder.defineMacro("__ARM_EABI__");
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004051 Builder.defineMacro("__ARM_PCS", "1");
4052
David Tweed8f676532012-10-25 13:33:01 +00004053 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp")
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004054 Builder.defineMacro("__ARM_PCS_VFP", "1");
4055 }
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004056
Daniel Dunbar893d4752009-12-19 04:15:38 +00004057 if (SoftFloat)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004058 Builder.defineMacro("__SOFTFP__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004059
4060 if (CPU == "xscale")
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004061 Builder.defineMacro("__XSCALE__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00004062
4063 if (IsThumb) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004064 Builder.defineMacro("__THUMBEL__");
4065 Builder.defineMacro("__thumb__");
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004066 if (supportsThumb2(ArchName, CPUArch, CPUArchVer))
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004067 Builder.defineMacro("__thumb2__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00004068 }
Silviu Barangaf9671dd2013-10-21 10:54:53 +00004069 if (((HWDiv & HWDivThumb) && IsThumb) || ((HWDiv & HWDivARM) && !IsThumb))
4070 Builder.defineMacro("__ARM_ARCH_EXT_IDIV__", "1");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00004071
4072 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004073 Builder.defineMacro("__APCS_32__");
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004074
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004075 if (FPUModeIsVFP((FPUMode) FPU)) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004076 Builder.defineMacro("__VFP_FP__");
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004077 if (FPU & VFP2FPU)
4078 Builder.defineMacro("__ARM_VFPV2__");
4079 if (FPU & VFP3FPU)
4080 Builder.defineMacro("__ARM_VFPV3__");
4081 if (FPU & VFP4FPU)
4082 Builder.defineMacro("__ARM_VFPV4__");
4083 }
Weiming Zhaofb5c21a2014-01-22 18:42:13 +00004084
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004085 // This only gets set when Neon instructions are actually available, unlike
4086 // the VFP define, hence the soft float and arch check. This is subtly
4087 // different from gcc, we follow the intent which was that it should be set
4088 // when Neon instructions are actually available.
Tim Northover5bb34ca2013-11-21 12:36:34 +00004089 if ((FPU & NeonFPU) && !SoftFloat && CPUArchVer >= 7) {
4090 Builder.defineMacro("__ARM_NEON");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004091 Builder.defineMacro("__ARM_NEON__");
Tim Northover5bb34ca2013-11-21 12:36:34 +00004092 }
Joey Gouly1e8637b2013-09-18 10:07:09 +00004093
Bradley Smith0f28f0c2014-01-20 10:52:00 +00004094 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
4095 Opts.ShortWChar ? "2" : "4");
4096
4097 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
4098 Opts.ShortEnums ? "1" : "4");
4099
Bernard Ogden18b57012013-10-29 09:47:51 +00004100 if (CRC)
Joey Gouly1e8637b2013-09-18 10:07:09 +00004101 Builder.defineMacro("__ARM_FEATURE_CRC32");
Weiming Zhao53a797c2013-09-30 22:51:32 +00004102
Tim Northover02e38602014-02-03 17:28:04 +00004103 if (Crypto)
4104 Builder.defineMacro("__ARM_FEATURE_CRYPTO");
4105
Bernard Ogden58a05cf2013-10-24 18:32:44 +00004106 if (CPUArchVer >= 6 && CPUArch != "6M") {
Weiming Zhao53a797c2013-09-30 22:51:32 +00004107 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
4108 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
4109 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
4110 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
4111 }
Chris Lattner17df24e2008-04-21 18:56:49 +00004112 }
Craig Topper3164f332014-03-11 03:39:26 +00004113 void getTargetBuiltins(const Builtin::Info *&Records,
4114 unsigned &NumRecords) const override {
Chris Lattner5cc15e02010-03-03 19:03:45 +00004115 Records = BuiltinInfo;
4116 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner17df24e2008-04-21 18:56:49 +00004117 }
Craig Topper3164f332014-03-11 03:39:26 +00004118 bool isCLZForZeroUndef() const override { return false; }
4119 BuiltinVaListKind getBuiltinVaListKind() const override {
Logan Chien57086ce2012-10-10 06:56:20 +00004120 return IsAAPCS ? AAPCSABIBuiltinVaList : TargetInfo::VoidPtrBuiltinVaList;
Chris Lattner17df24e2008-04-21 18:56:49 +00004121 }
Craig Topper3164f332014-03-11 03:39:26 +00004122 void getGCCRegNames(const char * const *&Names,
4123 unsigned &NumNames) const override;
4124 void getGCCRegAliases(const GCCRegAlias *&Aliases,
4125 unsigned &NumAliases) const override;
4126 bool validateAsmConstraint(const char *&Name,
4127 TargetInfo::ConstraintInfo &Info) const override {
Anders Carlsson58436352009-02-28 17:11:49 +00004128 switch (*Name) {
Eric Christopher9e491882012-08-16 23:50:41 +00004129 default: break;
Nate Begeman2908fa02008-04-22 05:03:19 +00004130 case 'l': // r0-r7
4131 case 'h': // r8-r15
4132 case 'w': // VFP Floating point register single precision
4133 case 'P': // VFP Floating point register double precision
Chris Lattnerd9725f72009-04-26 07:16:29 +00004134 Info.setAllowsRegister();
Nate Begeman2908fa02008-04-22 05:03:19 +00004135 return true;
Eric Christopherb081ba62011-07-29 21:20:35 +00004136 case 'Q': // A memory address that is a single base register.
4137 Info.setAllowsMemory();
4138 return true;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004139 case 'U': // a memory reference...
4140 switch (Name[1]) {
4141 case 'q': // ...ARMV4 ldrsb
4142 case 'v': // ...VFP load/store (reg+constant offset)
4143 case 'y': // ...iWMMXt load/store
Eric Christopherd1048542011-06-17 01:40:49 +00004144 case 't': // address valid for load/store opaque types wider
Eric Christopherfd081ca2012-11-14 22:08:59 +00004145 // than 128-bits
Eric Christopherd1048542011-06-17 01:40:49 +00004146 case 'n': // valid address for Neon doubleword vector load/store
4147 case 'm': // valid address for Neon element and structure load/store
4148 case 's': // valid address for non-offset loads/stores of quad-word
Eric Christopherfd081ca2012-11-14 22:08:59 +00004149 // values in four ARM registers
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004150 Info.setAllowsMemory();
4151 Name++;
4152 return true;
4153 }
Nate Begeman2908fa02008-04-22 05:03:19 +00004154 }
Chris Lattner17df24e2008-04-21 18:56:49 +00004155 return false;
4156 }
Craig Topper3164f332014-03-11 03:39:26 +00004157 std::string convertConstraint(const char *&Constraint) const override {
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004158 std::string R;
4159 switch (*Constraint) {
4160 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings5b7b11c2011-06-08 16:06:31 +00004161 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004162 Constraint++;
4163 break;
Eric Christopher7d237c12011-06-17 00:40:18 +00004164 case 'p': // 'p' should be translated to 'r' by default.
4165 R = std::string("r");
4166 break;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004167 default:
4168 return std::string(1, *Constraint);
4169 }
4170 return R;
4171 }
Akira Hatanaka987f1862014-08-22 06:05:21 +00004172 bool
Aaron Ballmane9c64792014-08-22 13:26:37 +00004173 validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size,
Akira Hatanaka987f1862014-08-22 06:05:21 +00004174 std::string &SuggestedModifier) const override {
Bill Wendling3c6591d2012-11-30 23:18:12 +00004175 bool isOutput = (Constraint[0] == '=');
Bill Wendling05175082012-11-30 23:46:56 +00004176 bool isInOut = (Constraint[0] == '+');
Bill Wendling3c6591d2012-11-30 23:18:12 +00004177
Bill Wendling9d1ee112012-10-25 23:28:48 +00004178 // Strip off constraint modifiers.
4179 while (Constraint[0] == '=' ||
4180 Constraint[0] == '+' ||
4181 Constraint[0] == '&')
4182 Constraint = Constraint.substr(1);
4183
4184 switch (Constraint[0]) {
4185 default: break;
4186 case 'r': {
4187 switch (Modifier) {
4188 default:
Tim Northover8f24b172013-12-08 15:24:55 +00004189 return (isInOut || isOutput || Size <= 64);
Bill Wendling9d1ee112012-10-25 23:28:48 +00004190 case 'q':
4191 // A register of size 32 cannot fit a vector type.
4192 return false;
4193 }
4194 }
4195 }
4196
4197 return true;
4198 }
Craig Topper3164f332014-03-11 03:39:26 +00004199 const char *getClobbers() const override {
Eli Friedmanf05b7722008-08-20 07:44:10 +00004200 // FIXME: Is this really right?
Chris Lattner17df24e2008-04-21 18:56:49 +00004201 return "";
4202 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00004203
Craig Topper3164f332014-03-11 03:39:26 +00004204 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Aaron Ballmane91c6be2012-10-02 14:26:08 +00004205 return (CC == CC_AAPCS || CC == CC_AAPCS_VFP) ? CCCR_OK : CCCR_Warning;
4206 }
Logan Chien5a5a96b2013-02-23 04:24:36 +00004207
Craig Topper3164f332014-03-11 03:39:26 +00004208 int getEHDataRegisterNumber(unsigned RegNo) const override {
Logan Chien5a5a96b2013-02-23 04:24:36 +00004209 if (RegNo == 0) return 0;
4210 if (RegNo == 1) return 1;
4211 return -1;
4212 }
Chris Lattner17df24e2008-04-21 18:56:49 +00004213};
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004214
Rafael Espindolaeb265472013-08-21 21:59:03 +00004215bool ARMTargetInfo::setFPMath(StringRef Name) {
4216 if (Name == "neon") {
4217 FPMath = FP_Neon;
4218 return true;
4219 } else if (Name == "vfp" || Name == "vfp2" || Name == "vfp3" ||
4220 Name == "vfp4") {
4221 FPMath = FP_VFP;
4222 return true;
4223 }
4224 return false;
4225}
4226
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004227const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbar9034aa32010-08-11 02:17:20 +00004228 // Integer registers
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004229 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00004230 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
4231
4232 // Float registers
4233 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
4234 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
4235 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00004236 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00004237
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00004238 // Double registers
4239 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
4240 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend2b2ad02010-10-28 01:05:37 +00004241 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
4242 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00004243
4244 // Quad registers
Dale Johannesend2b2ad02010-10-28 01:05:37 +00004245 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
4246 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004247};
4248
4249void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar256e1f32010-08-11 02:17:11 +00004250 unsigned &NumNames) const {
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004251 Names = GCCRegNames;
4252 NumNames = llvm::array_lengthof(GCCRegNames);
4253}
4254
4255const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004256 { { "a1" }, "r0" },
4257 { { "a2" }, "r1" },
4258 { { "a3" }, "r2" },
4259 { { "a4" }, "r3" },
4260 { { "v1" }, "r4" },
4261 { { "v2" }, "r5" },
4262 { { "v3" }, "r6" },
4263 { { "v4" }, "r7" },
4264 { { "v5" }, "r8" },
4265 { { "v6", "rfp" }, "r9" },
4266 { { "sl" }, "r10" },
4267 { { "fp" }, "r11" },
4268 { { "ip" }, "r12" },
Daniel Dunbar256e1f32010-08-11 02:17:11 +00004269 { { "r13" }, "sp" },
4270 { { "r14" }, "lr" },
4271 { { "r15" }, "pc" },
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00004272 // The S, D and Q registers overlap, but aren't really aliases; we
4273 // don't want to substitute one of these for a different-sized one.
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004274};
4275
4276void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4277 unsigned &NumAliases) const {
4278 Aliases = GCCRegAliases;
4279 NumAliases = llvm::array_lengthof(GCCRegAliases);
4280}
Chris Lattner5cc15e02010-03-03 19:03:45 +00004281
4282const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00004283#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +00004284#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00004285 ALL_LANGUAGES },
Tim Northovera2ee4332014-03-29 15:09:45 +00004286#include "clang/Basic/BuiltinsNEON.def"
Tim Northoverc322f832014-01-30 14:47:51 +00004287
4288#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Saleem Abdulrasool4bddd9d2014-07-02 17:41:27 +00004289#define LANGBUILTIN(ID, TYPE, ATTRS, LANG) { #ID, TYPE, ATTRS, 0, LANG },
Tim Northoverc322f832014-01-30 14:47:51 +00004290#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4291 ALL_LANGUAGES },
Chris Lattner5cc15e02010-03-03 19:03:45 +00004292#include "clang/Basic/BuiltinsARM.def"
4293};
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004294
4295class ARMleTargetInfo : public ARMTargetInfo {
4296public:
4297 ARMleTargetInfo(const llvm::Triple &Triple)
4298 : ARMTargetInfo(Triple, false) { }
4299 virtual void getTargetDefines(const LangOptions &Opts,
4300 MacroBuilder &Builder) const {
4301 Builder.defineMacro("__ARMEL__");
4302 ARMTargetInfo::getTargetDefines(Opts, Builder);
4303 }
4304};
4305
4306class ARMbeTargetInfo : public ARMTargetInfo {
4307public:
4308 ARMbeTargetInfo(const llvm::Triple &Triple)
4309 : ARMTargetInfo(Triple, true) { }
4310 virtual void getTargetDefines(const LangOptions &Opts,
4311 MacroBuilder &Builder) const {
4312 Builder.defineMacro("__ARMEB__");
4313 Builder.defineMacro("__ARM_BIG_ENDIAN");
4314 ARMTargetInfo::getTargetDefines(Opts, Builder);
4315 }
4316};
Chris Lattner17df24e2008-04-21 18:56:49 +00004317} // end anonymous namespace.
4318
Eli Friedmanf05b7722008-08-20 07:44:10 +00004319namespace {
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004320class WindowsARMTargetInfo : public WindowsTargetInfo<ARMleTargetInfo> {
4321 const llvm::Triple Triple;
4322public:
4323 WindowsARMTargetInfo(const llvm::Triple &Triple)
4324 : WindowsTargetInfo<ARMleTargetInfo>(Triple), Triple(Triple) {
4325 TLSSupported = false;
4326 WCharType = UnsignedShort;
4327 SizeType = UnsignedInt;
4328 UserLabelPrefix = "";
4329 }
4330 void getVisualStudioDefines(const LangOptions &Opts,
4331 MacroBuilder &Builder) const {
4332 WindowsTargetInfo<ARMleTargetInfo>::getVisualStudioDefines(Opts, Builder);
4333
4334 // FIXME: this is invalid for WindowsCE
4335 Builder.defineMacro("_M_ARM_NT", "1");
4336 Builder.defineMacro("_M_ARMT", "_M_ARM");
4337 Builder.defineMacro("_M_THUMB", "_M_ARM");
4338
4339 assert((Triple.getArch() == llvm::Triple::arm ||
4340 Triple.getArch() == llvm::Triple::thumb) &&
4341 "invalid architecture for Windows ARM target info");
4342 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
4343 Builder.defineMacro("_M_ARM", Triple.getArchName().substr(Offset));
4344
4345 // TODO map the complete set of values
4346 // 31: VFPv3 40: VFPv4
4347 Builder.defineMacro("_M_ARM_FP", "31");
4348 }
Saleem Abdulrasool521cec82014-06-29 23:05:41 +00004349 BuiltinVaListKind getBuiltinVaListKind() const override {
4350 return TargetInfo::CharPtrBuiltinVaList;
4351 }
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004352};
4353
4354// Windows ARM + Itanium C++ ABI Target
4355class ItaniumWindowsARMleTargetInfo : public WindowsARMTargetInfo {
4356public:
4357 ItaniumWindowsARMleTargetInfo(const llvm::Triple &Triple)
4358 : WindowsARMTargetInfo(Triple) {
4359 TheCXXABI.set(TargetCXXABI::GenericARM);
4360 }
4361
4362 void getTargetDefines(const LangOptions &Opts,
4363 MacroBuilder &Builder) const override {
4364 WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
4365
4366 if (Opts.MSVCCompat)
4367 WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder);
4368 }
4369};
4370
4371// Windows ARM, MS (C++) ABI
4372class MicrosoftARMleTargetInfo : public WindowsARMTargetInfo {
4373public:
4374 MicrosoftARMleTargetInfo(const llvm::Triple &Triple)
4375 : WindowsARMTargetInfo(Triple) {
4376 TheCXXABI.set(TargetCXXABI::Microsoft);
4377 }
4378
4379 void getTargetDefines(const LangOptions &Opts,
4380 MacroBuilder &Builder) const override {
4381 WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
4382 WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder);
4383 }
4384};
4385}
4386
4387
4388namespace {
Mike Stump11289f42009-09-09 15:08:12 +00004389class DarwinARMTargetInfo :
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004390 public DarwinTargetInfo<ARMleTargetInfo> {
Torok Edwinb2b37c62009-06-30 17:10:35 +00004391protected:
Craig Topper3164f332014-03-11 03:39:26 +00004392 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
4393 MacroBuilder &Builder) const override {
Douglas Gregor20b2ebd2011-03-23 00:50:03 +00004394 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmand88c8a12009-04-19 21:38:35 +00004395 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00004396
Torok Edwinb2b37c62009-06-30 17:10:35 +00004397public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00004398 DarwinARMTargetInfo(const llvm::Triple &Triple)
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004399 : DarwinTargetInfo<ARMleTargetInfo>(Triple) {
Daniel Dunbar3eeeccd2010-05-27 07:00:26 +00004400 HasAlignMac68kSupport = true;
Eli Friedman4b72fdd2011-10-14 20:59:01 +00004401 // iOS always has 64-bit atomic instructions.
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004402 // FIXME: This should be based off of the target features in ARMleTargetInfo.
Eli Friedman4b72fdd2011-10-14 20:59:01 +00004403 MaxAtomicInlineWidth = 64;
John McCall359b8852013-01-25 22:30:49 +00004404
4405 // Darwin on iOS uses a variant of the ARM C++ ABI.
4406 TheCXXABI.set(TargetCXXABI::iOS);
Daniel Dunbar3eeeccd2010-05-27 07:00:26 +00004407 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00004408};
4409} // end anonymous namespace.
4410
Tony Linthicum76329bf2011-12-12 21:14:55 +00004411
4412namespace {
Tim Northover573cbee2014-05-24 12:52:07 +00004413class AArch64TargetInfo : public TargetInfo {
James Molloy5e73df52014-04-16 15:06:20 +00004414 virtual void setDescriptionString() = 0;
Tim Northovera2ee4332014-03-29 15:09:45 +00004415 static const TargetInfo::GCCRegAlias GCCRegAliases[];
4416 static const char *const GCCRegNames[];
4417
James Molloy75f5f9e2014-04-16 15:33:48 +00004418 enum FPUModeEnum {
4419 FPUMode,
4420 NeonMode
4421 };
4422
4423 unsigned FPU;
Bradley Smith418c5932014-05-02 15:17:51 +00004424 unsigned CRC;
James Molloy75f5f9e2014-04-16 15:33:48 +00004425 unsigned Crypto;
4426
Tim Northovera2ee4332014-03-29 15:09:45 +00004427 static const Builtin::Info BuiltinInfo[];
4428
4429 std::string ABI;
4430
4431public:
Tim Northover573cbee2014-05-24 12:52:07 +00004432 AArch64TargetInfo(const llvm::Triple &Triple)
Tim Northovera2ee4332014-03-29 15:09:45 +00004433 : TargetInfo(Triple), ABI("aapcs") {
Tim Northover25e8a672014-05-24 12:51:25 +00004434
4435 if (getTriple().getOS() == llvm::Triple::NetBSD) {
4436 WCharType = SignedInt;
4437
4438 // NetBSD apparently prefers consistency across ARM targets to consistency
4439 // across 64-bit targets.
4440 Int64Type = SignedLongLong;
4441 IntMaxType = SignedLongLong;
Tim Northover25e8a672014-05-24 12:51:25 +00004442 } else {
4443 WCharType = UnsignedInt;
4444 Int64Type = SignedLong;
4445 IntMaxType = SignedLong;
Tim Northover25e8a672014-05-24 12:51:25 +00004446 }
4447
Tim Northovera2ee4332014-03-29 15:09:45 +00004448 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Tim Northovera2ee4332014-03-29 15:09:45 +00004449 MaxVectorAlign = 128;
4450 RegParmMax = 8;
4451 MaxAtomicInlineWidth = 128;
4452 MaxAtomicPromoteWidth = 128;
4453
4454 LongDoubleWidth = LongDoubleAlign = 128;
4455 LongDoubleFormat = &llvm::APFloat::IEEEquad;
4456
Tim Northovera2ee4332014-03-29 15:09:45 +00004457 // {} in inline assembly are neon specifiers, not assembly variant
4458 // specifiers.
4459 NoAsmVariants = true;
4460
Tim Northover573cbee2014-05-24 12:52:07 +00004461 // AArch64 targets default to using the ARM C++ ABI.
Tim Northovera2ee4332014-03-29 15:09:45 +00004462 TheCXXABI.set(TargetCXXABI::GenericAArch64);
4463 }
4464
Alp Toker4925ba72014-06-07 23:30:42 +00004465 StringRef getABI() const override { return ABI; }
Tim Northovera2ee4332014-03-29 15:09:45 +00004466 virtual bool setABI(const std::string &Name) {
4467 if (Name != "aapcs" && Name != "darwinpcs")
4468 return false;
4469
4470 ABI = Name;
4471 return true;
4472 }
4473
4474 virtual bool setCPU(const std::string &Name) {
4475 bool CPUKnown = llvm::StringSwitch<bool>(Name)
James Molloy5e73df52014-04-16 15:06:20 +00004476 .Case("generic", true)
James Molloyec78aa42014-04-17 12:51:28 +00004477 .Cases("cortex-a53", "cortex-a57", true)
Tim Northovera2ee4332014-03-29 15:09:45 +00004478 .Case("cyclone", true)
4479 .Default(false);
4480 return CPUKnown;
4481 }
4482
4483 virtual void getTargetDefines(const LangOptions &Opts,
4484 MacroBuilder &Builder) const {
4485 // Target identification.
Tim Northovera2ee4332014-03-29 15:09:45 +00004486 Builder.defineMacro("__aarch64__");
Tim Northovera2ee4332014-03-29 15:09:45 +00004487
4488 // Target properties.
4489 Builder.defineMacro("_LP64");
4490 Builder.defineMacro("__LP64__");
Tim Northovera2ee4332014-03-29 15:09:45 +00004491
4492 // ACLE predefines. Many can only have one possible value on v8 AArch64.
4493 Builder.defineMacro("__ARM_ACLE", "200");
4494 Builder.defineMacro("__ARM_ARCH", "8");
4495 Builder.defineMacro("__ARM_ARCH_PROFILE", "'A'");
4496
4497 Builder.defineMacro("__ARM_64BIT_STATE");
4498 Builder.defineMacro("__ARM_PCS_AAPCS64");
4499 Builder.defineMacro("__ARM_ARCH_ISA_A64");
4500
4501 Builder.defineMacro("__ARM_FEATURE_UNALIGNED");
4502 Builder.defineMacro("__ARM_FEATURE_CLZ");
4503 Builder.defineMacro("__ARM_FEATURE_FMA");
4504 Builder.defineMacro("__ARM_FEATURE_DIV");
James Molloy0ffb0932014-09-15 11:25:38 +00004505 Builder.defineMacro("__ARM_FEATURE_IDIV"); // As specified in ACLE
4506 Builder.defineMacro("__ARM_FEATURE_DIV"); // For backwards compatibility
4507 Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN");
4508 Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING");
Tim Northovera2ee4332014-03-29 15:09:45 +00004509
4510 Builder.defineMacro("__ARM_ALIGN_MAX_STACK_PWR", "4");
4511
4512 // 0xe implies support for half, single and double precision operations.
4513 Builder.defineMacro("__ARM_FP", "0xe");
4514
4515 // PCS specifies this for SysV variants, which is all we support. Other ABIs
4516 // may choose __ARM_FP16_FORMAT_ALTERNATIVE.
4517 Builder.defineMacro("__ARM_FP16_FORMAT_IEEE");
4518
4519 if (Opts.FastMath || Opts.FiniteMathOnly)
4520 Builder.defineMacro("__ARM_FP_FAST");
4521
4522 if ((Opts.C99 || Opts.C11) && !Opts.Freestanding)
4523 Builder.defineMacro("__ARM_FP_FENV_ROUNDING");
4524
4525 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T", Opts.ShortWChar ? "2" : "4");
4526
4527 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
4528 Opts.ShortEnums ? "1" : "4");
4529
James Molloy75f5f9e2014-04-16 15:33:48 +00004530 if (FPU == NeonMode) {
4531 Builder.defineMacro("__ARM_NEON");
4532 // 64-bit NEON supports half, single and double precision operations.
Bradley Smith9a6b2952014-05-02 15:18:38 +00004533 Builder.defineMacro("__ARM_NEON_FP", "0xe");
James Molloy75f5f9e2014-04-16 15:33:48 +00004534 }
Tim Northovera2ee4332014-03-29 15:09:45 +00004535
Bradley Smith418c5932014-05-02 15:17:51 +00004536 if (CRC)
4537 Builder.defineMacro("__ARM_FEATURE_CRC32");
4538
James Molloy75f5f9e2014-04-16 15:33:48 +00004539 if (Crypto)
4540 Builder.defineMacro("__ARM_FEATURE_CRYPTO");
Tim Northovera2ee4332014-03-29 15:09:45 +00004541 }
4542
4543 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4544 unsigned &NumRecords) const {
4545 Records = BuiltinInfo;
Tim Northover573cbee2014-05-24 12:52:07 +00004546 NumRecords = clang::AArch64::LastTSBuiltin - Builtin::FirstTSBuiltin;
Tim Northovera2ee4332014-03-29 15:09:45 +00004547 }
4548
4549 virtual bool hasFeature(StringRef Feature) const {
James Molloy75f5f9e2014-04-16 15:33:48 +00004550 return Feature == "aarch64" ||
4551 Feature == "arm64" ||
4552 (Feature == "neon" && FPU == NeonMode);
Tim Northovera2ee4332014-03-29 15:09:45 +00004553 }
4554
James Molloy5e73df52014-04-16 15:06:20 +00004555 bool handleTargetFeatures(std::vector<std::string> &Features,
4556 DiagnosticsEngine &Diags) override {
James Molloy75f5f9e2014-04-16 15:33:48 +00004557 FPU = FPUMode;
Bradley Smith418c5932014-05-02 15:17:51 +00004558 CRC = 0;
James Molloy75f5f9e2014-04-16 15:33:48 +00004559 Crypto = 0;
4560 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
4561 if (Features[i] == "+neon")
4562 FPU = NeonMode;
Bradley Smith418c5932014-05-02 15:17:51 +00004563 if (Features[i] == "+crc")
4564 CRC = 1;
James Molloy75f5f9e2014-04-16 15:33:48 +00004565 if (Features[i] == "+crypto")
4566 Crypto = 1;
4567 }
4568
James Molloy5e73df52014-04-16 15:06:20 +00004569 setDescriptionString();
4570
4571 return true;
4572 }
4573
Tim Northovera2ee4332014-03-29 15:09:45 +00004574 virtual bool isCLZForZeroUndef() const { return false; }
4575
4576 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4577 return TargetInfo::AArch64ABIBuiltinVaList;
4578 }
4579
4580 virtual void getGCCRegNames(const char *const *&Names,
4581 unsigned &NumNames) const;
4582 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4583 unsigned &NumAliases) const;
4584
4585 virtual bool validateAsmConstraint(const char *&Name,
4586 TargetInfo::ConstraintInfo &Info) const {
4587 switch (*Name) {
4588 default:
4589 return false;
4590 case 'w': // Floating point and SIMD registers (V0-V31)
4591 Info.setAllowsRegister();
4592 return true;
James Molloy8bdd24b2014-04-23 10:26:19 +00004593 case 'I': // Constant that can be used with an ADD instruction
4594 case 'J': // Constant that can be used with a SUB instruction
4595 case 'K': // Constant that can be used with a 32-bit logical instruction
4596 case 'L': // Constant that can be used with a 64-bit logical instruction
4597 case 'M': // Constant that can be used as a 32-bit MOV immediate
4598 case 'N': // Constant that can be used as a 64-bit MOV immediate
4599 case 'Y': // Floating point constant zero
4600 case 'Z': // Integer constant zero
4601 return true;
4602 case 'Q': // A memory reference with base register and no offset
4603 Info.setAllowsMemory();
4604 return true;
4605 case 'S': // A symbolic address
4606 Info.setAllowsRegister();
4607 return true;
4608 case 'U':
4609 // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes, whatever they may be
4610 // Utf: A memory address suitable for ldp/stp in TF mode, whatever it may be
4611 // Usa: An absolute symbolic address
4612 // Ush: The high part (bits 32:12) of a pc-relative symbolic address
4613 llvm_unreachable("FIXME: Unimplemented support for bizarre constraints");
Tim Northovera2ee4332014-03-29 15:09:45 +00004614 case 'z': // Zero register, wzr or xzr
4615 Info.setAllowsRegister();
4616 return true;
4617 case 'x': // Floating point and SIMD registers (V0-V15)
4618 Info.setAllowsRegister();
4619 return true;
Tim Northovera2ee4332014-03-29 15:09:45 +00004620 }
4621 return false;
4622 }
4623
Akira Hatanaka987f1862014-08-22 06:05:21 +00004624 bool
Aaron Ballmane9c64792014-08-22 13:26:37 +00004625 validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size,
Akira Hatanaka987f1862014-08-22 06:05:21 +00004626 std::string &SuggestedModifier) const override {
James Molloy8a157bf2014-07-25 10:19:47 +00004627 // Strip off constraint modifiers.
4628 while (Constraint[0] == '=' || Constraint[0] == '+' || Constraint[0] == '&')
4629 Constraint = Constraint.substr(1);
4630
4631 switch (Constraint[0]) {
4632 default:
4633 return true;
4634 case 'z':
4635 case 'r': {
4636 switch (Modifier) {
4637 case 'x':
4638 case 'w':
4639 // For now assume that the person knows what they're
4640 // doing with the modifier.
4641 return true;
4642 default:
4643 // By default an 'r' constraint will be in the 'x'
4644 // registers.
Akira Hatanaka987f1862014-08-22 06:05:21 +00004645 if (Size == 64)
4646 return true;
4647
4648 SuggestedModifier = "w";
4649 return false;
James Molloy8a157bf2014-07-25 10:19:47 +00004650 }
4651 }
4652 }
4653 }
4654
Tim Northovera2ee4332014-03-29 15:09:45 +00004655 virtual const char *getClobbers() const { return ""; }
4656
4657 int getEHDataRegisterNumber(unsigned RegNo) const {
4658 if (RegNo == 0)
4659 return 0;
4660 if (RegNo == 1)
4661 return 1;
4662 return -1;
4663 }
4664};
4665
Tim Northover573cbee2014-05-24 12:52:07 +00004666const char *const AArch64TargetInfo::GCCRegNames[] = {
Tim Northovera2ee4332014-03-29 15:09:45 +00004667 // 32-bit Integer registers
4668 "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7", "w8", "w9", "w10",
4669 "w11", "w12", "w13", "w14", "w15", "w16", "w17", "w18", "w19", "w20", "w21",
4670 "w22", "w23", "w24", "w25", "w26", "w27", "w28", "w29", "w30", "wsp",
4671
4672 // 64-bit Integer registers
4673 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9", "x10",
4674 "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "x19", "x20", "x21",
4675 "x22", "x23", "x24", "x25", "x26", "x27", "x28", "fp", "lr", "sp",
4676
4677 // 32-bit floating point regsisters
4678 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10",
4679 "s11", "s12", "s13", "s14", "s15", "s16", "s17", "s18", "s19", "s20", "s21",
4680 "s22", "s23", "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
4681
4682 // 64-bit floating point regsisters
4683 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "d10",
4684 "d11", "d12", "d13", "d14", "d15", "d16", "d17", "d18", "d19", "d20", "d21",
4685 "d22", "d23", "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
4686
4687 // Vector registers
4688 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9", "v10",
4689 "v11", "v12", "v13", "v14", "v15", "v16", "v17", "v18", "v19", "v20", "v21",
4690 "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31"
4691};
4692
Tim Northover573cbee2014-05-24 12:52:07 +00004693void AArch64TargetInfo::getGCCRegNames(const char *const *&Names,
Tim Northovera2ee4332014-03-29 15:09:45 +00004694 unsigned &NumNames) const {
4695 Names = GCCRegNames;
4696 NumNames = llvm::array_lengthof(GCCRegNames);
4697}
4698
Tim Northover573cbee2014-05-24 12:52:07 +00004699const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = {
Tim Northovera2ee4332014-03-29 15:09:45 +00004700 { { "w31" }, "wsp" },
4701 { { "x29" }, "fp" },
4702 { { "x30" }, "lr" },
4703 { { "x31" }, "sp" },
4704 // The S/D/Q and W/X registers overlap, but aren't really aliases; we
4705 // don't want to substitute one of these for a different-sized one.
4706};
4707
Tim Northover573cbee2014-05-24 12:52:07 +00004708void AArch64TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Tim Northovera2ee4332014-03-29 15:09:45 +00004709 unsigned &NumAliases) const {
4710 Aliases = GCCRegAliases;
4711 NumAliases = llvm::array_lengthof(GCCRegAliases);
4712}
4713
Tim Northover573cbee2014-05-24 12:52:07 +00004714const Builtin::Info AArch64TargetInfo::BuiltinInfo[] = {
Tim Northovera2ee4332014-03-29 15:09:45 +00004715#define BUILTIN(ID, TYPE, ATTRS) \
4716 { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4717#include "clang/Basic/BuiltinsNEON.def"
4718
4719#define BUILTIN(ID, TYPE, ATTRS) \
4720 { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Tim Northover573cbee2014-05-24 12:52:07 +00004721#include "clang/Basic/BuiltinsAArch64.def"
Tim Northovera2ee4332014-03-29 15:09:45 +00004722};
James Molloy5e73df52014-04-16 15:06:20 +00004723
Tim Northover573cbee2014-05-24 12:52:07 +00004724class AArch64leTargetInfo : public AArch64TargetInfo {
James Molloy5e73df52014-04-16 15:06:20 +00004725 void setDescriptionString() override {
4726 if (getTriple().isOSBinFormatMachO())
4727 DescriptionString = "e-m:o-i64:64-i128:128-n32:64-S128";
4728 else
4729 DescriptionString = "e-m:e-i64:64-i128:128-n32:64-S128";
4730 }
4731
4732public:
Tim Northover573cbee2014-05-24 12:52:07 +00004733 AArch64leTargetInfo(const llvm::Triple &Triple)
4734 : AArch64TargetInfo(Triple) {
James Molloy5e73df52014-04-16 15:06:20 +00004735 BigEndian = false;
4736 }
4737 void getTargetDefines(const LangOptions &Opts,
4738 MacroBuilder &Builder) const override {
4739 Builder.defineMacro("__AARCH64EL__");
Tim Northover573cbee2014-05-24 12:52:07 +00004740 AArch64TargetInfo::getTargetDefines(Opts, Builder);
James Molloy5e73df52014-04-16 15:06:20 +00004741 }
4742};
4743
Tim Northover573cbee2014-05-24 12:52:07 +00004744class AArch64beTargetInfo : public AArch64TargetInfo {
James Molloy5e73df52014-04-16 15:06:20 +00004745 void setDescriptionString() override {
4746 assert(!getTriple().isOSBinFormatMachO());
4747 DescriptionString = "E-m:e-i64:64-i128:128-n32:64-S128";
4748 }
4749
4750public:
Tim Northover573cbee2014-05-24 12:52:07 +00004751 AArch64beTargetInfo(const llvm::Triple &Triple)
4752 : AArch64TargetInfo(Triple) { }
James Molloy5e73df52014-04-16 15:06:20 +00004753 void getTargetDefines(const LangOptions &Opts,
4754 MacroBuilder &Builder) const override {
4755 Builder.defineMacro("__AARCH64EB__");
4756 Builder.defineMacro("__AARCH_BIG_ENDIAN");
4757 Builder.defineMacro("__ARM_BIG_ENDIAN");
Tim Northover573cbee2014-05-24 12:52:07 +00004758 AArch64TargetInfo::getTargetDefines(Opts, Builder);
James Molloy5e73df52014-04-16 15:06:20 +00004759 }
4760};
Tim Northovera2ee4332014-03-29 15:09:45 +00004761} // end anonymous namespace.
4762
4763namespace {
Tim Northover573cbee2014-05-24 12:52:07 +00004764class DarwinAArch64TargetInfo : public DarwinTargetInfo<AArch64leTargetInfo> {
James Molloy5e73df52014-04-16 15:06:20 +00004765protected:
4766 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
4767 MacroBuilder &Builder) const override {
4768 Builder.defineMacro("__AARCH64_SIMD__");
4769 Builder.defineMacro("__ARM64_ARCH_8__");
4770 Builder.defineMacro("__ARM_NEON__");
4771 Builder.defineMacro("__LITTLE_ENDIAN__");
4772 Builder.defineMacro("__REGISTER_PREFIX__", "");
4773 Builder.defineMacro("__arm64", "1");
4774 Builder.defineMacro("__arm64__", "1");
4775
4776 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
4777 }
4778
Tim Northovera2ee4332014-03-29 15:09:45 +00004779public:
Tim Northover573cbee2014-05-24 12:52:07 +00004780 DarwinAArch64TargetInfo(const llvm::Triple &Triple)
4781 : DarwinTargetInfo<AArch64leTargetInfo>(Triple) {
Tim Northovera2ee4332014-03-29 15:09:45 +00004782 Int64Type = SignedLongLong;
4783 WCharType = SignedInt;
4784 UseSignedCharForObjCBool = false;
4785
4786 LongDoubleWidth = LongDoubleAlign = 64;
4787 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
4788
4789 TheCXXABI.set(TargetCXXABI::iOS64);
4790 }
4791
4792 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4793 return TargetInfo::CharPtrBuiltinVaList;
4794 }
4795};
4796} // end anonymous namespace
4797
4798namespace {
Tony Linthicum76329bf2011-12-12 21:14:55 +00004799// Hexagon abstract base class
4800class HexagonTargetInfo : public TargetInfo {
4801 static const Builtin::Info BuiltinInfo[];
4802 static const char * const GCCRegNames[];
4803 static const TargetInfo::GCCRegAlias GCCRegAliases[];
4804 std::string CPU;
4805public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00004806 HexagonTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00004807 BigEndian = false;
Rafael Espindolac418ae92014-01-03 19:22:05 +00004808 DescriptionString = "e-m:e-p:32:32-i1:32-i64:64-a:0-n32";
Tony Linthicum76329bf2011-12-12 21:14:55 +00004809
4810 // {} in inline assembly are packet specifiers, not assembly variant
4811 // specifiers.
4812 NoAsmVariants = true;
4813 }
4814
Craig Topper3164f332014-03-11 03:39:26 +00004815 void getTargetBuiltins(const Builtin::Info *&Records,
4816 unsigned &NumRecords) const override {
Tony Linthicum76329bf2011-12-12 21:14:55 +00004817 Records = BuiltinInfo;
4818 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
4819 }
4820
Craig Topper3164f332014-03-11 03:39:26 +00004821 bool validateAsmConstraint(const char *&Name,
4822 TargetInfo::ConstraintInfo &Info) const override {
Tony Linthicum76329bf2011-12-12 21:14:55 +00004823 return true;
4824 }
4825
Craig Topper3164f332014-03-11 03:39:26 +00004826 void getTargetDefines(const LangOptions &Opts,
4827 MacroBuilder &Builder) const override;
Tony Linthicum76329bf2011-12-12 21:14:55 +00004828
Craig Topper3164f332014-03-11 03:39:26 +00004829 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00004830 return Feature == "hexagon";
4831 }
Craig Topper3164f332014-03-11 03:39:26 +00004832
4833 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00004834 return TargetInfo::CharPtrBuiltinVaList;
Tony Linthicum76329bf2011-12-12 21:14:55 +00004835 }
Craig Topper3164f332014-03-11 03:39:26 +00004836 void getGCCRegNames(const char * const *&Names,
4837 unsigned &NumNames) const override;
4838 void getGCCRegAliases(const GCCRegAlias *&Aliases,
4839 unsigned &NumAliases) const override;
4840 const char *getClobbers() const override {
Tony Linthicum76329bf2011-12-12 21:14:55 +00004841 return "";
4842 }
Sebastian Pop86500282012-01-13 20:37:10 +00004843
4844 static const char *getHexagonCPUSuffix(StringRef Name) {
4845 return llvm::StringSwitch<const char*>(Name)
Sebastian Pop86500282012-01-13 20:37:10 +00004846 .Case("hexagonv4", "4")
Sirish Pande11ebc4e2012-05-10 20:19:54 +00004847 .Case("hexagonv5", "5")
Craig Topperf1186c52014-05-08 06:41:40 +00004848 .Default(nullptr);
Sebastian Pop86500282012-01-13 20:37:10 +00004849 }
4850
Craig Topper3164f332014-03-11 03:39:26 +00004851 bool setCPU(const std::string &Name) override {
Sebastian Pop86500282012-01-13 20:37:10 +00004852 if (!getHexagonCPUSuffix(Name))
4853 return false;
4854
Tony Linthicum76329bf2011-12-12 21:14:55 +00004855 CPU = Name;
4856 return true;
4857 }
4858};
4859
4860void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
4861 MacroBuilder &Builder) const {
4862 Builder.defineMacro("qdsp6");
4863 Builder.defineMacro("__qdsp6", "1");
4864 Builder.defineMacro("__qdsp6__", "1");
4865
4866 Builder.defineMacro("hexagon");
4867 Builder.defineMacro("__hexagon", "1");
4868 Builder.defineMacro("__hexagon__", "1");
4869
4870 if(CPU == "hexagonv1") {
4871 Builder.defineMacro("__HEXAGON_V1__");
4872 Builder.defineMacro("__HEXAGON_ARCH__", "1");
4873 if(Opts.HexagonQdsp6Compat) {
4874 Builder.defineMacro("__QDSP6_V1__");
4875 Builder.defineMacro("__QDSP6_ARCH__", "1");
4876 }
4877 }
4878 else if(CPU == "hexagonv2") {
4879 Builder.defineMacro("__HEXAGON_V2__");
4880 Builder.defineMacro("__HEXAGON_ARCH__", "2");
4881 if(Opts.HexagonQdsp6Compat) {
4882 Builder.defineMacro("__QDSP6_V2__");
4883 Builder.defineMacro("__QDSP6_ARCH__", "2");
4884 }
4885 }
4886 else if(CPU == "hexagonv3") {
4887 Builder.defineMacro("__HEXAGON_V3__");
4888 Builder.defineMacro("__HEXAGON_ARCH__", "3");
4889 if(Opts.HexagonQdsp6Compat) {
4890 Builder.defineMacro("__QDSP6_V3__");
4891 Builder.defineMacro("__QDSP6_ARCH__", "3");
4892 }
4893 }
4894 else if(CPU == "hexagonv4") {
4895 Builder.defineMacro("__HEXAGON_V4__");
4896 Builder.defineMacro("__HEXAGON_ARCH__", "4");
4897 if(Opts.HexagonQdsp6Compat) {
4898 Builder.defineMacro("__QDSP6_V4__");
4899 Builder.defineMacro("__QDSP6_ARCH__", "4");
4900 }
4901 }
Sirish Pande11ebc4e2012-05-10 20:19:54 +00004902 else if(CPU == "hexagonv5") {
4903 Builder.defineMacro("__HEXAGON_V5__");
4904 Builder.defineMacro("__HEXAGON_ARCH__", "5");
4905 if(Opts.HexagonQdsp6Compat) {
4906 Builder.defineMacro("__QDSP6_V5__");
4907 Builder.defineMacro("__QDSP6_ARCH__", "5");
4908 }
4909 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00004910}
4911
4912const char * const HexagonTargetInfo::GCCRegNames[] = {
4913 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4914 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4915 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
4916 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
4917 "p0", "p1", "p2", "p3",
4918 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
4919};
4920
4921void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
4922 unsigned &NumNames) const {
4923 Names = GCCRegNames;
4924 NumNames = llvm::array_lengthof(GCCRegNames);
4925}
4926
4927
4928const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
4929 { { "sp" }, "r29" },
4930 { { "fp" }, "r30" },
4931 { { "lr" }, "r31" },
4932 };
4933
4934void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4935 unsigned &NumAliases) const {
4936 Aliases = GCCRegAliases;
4937 NumAliases = llvm::array_lengthof(GCCRegAliases);
4938}
4939
4940
4941const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
4942#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4943#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4944 ALL_LANGUAGES },
4945#include "clang/Basic/BuiltinsHexagon.def"
4946};
4947}
4948
4949
Chris Lattner5ba61f02006-10-14 07:39:34 +00004950namespace {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00004951// Shared base class for SPARC v8 (32-bit) and SPARC v9 (64-bit).
4952class SparcTargetInfo : public TargetInfo {
Chris Lattner9b415d62009-01-27 01:58:38 +00004953 static const TargetInfo::GCCRegAlias GCCRegAliases[];
4954 static const char * const GCCRegNames[];
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00004955 bool SoftFloat;
Gabor Greif49991682008-02-21 16:29:08 +00004956public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00004957 SparcTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {}
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00004958
Craig Topper3164f332014-03-11 03:39:26 +00004959 bool handleTargetFeatures(std::vector<std::string> &Features,
4960 DiagnosticsEngine &Diags) override {
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00004961 SoftFloat = false;
4962 for (unsigned i = 0, e = Features.size(); i != e; ++i)
4963 if (Features[i] == "+soft-float")
4964 SoftFloat = true;
Rafael Espindolaeb265472013-08-21 21:59:03 +00004965 return true;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00004966 }
Craig Topper3164f332014-03-11 03:39:26 +00004967 void getTargetDefines(const LangOptions &Opts,
4968 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004969 DefineStd(Builder, "sparc", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004970 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00004971
4972 if (SoftFloat)
4973 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif49991682008-02-21 16:29:08 +00004974 }
Craig Topper3164f332014-03-11 03:39:26 +00004975
4976 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00004977 return llvm::StringSwitch<bool>(Feature)
4978 .Case("softfloat", SoftFloat)
4979 .Case("sparc", true)
4980 .Default(false);
4981 }
Craig Topper3164f332014-03-11 03:39:26 +00004982
4983 void getTargetBuiltins(const Builtin::Info *&Records,
4984 unsigned &NumRecords) const override {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00004985 // FIXME: Implement!
Gabor Greif49991682008-02-21 16:29:08 +00004986 }
Craig Topper3164f332014-03-11 03:39:26 +00004987 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00004988 return TargetInfo::VoidPtrBuiltinVaList;
Gabor Greif49991682008-02-21 16:29:08 +00004989 }
Craig Topper3164f332014-03-11 03:39:26 +00004990 void getGCCRegNames(const char * const *&Names,
4991 unsigned &NumNames) const override;
4992 void getGCCRegAliases(const GCCRegAlias *&Aliases,
4993 unsigned &NumAliases) const override;
4994 bool validateAsmConstraint(const char *&Name,
4995 TargetInfo::ConstraintInfo &info) const override {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00004996 // FIXME: Implement!
4997 return false;
Gabor Greif49991682008-02-21 16:29:08 +00004998 }
Craig Topper3164f332014-03-11 03:39:26 +00004999 const char *getClobbers() const override {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005000 // FIXME: Implement!
5001 return "";
Gabor Greif49991682008-02-21 16:29:08 +00005002 }
5003};
5004
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005005const char * const SparcTargetInfo::GCCRegNames[] = {
Chris Lattner9b415d62009-01-27 01:58:38 +00005006 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5007 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
5008 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
5009 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
5010};
5011
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005012void SparcTargetInfo::getGCCRegNames(const char * const *&Names,
5013 unsigned &NumNames) const {
Chris Lattner9b415d62009-01-27 01:58:38 +00005014 Names = GCCRegNames;
5015 NumNames = llvm::array_lengthof(GCCRegNames);
5016}
5017
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005018const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = {
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00005019 { { "g0" }, "r0" },
5020 { { "g1" }, "r1" },
5021 { { "g2" }, "r2" },
5022 { { "g3" }, "r3" },
5023 { { "g4" }, "r4" },
5024 { { "g5" }, "r5" },
5025 { { "g6" }, "r6" },
5026 { { "g7" }, "r7" },
5027 { { "o0" }, "r8" },
5028 { { "o1" }, "r9" },
5029 { { "o2" }, "r10" },
5030 { { "o3" }, "r11" },
5031 { { "o4" }, "r12" },
5032 { { "o5" }, "r13" },
5033 { { "o6", "sp" }, "r14" },
5034 { { "o7" }, "r15" },
5035 { { "l0" }, "r16" },
5036 { { "l1" }, "r17" },
5037 { { "l2" }, "r18" },
5038 { { "l3" }, "r19" },
5039 { { "l4" }, "r20" },
5040 { { "l5" }, "r21" },
5041 { { "l6" }, "r22" },
5042 { { "l7" }, "r23" },
5043 { { "i0" }, "r24" },
5044 { { "i1" }, "r25" },
5045 { { "i2" }, "r26" },
5046 { { "i3" }, "r27" },
5047 { { "i4" }, "r28" },
5048 { { "i5" }, "r29" },
5049 { { "i6", "fp" }, "r30" },
5050 { { "i7" }, "r31" },
Chris Lattner9b415d62009-01-27 01:58:38 +00005051};
5052
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005053void SparcTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
5054 unsigned &NumAliases) const {
Chris Lattner9b415d62009-01-27 01:58:38 +00005055 Aliases = GCCRegAliases;
5056 NumAliases = llvm::array_lengthof(GCCRegAliases);
5057}
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005058
5059// SPARC v8 is the 32-bit mode selected by Triple::sparc.
5060class SparcV8TargetInfo : public SparcTargetInfo {
5061public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005062 SparcV8TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Rafael Espindolac418ae92014-01-03 19:22:05 +00005063 DescriptionString = "E-m:e-p:32:32-i64:64-f128:64-n32-S64";
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005064 }
5065
Craig Topper3164f332014-03-11 03:39:26 +00005066 void getTargetDefines(const LangOptions &Opts,
5067 MacroBuilder &Builder) const override {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005068 SparcTargetInfo::getTargetDefines(Opts, Builder);
5069 Builder.defineMacro("__sparcv8");
5070 }
5071};
5072
5073// SPARC v9 is the 64-bit mode selected by Triple::sparcv9.
5074class SparcV9TargetInfo : public SparcTargetInfo {
5075public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005076 SparcV9TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005077 // FIXME: Support Sparc quad-precision long double?
Rafael Espindolac418ae92014-01-03 19:22:05 +00005078 DescriptionString = "E-m:e-i64:64-n32:64-S128";
Jakob Stoklund Olesen248520b2013-05-15 03:22:33 +00005079 // This is an LP64 platform.
5080 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00005081
5082 // OpenBSD uses long long for int64_t and intmax_t.
Joerg Sonnenberger9b7060e2014-07-14 21:00:38 +00005083 if (getTriple().getOS() == llvm::Triple::OpenBSD)
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00005084 IntMaxType = SignedLongLong;
Joerg Sonnenberger9b7060e2014-07-14 21:00:38 +00005085 else
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00005086 IntMaxType = SignedLong;
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00005087 Int64Type = IntMaxType;
Jakob Stoklund Olesen497332c2014-01-16 16:43:19 +00005088
5089 // The SPARCv8 System V ABI has long double 128-bits in size, but 64-bit
5090 // aligned. The SPARCv9 SCD 2.4.1 says 16-byte aligned.
5091 LongDoubleWidth = 128;
5092 LongDoubleAlign = 128;
5093 LongDoubleFormat = &llvm::APFloat::IEEEquad;
Jakob Stoklund Olesen5b630b42014-01-30 04:48:04 +00005094 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005095 }
5096
Craig Topper3164f332014-03-11 03:39:26 +00005097 void getTargetDefines(const LangOptions &Opts,
5098 MacroBuilder &Builder) const override {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005099 SparcTargetInfo::getTargetDefines(Opts, Builder);
5100 Builder.defineMacro("__sparcv9");
Jakob Stoklund Olesenf7599892013-04-24 04:36:38 +00005101 Builder.defineMacro("__arch64__");
Rafael Espindola76483742014-08-14 15:14:51 +00005102 // Solaris doesn't need these variants, but the BSDs do.
5103 if (getTriple().getOS() != llvm::Triple::Solaris) {
Jakob Stoklund Olesenf7599892013-04-24 04:36:38 +00005104 Builder.defineMacro("__sparc64__");
5105 Builder.defineMacro("__sparc_v9__");
5106 Builder.defineMacro("__sparcv9__");
5107 }
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005108 }
Roman Divackyb1ae3d42014-02-25 18:35:30 +00005109
Craig Topper3164f332014-03-11 03:39:26 +00005110 bool setCPU(const std::string &Name) override {
Roman Divackyb1ae3d42014-02-25 18:35:30 +00005111 bool CPUKnown = llvm::StringSwitch<bool>(Name)
5112 .Case("v9", true)
5113 .Case("ultrasparc", true)
5114 .Case("ultrasparc3", true)
5115 .Case("niagara", true)
5116 .Case("niagara2", true)
5117 .Case("niagara3", true)
5118 .Case("niagara4", true)
5119 .Default(false);
5120
5121 // No need to store the CPU yet. There aren't any CPU-specific
5122 // macros to define.
5123 return CPUKnown;
5124 }
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005125};
5126
Gabor Greif49991682008-02-21 16:29:08 +00005127} // end anonymous namespace.
5128
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005129namespace {
Torok Edwinb2b37c62009-06-30 17:10:35 +00005130class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005131public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005132 SolarisSparcV8TargetInfo(const llvm::Triple &Triple)
5133 : SolarisTargetInfo<SparcV8TargetInfo>(Triple) {
Eli Friedmand50881c2008-11-02 02:43:55 +00005134 SizeType = UnsignedInt;
5135 PtrDiffType = SignedInt;
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005136 }
5137};
5138} // end anonymous namespace.
Chris Lattner5ba61f02006-10-14 07:39:34 +00005139
Chris Lattnerb781dc792008-05-08 05:58:21 +00005140namespace {
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005141class SystemZTargetInfo : public TargetInfo {
5142 static const char *const GCCRegNames[];
Ulrich Weigand47445072013-05-06 16:26:41 +00005143
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005144public:
5145 SystemZTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
5146 TLSSupported = true;
5147 IntWidth = IntAlign = 32;
5148 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
5149 PointerWidth = PointerAlign = 64;
5150 LongDoubleWidth = 128;
5151 LongDoubleAlign = 64;
5152 LongDoubleFormat = &llvm::APFloat::IEEEquad;
5153 MinGlobalAlign = 16;
5154 DescriptionString = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-a:8:16-n32:64";
5155 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
5156 }
5157 void getTargetDefines(const LangOptions &Opts,
5158 MacroBuilder &Builder) const override {
5159 Builder.defineMacro("__s390__");
5160 Builder.defineMacro("__s390x__");
5161 Builder.defineMacro("__zarch__");
5162 Builder.defineMacro("__LONG_DOUBLE_128__");
5163 }
5164 void getTargetBuiltins(const Builtin::Info *&Records,
5165 unsigned &NumRecords) const override {
5166 // FIXME: Implement.
Craig Topperf1186c52014-05-08 06:41:40 +00005167 Records = nullptr;
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005168 NumRecords = 0;
Ulrich Weigand47445072013-05-06 16:26:41 +00005169 }
5170
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005171 void getGCCRegNames(const char *const *&Names,
5172 unsigned &NumNames) const override;
5173 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5174 unsigned &NumAliases) const override {
5175 // No aliases.
Craig Topperf1186c52014-05-08 06:41:40 +00005176 Aliases = nullptr;
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005177 NumAliases = 0;
Ulrich Weigand47445072013-05-06 16:26:41 +00005178 }
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005179 bool validateAsmConstraint(const char *&Name,
5180 TargetInfo::ConstraintInfo &info) const override;
5181 const char *getClobbers() const override {
5182 // FIXME: Is this really right?
5183 return "";
5184 }
5185 BuiltinVaListKind getBuiltinVaListKind() const override {
5186 return TargetInfo::SystemZBuiltinVaList;
5187 }
5188 bool setCPU(const std::string &Name) override {
5189 bool CPUKnown = llvm::StringSwitch<bool>(Name)
5190 .Case("z10", true)
5191 .Case("z196", true)
5192 .Case("zEC12", true)
5193 .Default(false);
5194
5195 // No need to store the CPU yet. There aren't any CPU-specific
5196 // macros to define.
5197 return CPUKnown;
5198 }
5199};
5200
5201const char *const SystemZTargetInfo::GCCRegNames[] = {
5202 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5203 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
5204 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
5205 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15"
5206};
5207
5208void SystemZTargetInfo::getGCCRegNames(const char *const *&Names,
5209 unsigned &NumNames) const {
5210 Names = GCCRegNames;
5211 NumNames = llvm::array_lengthof(GCCRegNames);
5212}
5213
5214bool SystemZTargetInfo::
5215validateAsmConstraint(const char *&Name,
5216 TargetInfo::ConstraintInfo &Info) const {
5217 switch (*Name) {
5218 default:
5219 return false;
5220
5221 case 'a': // Address register
5222 case 'd': // Data register (equivalent to 'r')
5223 case 'f': // Floating-point register
5224 Info.setAllowsRegister();
5225 return true;
5226
5227 case 'I': // Unsigned 8-bit constant
5228 case 'J': // Unsigned 12-bit constant
5229 case 'K': // Signed 16-bit constant
5230 case 'L': // Signed 20-bit displacement (on all targets we support)
5231 case 'M': // 0x7fffffff
5232 return true;
5233
5234 case 'Q': // Memory with base and unsigned 12-bit displacement
5235 case 'R': // Likewise, plus an index
5236 case 'S': // Memory with base and signed 20-bit displacement
5237 case 'T': // Likewise, plus an index
5238 Info.setAllowsMemory();
5239 return true;
5240 }
5241}
Ulrich Weigand47445072013-05-06 16:26:41 +00005242}
5243
5244namespace {
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005245 class MSP430TargetInfo : public TargetInfo {
5246 static const char * const GCCRegNames[];
5247 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005248 MSP430TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00005249 BigEndian = false;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005250 TLSSupported = false;
Anton Korobeynikovcbc4e982010-01-30 12:55:11 +00005251 IntWidth = 16; IntAlign = 16;
5252 LongWidth = 32; LongLongWidth = 64;
5253 LongAlign = LongLongAlign = 16;
5254 PointerWidth = 16; PointerAlign = 16;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00005255 SuitableAlign = 16;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005256 SizeType = UnsignedInt;
Anton Korobeynikovef412902013-07-01 19:42:40 +00005257 IntMaxType = SignedLongLong;
Anton Korobeynikovef412902013-07-01 19:42:40 +00005258 IntPtrType = SignedInt;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005259 PtrDiffType = SignedInt;
Edward O'Callaghan847f2a12009-11-21 00:49:54 +00005260 SigAtomicType = SignedLong;
Rafael Espindolac418ae92014-01-03 19:22:05 +00005261 DescriptionString = "e-m:e-p:16:16-i32:16:32-n8:16";
Craig Topper3164f332014-03-11 03:39:26 +00005262 }
5263 void getTargetDefines(const LangOptions &Opts,
5264 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005265 Builder.defineMacro("MSP430");
5266 Builder.defineMacro("__MSP430__");
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005267 // FIXME: defines for different 'flavours' of MCU
5268 }
Craig Topper3164f332014-03-11 03:39:26 +00005269 void getTargetBuiltins(const Builtin::Info *&Records,
5270 unsigned &NumRecords) const override {
5271 // FIXME: Implement.
Craig Topperf1186c52014-05-08 06:41:40 +00005272 Records = nullptr;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005273 NumRecords = 0;
5274 }
Craig Topper3164f332014-03-11 03:39:26 +00005275 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005276 return Feature == "msp430";
5277 }
Craig Topper3164f332014-03-11 03:39:26 +00005278 void getGCCRegNames(const char * const *&Names,
5279 unsigned &NumNames) const override;
5280 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5281 unsigned &NumAliases) const override {
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005282 // No aliases.
Craig Topperf1186c52014-05-08 06:41:40 +00005283 Aliases = nullptr;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005284 NumAliases = 0;
5285 }
Craig Topper3164f332014-03-11 03:39:26 +00005286 bool validateAsmConstraint(const char *&Name,
5287 TargetInfo::ConstraintInfo &info) const override {
Anton Korobeynikov051913b2009-10-15 23:17:13 +00005288 // No target constraints for now.
5289 return false;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005290 }
Craig Topper3164f332014-03-11 03:39:26 +00005291 const char *getClobbers() const override {
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005292 // FIXME: Is this really right?
5293 return "";
5294 }
Craig Topper3164f332014-03-11 03:39:26 +00005295 BuiltinVaListKind getBuiltinVaListKind() const override {
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005296 // FIXME: implement
Meador Inge5d3fb222012-06-16 03:34:49 +00005297 return TargetInfo::CharPtrBuiltinVaList;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005298 }
5299 };
5300
5301 const char * const MSP430TargetInfo::GCCRegNames[] = {
5302 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5303 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
5304 };
5305
5306 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
5307 unsigned &NumNames) const {
5308 Names = GCCRegNames;
5309 NumNames = llvm::array_lengthof(GCCRegNames);
5310 }
5311}
5312
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00005313namespace {
Eli Friedmana9c3d712009-08-19 20:47:07 +00005314
Mike Stump11289f42009-09-09 15:08:12 +00005315 // LLVM and Clang cannot be used directly to output native binaries for
5316 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmana9c3d712009-08-19 20:47:07 +00005317 // type and alignment information.
Mike Stump11289f42009-09-09 15:08:12 +00005318 //
5319 // TCE uses the llvm bitcode as input and uses it for generating customized
5320 // target processor and program binary. TCE co-design environment is
Eli Friedmana9c3d712009-08-19 20:47:07 +00005321 // publicly available in http://tce.cs.tut.fi
5322
Eli Friedman1f191002011-10-07 19:51:42 +00005323 static const unsigned TCEOpenCLAddrSpaceMap[] = {
5324 3, // opencl_global
5325 4, // opencl_local
Peter Collingbournef44bdf92012-05-20 21:08:35 +00005326 5, // opencl_constant
5327 0, // cuda_device
5328 0, // cuda_constant
5329 0 // cuda_shared
Eli Friedman1f191002011-10-07 19:51:42 +00005330 };
5331
Eli Friedmana9c3d712009-08-19 20:47:07 +00005332 class TCETargetInfo : public TargetInfo{
5333 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005334 TCETargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmana9c3d712009-08-19 20:47:07 +00005335 TLSSupported = false;
5336 IntWidth = 32;
5337 LongWidth = LongLongWidth = 32;
Eli Friedmana9c3d712009-08-19 20:47:07 +00005338 PointerWidth = 32;
5339 IntAlign = 32;
5340 LongAlign = LongLongAlign = 32;
5341 PointerAlign = 32;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00005342 SuitableAlign = 32;
Eli Friedmana9c3d712009-08-19 20:47:07 +00005343 SizeType = UnsignedInt;
5344 IntMaxType = SignedLong;
Eli Friedmana9c3d712009-08-19 20:47:07 +00005345 IntPtrType = SignedInt;
5346 PtrDiffType = SignedInt;
5347 FloatWidth = 32;
5348 FloatAlign = 32;
5349 DoubleWidth = 32;
5350 DoubleAlign = 32;
5351 LongDoubleWidth = 32;
5352 LongDoubleAlign = 32;
5353 FloatFormat = &llvm::APFloat::IEEEsingle;
5354 DoubleFormat = &llvm::APFloat::IEEEsingle;
5355 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Rafael Espindola29db13a2014-01-03 18:13:17 +00005356 DescriptionString = "E-p:32:32-i8:8:32-i16:16:32-i64:32"
5357 "-f64:32-v64:32-v128:32-a:0:32-n32";
Eli Friedman1f191002011-10-07 19:51:42 +00005358 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
David Tweed31d09b02013-09-13 12:04:22 +00005359 UseAddrSpaceMapMangling = true;
Eli Friedmana9c3d712009-08-19 20:47:07 +00005360 }
5361
Craig Topper3164f332014-03-11 03:39:26 +00005362 void getTargetDefines(const LangOptions &Opts,
5363 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005364 DefineStd(Builder, "tce", Opts);
5365 Builder.defineMacro("__TCE__");
5366 Builder.defineMacro("__TCE_V1__");
Eli Friedmana9c3d712009-08-19 20:47:07 +00005367 }
Craig Topper3164f332014-03-11 03:39:26 +00005368 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005369 return Feature == "tce";
5370 }
Craig Topper3164f332014-03-11 03:39:26 +00005371
5372 void getTargetBuiltins(const Builtin::Info *&Records,
5373 unsigned &NumRecords) const override {}
5374 const char *getClobbers() const override {
Daniel Dunbar576d90d2009-08-24 09:54:37 +00005375 return "";
5376 }
Craig Topper3164f332014-03-11 03:39:26 +00005377 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00005378 return TargetInfo::VoidPtrBuiltinVaList;
Eli Friedmana9c3d712009-08-19 20:47:07 +00005379 }
Craig Topper3164f332014-03-11 03:39:26 +00005380 void getGCCRegNames(const char * const *&Names,
5381 unsigned &NumNames) const override {}
5382 bool validateAsmConstraint(const char *&Name,
5383 TargetInfo::ConstraintInfo &info) const override{
Eli Friedmana9c3d712009-08-19 20:47:07 +00005384 return true;
5385 }
Craig Topper3164f332014-03-11 03:39:26 +00005386 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5387 unsigned &NumAliases) const override {}
Eli Friedmana9c3d712009-08-19 20:47:07 +00005388 };
5389}
5390
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005391namespace {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005392class MipsTargetInfoBase : public TargetInfo {
Akira Hatanaka9064e362013-10-29 18:30:33 +00005393 virtual void setDescriptionString() = 0;
5394
Simon Atanasyan07ce7d8f2012-06-28 18:23:16 +00005395 static const Builtin::Info BuiltinInfo[];
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005396 std::string CPU;
Simon Atanasyan72244b62012-07-05 16:06:06 +00005397 bool IsMips16;
Simon Atanasyan60777612013-04-14 14:07:51 +00005398 bool IsMicromips;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00005399 bool IsNan2008;
Simon Atanasyan16071912013-04-14 14:07:30 +00005400 bool IsSingleFloat;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005401 enum MipsFloatABI {
Simon Atanasyan16071912013-04-14 14:07:30 +00005402 HardFloat, SoftFloat
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005403 } FloatABI;
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00005404 enum DspRevEnum {
5405 NoDSP, DSP1, DSP2
5406 } DspRev;
Jack Carter44ff1e52013-08-12 17:20:29 +00005407 bool HasMSA;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005408
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005409protected:
Akira Hatanaka618b2982013-10-29 19:00:35 +00005410 bool HasFP64;
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005411 std::string ABI;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005412
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005413public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005414 MipsTargetInfoBase(const llvm::Triple &Triple, const std::string &ABIStr,
5415 const std::string &CPUStr)
5416 : TargetInfo(Triple), CPU(CPUStr), IsMips16(false), IsMicromips(false),
Simon Atanasyan22127ce2013-09-24 09:09:16 +00005417 IsNan2008(false), IsSingleFloat(false), FloatABI(HardFloat),
Simon Atanasyan2c97a812013-10-18 13:13:53 +00005418 DspRev(NoDSP), HasMSA(false), HasFP64(false), ABI(ABIStr) {}
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005419
Daniel Sanders9500d2d2014-07-09 13:56:23 +00005420 bool isNaN2008Default() const {
5421 return CPU == "mips32r6" || CPU == "mips64r6";
5422 }
5423
5424 bool isFP64Default() const {
5425 return CPU == "mips32r6" || ABI == "n32" || ABI == "n64" || ABI == "64";
5426 }
5427
Alp Toker4925ba72014-06-07 23:30:42 +00005428 StringRef getABI() const override { return ABI; }
Craig Topper3164f332014-03-11 03:39:26 +00005429 bool setCPU(const std::string &Name) override {
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00005430 bool IsMips32 = getTriple().getArch() == llvm::Triple::mips ||
5431 getTriple().getArch() == llvm::Triple::mipsel;
Eric Christopher0b26a612010-03-02 02:41:08 +00005432 CPU = Name;
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00005433 return llvm::StringSwitch<bool>(Name)
Simon Atanasyan26610c52014-07-04 12:36:56 +00005434 .Case("mips1", IsMips32)
5435 .Case("mips2", IsMips32)
5436 .Case("mips3", true)
5437 .Case("mips4", true)
5438 .Case("mips5", true)
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00005439 .Case("mips32", IsMips32)
5440 .Case("mips32r2", IsMips32)
5441 .Case("mips32r6", IsMips32)
5442 .Case("mips64", true)
5443 .Case("mips64r2", true)
5444 .Case("mips64r6", true)
Simon Atanasyan4e16a422014-07-04 12:37:04 +00005445 .Case("octeon", true)
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00005446 .Default(false);
Eric Christopher0b26a612010-03-02 02:41:08 +00005447 }
Matheus Almeidab84b37d2014-06-05 14:59:18 +00005448 const std::string& getCPU() const { return CPU; }
Craig Topper3164f332014-03-11 03:39:26 +00005449 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override {
Daniel Sanders5a1449d2014-02-20 14:58:19 +00005450 // The backend enables certain ABI's by default according to the
5451 // architecture.
5452 // Disable both possible defaults so that we don't end up with multiple
5453 // ABI's selected and trigger an assertion.
5454 Features["o32"] = false;
5455 Features["n64"] = false;
5456
Eric Christopher0b26a612010-03-02 02:41:08 +00005457 Features[ABI] = true;
Simon Atanasyan4e16a422014-07-04 12:37:04 +00005458 if (CPU == "octeon")
5459 Features["mips64r2"] = Features["cnmips"] = true;
5460 else
5461 Features[CPU] = true;
Eric Christopher0b26a612010-03-02 02:41:08 +00005462 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005463
Craig Topper3164f332014-03-11 03:39:26 +00005464 void getTargetDefines(const LangOptions &Opts,
5465 MacroBuilder &Builder) const override {
Simon Atanasyan26292cc2014-01-27 13:59:11 +00005466 Builder.defineMacro("__mips__");
Simon Atanasyan683535b2012-08-29 19:14:58 +00005467 Builder.defineMacro("_mips");
Simon Atanasyan26292cc2014-01-27 13:59:11 +00005468 if (Opts.GNUMode)
5469 Builder.defineMacro("mips");
5470
Simon Atanasyan683535b2012-08-29 19:14:58 +00005471 Builder.defineMacro("__REGISTER_PREFIX__", "");
5472
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005473 switch (FloatABI) {
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005474 case HardFloat:
Simon Atanasyand3d173d2012-06-05 13:06:56 +00005475 Builder.defineMacro("__mips_hard_float", Twine(1));
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005476 break;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005477 case SoftFloat:
5478 Builder.defineMacro("__mips_soft_float", Twine(1));
5479 break;
Simon Atanasyand3d173d2012-06-05 13:06:56 +00005480 }
Simon Atanasyan26f19672012-04-05 19:28:31 +00005481
Simon Atanasyan16071912013-04-14 14:07:30 +00005482 if (IsSingleFloat)
5483 Builder.defineMacro("__mips_single_float", Twine(1));
5484
Simon Atanasyan2c97a812013-10-18 13:13:53 +00005485 Builder.defineMacro("__mips_fpr", HasFP64 ? Twine(64) : Twine(32));
5486 Builder.defineMacro("_MIPS_FPSET",
5487 Twine(32 / (HasFP64 || IsSingleFloat ? 1 : 2)));
5488
Simon Atanasyan72244b62012-07-05 16:06:06 +00005489 if (IsMips16)
5490 Builder.defineMacro("__mips16", Twine(1));
5491
Simon Atanasyan60777612013-04-14 14:07:51 +00005492 if (IsMicromips)
5493 Builder.defineMacro("__mips_micromips", Twine(1));
5494
Simon Atanasyan22127ce2013-09-24 09:09:16 +00005495 if (IsNan2008)
5496 Builder.defineMacro("__mips_nan2008", Twine(1));
5497
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00005498 switch (DspRev) {
5499 default:
5500 break;
5501 case DSP1:
5502 Builder.defineMacro("__mips_dsp_rev", Twine(1));
5503 Builder.defineMacro("__mips_dsp", Twine(1));
5504 break;
5505 case DSP2:
5506 Builder.defineMacro("__mips_dsp_rev", Twine(2));
5507 Builder.defineMacro("__mips_dspr2", Twine(1));
5508 Builder.defineMacro("__mips_dsp", Twine(1));
5509 break;
5510 }
5511
Jack Carter44ff1e52013-08-12 17:20:29 +00005512 if (HasMSA)
5513 Builder.defineMacro("__mips_msa", Twine(1));
5514
Simon Atanasyan26f19672012-04-05 19:28:31 +00005515 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
5516 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
5517 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
Simon Atanasyan5a0642f2012-08-29 15:17:29 +00005518
5519 Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
5520 Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005521 }
5522
Craig Topper3164f332014-03-11 03:39:26 +00005523 void getTargetBuiltins(const Builtin::Info *&Records,
5524 unsigned &NumRecords) const override {
Simon Atanasyan07ce7d8f2012-06-28 18:23:16 +00005525 Records = BuiltinInfo;
5526 NumRecords = clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005527 }
Craig Topper3164f332014-03-11 03:39:26 +00005528 bool hasFeature(StringRef Feature) const override {
Akira Hatanaka618b2982013-10-29 19:00:35 +00005529 return llvm::StringSwitch<bool>(Feature)
5530 .Case("mips", true)
5531 .Case("fp64", HasFP64)
5532 .Default(false);
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005533 }
Craig Topper3164f332014-03-11 03:39:26 +00005534 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00005535 return TargetInfo::VoidPtrBuiltinVaList;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005536 }
Craig Topper3164f332014-03-11 03:39:26 +00005537 void getGCCRegNames(const char * const *&Names,
5538 unsigned &NumNames) const override {
Daniel Sanders8b59af12013-11-12 12:56:01 +00005539 static const char *const GCCRegNames[] = {
Eric Christopher8b6d0512012-03-27 19:56:11 +00005540 // CPU register names
5541 // Must match second column of GCCRegAliases
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005542 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
5543 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
5544 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
Eric Christopher8b6d0512012-03-27 19:56:11 +00005545 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",
5546 // Floating point register names
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005547 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
5548 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
5549 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
5550 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
Eric Christopher8b6d0512012-03-27 19:56:11 +00005551 // Hi/lo and condition register names
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005552 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
Daniel Sanders8b59af12013-11-12 12:56:01 +00005553 "$fcc5","$fcc6","$fcc7",
5554 // MSA register names
5555 "$w0", "$w1", "$w2", "$w3", "$w4", "$w5", "$w6", "$w7",
5556 "$w8", "$w9", "$w10", "$w11", "$w12", "$w13", "$w14", "$w15",
5557 "$w16", "$w17", "$w18", "$w19", "$w20", "$w21", "$w22", "$w23",
5558 "$w24", "$w25", "$w26", "$w27", "$w28", "$w29", "$w30", "$w31",
5559 // MSA control register names
5560 "$msair", "$msacsr", "$msaaccess", "$msasave", "$msamodify",
5561 "$msarequest", "$msamap", "$msaunmap"
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005562 };
5563 Names = GCCRegNames;
5564 NumNames = llvm::array_lengthof(GCCRegNames);
5565 }
Craig Topper3164f332014-03-11 03:39:26 +00005566 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5567 unsigned &NumAliases) const override = 0;
5568 bool validateAsmConstraint(const char *&Name,
5569 TargetInfo::ConstraintInfo &Info) const override {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005570 switch (*Name) {
5571 default:
Douglas Gregor07216d12011-11-02 20:52:01 +00005572 return false;
5573
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005574 case 'r': // CPU registers.
5575 case 'd': // Equivalent to "r" unless generating MIPS16 code.
Alp Toker958027b2014-07-14 19:42:55 +00005576 case 'y': // Equivalent to "r", backward compatibility only.
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005577 case 'f': // floating-point registers.
Eric Christopherb7e28cc2012-04-03 01:16:32 +00005578 case 'c': // $25 for indirect jumps
5579 case 'l': // lo register
5580 case 'x': // hilo register pair
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005581 Info.setAllowsRegister();
5582 return true;
Jack Carterbeaccdd2013-03-05 19:10:54 +00005583 case 'R': // An address that can be used in a non-macro load or store
Jack Carter427b4042013-03-04 21:36:11 +00005584 Info.setAllowsMemory();
5585 return true;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005586 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005587 }
5588
Craig Topper3164f332014-03-11 03:39:26 +00005589 const char *getClobbers() const override {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005590 // FIXME: Implement!
5591 return "";
5592 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005593
Craig Topper3164f332014-03-11 03:39:26 +00005594 bool handleTargetFeatures(std::vector<std::string> &Features,
5595 DiagnosticsEngine &Diags) override {
Simon Atanasyan72244b62012-07-05 16:06:06 +00005596 IsMips16 = false;
Simon Atanasyan60777612013-04-14 14:07:51 +00005597 IsMicromips = false;
Daniel Sanders9500d2d2014-07-09 13:56:23 +00005598 IsNan2008 = isNaN2008Default();
Simon Atanasyan16071912013-04-14 14:07:30 +00005599 IsSingleFloat = false;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005600 FloatABI = HardFloat;
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00005601 DspRev = NoDSP;
Daniel Sanders9500d2d2014-07-09 13:56:23 +00005602 HasFP64 = isFP64Default();
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005603
5604 for (std::vector<std::string>::iterator it = Features.begin(),
5605 ie = Features.end(); it != ie; ++it) {
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005606 if (*it == "+single-float")
Simon Atanasyan16071912013-04-14 14:07:30 +00005607 IsSingleFloat = true;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005608 else if (*it == "+soft-float")
5609 FloatABI = SoftFloat;
Simon Atanasyan72244b62012-07-05 16:06:06 +00005610 else if (*it == "+mips16")
5611 IsMips16 = true;
Simon Atanasyan60777612013-04-14 14:07:51 +00005612 else if (*it == "+micromips")
5613 IsMicromips = true;
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00005614 else if (*it == "+dsp")
5615 DspRev = std::max(DspRev, DSP1);
5616 else if (*it == "+dspr2")
5617 DspRev = std::max(DspRev, DSP2);
Jack Carter44ff1e52013-08-12 17:20:29 +00005618 else if (*it == "+msa")
5619 HasMSA = true;
Simon Atanasyan2c97a812013-10-18 13:13:53 +00005620 else if (*it == "+fp64")
5621 HasFP64 = true;
5622 else if (*it == "-fp64")
5623 HasFP64 = false;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00005624 else if (*it == "+nan2008")
5625 IsNan2008 = true;
Daniel Sanders9500d2d2014-07-09 13:56:23 +00005626 else if (*it == "-nan2008")
5627 IsNan2008 = false;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005628 }
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005629
Simon Atanasyan22127ce2013-09-24 09:09:16 +00005630 // Remove front-end specific options.
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005631 std::vector<std::string>::iterator it =
5632 std::find(Features.begin(), Features.end(), "+soft-float");
5633 if (it != Features.end())
5634 Features.erase(it);
Rafael Espindolaeb265472013-08-21 21:59:03 +00005635
Akira Hatanaka9064e362013-10-29 18:30:33 +00005636 setDescriptionString();
5637
Rafael Espindolaeb265472013-08-21 21:59:03 +00005638 return true;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005639 }
Logan Chien5a5a96b2013-02-23 04:24:36 +00005640
Craig Topper3164f332014-03-11 03:39:26 +00005641 int getEHDataRegisterNumber(unsigned RegNo) const override {
Logan Chien5a5a96b2013-02-23 04:24:36 +00005642 if (RegNo == 0) return 4;
5643 if (RegNo == 1) return 5;
5644 return -1;
5645 }
Daniel Sanderscfbb71d2014-07-09 13:43:19 +00005646
5647 bool isCLZForZeroUndef() const override { return false; }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005648};
5649
Simon Atanasyan07ce7d8f2012-06-28 18:23:16 +00005650const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = {
5651#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
5652#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
5653 ALL_LANGUAGES },
5654#include "clang/Basic/BuiltinsMips.def"
5655};
5656
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005657class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005658public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005659 Mips32TargetInfoBase(const llvm::Triple &Triple)
Simon Atanasyan1a3665b62014-01-27 13:59:04 +00005660 : MipsTargetInfoBase(Triple, "o32", "mips32r2") {
Akira Hatanaka8cc2e862011-11-05 01:48:34 +00005661 SizeType = UnsignedInt;
5662 PtrDiffType = SignedInt;
Akira Hatanakab2206e72013-01-18 21:58:11 +00005663 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Akira Hatanaka8cc2e862011-11-05 01:48:34 +00005664 }
Craig Topper3164f332014-03-11 03:39:26 +00005665 bool setABI(const std::string &Name) override {
Simon Atanasyan755d7f92014-06-28 15:56:03 +00005666 if (Name == "o32" || Name == "eabi") {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005667 ABI = Name;
5668 return true;
Simon Atanasyan98ba8a62014-06-28 15:56:08 +00005669 }
Simon Atanasyan98ba8a62014-06-28 15:56:08 +00005670 return false;
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005671 }
Craig Topper3164f332014-03-11 03:39:26 +00005672 void getTargetDefines(const LangOptions &Opts,
5673 MacroBuilder &Builder) const override {
Simon Atanasyan16ee0052012-08-29 19:59:32 +00005674 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005675
Simon Atanasyan26292cc2014-01-27 13:59:11 +00005676 Builder.defineMacro("__mips", "32");
Matheus Almeidab84b37d2014-06-05 14:59:18 +00005677 Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS32");
5678
5679 const std::string& CPUStr = getCPU();
5680 if (CPUStr == "mips32")
5681 Builder.defineMacro("__mips_isa_rev", "1");
5682 else if (CPUStr == "mips32r2")
5683 Builder.defineMacro("__mips_isa_rev", "2");
Simon Atanasyan26292cc2014-01-27 13:59:11 +00005684
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005685 if (ABI == "o32") {
5686 Builder.defineMacro("__mips_o32");
5687 Builder.defineMacro("_ABIO32", "1");
5688 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
5689 }
5690 else if (ABI == "eabi")
5691 Builder.defineMacro("__mips_eabi");
5692 else
David Blaikie83d382b2011-09-23 05:06:16 +00005693 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005694 }
Craig Topper3164f332014-03-11 03:39:26 +00005695 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5696 unsigned &NumAliases) const override {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005697 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
5698 { { "at" }, "$1" },
5699 { { "v0" }, "$2" },
5700 { { "v1" }, "$3" },
5701 { { "a0" }, "$4" },
5702 { { "a1" }, "$5" },
5703 { { "a2" }, "$6" },
5704 { { "a3" }, "$7" },
5705 { { "t0" }, "$8" },
5706 { { "t1" }, "$9" },
5707 { { "t2" }, "$10" },
5708 { { "t3" }, "$11" },
5709 { { "t4" }, "$12" },
5710 { { "t5" }, "$13" },
5711 { { "t6" }, "$14" },
5712 { { "t7" }, "$15" },
5713 { { "s0" }, "$16" },
5714 { { "s1" }, "$17" },
5715 { { "s2" }, "$18" },
5716 { { "s3" }, "$19" },
5717 { { "s4" }, "$20" },
5718 { { "s5" }, "$21" },
5719 { { "s6" }, "$22" },
5720 { { "s7" }, "$23" },
5721 { { "t8" }, "$24" },
5722 { { "t9" }, "$25" },
5723 { { "k0" }, "$26" },
5724 { { "k1" }, "$27" },
5725 { { "gp" }, "$28" },
Eric Christopher8b6d0512012-03-27 19:56:11 +00005726 { { "sp","$sp" }, "$29" },
5727 { { "fp","$fp" }, "$30" },
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005728 { { "ra" }, "$31" }
5729 };
5730 Aliases = GCCRegAliases;
5731 NumAliases = llvm::array_lengthof(GCCRegAliases);
5732 }
5733};
5734
5735class Mips32EBTargetInfo : public Mips32TargetInfoBase {
Craig Topper3164f332014-03-11 03:39:26 +00005736 void setDescriptionString() override {
Rafael Espindolac418ae92014-01-03 19:22:05 +00005737 DescriptionString = "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64";
Akira Hatanaka9064e362013-10-29 18:30:33 +00005738 }
5739
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005740public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005741 Mips32EBTargetInfo(const llvm::Triple &Triple)
5742 : Mips32TargetInfoBase(Triple) {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005743 }
Craig Topper3164f332014-03-11 03:39:26 +00005744 void getTargetDefines(const LangOptions &Opts,
5745 MacroBuilder &Builder) const override {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005746 DefineStd(Builder, "MIPSEB", Opts);
5747 Builder.defineMacro("_MIPSEB");
Simon Atanasyan16ee0052012-08-29 19:59:32 +00005748 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005749 }
5750};
5751
5752class Mips32ELTargetInfo : public Mips32TargetInfoBase {
Craig Topper3164f332014-03-11 03:39:26 +00005753 void setDescriptionString() override {
Rafael Espindolac418ae92014-01-03 19:22:05 +00005754 DescriptionString = "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64";
Akira Hatanaka9064e362013-10-29 18:30:33 +00005755 }
5756
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005757public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005758 Mips32ELTargetInfo(const llvm::Triple &Triple)
5759 : Mips32TargetInfoBase(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00005760 BigEndian = false;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005761 }
Craig Topper3164f332014-03-11 03:39:26 +00005762 void getTargetDefines(const LangOptions &Opts,
5763 MacroBuilder &Builder) const override {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005764 DefineStd(Builder, "MIPSEL", Opts);
5765 Builder.defineMacro("_MIPSEL");
Simon Atanasyan16ee0052012-08-29 19:59:32 +00005766 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005767 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005768};
Akira Hatanakabef17452011-09-20 19:21:49 +00005769
5770class Mips64TargetInfoBase : public MipsTargetInfoBase {
Akira Hatanakabef17452011-09-20 19:21:49 +00005771public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005772 Mips64TargetInfoBase(const llvm::Triple &Triple)
Simon Atanasyan1a3665b62014-01-27 13:59:04 +00005773 : MipsTargetInfoBase(Triple, "n64", "mips64r2") {
Akira Hatanakac12a2712011-10-22 00:07:27 +00005774 LongDoubleWidth = LongDoubleAlign = 128;
5775 LongDoubleFormat = &llvm::APFloat::IEEEquad;
David Chisnalla87d8592012-12-08 09:06:08 +00005776 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
5777 LongDoubleWidth = LongDoubleAlign = 64;
5778 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
5779 }
Daniel Sandersff1c0442014-04-24 09:58:52 +00005780 setN64ABITypes();
Nick Lewyckyf59e1292011-12-16 22:34:14 +00005781 SuitableAlign = 128;
Akira Hatanakab2206e72013-01-18 21:58:11 +00005782 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Akira Hatanakac12a2712011-10-22 00:07:27 +00005783 }
Daniel Sandersff1c0442014-04-24 09:58:52 +00005784
5785 void setN64ABITypes() {
5786 LongWidth = LongAlign = 64;
5787 PointerWidth = PointerAlign = 64;
5788 SizeType = UnsignedLong;
5789 PtrDiffType = SignedLong;
5790 }
5791
5792 void setN32ABITypes() {
5793 LongWidth = LongAlign = 32;
5794 PointerWidth = PointerAlign = 32;
5795 SizeType = UnsignedInt;
5796 PtrDiffType = SignedInt;
5797 }
5798
Craig Topper3164f332014-03-11 03:39:26 +00005799 bool setABI(const std::string &Name) override {
Akira Hatanakac12a2712011-10-22 00:07:27 +00005800 if (Name == "n32") {
Daniel Sandersff1c0442014-04-24 09:58:52 +00005801 setN32ABITypes();
Simon Atanasyan0da400c2013-02-27 14:55:49 +00005802 ABI = Name;
5803 return true;
Simon Atanasyan98ba8a62014-06-28 15:56:08 +00005804 }
Simon Atanasyanad805952014-07-01 10:59:09 +00005805 if (Name == "n64") {
Daniel Sandersff1c0442014-04-24 09:58:52 +00005806 setN64ABITypes();
Simon Atanasyanad805952014-07-01 10:59:09 +00005807 ABI = Name;
Simon Atanasyan0da400c2013-02-27 14:55:49 +00005808 return true;
Daniel Sandersff1c0442014-04-24 09:58:52 +00005809 }
5810 return false;
Akira Hatanakabef17452011-09-20 19:21:49 +00005811 }
Daniel Sandersff1c0442014-04-24 09:58:52 +00005812
Craig Topper3164f332014-03-11 03:39:26 +00005813 void getTargetDefines(const LangOptions &Opts,
5814 MacroBuilder &Builder) const override {
Simon Atanasyan16ee0052012-08-29 19:59:32 +00005815 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005816
Simon Atanasyan26292cc2014-01-27 13:59:11 +00005817 Builder.defineMacro("__mips", "64");
Simon Atanasyanc6a0be02012-08-29 20:50:11 +00005818 Builder.defineMacro("__mips64");
5819 Builder.defineMacro("__mips64__");
Matheus Almeidab84b37d2014-06-05 14:59:18 +00005820 Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS64");
5821
5822 const std::string& CPUStr = getCPU();
5823 if (CPUStr == "mips64")
5824 Builder.defineMacro("__mips_isa_rev", "1");
5825 else if (CPUStr == "mips64r2")
5826 Builder.defineMacro("__mips_isa_rev", "2");
Simon Atanasyanc6a0be02012-08-29 20:50:11 +00005827
Akira Hatanakabef17452011-09-20 19:21:49 +00005828 if (ABI == "n32") {
5829 Builder.defineMacro("__mips_n32");
5830 Builder.defineMacro("_ABIN32", "2");
5831 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
5832 }
5833 else if (ABI == "n64") {
5834 Builder.defineMacro("__mips_n64");
5835 Builder.defineMacro("_ABI64", "3");
5836 Builder.defineMacro("_MIPS_SIM", "_ABI64");
5837 }
5838 else
David Blaikie83d382b2011-09-23 05:06:16 +00005839 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabef17452011-09-20 19:21:49 +00005840 }
Craig Topper3164f332014-03-11 03:39:26 +00005841 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5842 unsigned &NumAliases) const override {
Akira Hatanakabef17452011-09-20 19:21:49 +00005843 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
5844 { { "at" }, "$1" },
5845 { { "v0" }, "$2" },
5846 { { "v1" }, "$3" },
5847 { { "a0" }, "$4" },
5848 { { "a1" }, "$5" },
5849 { { "a2" }, "$6" },
5850 { { "a3" }, "$7" },
5851 { { "a4" }, "$8" },
5852 { { "a5" }, "$9" },
5853 { { "a6" }, "$10" },
5854 { { "a7" }, "$11" },
5855 { { "t0" }, "$12" },
5856 { { "t1" }, "$13" },
5857 { { "t2" }, "$14" },
5858 { { "t3" }, "$15" },
5859 { { "s0" }, "$16" },
5860 { { "s1" }, "$17" },
5861 { { "s2" }, "$18" },
5862 { { "s3" }, "$19" },
5863 { { "s4" }, "$20" },
5864 { { "s5" }, "$21" },
5865 { { "s6" }, "$22" },
5866 { { "s7" }, "$23" },
5867 { { "t8" }, "$24" },
5868 { { "t9" }, "$25" },
5869 { { "k0" }, "$26" },
5870 { { "k1" }, "$27" },
5871 { { "gp" }, "$28" },
Eric Christopher8b6d0512012-03-27 19:56:11 +00005872 { { "sp","$sp" }, "$29" },
5873 { { "fp","$fp" }, "$30" },
Akira Hatanakabef17452011-09-20 19:21:49 +00005874 { { "ra" }, "$31" }
5875 };
5876 Aliases = GCCRegAliases;
5877 NumAliases = llvm::array_lengthof(GCCRegAliases);
5878 }
Daniel Sanders81ea6012014-04-24 16:05:26 +00005879
5880 bool hasInt128Type() const override { return true; }
Akira Hatanakabef17452011-09-20 19:21:49 +00005881};
5882
5883class Mips64EBTargetInfo : public Mips64TargetInfoBase {
Craig Topper3164f332014-03-11 03:39:26 +00005884 void setDescriptionString() override {
Akira Hatanaka9064e362013-10-29 18:30:33 +00005885 if (ABI == "n32")
Rafael Espindolac418ae92014-01-03 19:22:05 +00005886 DescriptionString = "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128";
Akira Hatanaka9064e362013-10-29 18:30:33 +00005887 else
Rafael Espindolac418ae92014-01-03 19:22:05 +00005888 DescriptionString = "E-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128";
Akira Hatanaka9064e362013-10-29 18:30:33 +00005889
Akira Hatanakabef17452011-09-20 19:21:49 +00005890 }
Akira Hatanaka9064e362013-10-29 18:30:33 +00005891
Akira Hatanakabef17452011-09-20 19:21:49 +00005892public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005893 Mips64EBTargetInfo(const llvm::Triple &Triple)
Akira Hatanaka9064e362013-10-29 18:30:33 +00005894 : Mips64TargetInfoBase(Triple) {}
Craig Topper3164f332014-03-11 03:39:26 +00005895 void getTargetDefines(const LangOptions &Opts,
5896 MacroBuilder &Builder) const override {
Akira Hatanakabef17452011-09-20 19:21:49 +00005897 DefineStd(Builder, "MIPSEB", Opts);
5898 Builder.defineMacro("_MIPSEB");
Simon Atanasyan16ee0052012-08-29 19:59:32 +00005899 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabef17452011-09-20 19:21:49 +00005900 }
5901};
5902
5903class Mips64ELTargetInfo : public Mips64TargetInfoBase {
Craig Topper3164f332014-03-11 03:39:26 +00005904 void setDescriptionString() override {
Akira Hatanaka9064e362013-10-29 18:30:33 +00005905 if (ABI == "n32")
Rafael Espindolac418ae92014-01-03 19:22:05 +00005906 DescriptionString = "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128";
Akira Hatanaka9064e362013-10-29 18:30:33 +00005907 else
Rafael Espindolac418ae92014-01-03 19:22:05 +00005908 DescriptionString = "e-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128";
Akira Hatanakabef17452011-09-20 19:21:49 +00005909 }
5910public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005911 Mips64ELTargetInfo(const llvm::Triple &Triple)
5912 : Mips64TargetInfoBase(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00005913 // Default ABI is n64.
5914 BigEndian = false;
Akira Hatanakabef17452011-09-20 19:21:49 +00005915 }
Craig Topper3164f332014-03-11 03:39:26 +00005916 void getTargetDefines(const LangOptions &Opts,
5917 MacroBuilder &Builder) const override {
Akira Hatanakabef17452011-09-20 19:21:49 +00005918 DefineStd(Builder, "MIPSEL", Opts);
5919 Builder.defineMacro("_MIPSEL");
Simon Atanasyan16ee0052012-08-29 19:59:32 +00005920 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabef17452011-09-20 19:21:49 +00005921 }
5922};
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005923} // end anonymous namespace.
5924
Ivan Krasindd7403e2011-08-24 20:22:22 +00005925namespace {
5926class PNaClTargetInfo : public TargetInfo {
5927public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005928 PNaClTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00005929 BigEndian = false;
Ivan Krasindd7403e2011-08-24 20:22:22 +00005930 this->UserLabelPrefix = "";
5931 this->LongAlign = 32;
5932 this->LongWidth = 32;
5933 this->PointerAlign = 32;
5934 this->PointerWidth = 32;
5935 this->IntMaxType = TargetInfo::SignedLongLong;
Ivan Krasindd7403e2011-08-24 20:22:22 +00005936 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasin69a990b2011-08-29 22:39:12 +00005937 this->DoubleAlign = 64;
Ivan Krasin96a80612011-09-20 14:56:54 +00005938 this->LongDoubleWidth = 64;
Ivan Krasin69a990b2011-08-29 22:39:12 +00005939 this->LongDoubleAlign = 64;
Ivan Krasin96a80612011-09-20 14:56:54 +00005940 this->SizeType = TargetInfo::UnsignedInt;
5941 this->PtrDiffType = TargetInfo::SignedInt;
5942 this->IntPtrType = TargetInfo::SignedInt;
Eli Bendersky4f6791c2013-04-08 21:31:01 +00005943 this->RegParmMax = 0; // Disallow regparm
Ivan Krasindd7403e2011-08-24 20:22:22 +00005944 }
5945
Craig Topper3164f332014-03-11 03:39:26 +00005946 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00005947 }
Craig Toppere6f17d02014-03-11 04:07:52 +00005948 void getArchDefines(const LangOptions &Opts, MacroBuilder &Builder) const {
Ivan Krasindd7403e2011-08-24 20:22:22 +00005949 Builder.defineMacro("__le32__");
5950 Builder.defineMacro("__pnacl__");
5951 }
Craig Topper3164f332014-03-11 03:39:26 +00005952 void getTargetDefines(const LangOptions &Opts,
5953 MacroBuilder &Builder) const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00005954 getArchDefines(Opts, Builder);
5955 }
Craig Topper3164f332014-03-11 03:39:26 +00005956 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005957 return Feature == "pnacl";
5958 }
Craig Topper3164f332014-03-11 03:39:26 +00005959 void getTargetBuiltins(const Builtin::Info *&Records,
5960 unsigned &NumRecords) const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00005961 }
Craig Topper3164f332014-03-11 03:39:26 +00005962 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00005963 return TargetInfo::PNaClABIBuiltinVaList;
Ivan Krasindd7403e2011-08-24 20:22:22 +00005964 }
Craig Topper3164f332014-03-11 03:39:26 +00005965 void getGCCRegNames(const char * const *&Names,
5966 unsigned &NumNames) const override;
5967 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5968 unsigned &NumAliases) const override;
5969 bool validateAsmConstraint(const char *&Name,
5970 TargetInfo::ConstraintInfo &Info) const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00005971 return false;
5972 }
5973
Craig Topper3164f332014-03-11 03:39:26 +00005974 const char *getClobbers() const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00005975 return "";
5976 }
5977};
5978
5979void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
5980 unsigned &NumNames) const {
Craig Topperf1186c52014-05-08 06:41:40 +00005981 Names = nullptr;
Ivan Krasindd7403e2011-08-24 20:22:22 +00005982 NumNames = 0;
5983}
5984
5985void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
5986 unsigned &NumAliases) const {
Craig Topperf1186c52014-05-08 06:41:40 +00005987 Aliases = nullptr;
Ivan Krasindd7403e2011-08-24 20:22:22 +00005988 NumAliases = 0;
5989}
5990} // end anonymous namespace.
5991
Guy Benyeib798fc92012-12-11 21:38:14 +00005992namespace {
JF Bastien643817d2014-09-12 17:52:47 +00005993class Le64TargetInfo : public TargetInfo {
5994 static const Builtin::Info BuiltinInfo[];
5995
5996public:
5997 Le64TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
5998 BigEndian = false;
5999 NoAsmVariants = true;
6000 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
6001 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
6002 DescriptionString =
6003 "e-S128-p:64:64-v16:16-v32:32-v64:64-v96:32-v128:32-m:e-n8:16:32:64";
6004 }
6005
6006 void getTargetDefines(const LangOptions &Opts,
6007 MacroBuilder &Builder) const override {
6008 DefineStd(Builder, "unix", Opts);
6009 defineCPUMacros(Builder, "le64", /*Tuning=*/false);
6010 Builder.defineMacro("__ELF__");
6011 }
6012 void getTargetBuiltins(const Builtin::Info *&Records,
6013 unsigned &NumRecords) const override {
6014 Records = BuiltinInfo;
6015 NumRecords = clang::Le64::LastTSBuiltin - Builtin::FirstTSBuiltin;
6016 }
6017 BuiltinVaListKind getBuiltinVaListKind() const override {
6018 return TargetInfo::PNaClABIBuiltinVaList;
6019 }
6020 const char *getClobbers() const override { return ""; }
6021 void getGCCRegNames(const char *const *&Names,
6022 unsigned &NumNames) const override {
6023 Names = nullptr;
6024 NumNames = 0;
6025 }
6026 void getGCCRegAliases(const GCCRegAlias *&Aliases,
6027 unsigned &NumAliases) const override {
6028 Aliases = nullptr;
6029 NumAliases = 0;
6030 }
6031 bool validateAsmConstraint(const char *&Name,
6032 TargetInfo::ConstraintInfo &Info) const override {
6033 return false;
6034 }
6035
6036 bool hasProtectedVisibility() const override { return false; }
JF Bastien643817d2014-09-12 17:52:47 +00006037};
6038} // end anonymous namespace.
6039
6040const Builtin::Info Le64TargetInfo::BuiltinInfo[] = {
6041#define BUILTIN(ID, TYPE, ATTRS) \
6042 { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
6043#include "clang/Basic/BuiltinsLe64.def"
6044};
6045
6046namespace {
Guy Benyeib798fc92012-12-11 21:38:14 +00006047 static const unsigned SPIRAddrSpaceMap[] = {
6048 1, // opencl_global
6049 3, // opencl_local
6050 2, // opencl_constant
6051 0, // cuda_device
6052 0, // cuda_constant
6053 0 // cuda_shared
6054 };
6055 class SPIRTargetInfo : public TargetInfo {
Guy Benyeib798fc92012-12-11 21:38:14 +00006056 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006057 SPIRTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Guy Benyeib798fc92012-12-11 21:38:14 +00006058 assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
6059 "SPIR target must use unknown OS");
6060 assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
6061 "SPIR target must use unknown environment type");
6062 BigEndian = false;
6063 TLSSupported = false;
6064 LongWidth = LongAlign = 64;
6065 AddrSpaceMap = &SPIRAddrSpaceMap;
David Tweed31d09b02013-09-13 12:04:22 +00006066 UseAddrSpaceMapMangling = true;
Guy Benyeib798fc92012-12-11 21:38:14 +00006067 // Define available target features
6068 // These must be defined in sorted order!
6069 NoAsmVariants = true;
6070 }
Craig Topper3164f332014-03-11 03:39:26 +00006071 void getTargetDefines(const LangOptions &Opts,
6072 MacroBuilder &Builder) const override {
Guy Benyeib798fc92012-12-11 21:38:14 +00006073 DefineStd(Builder, "SPIR", Opts);
6074 }
Craig Topper3164f332014-03-11 03:39:26 +00006075 bool hasFeature(StringRef Feature) const override {
Guy Benyeib798fc92012-12-11 21:38:14 +00006076 return Feature == "spir";
6077 }
Craig Topper3164f332014-03-11 03:39:26 +00006078
6079 void getTargetBuiltins(const Builtin::Info *&Records,
6080 unsigned &NumRecords) const override {}
6081 const char *getClobbers() const override {
Guy Benyeib798fc92012-12-11 21:38:14 +00006082 return "";
6083 }
Craig Topper3164f332014-03-11 03:39:26 +00006084 void getGCCRegNames(const char * const *&Names,
6085 unsigned &NumNames) const override {}
6086 bool validateAsmConstraint(const char *&Name,
6087 TargetInfo::ConstraintInfo &info) const override {
Guy Benyeib798fc92012-12-11 21:38:14 +00006088 return true;
6089 }
Craig Topper3164f332014-03-11 03:39:26 +00006090 void getGCCRegAliases(const GCCRegAlias *&Aliases,
6091 unsigned &NumAliases) const override {}
6092 BuiltinVaListKind getBuiltinVaListKind() const override {
Guy Benyeib798fc92012-12-11 21:38:14 +00006093 return TargetInfo::VoidPtrBuiltinVaList;
6094 }
6095 };
6096
6097
6098 class SPIR32TargetInfo : public SPIRTargetInfo {
6099 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006100 SPIR32TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
Guy Benyeib798fc92012-12-11 21:38:14 +00006101 PointerWidth = PointerAlign = 32;
6102 SizeType = TargetInfo::UnsignedInt;
6103 PtrDiffType = IntPtrType = TargetInfo::SignedInt;
6104 DescriptionString
Rafael Espindola29db13a2014-01-03 18:13:17 +00006105 = "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-"
6106 "v96:128-v192:256-v256:256-v512:512-v1024:1024";
Guy Benyei5ea30272013-03-07 13:06:10 +00006107 }
Craig Topper3164f332014-03-11 03:39:26 +00006108 void getTargetDefines(const LangOptions &Opts,
6109 MacroBuilder &Builder) const override {
Guy Benyei5ea30272013-03-07 13:06:10 +00006110 DefineStd(Builder, "SPIR32", Opts);
6111 }
Guy Benyeib798fc92012-12-11 21:38:14 +00006112 };
6113
6114 class SPIR64TargetInfo : public SPIRTargetInfo {
6115 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006116 SPIR64TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
Guy Benyeib798fc92012-12-11 21:38:14 +00006117 PointerWidth = PointerAlign = 64;
6118 SizeType = TargetInfo::UnsignedLong;
6119 PtrDiffType = IntPtrType = TargetInfo::SignedLong;
Rafael Espindola29db13a2014-01-03 18:13:17 +00006120 DescriptionString = "e-i64:64-v16:16-v24:32-v32:32-v48:64-"
6121 "v96:128-v192:256-v256:256-v512:512-v1024:1024";
Guy Benyei5ea30272013-03-07 13:06:10 +00006122 }
Craig Topper3164f332014-03-11 03:39:26 +00006123 void getTargetDefines(const LangOptions &Opts,
6124 MacroBuilder &Builder) const override {
Guy Benyei5ea30272013-03-07 13:06:10 +00006125 DefineStd(Builder, "SPIR64", Opts);
6126 }
Guy Benyeib798fc92012-12-11 21:38:14 +00006127 };
6128}
6129
Robert Lytton0e076492013-08-13 09:43:10 +00006130namespace {
6131class XCoreTargetInfo : public TargetInfo {
6132 static const Builtin::Info BuiltinInfo[];
6133public:
6134 XCoreTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
6135 BigEndian = false;
6136 NoAsmVariants = true;
6137 LongLongAlign = 32;
6138 SuitableAlign = 32;
6139 DoubleAlign = LongDoubleAlign = 32;
Robert Lyttoncc424662013-11-12 10:09:30 +00006140 SizeType = UnsignedInt;
6141 PtrDiffType = SignedInt;
6142 IntPtrType = SignedInt;
6143 WCharType = UnsignedChar;
6144 WIntType = UnsignedInt;
Robert Lytton0e076492013-08-13 09:43:10 +00006145 UseZeroLengthBitfieldAlignment = true;
Rafael Espindolac418ae92014-01-03 19:22:05 +00006146 DescriptionString = "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32"
Rafael Espindola26c67b72013-12-17 14:34:42 +00006147 "-f64:32-a:0:32-n32";
Robert Lytton0e076492013-08-13 09:43:10 +00006148 }
Craig Topper3164f332014-03-11 03:39:26 +00006149 void getTargetDefines(const LangOptions &Opts,
6150 MacroBuilder &Builder) const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006151 Builder.defineMacro("__XS1B__");
6152 }
Craig Topper3164f332014-03-11 03:39:26 +00006153 void getTargetBuiltins(const Builtin::Info *&Records,
6154 unsigned &NumRecords) const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006155 Records = BuiltinInfo;
6156 NumRecords = clang::XCore::LastTSBuiltin-Builtin::FirstTSBuiltin;
6157 }
Craig Topper3164f332014-03-11 03:39:26 +00006158 BuiltinVaListKind getBuiltinVaListKind() const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006159 return TargetInfo::VoidPtrBuiltinVaList;
6160 }
Craig Topper3164f332014-03-11 03:39:26 +00006161 const char *getClobbers() const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006162 return "";
6163 }
Craig Topper3164f332014-03-11 03:39:26 +00006164 void getGCCRegNames(const char * const *&Names,
6165 unsigned &NumNames) const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006166 static const char * const GCCRegNames[] = {
6167 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
6168 "r8", "r9", "r10", "r11", "cp", "dp", "sp", "lr"
6169 };
6170 Names = GCCRegNames;
6171 NumNames = llvm::array_lengthof(GCCRegNames);
6172 }
Craig Topper3164f332014-03-11 03:39:26 +00006173 void getGCCRegAliases(const GCCRegAlias *&Aliases,
6174 unsigned &NumAliases) const override {
Craig Topperf1186c52014-05-08 06:41:40 +00006175 Aliases = nullptr;
Robert Lytton0e076492013-08-13 09:43:10 +00006176 NumAliases = 0;
6177 }
Craig Topper3164f332014-03-11 03:39:26 +00006178 bool validateAsmConstraint(const char *&Name,
6179 TargetInfo::ConstraintInfo &Info) const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006180 return false;
6181 }
Craig Topper3164f332014-03-11 03:39:26 +00006182 int getEHDataRegisterNumber(unsigned RegNo) const override {
Robert Lytton1a229262014-01-27 17:56:25 +00006183 // R0=ExceptionPointerRegister R1=ExceptionSelectorRegister
6184 return (RegNo < 2)? RegNo : -1;
6185 }
Robert Lytton0e076492013-08-13 09:43:10 +00006186};
6187
6188const Builtin::Info XCoreTargetInfo::BuiltinInfo[] = {
6189#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
6190#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
6191 ALL_LANGUAGES },
6192#include "clang/Basic/BuiltinsXCore.def"
6193};
6194} // end anonymous namespace.
6195
Ivan Krasindd7403e2011-08-24 20:22:22 +00006196
Chris Lattner5ba61f02006-10-14 07:39:34 +00006197//===----------------------------------------------------------------------===//
6198// Driver code
6199//===----------------------------------------------------------------------===//
6200
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006201static TargetInfo *AllocateTarget(const llvm::Triple &Triple) {
Daniel Dunbar52322032009-08-18 05:47:58 +00006202 llvm::Triple::OSType os = Triple.getOS();
Eli Friedmanb5366062008-05-20 14:21:01 +00006203
Daniel Dunbar52322032009-08-18 05:47:58 +00006204 switch (Triple.getArch()) {
6205 default:
Craig Topperf1186c52014-05-08 06:41:40 +00006206 return nullptr;
Eli Friedmanb5366062008-05-20 14:21:01 +00006207
Tim Northover2a0783d2014-05-30 14:14:07 +00006208 case llvm::Triple::xcore:
6209 return new XCoreTargetInfo(Triple);
6210
6211 case llvm::Triple::hexagon:
6212 return new HexagonTargetInfo(Triple);
6213
6214 case llvm::Triple::aarch64:
Tim Northovera2ee4332014-03-29 15:09:45 +00006215 if (Triple.isOSDarwin())
Tim Northover573cbee2014-05-24 12:52:07 +00006216 return new DarwinAArch64TargetInfo(Triple);
Tim Northovera2ee4332014-03-29 15:09:45 +00006217
6218 switch (os) {
6219 case llvm::Triple::Linux:
Tim Northover573cbee2014-05-24 12:52:07 +00006220 return new LinuxTargetInfo<AArch64leTargetInfo>(Triple);
James Molloy5e73df52014-04-16 15:06:20 +00006221 case llvm::Triple::NetBSD:
Tim Northover573cbee2014-05-24 12:52:07 +00006222 return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple);
Tim Northovera2ee4332014-03-29 15:09:45 +00006223 default:
Tim Northover573cbee2014-05-24 12:52:07 +00006224 return new AArch64leTargetInfo(Triple);
James Molloy5e73df52014-04-16 15:06:20 +00006225 }
6226
Christian Pirker9b019ae2014-02-25 13:51:00 +00006227 case llvm::Triple::aarch64_be:
6228 switch (os) {
6229 case llvm::Triple::Linux:
Tim Northover573cbee2014-05-24 12:52:07 +00006230 return new LinuxTargetInfo<AArch64beTargetInfo>(Triple);
Christian Pirker9b019ae2014-02-25 13:51:00 +00006231 case llvm::Triple::NetBSD:
Tim Northover573cbee2014-05-24 12:52:07 +00006232 return new NetBSDTargetInfo<AArch64beTargetInfo>(Triple);
Christian Pirker9b019ae2014-02-25 13:51:00 +00006233 default:
Tim Northover573cbee2014-05-24 12:52:07 +00006234 return new AArch64beTargetInfo(Triple);
Tim Northover9bb857a2013-01-31 12:13:10 +00006235 }
6236
Daniel Dunbar52322032009-08-18 05:47:58 +00006237 case llvm::Triple::arm:
Daniel Dunbar33a004e2009-09-11 01:14:50 +00006238 case llvm::Triple::thumb:
Tim Northover157d9112014-01-16 08:48:16 +00006239 if (Triple.isOSBinFormatMachO())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006240 return new DarwinARMTargetInfo(Triple);
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006241
Daniel Dunbar52322032009-08-18 05:47:58 +00006242 switch (os) {
Rafael Espindolaad8fed52010-06-10 00:46:51 +00006243 case llvm::Triple::Linux:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006244 return new LinuxTargetInfo<ARMleTargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006245 case llvm::Triple::FreeBSD:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006246 return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006247 case llvm::Triple::NetBSD:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006248 return new NetBSDTargetInfo<ARMleTargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00006249 case llvm::Triple::OpenBSD:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006250 return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple);
Eli Friedman9fa28852012-08-08 23:57:20 +00006251 case llvm::Triple::Bitrig:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006252 return new BitrigTargetInfo<ARMleTargetInfo>(Triple);
Douglas Gregor9fabd852011-07-01 22:41:14 +00006253 case llvm::Triple::RTEMS:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006254 return new RTEMSTargetInfo<ARMleTargetInfo>(Triple);
Eli Benderskyd7c92032012-12-04 18:38:10 +00006255 case llvm::Triple::NaCl:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006256 return new NaClTargetInfo<ARMleTargetInfo>(Triple);
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00006257 case llvm::Triple::Win32:
6258 switch (Triple.getEnvironment()) {
6259 default:
6260 return new ARMleTargetInfo(Triple);
6261 case llvm::Triple::Itanium:
6262 return new ItaniumWindowsARMleTargetInfo(Triple);
6263 case llvm::Triple::MSVC:
6264 return new MicrosoftARMleTargetInfo(Triple);
6265 }
Daniel Dunbar52322032009-08-18 05:47:58 +00006266 default:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006267 return new ARMleTargetInfo(Triple);
6268 }
6269
6270 case llvm::Triple::armeb:
6271 case llvm::Triple::thumbeb:
6272 if (Triple.isOSDarwin())
6273 return new DarwinARMTargetInfo(Triple);
6274
6275 switch (os) {
6276 case llvm::Triple::Linux:
6277 return new LinuxTargetInfo<ARMbeTargetInfo>(Triple);
6278 case llvm::Triple::FreeBSD:
6279 return new FreeBSDTargetInfo<ARMbeTargetInfo>(Triple);
6280 case llvm::Triple::NetBSD:
6281 return new NetBSDTargetInfo<ARMbeTargetInfo>(Triple);
6282 case llvm::Triple::OpenBSD:
6283 return new OpenBSDTargetInfo<ARMbeTargetInfo>(Triple);
6284 case llvm::Triple::Bitrig:
6285 return new BitrigTargetInfo<ARMbeTargetInfo>(Triple);
6286 case llvm::Triple::RTEMS:
6287 return new RTEMSTargetInfo<ARMbeTargetInfo>(Triple);
6288 case llvm::Triple::NaCl:
6289 return new NaClTargetInfo<ARMbeTargetInfo>(Triple);
6290 default:
6291 return new ARMbeTargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006292 }
Eli Friedmanb5366062008-05-20 14:21:01 +00006293
Daniel Dunbar52322032009-08-18 05:47:58 +00006294 case llvm::Triple::msp430:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006295 return new MSP430TargetInfo(Triple);
Eli Friedmanb5366062008-05-20 14:21:01 +00006296
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006297 case llvm::Triple::mips:
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006298 switch (os) {
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006299 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006300 return new LinuxTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006301 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006302 return new RTEMSTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006303 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006304 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006305 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006306 return new NetBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006307 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006308 return new Mips32EBTargetInfo(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006309 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006310
6311 case llvm::Triple::mipsel:
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006312 switch (os) {
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006313 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006314 return new LinuxTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006315 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006316 return new RTEMSTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006317 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006318 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006319 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006320 return new NetBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Petar Jovanovicc19a2842013-09-21 01:27:01 +00006321 case llvm::Triple::NaCl:
6322 return new NaClTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006323 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006324 return new Mips32ELTargetInfo(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006325 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006326
Akira Hatanakabef17452011-09-20 19:21:49 +00006327 case llvm::Triple::mips64:
6328 switch (os) {
6329 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006330 return new LinuxTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006331 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006332 return new RTEMSTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006333 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006334 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006335 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006336 return new NetBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00006337 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006338 return new OpenBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006339 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006340 return new Mips64EBTargetInfo(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006341 }
6342
6343 case llvm::Triple::mips64el:
6344 switch (os) {
6345 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006346 return new LinuxTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006347 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006348 return new RTEMSTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006349 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006350 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006351 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006352 return new NetBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00006353 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006354 return new OpenBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006355 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006356 return new Mips64ELTargetInfo(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006357 }
6358
Ivan Krasindd7403e2011-08-24 20:22:22 +00006359 case llvm::Triple::le32:
6360 switch (os) {
Eli Benderskyd7c92032012-12-04 18:38:10 +00006361 case llvm::Triple::NaCl:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006362 return new NaClTargetInfo<PNaClTargetInfo>(Triple);
Ivan Krasindd7403e2011-08-24 20:22:22 +00006363 default:
Craig Topperf1186c52014-05-08 06:41:40 +00006364 return nullptr;
Ivan Krasindd7403e2011-08-24 20:22:22 +00006365 }
6366
JF Bastien643817d2014-09-12 17:52:47 +00006367 case llvm::Triple::le64:
6368 return new Le64TargetInfo(Triple);
6369
Daniel Dunbar52322032009-08-18 05:47:58 +00006370 case llvm::Triple::ppc:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006371 if (Triple.isOSDarwin())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006372 return new DarwinPPC32TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006373 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00006374 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006375 return new LinuxTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006376 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006377 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006378 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006379 return new NetBSDTargetInfo<PPC32TargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00006380 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006381 return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006382 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006383 return new RTEMSTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006384 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006385 return new PPC32TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006386 }
Daniel Dunbar52322032009-08-18 05:47:58 +00006387
6388 case llvm::Triple::ppc64:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006389 if (Triple.isOSDarwin())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006390 return new DarwinPPC64TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006391 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00006392 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006393 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006394 case llvm::Triple::Lv2:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006395 return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006396 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006397 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006398 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006399 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006400 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006401 return new PPC64TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006402 }
Daniel Dunbar52322032009-08-18 05:47:58 +00006403
Bill Schmidt778d3872013-07-26 01:36:11 +00006404 case llvm::Triple::ppc64le:
6405 switch (os) {
6406 case llvm::Triple::Linux:
6407 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
6408 default:
6409 return new PPC64TargetInfo(Triple);
6410 }
6411
Peter Collingbournec947aae2012-05-20 23:28:41 +00006412 case llvm::Triple::nvptx:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006413 return new NVPTX32TargetInfo(Triple);
Peter Collingbournec947aae2012-05-20 23:28:41 +00006414 case llvm::Triple::nvptx64:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006415 return new NVPTX64TargetInfo(Triple);
Peter Collingbournec947aae2012-05-20 23:28:41 +00006416
Eli Friedmand13b41e2012-10-12 23:32:00 +00006417 case llvm::Triple::r600:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006418 return new R600TargetInfo(Triple);
Eli Friedmand13b41e2012-10-12 23:32:00 +00006419
Daniel Dunbar52322032009-08-18 05:47:58 +00006420 case llvm::Triple::sparc:
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006421 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00006422 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006423 return new LinuxTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006424 case llvm::Triple::Solaris:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006425 return new SolarisSparcV8TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006426 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006427 return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00006428 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006429 return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006430 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006431 return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006432 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006433 return new SparcV8TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006434 }
Daniel Dunbar52322032009-08-18 05:47:58 +00006435
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006436 case llvm::Triple::sparcv9:
6437 switch (os) {
6438 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006439 return new LinuxTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006440 case llvm::Triple::Solaris:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006441 return new SolarisTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006442 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006443 return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006444 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006445 return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006446 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006447 return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006448 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006449 return new SparcV9TargetInfo(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006450 }
6451
Ulrich Weigand47445072013-05-06 16:26:41 +00006452 case llvm::Triple::systemz:
6453 switch (os) {
6454 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006455 return new LinuxTargetInfo<SystemZTargetInfo>(Triple);
Ulrich Weigand47445072013-05-06 16:26:41 +00006456 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006457 return new SystemZTargetInfo(Triple);
Ulrich Weigand47445072013-05-06 16:26:41 +00006458 }
6459
Eli Friedmana9c3d712009-08-19 20:47:07 +00006460 case llvm::Triple::tce:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006461 return new TCETargetInfo(Triple);
Eli Friedmana9c3d712009-08-19 20:47:07 +00006462
Daniel Dunbar52322032009-08-18 05:47:58 +00006463 case llvm::Triple::x86:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006464 if (Triple.isOSDarwin())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006465 return new DarwinI386TargetInfo(Triple);
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006466
Daniel Dunbar52322032009-08-18 05:47:58 +00006467 switch (os) {
Daniel Dunbar52322032009-08-18 05:47:58 +00006468 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006469 return new LinuxTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006470 case llvm::Triple::DragonFly:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006471 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006472 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006473 return new NetBSDI386TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006474 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006475 return new OpenBSDI386TargetInfo(Triple);
Eli Friedman9fa28852012-08-08 23:57:20 +00006476 case llvm::Triple::Bitrig:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006477 return new BitrigI386TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006478 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006479 return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple);
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +00006480 case llvm::Triple::KFreeBSD:
6481 return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple);
Chris Lattner3e2ee142010-07-07 16:01:42 +00006482 case llvm::Triple::Minix:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006483 return new MinixTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006484 case llvm::Triple::Solaris:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006485 return new SolarisTargetInfo<X86_32TargetInfo>(Triple);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006486 case llvm::Triple::Win32: {
6487 switch (Triple.getEnvironment()) {
6488 default:
6489 return new X86_32TargetInfo(Triple);
6490 case llvm::Triple::Cygnus:
6491 return new CygwinX86_32TargetInfo(Triple);
6492 case llvm::Triple::GNU:
6493 return new MinGWX86_32TargetInfo(Triple);
Saleem Abdulrasool24bd7da2014-06-28 23:34:11 +00006494 case llvm::Triple::Itanium:
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006495 case llvm::Triple::MSVC:
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00006496 return new MicrosoftX86_32TargetInfo(Triple);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006497 }
6498 }
Chris Lattnerb986aba2010-04-11 19:29:39 +00006499 case llvm::Triple::Haiku:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006500 return new HaikuX86_32TargetInfo(Triple);
Douglas Gregor9fabd852011-07-01 22:41:14 +00006501 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006502 return new RTEMSX86_32TargetInfo(Triple);
Eli Benderskyd7c92032012-12-04 18:38:10 +00006503 case llvm::Triple::NaCl:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006504 return new NaClTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006505 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006506 return new X86_32TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006507 }
6508
6509 case llvm::Triple::x86_64:
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006510 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006511 return new DarwinX86_64TargetInfo(Triple);
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006512
Daniel Dunbar52322032009-08-18 05:47:58 +00006513 switch (os) {
Daniel Dunbar52322032009-08-18 05:47:58 +00006514 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006515 return new LinuxTargetInfo<X86_64TargetInfo>(Triple);
Chris Lattner002ba6b2010-01-09 05:41:14 +00006516 case llvm::Triple::DragonFly:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006517 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006518 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006519 return new NetBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006520 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006521 return new OpenBSDX86_64TargetInfo(Triple);
Eli Friedman9fa28852012-08-08 23:57:20 +00006522 case llvm::Triple::Bitrig:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006523 return new BitrigX86_64TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006524 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006525 return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple);
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +00006526 case llvm::Triple::KFreeBSD:
6527 return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006528 case llvm::Triple::Solaris:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006529 return new SolarisTargetInfo<X86_64TargetInfo>(Triple);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006530 case llvm::Triple::Win32: {
6531 switch (Triple.getEnvironment()) {
6532 default:
6533 return new X86_64TargetInfo(Triple);
6534 case llvm::Triple::GNU:
6535 return new MinGWX86_64TargetInfo(Triple);
6536 case llvm::Triple::MSVC:
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00006537 return new MicrosoftX86_64TargetInfo(Triple);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006538 }
6539 }
Eli Benderskyd7c92032012-12-04 18:38:10 +00006540 case llvm::Triple::NaCl:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006541 return new NaClTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006542 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006543 return new X86_64TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006544 }
Guy Benyeib798fc92012-12-11 21:38:14 +00006545
6546 case llvm::Triple::spir: {
Guy Benyeib798fc92012-12-11 21:38:14 +00006547 if (Triple.getOS() != llvm::Triple::UnknownOS ||
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006548 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
Craig Topperf1186c52014-05-08 06:41:40 +00006549 return nullptr;
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006550 return new SPIR32TargetInfo(Triple);
Guy Benyeib798fc92012-12-11 21:38:14 +00006551 }
6552 case llvm::Triple::spir64: {
Guy Benyeib798fc92012-12-11 21:38:14 +00006553 if (Triple.getOS() != llvm::Triple::UnknownOS ||
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006554 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
Craig Topperf1186c52014-05-08 06:41:40 +00006555 return nullptr;
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006556 return new SPIR64TargetInfo(Triple);
Guy Benyeib798fc92012-12-11 21:38:14 +00006557 }
Daniel Dunbar52322032009-08-18 05:47:58 +00006558 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00006559}
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006560
6561/// CreateTargetInfo - Return the target info object for the specified target
6562/// triple.
Alp Toker80758082014-07-06 05:26:44 +00006563TargetInfo *
6564TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
6565 const std::shared_ptr<TargetOptions> &Opts) {
Douglas Gregorf8715de2012-11-16 04:24:59 +00006566 llvm::Triple Triple(Opts->Triple);
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006567
6568 // Construct the target
Ahmed Charlesb8984322014-03-07 20:03:18 +00006569 std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple));
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006570 if (!Target) {
6571 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
Craig Topperf1186c52014-05-08 06:41:40 +00006572 return nullptr;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006573 }
Alp Toker80758082014-07-06 05:26:44 +00006574 Target->TargetOpts = Opts;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006575
Daniel Dunbaracde99e2009-12-18 18:42:37 +00006576 // Set the target CPU if specified.
Douglas Gregorf8715de2012-11-16 04:24:59 +00006577 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
6578 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
Craig Topperf1186c52014-05-08 06:41:40 +00006579 return nullptr;
Daniel Dunbaracde99e2009-12-18 18:42:37 +00006580 }
6581
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006582 // Set the target ABI if specified.
Douglas Gregorf8715de2012-11-16 04:24:59 +00006583 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
6584 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
Craig Topperf1186c52014-05-08 06:41:40 +00006585 return nullptr;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006586 }
6587
Rafael Espindolaeb265472013-08-21 21:59:03 +00006588 // Set the fp math unit.
6589 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
6590 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
Craig Topperf1186c52014-05-08 06:41:40 +00006591 return nullptr;
Rafael Espindolaeb265472013-08-21 21:59:03 +00006592 }
6593
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006594 // Compute the default target features, we need the target to handle this
6595 // because features may have dependencies on one another.
6596 llvm::StringMap<bool> Features;
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00006597 Target->getDefaultFeatures(Features);
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006598
Rafael Espindoladb0fcfb2013-08-20 18:57:55 +00006599 // Apply the user specified deltas.
6600 for (unsigned I = 0, N = Opts->FeaturesAsWritten.size();
6601 I < N; ++I) {
6602 const char *Name = Opts->FeaturesAsWritten[I].c_str();
Rafael Espindolaa6416a72011-11-27 20:00:43 +00006603 // Apply the feature via the target.
Rafael Espindoladb0fcfb2013-08-20 18:57:55 +00006604 bool Enabled = Name[0] == '+';
6605 Target->setFeatureEnabled(Features, Name + 1, Enabled);
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006606 }
6607
6608 // Add the features to the compile options.
6609 //
6610 // FIXME: If we are completely confident that we have the right set, we only
6611 // need to pass the minuses.
Douglas Gregorf8715de2012-11-16 04:24:59 +00006612 Opts->Features.clear();
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006613 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
6614 ie = Features.end(); it != ie; ++it)
Douglas Gregorf8715de2012-11-16 04:24:59 +00006615 Opts->Features.push_back((it->second ? "+" : "-") + it->first().str());
Eric Christopher3ff21b32013-10-16 21:26:26 +00006616 if (!Target->handleTargetFeatures(Opts->Features, Diags))
Craig Topperf1186c52014-05-08 06:41:40 +00006617 return nullptr;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006618
Ahmed Charles9a16beb2014-03-07 19:33:25 +00006619 return Target.release();
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006620}