blob: 2b3f9a51a41ff2fc60ed9a635da7bcb76b17e5f2 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- Targets.cpp - Implement -arch option and targets -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
Anton Korobeynikova7c47172009-05-03 13:42:53 +000010// This file implements construction of a TargetInfo object from a
Ted Kremenekbbced582007-12-12 18:05:32 +000011// target triple.
Reid Spencer5f016e22007-07-11 17:01:13 +000012//
13//===----------------------------------------------------------------------===//
14
Reid Spencer5f016e22007-07-11 17:01:13 +000015#include "clang/Basic/TargetInfo.h"
Daniel Dunbard58c03f2009-11-15 06:48:46 +000016#include "clang/Basic/Builtins.h"
17#include "clang/Basic/Diagnostic.h"
Chris Lattner8fc4dfb2008-12-04 22:54:33 +000018#include "clang/Basic/LangOptions.h"
Chandler Carruth103b71c2010-01-20 06:13:02 +000019#include "clang/Basic/MacroBuilder.h"
Daniel Dunbard58c03f2009-11-15 06:48:46 +000020#include "clang/Basic/TargetBuiltins.h"
21#include "clang/Basic/TargetOptions.h"
Eli Friedman25531262008-05-20 14:27:34 +000022#include "llvm/ADT/APFloat.h"
Daniel Dunbard58c03f2009-11-15 06:48:46 +000023#include "llvm/ADT/OwningPtr.h"
Daniel Dunbar29a790b2009-11-11 09:38:56 +000024#include "llvm/ADT/STLExtras.h"
Daniel Dunbar77659342009-08-19 20:04:03 +000025#include "llvm/ADT/StringRef.h"
Daniel Dunbar29a790b2009-11-11 09:38:56 +000026#include "llvm/ADT/StringSwitch.h"
Chris Lattner4c28b1c2009-08-12 06:24:27 +000027#include "llvm/ADT/Triple.h"
Chandler Carruth3b844ba2013-01-02 11:45:17 +000028#include "llvm/IR/Type.h"
Chris Lattner797c3c42009-08-10 19:03:04 +000029#include "llvm/MC/MCSectionMachO.h"
David Blaikie9fe8c742011-09-23 05:35:21 +000030#include "llvm/Support/ErrorHandling.h"
Benjamin Kramer48725082010-01-09 18:20:57 +000031#include <algorithm>
Reid Spencer5f016e22007-07-11 17:01:13 +000032using namespace clang;
33
Reid Spencer5f016e22007-07-11 17:01:13 +000034//===----------------------------------------------------------------------===//
35// Common code shared among targets.
36//===----------------------------------------------------------------------===//
37
Chris Lattnerca45cff2009-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 Lattner5f9e2722011-07-23 10:55:15 +000041static void DefineStd(MacroBuilder &Builder, StringRef MacroName,
Chris Lattnerca45cff2009-03-20 16:06:38 +000042 const LangOptions &Opts) {
43 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000044
Chris Lattnerca45cff2009-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 Kramera9992772010-01-09 17:55:51 +000048 Builder.defineMacro(MacroName);
Anton Korobeynikova7c47172009-05-03 13:42:53 +000049
Chris Lattnerca45cff2009-03-20 16:06:38 +000050 // Define __unix.
Benjamin Kramera9992772010-01-09 17:55:51 +000051 Builder.defineMacro("__" + MacroName);
Anton Korobeynikova7c47172009-05-03 13:42:53 +000052
Chris Lattnerca45cff2009-03-20 16:06:38 +000053 // Define __unix__.
Benjamin Kramera9992772010-01-09 17:55:51 +000054 Builder.defineMacro("__" + MacroName + "__");
Chris Lattnerca45cff2009-03-20 16:06:38 +000055}
56
Benjamin Kramer448f68d2012-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 Lattnerd29b6302008-10-05 21:50:58 +000065//===----------------------------------------------------------------------===//
66// Defines specific to certain operating systems.
67//===----------------------------------------------------------------------===//
Chris Lattner797c3c42009-08-10 19:03:04 +000068
Torok Edwin5f6c1942009-06-30 17:10:35 +000069namespace {
Douglas Gregora3844922009-07-01 15:12:53 +000070template<typename TgtInfo>
71class OSTargetInfo : public TgtInfo {
Torok Edwin5f6c1942009-06-30 17:10:35 +000072protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +000073 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +000074 MacroBuilder &Builder) const=0;
Torok Edwin5f6c1942009-06-30 17:10:35 +000075public:
Benjamin Kramer9df08232013-06-29 16:37:14 +000076 OSTargetInfo(const llvm::Triple &Triple) : TgtInfo(Triple) {}
Torok Edwin5f6c1942009-06-30 17:10:35 +000077 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +000078 MacroBuilder &Builder) const {
79 TgtInfo::getTargetDefines(Opts, Builder);
80 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Torok Edwinb0a5b242009-06-30 17:00:25 +000081 }
Torok Edwin5f6c1942009-06-30 17:10:35 +000082
83};
Chris Lattner4c28b1c2009-08-12 06:24:27 +000084} // end anonymous namespace
Torok Edwinb0a5b242009-06-30 17:00:25 +000085
Chris Lattner797c3c42009-08-10 19:03:04 +000086
Daniel Dunbar21ae3192010-01-26 01:44:04 +000087static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +000088 const llvm::Triple &Triple,
Chris Lattner5f9e2722011-07-23 10:55:15 +000089 StringRef &PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +000090 VersionTuple &PlatformMinVersion) {
Bob Wilsond588f5c2013-08-19 20:23:37 +000091 Builder.defineMacro("__APPLE_CC__", "6000");
Benjamin Kramera9992772010-01-09 17:55:51 +000092 Builder.defineMacro("__APPLE__");
93 Builder.defineMacro("__MACH__");
94 Builder.defineMacro("OBJC_NEW_PROPERTIES");
Alexander Potapenko087c65f2012-09-20 10:10:01 +000095 // AddressSanitizer doesn't play well with source fortification, which is on
96 // by default on Darwin.
Will Dietz4f45bc02013-01-18 11:30:38 +000097 if (Opts.Sanitize.Address) Builder.defineMacro("_FORTIFY_SOURCE", "0");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000098
John McCall098df7f2011-06-16 00:03:19 +000099 if (!Opts.ObjCAutoRefCount) {
John McCallf85e1932011-06-15 23:02:42 +0000100 // __weak is always defined, for use in blocks and with objc pointers.
101 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000102
John McCallf85e1932011-06-15 23:02:42 +0000103 // Darwin defines __strong even in C mode (just to nothing).
Douglas Gregore289d812011-09-13 17:21:33 +0000104 if (Opts.getGC() != LangOptions::NonGC)
John McCallf85e1932011-06-15 23:02:42 +0000105 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
106 else
107 Builder.defineMacro("__strong", "");
Eric Christopher7c9adf92011-07-07 22:55:26 +0000108
John McCallf85e1932011-06-15 23:02:42 +0000109 // __unsafe_unretained is defined to nothing in non-ARC mode. We even
110 // allow this in C, since one might have block pointers in structs that
111 // are used in pure C code and in Objective-C ARC.
112 Builder.defineMacro("__unsafe_unretained", "");
John McCallf85e1932011-06-15 23:02:42 +0000113 }
Eric Christopher7c9adf92011-07-07 22:55:26 +0000114
Eli Friedman2de4fee2009-06-04 23:00:29 +0000115 if (Opts.Static)
Benjamin Kramera9992772010-01-09 17:55:51 +0000116 Builder.defineMacro("__STATIC__");
Eli Friedman2de4fee2009-06-04 23:00:29 +0000117 else
Benjamin Kramera9992772010-01-09 17:55:51 +0000118 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000119
120 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000121 Builder.defineMacro("_REENTRANT");
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000122
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000123 // Get the platform type and version number from the triple.
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000124 unsigned Maj, Min, Rev;
Bob Wilson48b68a02012-01-31 23:52:58 +0000125 if (Triple.isMacOSX()) {
126 Triple.getMacOSXVersion(Maj, Min, Rev);
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000127 PlatformName = "macosx";
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000128 } else {
Bob Wilson48b68a02012-01-31 23:52:58 +0000129 Triple.getOSVersion(Maj, Min, Rev);
130 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000131 }
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000132
Sebastian Pop9ec60df2012-01-20 22:01:23 +0000133 // If -target arch-pc-win32-macho option specified, we're
Eric Christopher895d4222011-07-29 21:20:35 +0000134 // generating code for Win32 ABI. No need to emit
Chad Rosierd9259f32011-07-19 20:00:06 +0000135 // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
136 if (PlatformName == "win32") {
137 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
138 return;
139 }
140
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000141 // Set the appropriate OS version define.
Cameron Esfahani57b1da12013-09-14 01:09:11 +0000142 if (Triple.isiOS()) {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000143 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000144 char Str[6];
145 Str[0] = '0' + Maj;
146 Str[1] = '0' + (Min / 10);
147 Str[2] = '0' + (Min % 10);
148 Str[3] = '0' + (Rev / 10);
149 Str[4] = '0' + (Rev % 10);
150 Str[5] = '\0';
151 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
Tim Northover66b5dac2013-10-24 10:48:50 +0000152 } else if (Triple.getArchName() != "thumbv6m" &&
153 Triple.getArchName() != "thumbv7m" &&
154 Triple.getArchName() != "thumbv7em") {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000155 // Note that the Driver allows versions which aren't representable in the
156 // define (because we only get a single digit for the minor and micro
157 // revision numbers). So, we limit them to the maximum representable
158 // version.
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000159 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000160 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000161 char Str[5];
162 Str[0] = '0' + (Maj / 10);
163 Str[1] = '0' + (Maj % 10);
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000164 Str[2] = '0' + std::min(Min, 9U);
165 Str[3] = '0' + std::min(Rev, 9U);
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000166 Str[4] = '\0';
167 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000168 }
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000169
170 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman618234a2008-08-20 02:34:37 +0000171}
Reid Spencer5f016e22007-07-11 17:01:13 +0000172
Chris Lattner797c3c42009-08-10 19:03:04 +0000173namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000174template<typename Target>
175class DarwinTargetInfo : public OSTargetInfo<Target> {
176protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000177 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000178 MacroBuilder &Builder) const {
Eric Christopher7c9adf92011-07-07 22:55:26 +0000179 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000180 this->PlatformMinVersion);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000181 }
Mike Stump1eb44332009-09-09 15:08:12 +0000182
Torok Edwin5f6c1942009-06-30 17:10:35 +0000183public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000184 DarwinTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
185 this->TLSSupported = Triple.isMacOSX() && !Triple.isMacOSXVersionLT(10, 7);
186 this->MCountName = "\01mcount";
187 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000188
Chris Lattner5f9e2722011-07-23 10:55:15 +0000189 virtual std::string isValidSectionSpecifier(StringRef SR) const {
Chris Lattner797c3c42009-08-10 19:03:04 +0000190 // Let MCSectionMachO validate this.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000191 StringRef Segment, Section;
Chris Lattner797c3c42009-08-10 19:03:04 +0000192 unsigned TAA, StubSize;
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000193 bool HasTAA;
Chris Lattner797c3c42009-08-10 19:03:04 +0000194 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000195 TAA, HasTAA, StubSize);
Chris Lattner797c3c42009-08-10 19:03:04 +0000196 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000197
Anders Carlsson18af3682010-06-08 22:47:50 +0000198 virtual const char *getStaticInitSectionSpecifier() const {
199 // FIXME: We should return 0 when building kexts.
200 return "__TEXT,__StaticInit,regular,pure_instructions";
201 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000202
John McCall41887602012-01-29 01:20:30 +0000203 /// Darwin does not support protected visibility. Darwin's "default"
204 /// is very similar to ELF's "protected"; Darwin requires a "weak"
205 /// attribute on declarations that can be dynamically replaced.
206 virtual bool hasProtectedVisibility() const {
207 return false;
208 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000209};
210
Chris Lattner797c3c42009-08-10 19:03:04 +0000211
Torok Edwin5f6c1942009-06-30 17:10:35 +0000212// DragonFlyBSD Target
213template<typename Target>
214class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
215protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000216 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000217 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000218 // DragonFly defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000219 Builder.defineMacro("__DragonFly__");
220 Builder.defineMacro("__DragonFly_cc_version", "100001");
221 Builder.defineMacro("__ELF__");
222 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
223 Builder.defineMacro("__tune_i386__");
224 DefineStd(Builder, "unix", Opts);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000225 }
226public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000227 DragonFlyBSDTargetInfo(const llvm::Triple &Triple)
228 : OSTargetInfo<Target>(Triple) {
229 this->UserLabelPrefix = "";
Eli Friedmanb089c4d2012-02-10 23:02:29 +0000230
Benjamin Kramer9df08232013-06-29 16:37:14 +0000231 switch (Triple.getArch()) {
232 default:
233 case llvm::Triple::x86:
234 case llvm::Triple::x86_64:
235 this->MCountName = ".mcount";
236 break;
237 }
Eli Friedmanb089c4d2012-02-10 23:02:29 +0000238 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000239};
240
241// FreeBSD Target
242template<typename Target>
243class FreeBSDTargetInfo : public OSTargetInfo<Target> {
244protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000245 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000246 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000247 // FreeBSD defines; list based off of gcc output
248
Benjamin Kramer474202f2011-10-18 10:10:08 +0000249 unsigned Release = Triple.getOSMajorVersion();
250 if (Release == 0U)
251 Release = 8;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000252
Benjamin Kramer474202f2011-10-18 10:10:08 +0000253 Builder.defineMacro("__FreeBSD__", Twine(Release));
254 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramera9992772010-01-09 17:55:51 +0000255 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
256 DefineStd(Builder, "unix", Opts);
257 Builder.defineMacro("__ELF__");
Ed Schouten5ada7a52013-09-29 07:54:52 +0000258
259 // On FreeBSD, wchar_t contains the number of the code point as
260 // used by the character set of the locale. These character sets are
261 // not necessarily a superset of ASCII.
262 Builder.defineMacro("__STDC_MB_MIGHT_NEQ_WC__", "1");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000263 }
264public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000265 FreeBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
266 this->UserLabelPrefix = "";
Roman Divackybe4c8702011-02-10 16:52:03 +0000267
Benjamin Kramer9df08232013-06-29 16:37:14 +0000268 switch (Triple.getArch()) {
269 default:
270 case llvm::Triple::x86:
271 case llvm::Triple::x86_64:
272 this->MCountName = ".mcount";
273 break;
274 case llvm::Triple::mips:
275 case llvm::Triple::mipsel:
276 case llvm::Triple::ppc:
277 case llvm::Triple::ppc64:
Bill Schmidtea7fb0c2013-07-26 01:36:11 +0000278 case llvm::Triple::ppc64le:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000279 this->MCountName = "_mcount";
280 break;
281 case llvm::Triple::arm:
282 this->MCountName = "__mcount";
283 break;
Duncan Sands1e90faf2009-07-08 13:55:08 +0000284 }
Benjamin Kramer9df08232013-06-29 16:37:14 +0000285 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000286};
287
Sylvestre Ledru3309a782013-09-05 13:47:07 +0000288// GNU/kFreeBSD Target
289template<typename Target>
290class KFreeBSDTargetInfo : public OSTargetInfo<Target> {
291protected:
292 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
293 MacroBuilder &Builder) const {
294 // GNU/kFreeBSD defines; list based off of gcc output
295
296 DefineStd(Builder, "unix", Opts);
297 Builder.defineMacro("__FreeBSD_kernel__");
298 Builder.defineMacro("__GLIBC__");
299 Builder.defineMacro("__ELF__");
300 if (Opts.POSIXThreads)
301 Builder.defineMacro("_REENTRANT");
302 if (Opts.CPlusPlus)
303 Builder.defineMacro("_GNU_SOURCE");
304 }
305public:
Sylvestre Ledrudeb77992013-09-05 13:58:07 +0000306 KFreeBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Sylvestre Ledru3309a782013-09-05 13:47:07 +0000307 this->UserLabelPrefix = "";
308 }
309};
310
Chris Lattner38e317d2010-07-07 16:01:42 +0000311// Minix Target
312template<typename Target>
313class MinixTargetInfo : public OSTargetInfo<Target> {
314protected:
315 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
316 MacroBuilder &Builder) const {
317 // Minix defines
318
319 Builder.defineMacro("__minix", "3");
320 Builder.defineMacro("_EM_WSIZE", "4");
321 Builder.defineMacro("_EM_PSIZE", "4");
322 Builder.defineMacro("_EM_SSIZE", "2");
323 Builder.defineMacro("_EM_LSIZE", "4");
324 Builder.defineMacro("_EM_FSIZE", "4");
325 Builder.defineMacro("_EM_DSIZE", "8");
Eli Friedman6d402dc2011-12-08 23:54:21 +0000326 Builder.defineMacro("__ELF__");
Chris Lattner38e317d2010-07-07 16:01:42 +0000327 DefineStd(Builder, "unix", Opts);
328 }
329public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000330 MinixTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
331 this->UserLabelPrefix = "";
332 }
Chris Lattner38e317d2010-07-07 16:01:42 +0000333};
334
Torok Edwin5f6c1942009-06-30 17:10:35 +0000335// Linux target
336template<typename Target>
337class LinuxTargetInfo : public OSTargetInfo<Target> {
338protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000339 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000340 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000341 // Linux defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000342 DefineStd(Builder, "unix", Opts);
343 DefineStd(Builder, "linux", Opts);
344 Builder.defineMacro("__gnu_linux__");
345 Builder.defineMacro("__ELF__");
Logan Chien94a71422012-09-02 09:30:11 +0000346 if (Triple.getEnvironment() == llvm::Triple::Android)
Evgeniy Stepanov32064032012-04-26 12:08:09 +0000347 Builder.defineMacro("__ANDROID__", "1");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000348 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000349 Builder.defineMacro("_REENTRANT");
Douglas Gregor2b003fd2010-04-21 05:52:38 +0000350 if (Opts.CPlusPlus)
351 Builder.defineMacro("_GNU_SOURCE");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000352 }
353public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000354 LinuxTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000355 this->UserLabelPrefix = "";
Douglas Gregor12e84642011-01-12 21:19:25 +0000356 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000357 }
Benjamin Kramer86d18c52011-10-15 17:53:33 +0000358
359 virtual const char *getStaticInitSectionSpecifier() const {
360 return ".text.startup";
361 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000362};
363
Chris Lattnerb62bb282009-07-13 20:29:08 +0000364// NetBSD Target
365template<typename Target>
366class NetBSDTargetInfo : public OSTargetInfo<Target> {
367protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000368 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000369 MacroBuilder &Builder) const {
Chris Lattnerb62bb282009-07-13 20:29:08 +0000370 // NetBSD defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000371 Builder.defineMacro("__NetBSD__");
372 Builder.defineMacro("__unix__");
373 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000374 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000375 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerb62bb282009-07-13 20:29:08 +0000376 }
377public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000378 NetBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
379 this->UserLabelPrefix = "";
380 }
Chris Lattnerb62bb282009-07-13 20:29:08 +0000381};
382
Torok Edwin5f6c1942009-06-30 17:10:35 +0000383// OpenBSD Target
384template<typename Target>
385class OpenBSDTargetInfo : public OSTargetInfo<Target> {
386protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000387 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000388 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000389 // OpenBSD defines; list based off of gcc output
390
Benjamin Kramera9992772010-01-09 17:55:51 +0000391 Builder.defineMacro("__OpenBSD__");
392 DefineStd(Builder, "unix", Opts);
393 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000394 if (Opts.POSIXThreads)
Chris Lattner4ddcf3b2012-04-25 06:12:24 +0000395 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000396 }
397public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000398 OpenBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
399 this->UserLabelPrefix = "";
400 this->TLSSupported = false;
Eli Friedman62d829a2011-12-15 02:15:56 +0000401
Eli Friedman62d829a2011-12-15 02:15:56 +0000402 switch (Triple.getArch()) {
403 default:
404 case llvm::Triple::x86:
405 case llvm::Triple::x86_64:
406 case llvm::Triple::arm:
Eric Christopher825d3862012-11-14 22:08:59 +0000407 case llvm::Triple::sparc:
Eli Friedman62d829a2011-12-15 02:15:56 +0000408 this->MCountName = "__mcount";
409 break;
410 case llvm::Triple::mips64:
411 case llvm::Triple::mips64el:
412 case llvm::Triple::ppc:
Eric Christopher825d3862012-11-14 22:08:59 +0000413 case llvm::Triple::sparcv9:
Eli Friedman62d829a2011-12-15 02:15:56 +0000414 this->MCountName = "_mcount";
415 break;
416 }
417 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000418};
419
Eli Friedman42f74f22012-08-08 23:57:20 +0000420// Bitrig Target
421template<typename Target>
422class BitrigTargetInfo : public OSTargetInfo<Target> {
423protected:
424 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
425 MacroBuilder &Builder) const {
426 // Bitrig defines; list based off of gcc output
427
428 Builder.defineMacro("__Bitrig__");
429 DefineStd(Builder, "unix", Opts);
430 Builder.defineMacro("__ELF__");
431 if (Opts.POSIXThreads)
432 Builder.defineMacro("_REENTRANT");
433 }
434public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000435 BitrigTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
436 this->UserLabelPrefix = "";
437 this->TLSSupported = false;
438 this->MCountName = "__mcount";
Eli Friedman42f74f22012-08-08 23:57:20 +0000439 }
440};
441
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000442// PSP Target
443template<typename Target>
444class PSPTargetInfo : public OSTargetInfo<Target> {
445protected:
446 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000447 MacroBuilder &Builder) const {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000448 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramera9992772010-01-09 17:55:51 +0000449 Builder.defineMacro("PSP");
450 Builder.defineMacro("_PSP");
451 Builder.defineMacro("__psp__");
452 Builder.defineMacro("__ELF__");
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000453 }
454public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000455 PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000456 this->UserLabelPrefix = "";
457 }
458};
459
John Thompson3f6918a2009-11-19 17:18:50 +0000460// PS3 PPU Target
461template<typename Target>
462class PS3PPUTargetInfo : public OSTargetInfo<Target> {
463protected:
464 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000465 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000466 // PS3 PPU defines.
John Thompsonfb457972010-03-25 16:18:32 +0000467 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000468 Builder.defineMacro("__PPU__");
469 Builder.defineMacro("__CELLOS_LV2__");
470 Builder.defineMacro("__ELF__");
471 Builder.defineMacro("__LP32__");
John Thompson8e6065a2010-06-24 22:44:13 +0000472 Builder.defineMacro("_ARCH_PPC64");
473 Builder.defineMacro("__powerpc64__");
John Thompson3f6918a2009-11-19 17:18:50 +0000474 }
475public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000476 PS3PPUTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
John Thompson3f6918a2009-11-19 17:18:50 +0000477 this->UserLabelPrefix = "";
Nick Lewycky99520702011-12-16 22:32:39 +0000478 this->LongWidth = this->LongAlign = 32;
479 this->PointerWidth = this->PointerAlign = 32;
John Thompson8e6065a2010-06-24 22:44:13 +0000480 this->IntMaxType = TargetInfo::SignedLongLong;
481 this->UIntMaxType = TargetInfo::UnsignedLongLong;
482 this->Int64Type = TargetInfo::SignedLongLong;
John Thompsonec387af2009-12-18 14:21:08 +0000483 this->SizeType = TargetInfo::UnsignedInt;
John Thompson8e6065a2010-06-24 22:44:13 +0000484 this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Nick Lewycky99520702011-12-16 22:32:39 +0000485 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompson3f6918a2009-11-19 17:18:50 +0000486 }
487};
488
489// FIXME: Need a real SPU target.
490// PS3 SPU Target
491template<typename Target>
492class PS3SPUTargetInfo : public OSTargetInfo<Target> {
493protected:
494 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000495 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000496 // PS3 PPU defines.
Benjamin Kramera9992772010-01-09 17:55:51 +0000497 Builder.defineMacro("__SPU__");
498 Builder.defineMacro("__ELF__");
John Thompson3f6918a2009-11-19 17:18:50 +0000499 }
500public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000501 PS3SPUTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
John Thompson3f6918a2009-11-19 17:18:50 +0000502 this->UserLabelPrefix = "";
503 }
504};
505
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000506// AuroraUX target
507template<typename Target>
508class AuroraUXTargetInfo : public OSTargetInfo<Target> {
509protected:
510 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000511 MacroBuilder &Builder) const {
512 DefineStd(Builder, "sun", Opts);
513 DefineStd(Builder, "unix", Opts);
514 Builder.defineMacro("__ELF__");
515 Builder.defineMacro("__svr4__");
516 Builder.defineMacro("__SVR4");
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000517 }
518public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000519 AuroraUXTargetInfo(const llvm::Triple &Triple)
520 : OSTargetInfo<Target>(Triple) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000521 this->UserLabelPrefix = "";
522 this->WCharType = this->SignedLong;
523 // FIXME: WIntType should be SignedLong
524 }
525};
526
Torok Edwin5f6c1942009-06-30 17:10:35 +0000527// Solaris target
528template<typename Target>
529class SolarisTargetInfo : public OSTargetInfo<Target> {
530protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000531 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000532 MacroBuilder &Builder) const {
533 DefineStd(Builder, "sun", Opts);
534 DefineStd(Builder, "unix", Opts);
535 Builder.defineMacro("__ELF__");
536 Builder.defineMacro("__svr4__");
537 Builder.defineMacro("__SVR4");
David Chisnall165329c2012-02-28 17:10:04 +0000538 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
539 // newer, but to 500 for everything else. feature_test.h has a check to
540 // ensure that you are not using C99 with an old version of X/Open or C89
541 // with a new version.
542 if (Opts.C99 || Opts.C11)
543 Builder.defineMacro("_XOPEN_SOURCE", "600");
544 else
545 Builder.defineMacro("_XOPEN_SOURCE", "500");
David Chisnallb4f0bd62012-03-02 10:49:52 +0000546 if (Opts.CPlusPlus)
David Chisnall165329c2012-02-28 17:10:04 +0000547 Builder.defineMacro("__C99FEATURES__");
David Chisnall48fad492012-02-17 18:35:11 +0000548 Builder.defineMacro("_LARGEFILE_SOURCE");
549 Builder.defineMacro("_LARGEFILE64_SOURCE");
550 Builder.defineMacro("__EXTENSIONS__");
David Chisnall165329c2012-02-28 17:10:04 +0000551 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000552 }
553public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000554 SolarisTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000555 this->UserLabelPrefix = "";
David Chisnallfb027842012-03-28 18:04:14 +0000556 this->WCharType = this->SignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000557 // FIXME: WIntType should be SignedLong
558 }
559};
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000560
561// Windows target
562template<typename Target>
563class WindowsTargetInfo : public OSTargetInfo<Target> {
564protected:
565 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
566 MacroBuilder &Builder) const {
Michael J. Spencera764e832010-10-21 08:22:51 +0000567 Builder.defineMacro("_WIN32");
568 }
569 void getVisualStudioDefines(const LangOptions &Opts,
570 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000571 if (Opts.CPlusPlus) {
572 if (Opts.RTTI)
573 Builder.defineMacro("_CPPRTTI");
574
575 if (Opts.Exceptions)
576 Builder.defineMacro("_CPPUNWIND");
577 }
578
579 if (!Opts.CharIsSigned)
580 Builder.defineMacro("_CHAR_UNSIGNED");
581
582 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
583 // but it works for now.
584 if (Opts.POSIXThreads)
585 Builder.defineMacro("_MT");
Michael J. Spencera764e832010-10-21 08:22:51 +0000586
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000587 if (Opts.MSCVersion != 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000588 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000589
Francois Pichet62ec1f22011-09-17 17:15:52 +0000590 if (Opts.MicrosoftExt) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000591 Builder.defineMacro("_MSC_EXTENSIONS");
592
Richard Smith80ad52f2013-01-02 11:42:31 +0000593 if (Opts.CPlusPlus11) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000594 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
595 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
596 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
597 }
598 }
599
600 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000601 }
602
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000603public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000604 WindowsTargetInfo(const llvm::Triple &Triple)
605 : OSTargetInfo<Target>(Triple) {}
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000606};
607
Derek Schuff7da46f92012-10-11 16:55:58 +0000608template <typename Target>
609class NaClTargetInfo : public OSTargetInfo<Target> {
Benjamin Kramer9df08232013-06-29 16:37:14 +0000610protected:
Derek Schuff7da46f92012-10-11 16:55:58 +0000611 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
612 MacroBuilder &Builder) const {
613 if (Opts.POSIXThreads)
614 Builder.defineMacro("_REENTRANT");
615 if (Opts.CPlusPlus)
616 Builder.defineMacro("_GNU_SOURCE");
617
618 DefineStd(Builder, "unix", Opts);
619 Builder.defineMacro("__ELF__");
620 Builder.defineMacro("__native_client__");
621 }
Benjamin Kramer9df08232013-06-29 16:37:14 +0000622
623public:
624 NaClTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Derek Schuff7da46f92012-10-11 16:55:58 +0000625 this->UserLabelPrefix = "";
626 this->LongAlign = 32;
627 this->LongWidth = 32;
628 this->PointerAlign = 32;
629 this->PointerWidth = 32;
630 this->IntMaxType = TargetInfo::SignedLongLong;
631 this->UIntMaxType = TargetInfo::UnsignedLongLong;
632 this->Int64Type = TargetInfo::SignedLongLong;
633 this->DoubleAlign = 64;
634 this->LongDoubleWidth = 64;
635 this->LongDoubleAlign = 64;
636 this->SizeType = TargetInfo::UnsignedInt;
637 this->PtrDiffType = TargetInfo::SignedInt;
638 this->IntPtrType = TargetInfo::SignedInt;
Eli Benderskyc0783dc2013-04-08 21:31:01 +0000639 // RegParmMax is inherited from the underlying architecture
Derek Schuff7da46f92012-10-11 16:55:58 +0000640 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble;
641 this->DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
642 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
643 }
Derek Schuff263366f2012-10-16 22:30:41 +0000644 virtual typename Target::CallingConvCheckResult checkCallingConvention(
645 CallingConv CC) const {
646 return CC == CC_PnaclCall ? Target::CCCR_OK :
647 Target::checkCallingConvention(CC);
648 }
Derek Schuff7da46f92012-10-11 16:55:58 +0000649};
Mike Stump1eb44332009-09-09 15:08:12 +0000650} // end anonymous namespace.
Torok Edwin5f6c1942009-06-30 17:10:35 +0000651
Chris Lattnerd29b6302008-10-05 21:50:58 +0000652//===----------------------------------------------------------------------===//
Eli Friedmane4277982008-08-20 23:11:40 +0000653// Specific target implementations.
654//===----------------------------------------------------------------------===//
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +0000655
Eli Friedmane4277982008-08-20 23:11:40 +0000656namespace {
657// PPC abstract base class
658class PPCTargetInfo : public TargetInfo {
659 static const Builtin::Info BuiltinInfo[];
660 static const char * const GCCRegNames[];
661 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Hal Finkel02a84272012-06-11 22:35:19 +0000662 std::string CPU;
Eric Christopher16543202013-10-16 21:19:26 +0000663
664 // Target cpu features.
665 bool HasVSX;
666
Eli Friedmane4277982008-08-20 23:11:40 +0000667public:
Eric Christopher16543202013-10-16 21:19:26 +0000668 PPCTargetInfo(const llvm::Triple &Triple)
669 : TargetInfo(Triple), HasVSX(false) {
Bill Schmidtea7fb0c2013-07-26 01:36:11 +0000670 BigEndian = (Triple.getArch() != llvm::Triple::ppc64le);
Nico Weber6e1d2ea2012-01-31 02:07:33 +0000671 LongDoubleWidth = LongDoubleAlign = 128;
672 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
673 }
Eli Friedman15b91762009-06-05 07:05:05 +0000674
Hal Finkel39d5fa12012-07-03 16:51:04 +0000675 /// \brief Flags for architecture specific defines.
676 typedef enum {
677 ArchDefineNone = 0,
678 ArchDefineName = 1 << 0, // <name> is substituted for arch name.
679 ArchDefinePpcgr = 1 << 1,
680 ArchDefinePpcsq = 1 << 2,
681 ArchDefine440 = 1 << 3,
682 ArchDefine603 = 1 << 4,
683 ArchDefine604 = 1 << 5,
684 ArchDefinePwr4 = 1 << 6,
Bill Schmidt2821e182013-02-01 20:23:10 +0000685 ArchDefinePwr5 = 1 << 7,
686 ArchDefinePwr5x = 1 << 8,
687 ArchDefinePwr6 = 1 << 9,
688 ArchDefinePwr6x = 1 << 10,
689 ArchDefinePwr7 = 1 << 11,
690 ArchDefineA2 = 1 << 12,
691 ArchDefineA2q = 1 << 13
Hal Finkel39d5fa12012-07-03 16:51:04 +0000692 } ArchDefineTypes;
693
Bill Schmidt2821e182013-02-01 20:23:10 +0000694 // Note: GCC recognizes the following additional cpus:
695 // 401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801,
696 // 821, 823, 8540, 8548, e300c2, e300c3, e500mc64, e6500, 860, cell,
697 // titan, rs64.
Hal Finkel02a84272012-06-11 22:35:19 +0000698 virtual bool setCPU(const std::string &Name) {
699 bool CPUKnown = llvm::StringSwitch<bool>(Name)
700 .Case("generic", true)
701 .Case("440", true)
702 .Case("450", true)
703 .Case("601", true)
704 .Case("602", true)
705 .Case("603", true)
706 .Case("603e", true)
707 .Case("603ev", true)
708 .Case("604", true)
709 .Case("604e", true)
710 .Case("620", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000711 .Case("630", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000712 .Case("g3", true)
713 .Case("7400", true)
714 .Case("g4", true)
715 .Case("7450", true)
716 .Case("g4+", true)
717 .Case("750", true)
718 .Case("970", true)
719 .Case("g5", true)
720 .Case("a2", true)
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000721 .Case("a2q", true)
Hal Finkel7de32962012-09-18 22:25:03 +0000722 .Case("e500mc", true)
723 .Case("e5500", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000724 .Case("power3", true)
725 .Case("pwr3", true)
726 .Case("power4", true)
727 .Case("pwr4", true)
728 .Case("power5", true)
729 .Case("pwr5", true)
730 .Case("power5x", true)
731 .Case("pwr5x", true)
732 .Case("power6", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000733 .Case("pwr6", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000734 .Case("power6x", true)
735 .Case("pwr6x", true)
736 .Case("power7", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000737 .Case("pwr7", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000738 .Case("powerpc", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000739 .Case("ppc", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000740 .Case("powerpc64", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000741 .Case("ppc64", true)
Bill Schmidtea7fb0c2013-07-26 01:36:11 +0000742 .Case("powerpc64le", true)
743 .Case("ppc64le", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000744 .Default(false);
745
746 if (CPUKnown)
747 CPU = Name;
748
749 return CPUKnown;
750 }
751
Eli Friedmane4277982008-08-20 23:11:40 +0000752 virtual void getTargetBuiltins(const Builtin::Info *&Records,
753 unsigned &NumRecords) const {
Reid Spencer5f016e22007-07-11 17:01:13 +0000754 Records = BuiltinInfo;
Eli Friedmane4277982008-08-20 23:11:40 +0000755 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +0000756 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000757
Bob Wilson9f1c49c2012-01-28 18:02:29 +0000758 virtual bool isCLZForZeroUndef() const { return false; }
759
Chris Lattner33328642009-03-20 15:52:06 +0000760 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000761 MacroBuilder &Builder) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000762
Bill Schmidt199402b2013-02-01 02:14:03 +0000763 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
764
Eric Christopher3d11ced2013-10-16 21:26:26 +0000765 virtual bool handleTargetFeatures(std::vector<std::string> &Features,
Eric Christopher16543202013-10-16 21:19:26 +0000766 DiagnosticsEngine &Diags);
Douglas Gregore727d212012-01-30 06:38:25 +0000767 virtual bool hasFeature(StringRef Feature) const;
768
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000769 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000770 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000771 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000772 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000773 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +0000774 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000775 switch (*Name) {
Anders Carlssond04c6e22007-11-27 04:11:28 +0000776 default: return false;
777 case 'O': // Zero
John Thompson8e6065a2010-06-24 22:44:13 +0000778 break;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000779 case 'b': // Base register
780 case 'f': // Floating point register
Chris Lattner44def072009-04-26 07:16:29 +0000781 Info.setAllowsRegister();
John Thompson8e6065a2010-06-24 22:44:13 +0000782 break;
783 // FIXME: The following are added to allow parsing.
784 // I just took a guess at what the actions should be.
785 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer20249a12010-10-21 03:16:25 +0000786 case 'd': // Floating point register (containing 64-bit value)
John Thompson8e6065a2010-06-24 22:44:13 +0000787 case 'v': // Altivec vector register
788 Info.setAllowsRegister();
789 break;
790 case 'w':
791 switch (Name[1]) {
Michael J. Spencer20249a12010-10-21 03:16:25 +0000792 case 'd':// VSX vector register to hold vector double data
793 case 'f':// VSX vector register to hold vector float data
794 case 's':// VSX vector register to hold scalar float data
795 case 'a':// Any VSX register
John Thompson8e6065a2010-06-24 22:44:13 +0000796 break;
797 default:
798 return false;
799 }
800 Info.setAllowsRegister();
801 Name++; // Skip over 'w'.
802 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000803 case 'h': // `MQ', `CTR', or `LINK' register
804 case 'q': // `MQ' register
805 case 'c': // `CTR' register
806 case 'l': // `LINK' register
807 case 'x': // `CR' register (condition register) number 0
808 case 'y': // `CR' register (condition register)
809 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson8e6065a2010-06-24 22:44:13 +0000810 Info.setAllowsRegister();
811 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000812 case 'I': // Signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000813 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer20249a12010-10-21 03:16:25 +0000814 // (use `L' instead for SImode constants)
815 case 'K': // Unsigned 16-bit constant
816 case 'L': // Signed 16-bit constant shifted left 16 bits
817 case 'M': // Constant larger than 31
818 case 'N': // Exact power of 2
819 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000820 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000821 // register with one instruction per word
John Thompson8e6065a2010-06-24 22:44:13 +0000822 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer20249a12010-10-21 03:16:25 +0000823 // into a register using three instructions
John Thompson8e6065a2010-06-24 22:44:13 +0000824 break;
825 case 'm': // Memory operand. Note that on PowerPC targets, m can
826 // include addresses that update the base register. It
827 // is therefore only safe to use `m' in an asm statement
828 // if that asm statement accesses the operand exactly once.
829 // The asm statement must also use `%U<opno>' as a
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000830 // placeholder for the "update" flag in the corresponding
Michael J. Spencer20249a12010-10-21 03:16:25 +0000831 // load or store instruction. For example:
John Thompson8e6065a2010-06-24 22:44:13 +0000832 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000833 // is correct but:
John Thompson8e6065a2010-06-24 22:44:13 +0000834 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
835 // is not. Use es rather than m if you don't want the base
Michael J. Spencer20249a12010-10-21 03:16:25 +0000836 // register to be updated.
837 case 'e':
John Thompson56b6eca2010-06-25 00:02:05 +0000838 if (Name[1] != 's')
839 return false;
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000840 // es: A "stable" memory operand; that is, one which does not
John Thompson8e6065a2010-06-24 22:44:13 +0000841 // include any automodification of the base register. Unlike
842 // `m', this constraint can be used in asm statements that
843 // might access the operand several times, or that might not
John Thompson56b6eca2010-06-25 00:02:05 +0000844 // access it at all.
John Thompson8e6065a2010-06-24 22:44:13 +0000845 Info.setAllowsMemory();
John Thompson56b6eca2010-06-25 00:02:05 +0000846 Name++; // Skip over 'e'.
John Thompson8e6065a2010-06-24 22:44:13 +0000847 break;
848 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer20249a12010-10-21 03:16:25 +0000849 // usually better to use `m' or `es' in asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000850 case 'Z': // Memory operand that is an indexed or indirect from a
851 // register (it is usually better to use `m' or `es' in
Michael J. Spencer20249a12010-10-21 03:16:25 +0000852 // asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000853 Info.setAllowsMemory();
854 Info.setAllowsRegister();
855 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000856 case 'R': // AIX TOC entry
John Thompson8e6065a2010-06-24 22:44:13 +0000857 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000858 // register (`p' is preferable for asm statements)
859 case 'S': // Constant suitable as a 64-bit mask operand
860 case 'T': // Constant suitable as a 32-bit mask operand
861 case 'U': // System V Release 4 small data area reference
John Thompson8e6065a2010-06-24 22:44:13 +0000862 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000863 // instructions
864 case 'W': // Vector constant that does not require memory
865 case 'j': // Vector constant that is all zeros.
John Thompson8e6065a2010-06-24 22:44:13 +0000866 break;
867 // End FIXME.
Anders Carlssond04c6e22007-11-27 04:11:28 +0000868 }
John Thompson8e6065a2010-06-24 22:44:13 +0000869 return true;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000870 }
Eli Friedmane4277982008-08-20 23:11:40 +0000871 virtual const char *getClobbers() const {
872 return "";
Anders Carlssond04c6e22007-11-27 04:11:28 +0000873 }
Adhemerval Zanellab0fc94c2013-01-22 20:02:45 +0000874 int getEHDataRegisterNumber(unsigned RegNo) const {
875 if (RegNo == 0) return 3;
876 if (RegNo == 1) return 4;
877 return -1;
878 }
Eli Friedmane4277982008-08-20 23:11:40 +0000879};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000880
Eli Friedmane4277982008-08-20 23:11:40 +0000881const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000882#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000883#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000884 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000885#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000886};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000887
Eric Christopher3d11ced2013-10-16 21:26:26 +0000888 /// handleTargetFeatures - Perform initialization based on the user
Eric Christopher16543202013-10-16 21:19:26 +0000889/// configured set of features.
Eric Christopher3d11ced2013-10-16 21:26:26 +0000890bool PPCTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
Eric Christopher16543202013-10-16 21:19:26 +0000891 DiagnosticsEngine &Diags) {
892 // Remember the maximum enabled sselevel.
893 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
894 // Ignore disabled features.
895 if (Features[i][0] == '-')
896 continue;
897
898 StringRef Feature = StringRef(Features[i]).substr(1);
899
900 if (Feature == "vsx") {
901 HasVSX = true;
902 continue;
903 }
904
905 // TODO: Finish this list and add an assert that we've handled them
906 // all.
907 }
908
909 return true;
910}
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000911
Chris Lattnerc0f59212009-03-02 22:27:17 +0000912/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
913/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000914void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000915 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000916 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000917 Builder.defineMacro("__ppc__");
Chandler Carruthc6fa1152013-06-25 11:13:47 +0000918 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000919 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000920 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000921 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000922 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000923 Builder.defineMacro("_ARCH_PPC64");
Chris Lattnere03ae302010-02-16 18:14:57 +0000924 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000925 Builder.defineMacro("__ppc64__");
Chandler Carruthc6fa1152013-06-25 11:13:47 +0000926 Builder.defineMacro("__PPC64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000927 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000928
Chris Lattnerc0f59212009-03-02 22:27:17 +0000929 // Target properties.
Bill Schmidtea7fb0c2013-07-26 01:36:11 +0000930 if (getTriple().getArch() == llvm::Triple::ppc64le) {
931 Builder.defineMacro("_LITTLE_ENDIAN");
932 Builder.defineMacro("__LITTLE_ENDIAN__");
933 } else {
934 if (getTriple().getOS() != llvm::Triple::NetBSD &&
935 getTriple().getOS() != llvm::Triple::OpenBSD)
936 Builder.defineMacro("_BIG_ENDIAN");
937 Builder.defineMacro("__BIG_ENDIAN__");
938 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000939
Chris Lattnerc0f59212009-03-02 22:27:17 +0000940 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000941 Builder.defineMacro("__NATURAL_ALIGNMENT__");
942 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000943
Chris Lattnerc0f59212009-03-02 22:27:17 +0000944 // FIXME: Should be controlled by command line option.
Roman Divackyb2f6f472013-07-03 19:45:54 +0000945 if (LongDoubleWidth == 128)
946 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000947
John Thompson3f6918a2009-11-19 17:18:50 +0000948 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000949 Builder.defineMacro("__VEC__", "10206");
950 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000951 }
Hal Finkel02a84272012-06-11 22:35:19 +0000952
953 // CPU identification.
Hal Finkel39d5fa12012-07-03 16:51:04 +0000954 ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
955 .Case("440", ArchDefineName)
956 .Case("450", ArchDefineName | ArchDefine440)
957 .Case("601", ArchDefineName)
958 .Case("602", ArchDefineName | ArchDefinePpcgr)
959 .Case("603", ArchDefineName | ArchDefinePpcgr)
960 .Case("603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
961 .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
962 .Case("604", ArchDefineName | ArchDefinePpcgr)
963 .Case("604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
964 .Case("620", ArchDefineName | ArchDefinePpcgr)
Bill Schmidt2821e182013-02-01 20:23:10 +0000965 .Case("630", ArchDefineName | ArchDefinePpcgr)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000966 .Case("7400", ArchDefineName | ArchDefinePpcgr)
967 .Case("7450", ArchDefineName | ArchDefinePpcgr)
968 .Case("750", ArchDefineName | ArchDefinePpcgr)
969 .Case("970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
970 | ArchDefinePpcsq)
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000971 .Case("a2", ArchDefineA2)
972 .Case("a2q", ArchDefineName | ArchDefineA2 | ArchDefineA2q)
Bill Schmidt2821e182013-02-01 20:23:10 +0000973 .Case("pwr3", ArchDefinePpcgr)
974 .Case("pwr4", ArchDefineName | ArchDefinePpcgr | ArchDefinePpcsq)
975 .Case("pwr5", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
976 | ArchDefinePpcsq)
977 .Case("pwr5x", ArchDefineName | ArchDefinePwr5 | ArchDefinePwr4
978 | ArchDefinePpcgr | ArchDefinePpcsq)
979 .Case("pwr6", ArchDefineName | ArchDefinePwr5x | ArchDefinePwr5
980 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
981 .Case("pwr6x", ArchDefineName | ArchDefinePwr6 | ArchDefinePwr5x
982 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
983 | ArchDefinePpcsq)
984 .Case("pwr7", ArchDefineName | ArchDefinePwr6x | ArchDefinePwr6
985 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
986 | ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq)
987 .Case("power3", ArchDefinePpcgr)
988 .Case("power4", ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
989 .Case("power5", ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
990 | ArchDefinePpcsq)
991 .Case("power5x", ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
992 | ArchDefinePpcgr | ArchDefinePpcsq)
993 .Case("power6", ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
994 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
995 .Case("power6x", ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x
996 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
997 | ArchDefinePpcsq)
998 .Case("power7", ArchDefinePwr7 | ArchDefinePwr6x | ArchDefinePwr6
999 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
1000 | ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq)
Hal Finkel39d5fa12012-07-03 16:51:04 +00001001 .Default(ArchDefineNone);
1002
1003 if (defs & ArchDefineName)
1004 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
1005 if (defs & ArchDefinePpcgr)
1006 Builder.defineMacro("_ARCH_PPCGR");
1007 if (defs & ArchDefinePpcsq)
1008 Builder.defineMacro("_ARCH_PPCSQ");
1009 if (defs & ArchDefine440)
Hal Finkel02a84272012-06-11 22:35:19 +00001010 Builder.defineMacro("_ARCH_440");
Hal Finkel39d5fa12012-07-03 16:51:04 +00001011 if (defs & ArchDefine603)
1012 Builder.defineMacro("_ARCH_603");
1013 if (defs & ArchDefine604)
1014 Builder.defineMacro("_ARCH_604");
Bill Schmidt2821e182013-02-01 20:23:10 +00001015 if (defs & ArchDefinePwr4)
Hal Finkel39d5fa12012-07-03 16:51:04 +00001016 Builder.defineMacro("_ARCH_PWR4");
Bill Schmidt2821e182013-02-01 20:23:10 +00001017 if (defs & ArchDefinePwr5)
Hal Finkel39d5fa12012-07-03 16:51:04 +00001018 Builder.defineMacro("_ARCH_PWR5");
Bill Schmidt2821e182013-02-01 20:23:10 +00001019 if (defs & ArchDefinePwr5x)
1020 Builder.defineMacro("_ARCH_PWR5X");
1021 if (defs & ArchDefinePwr6)
Hal Finkel02a84272012-06-11 22:35:19 +00001022 Builder.defineMacro("_ARCH_PWR6");
Bill Schmidt2821e182013-02-01 20:23:10 +00001023 if (defs & ArchDefinePwr6x)
1024 Builder.defineMacro("_ARCH_PWR6X");
1025 if (defs & ArchDefinePwr7)
1026 Builder.defineMacro("_ARCH_PWR7");
Hal Finkel5ccd3d02013-02-01 05:53:33 +00001027 if (defs & ArchDefineA2)
1028 Builder.defineMacro("_ARCH_A2");
1029 if (defs & ArchDefineA2q) {
1030 Builder.defineMacro("_ARCH_A2Q");
1031 Builder.defineMacro("_ARCH_QP");
1032 }
1033
1034 if (getTriple().getVendor() == llvm::Triple::BGQ) {
1035 Builder.defineMacro("__bg__");
1036 Builder.defineMacro("__THW_BLUEGENE__");
1037 Builder.defineMacro("__bgq__");
1038 Builder.defineMacro("__TOS_BGQ__");
1039 }
Bill Schmidt2821e182013-02-01 20:23:10 +00001040
Eric Christopher16543202013-10-16 21:19:26 +00001041 if (HasVSX)
1042 Builder.defineMacro("__VSX__");
1043
Bill Schmidt2821e182013-02-01 20:23:10 +00001044 // FIXME: The following are not yet generated here by Clang, but are
1045 // generated by GCC:
1046 //
1047 // _SOFT_FLOAT_
1048 // __RECIP_PRECISION__
1049 // __APPLE_ALTIVEC__
Bill Schmidt2821e182013-02-01 20:23:10 +00001050 // __RECIP__
1051 // __RECIPF__
1052 // __RSQRTE__
1053 // __RSQRTEF__
1054 // _SOFT_DOUBLE_
1055 // __NO_LWSYNC__
1056 // __HAVE_BSWAP__
1057 // __LONGDOUBLE128
1058 // __CMODEL_MEDIUM__
1059 // __CMODEL_LARGE__
1060 // _CALL_SYSV
1061 // _CALL_DARWIN
1062 // __NO_FPRS__
Bill Schmidt199402b2013-02-01 02:14:03 +00001063}
1064
1065void PPCTargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
1066 Features["altivec"] = llvm::StringSwitch<bool>(CPU)
1067 .Case("7400", true)
1068 .Case("g4", true)
1069 .Case("7450", true)
1070 .Case("g4+", true)
1071 .Case("970", true)
1072 .Case("g5", true)
1073 .Case("pwr6", true)
1074 .Case("pwr7", true)
1075 .Case("ppc64", true)
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00001076 .Case("ppc64le", true)
Bill Schmidt199402b2013-02-01 02:14:03 +00001077 .Default(false);
Hal Finkel3c6aaeb2013-02-01 18:44:19 +00001078
1079 Features["qpx"] = (CPU == "a2q");
Bill Schmidt199402b2013-02-01 02:14:03 +00001080}
1081
Douglas Gregore727d212012-01-30 06:38:25 +00001082bool PPCTargetInfo::hasFeature(StringRef Feature) const {
1083 return Feature == "powerpc";
1084}
Chris Lattner393ff042008-04-21 18:56:49 +00001085
Douglas Gregore727d212012-01-30 06:38:25 +00001086
Eli Friedmane4277982008-08-20 23:11:40 +00001087const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +00001088 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1089 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1090 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1091 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1092 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
1093 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
1094 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
1095 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +00001096 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +00001097 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +00001098 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +00001099 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1100 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
1101 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
1102 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +00001103 "vrsave", "vscr",
1104 "spe_acc", "spefscr",
1105 "sfp"
1106};
Reid Spencer5f016e22007-07-11 17:01:13 +00001107
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001108void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +00001109 unsigned &NumNames) const {
1110 Names = GCCRegNames;
1111 NumNames = llvm::array_lengthof(GCCRegNames);
1112}
Reid Spencer5f016e22007-07-11 17:01:13 +00001113
Eli Friedmane4277982008-08-20 23:11:40 +00001114const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
1115 // While some of these aliases do map to different registers
1116 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00001117 { { "0" }, "r0" },
1118 { { "1"}, "r1" },
1119 { { "2" }, "r2" },
1120 { { "3" }, "r3" },
1121 { { "4" }, "r4" },
1122 { { "5" }, "r5" },
1123 { { "6" }, "r6" },
1124 { { "7" }, "r7" },
1125 { { "8" }, "r8" },
1126 { { "9" }, "r9" },
1127 { { "10" }, "r10" },
1128 { { "11" }, "r11" },
1129 { { "12" }, "r12" },
1130 { { "13" }, "r13" },
1131 { { "14" }, "r14" },
1132 { { "15" }, "r15" },
1133 { { "16" }, "r16" },
1134 { { "17" }, "r17" },
1135 { { "18" }, "r18" },
1136 { { "19" }, "r19" },
1137 { { "20" }, "r20" },
1138 { { "21" }, "r21" },
1139 { { "22" }, "r22" },
1140 { { "23" }, "r23" },
1141 { { "24" }, "r24" },
1142 { { "25" }, "r25" },
1143 { { "26" }, "r26" },
1144 { { "27" }, "r27" },
1145 { { "28" }, "r28" },
1146 { { "29" }, "r29" },
1147 { { "30" }, "r30" },
1148 { { "31" }, "r31" },
1149 { { "fr0" }, "f0" },
1150 { { "fr1" }, "f1" },
1151 { { "fr2" }, "f2" },
1152 { { "fr3" }, "f3" },
1153 { { "fr4" }, "f4" },
1154 { { "fr5" }, "f5" },
1155 { { "fr6" }, "f6" },
1156 { { "fr7" }, "f7" },
1157 { { "fr8" }, "f8" },
1158 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +00001159 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00001160 { { "fr11" }, "f11" },
1161 { { "fr12" }, "f12" },
1162 { { "fr13" }, "f13" },
1163 { { "fr14" }, "f14" },
1164 { { "fr15" }, "f15" },
1165 { { "fr16" }, "f16" },
1166 { { "fr17" }, "f17" },
1167 { { "fr18" }, "f18" },
1168 { { "fr19" }, "f19" },
1169 { { "fr20" }, "f20" },
1170 { { "fr21" }, "f21" },
1171 { { "fr22" }, "f22" },
1172 { { "fr23" }, "f23" },
1173 { { "fr24" }, "f24" },
1174 { { "fr25" }, "f25" },
1175 { { "fr26" }, "f26" },
1176 { { "fr27" }, "f27" },
1177 { { "fr28" }, "f28" },
1178 { { "fr29" }, "f29" },
1179 { { "fr30" }, "f30" },
1180 { { "fr31" }, "f31" },
1181 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +00001182};
1183
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001184void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +00001185 unsigned &NumAliases) const {
1186 Aliases = GCCRegAliases;
1187 NumAliases = llvm::array_lengthof(GCCRegAliases);
1188}
1189} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00001190
1191namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001192class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001193public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001194 PPC32TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +00001195 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner1932e122009-11-07 18:59:41 +00001196 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +00001197
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001198 switch (getTriple().getOS()) {
Nico Weber6e1d2ea2012-01-31 02:07:33 +00001199 case llvm::Triple::Linux:
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001200 case llvm::Triple::FreeBSD:
1201 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001202 SizeType = UnsignedInt;
Hal Finkel178a9b82012-03-02 20:54:36 +00001203 PtrDiffType = SignedInt;
1204 IntPtrType = SignedInt;
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001205 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +00001206 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001207 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001208 }
Roman Divackye3d175d2012-03-13 16:53:54 +00001209
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001210 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1211 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001212 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001213 }
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001214
1215 // PPC32 supports atomics up to 4 bytes.
1216 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001217 }
1218
Meador Ingec5613b22012-06-16 03:34:49 +00001219 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001220 // This is the ELF definition, and is overridden by the Darwin sub-target
Meador Ingec5613b22012-06-16 03:34:49 +00001221 return TargetInfo::PowerABIBuiltinVaList;
Eli Friedmaned855cb2008-08-21 00:13:15 +00001222 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001223};
1224} // end anonymous namespace.
1225
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00001226// Note: ABI differences may eventually require us to have a separate
1227// TargetInfo for little endian.
Reid Spencer5f016e22007-07-11 17:01:13 +00001228namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001229class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001230public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001231 PPC64TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00001232 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00001233 IntMaxType = SignedLong;
1234 UIntMaxType = UnsignedLong;
1235 Int64Type = SignedLong;
Roman Divackye3d175d2012-03-13 16:53:54 +00001236
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001237 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1238 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001239 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001240 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Bill Schmidtb1baad62013-07-03 21:03:06 +00001241 "i64:64:64-f32:32:32-f64:64:64-"
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001242 "v128:128:128-n32:64";
1243 } else
1244 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1245 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
1246 "v128:128:128-n32:64";
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001247
1248 // PPC64 supports atomics up to 8 bytes.
1249 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Chris Lattnerf291b102008-05-09 06:17:04 +00001250 }
Meador Ingec5613b22012-06-16 03:34:49 +00001251 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1252 return TargetInfo::CharPtrBuiltinVaList;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001253 }
Eli Friedmane4277982008-08-20 23:11:40 +00001254};
1255} // end anonymous namespace.
1256
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001257
1258namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001259class DarwinPPC32TargetInfo :
1260 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001261public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001262 DarwinPPC32TargetInfo(const llvm::Triple &Triple)
1263 : DarwinTargetInfo<PPC32TargetInfo>(Triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001264 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001265 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
Eric Christopherf2174002013-10-16 21:19:19 +00001266 PtrDiffType = SignedInt; // for http://llvm.org/bugs/show_bug.cgi?id=15726
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001267 LongLongAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001268 SuitableAlign = 128;
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001269 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1270 "i64:32:64-f32:32:32-f64:64:64-v128:128:128-n32";
Roman Divackyc81f2a22011-01-06 08:27:10 +00001271 }
Meador Ingec5613b22012-06-16 03:34:49 +00001272 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1273 return TargetInfo::CharPtrBuiltinVaList;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001274 }
1275};
1276
1277class DarwinPPC64TargetInfo :
1278 public DarwinTargetInfo<PPC64TargetInfo> {
1279public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001280 DarwinPPC64TargetInfo(const llvm::Triple &Triple)
1281 : DarwinTargetInfo<PPC64TargetInfo>(Triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001282 HasAlignMac68kSupport = true;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001283 SuitableAlign = 128;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001284 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1285 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001286 }
1287};
1288} // end anonymous namespace.
1289
Reid Spencer5f016e22007-07-11 17:01:13 +00001290namespace {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001291 static const unsigned NVPTXAddrSpaceMap[] = {
1292 1, // opencl_global
1293 3, // opencl_local
1294 4, // opencl_constant
1295 1, // cuda_device
1296 4, // cuda_constant
1297 3, // cuda_shared
1298 };
1299 class NVPTXTargetInfo : public TargetInfo {
1300 static const char * const GCCRegNames[];
Justin Holewinski2c585b92012-05-24 17:43:12 +00001301 static const Builtin::Info BuiltinInfo[];
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001302 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001303 NVPTXTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001304 BigEndian = false;
1305 TLSSupported = false;
1306 LongWidth = LongAlign = 64;
1307 AddrSpaceMap = &NVPTXAddrSpaceMap;
David Tweed1eef8522013-09-13 12:04:22 +00001308 UseAddrSpaceMapMangling = true;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001309 // Define available target features
1310 // These must be defined in sorted order!
Justin Holewinski9903e942012-07-11 15:34:55 +00001311 NoAsmVariants = true;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001312 }
1313 virtual void getTargetDefines(const LangOptions &Opts,
1314 MacroBuilder &Builder) const {
1315 Builder.defineMacro("__PTX__");
Justin Holewinski2c585b92012-05-24 17:43:12 +00001316 Builder.defineMacro("__NVPTX__");
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001317 }
1318 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1319 unsigned &NumRecords) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001320 Records = BuiltinInfo;
1321 NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001322 }
1323 virtual bool hasFeature(StringRef Feature) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001324 return Feature == "ptx" || Feature == "nvptx";
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001325 }
1326
1327 virtual void getGCCRegNames(const char * const *&Names,
1328 unsigned &NumNames) const;
1329 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1330 unsigned &NumAliases) const {
1331 // No aliases.
1332 Aliases = 0;
1333 NumAliases = 0;
1334 }
1335 virtual bool validateAsmConstraint(const char *&Name,
Justin Holewinski0ac428e2013-06-21 18:51:24 +00001336 TargetInfo::ConstraintInfo &Info) const {
1337 switch (*Name) {
1338 default: return false;
1339 case 'c':
1340 case 'h':
1341 case 'r':
1342 case 'l':
1343 case 'f':
1344 case 'd':
1345 Info.setAllowsRegister();
1346 return true;
1347 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001348 }
1349 virtual const char *getClobbers() const {
1350 // FIXME: Is this really right?
1351 return "";
1352 }
Meador Ingec5613b22012-06-16 03:34:49 +00001353 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001354 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00001355 return TargetInfo::CharPtrBuiltinVaList;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001356 }
1357 virtual bool setCPU(const std::string &Name) {
Justin Holewinskiaffa3af2013-03-30 14:38:26 +00001358 bool Valid = llvm::StringSwitch<bool>(Name)
1359 .Case("sm_20", true)
1360 .Case("sm_21", true)
1361 .Case("sm_30", true)
1362 .Case("sm_35", true)
1363 .Default(false);
1364
1365 return Valid;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001366 }
Justin Holewinski2c585b92012-05-24 17:43:12 +00001367 };
1368
1369 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1370#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1371#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1372 ALL_LANGUAGES },
1373#include "clang/Basic/BuiltinsNVPTX.def"
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001374 };
1375
1376 const char * const NVPTXTargetInfo::GCCRegNames[] = {
1377 "r0"
1378 };
1379
1380 void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names,
1381 unsigned &NumNames) const {
1382 Names = GCCRegNames;
1383 NumNames = llvm::array_lengthof(GCCRegNames);
1384 }
1385
1386 class NVPTX32TargetInfo : public NVPTXTargetInfo {
1387 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001388 NVPTX32TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001389 PointerWidth = PointerAlign = 32;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001390 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001391 DescriptionString
1392 = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1393 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1394 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001395 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001396 };
1397
1398 class NVPTX64TargetInfo : public NVPTXTargetInfo {
1399 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001400 NVPTX64TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001401 PointerWidth = PointerAlign = 64;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001402 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001403 DescriptionString
1404 = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1405 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1406 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001407 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001408 };
1409}
1410
1411namespace {
Eli Friedman6505a292012-10-12 23:32:00 +00001412
1413static const unsigned R600AddrSpaceMap[] = {
1414 1, // opencl_global
1415 3, // opencl_local
1416 2, // opencl_constant
1417 1, // cuda_device
1418 2, // cuda_constant
1419 3 // cuda_shared
1420};
1421
Tom Stellardfd075912013-03-04 17:40:53 +00001422static const char *DescriptionStringR600 =
1423 "e"
1424 "-p:32:32:32"
1425 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32"
1426 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1427 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1428 "-n32:64";
1429
1430static const char *DescriptionStringR600DoubleOps =
1431 "e"
1432 "-p:32:32:32"
1433 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64"
1434 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1435 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1436 "-n32:64";
1437
1438static const char *DescriptionStringSI =
1439 "e"
1440 "-p:64:64:64"
Tom Stellard9a3d2bd2013-08-27 00:55:26 +00001441 "-p3:32:32:32"
Tom Stellardfd075912013-03-04 17:40:53 +00001442 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64"
1443 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1444 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1445 "-n32:64";
1446
Eli Friedman6505a292012-10-12 23:32:00 +00001447class R600TargetInfo : public TargetInfo {
Tom Stellardfd075912013-03-04 17:40:53 +00001448 /// \brief The GPU profiles supported by the R600 target.
1449 enum GPUKind {
1450 GK_NONE,
1451 GK_R600,
1452 GK_R600_DOUBLE_OPS,
1453 GK_R700,
1454 GK_R700_DOUBLE_OPS,
1455 GK_EVERGREEN,
1456 GK_EVERGREEN_DOUBLE_OPS,
1457 GK_NORTHERN_ISLANDS,
1458 GK_CAYMAN,
1459 GK_SOUTHERN_ISLANDS
1460 } GPU;
1461
Eli Friedman6505a292012-10-12 23:32:00 +00001462public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001463 R600TargetInfo(const llvm::Triple &Triple)
1464 : TargetInfo(Triple), GPU(GK_R600) {
Tom Stellardfd075912013-03-04 17:40:53 +00001465 DescriptionString = DescriptionStringR600;
Eli Friedman6505a292012-10-12 23:32:00 +00001466 AddrSpaceMap = &R600AddrSpaceMap;
David Tweed1eef8522013-09-13 12:04:22 +00001467 UseAddrSpaceMapMangling = true;
Eli Friedman6505a292012-10-12 23:32:00 +00001468 }
1469
1470 virtual const char * getClobbers() const {
1471 return "";
1472 }
1473
1474 virtual void getGCCRegNames(const char * const *&Names,
1475 unsigned &numNames) const {
1476 Names = NULL;
1477 numNames = 0;
1478 }
1479
1480 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1481 unsigned &NumAliases) const {
1482 Aliases = NULL;
1483 NumAliases = 0;
1484 }
1485
1486 virtual bool validateAsmConstraint(const char *&Name,
1487 TargetInfo::ConstraintInfo &info) const {
1488 return true;
1489 }
1490
1491 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1492 unsigned &NumRecords) const {
1493 Records = NULL;
1494 NumRecords = 0;
1495 }
1496
1497
1498 virtual void getTargetDefines(const LangOptions &Opts,
1499 MacroBuilder &Builder) const {
1500 Builder.defineMacro("__R600__");
1501 }
1502
1503 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1504 return TargetInfo::CharPtrBuiltinVaList;
1505 }
1506
Tom Stellardfd075912013-03-04 17:40:53 +00001507 virtual bool setCPU(const std::string &Name) {
1508 GPU = llvm::StringSwitch<GPUKind>(Name)
1509 .Case("r600" , GK_R600)
1510 .Case("rv610", GK_R600)
1511 .Case("rv620", GK_R600)
1512 .Case("rv630", GK_R600)
1513 .Case("rv635", GK_R600)
1514 .Case("rs780", GK_R600)
1515 .Case("rs880", GK_R600)
1516 .Case("rv670", GK_R600_DOUBLE_OPS)
1517 .Case("rv710", GK_R700)
1518 .Case("rv730", GK_R700)
1519 .Case("rv740", GK_R700_DOUBLE_OPS)
1520 .Case("rv770", GK_R700_DOUBLE_OPS)
1521 .Case("palm", GK_EVERGREEN)
1522 .Case("cedar", GK_EVERGREEN)
1523 .Case("sumo", GK_EVERGREEN)
1524 .Case("sumo2", GK_EVERGREEN)
1525 .Case("redwood", GK_EVERGREEN)
1526 .Case("juniper", GK_EVERGREEN)
1527 .Case("hemlock", GK_EVERGREEN_DOUBLE_OPS)
1528 .Case("cypress", GK_EVERGREEN_DOUBLE_OPS)
1529 .Case("barts", GK_NORTHERN_ISLANDS)
1530 .Case("turks", GK_NORTHERN_ISLANDS)
1531 .Case("caicos", GK_NORTHERN_ISLANDS)
1532 .Case("cayman", GK_CAYMAN)
1533 .Case("aruba", GK_CAYMAN)
Tom Stellard3b848ec2013-04-01 20:56:49 +00001534 .Case("tahiti", GK_SOUTHERN_ISLANDS)
Tom Stellardfd075912013-03-04 17:40:53 +00001535 .Case("pitcairn", GK_SOUTHERN_ISLANDS)
1536 .Case("verde", GK_SOUTHERN_ISLANDS)
1537 .Case("oland", GK_SOUTHERN_ISLANDS)
1538 .Default(GK_NONE);
1539
1540 if (GPU == GK_NONE) {
1541 return false;
1542 }
1543
1544 // Set the correct data layout
1545 switch (GPU) {
1546 case GK_NONE:
1547 case GK_R600:
1548 case GK_R700:
1549 case GK_EVERGREEN:
1550 case GK_NORTHERN_ISLANDS:
1551 DescriptionString = DescriptionStringR600;
1552 break;
1553 case GK_R600_DOUBLE_OPS:
1554 case GK_R700_DOUBLE_OPS:
1555 case GK_EVERGREEN_DOUBLE_OPS:
1556 case GK_CAYMAN:
1557 DescriptionString = DescriptionStringR600DoubleOps;
1558 break;
1559 case GK_SOUTHERN_ISLANDS:
1560 DescriptionString = DescriptionStringSI;
1561 break;
1562 }
1563
1564 return true;
1565 }
Eli Friedman6505a292012-10-12 23:32:00 +00001566};
1567
1568} // end anonymous namespace
1569
1570namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001571// Namespace for x86 abstract base class
1572const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001573#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001574#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001575 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001576#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001577};
Eli Friedman61538a72008-05-20 14:21:01 +00001578
Nuno Lopes2550d702009-12-23 17:49:57 +00001579static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001580 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1581 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001582 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001583 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1584 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1585 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001586 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopherc5f9a012011-12-02 02:12:16 +00001587 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1588 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001589};
1590
Eric Christophercfd323d2011-06-21 00:05:20 +00001591const TargetInfo::AddlRegName AddlRegNames[] = {
1592 { { "al", "ah", "eax", "rax" }, 0 },
1593 { { "bl", "bh", "ebx", "rbx" }, 3 },
1594 { { "cl", "ch", "ecx", "rcx" }, 2 },
1595 { { "dl", "dh", "edx", "rdx" }, 1 },
1596 { { "esi", "rsi" }, 4 },
1597 { { "edi", "rdi" }, 5 },
1598 { { "esp", "rsp" }, 7 },
1599 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001600};
1601
1602// X86 target abstract base class; x86-32 and x86-64 are very close, so
1603// most of the implementation can be shared.
1604class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001605 enum X86SSEEnum {
Craig Topperb7a95d22013-08-21 03:59:22 +00001606 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2, AVX512F
Chris Lattner84f0ea82009-03-02 22:40:39 +00001607 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001608 enum MMX3DNowEnum {
1609 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1610 } MMX3DNowLevel;
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00001611 enum XOPEnum {
1612 NoXOP,
1613 SSE4A,
1614 FMA4,
1615 XOP
1616 } XOPLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001617
Eric Christophereea12d12010-04-02 23:50:19 +00001618 bool HasAES;
Craig Topper3c0bc152012-05-31 05:18:48 +00001619 bool HasPCLMUL;
Craig Topper31ceea02011-12-25 05:06:45 +00001620 bool HasLZCNT;
Benjamin Kramer84f30802012-07-07 09:39:18 +00001621 bool HasRDRND;
Craig Topper31ceea02011-12-25 05:06:45 +00001622 bool HasBMI;
1623 bool HasBMI2;
Craig Toppere14e08b2011-12-29 16:10:46 +00001624 bool HasPOPCNT;
Michael Liao463eb892012-11-10 05:17:46 +00001625 bool HasRTM;
Michael Liao72339a02013-03-26 17:52:08 +00001626 bool HasPRFCHW;
Michael Liao1bfc28c2013-03-29 05:17:55 +00001627 bool HasRDSEED;
Yunzhong Gaoa8f7d9d2013-09-24 19:00:58 +00001628 bool HasTBM;
Craig Topper2ae95072012-06-03 21:46:30 +00001629 bool HasFMA;
Manman Ren146e5a42012-10-11 00:59:55 +00001630 bool HasF16C;
Craig Topperbca2c4f2013-08-21 05:29:10 +00001631 bool HasAVX512CD, HasAVX512ER, HasAVX512PF;
Ben Langmuirb83f5a72013-09-19 13:22:04 +00001632 bool HasSHA;
Nick Lewyckyaf945462013-10-05 20:14:27 +00001633 bool HasCX16;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001634
Chandler Carruth499d9722011-09-28 08:55:34 +00001635 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1636 ///
1637 /// Each enumeration represents a particular CPU supported by Clang. These
1638 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1639 enum CPUKind {
1640 CK_Generic,
1641
1642 /// \name i386
1643 /// i386-generation processors.
1644 //@{
1645 CK_i386,
1646 //@}
1647
1648 /// \name i486
1649 /// i486-generation processors.
1650 //@{
1651 CK_i486,
1652 CK_WinChipC6,
1653 CK_WinChip2,
1654 CK_C3,
1655 //@}
1656
1657 /// \name i586
1658 /// i586-generation processors, P5 microarchitecture based.
1659 //@{
1660 CK_i586,
1661 CK_Pentium,
1662 CK_PentiumMMX,
1663 //@}
1664
1665 /// \name i686
1666 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1667 //@{
1668 CK_i686,
1669 CK_PentiumPro,
1670 CK_Pentium2,
1671 CK_Pentium3,
1672 CK_Pentium3M,
1673 CK_PentiumM,
1674 CK_C3_2,
1675
1676 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1677 /// Clang however has some logic to suport this.
1678 // FIXME: Warn, deprecate, and potentially remove this.
1679 CK_Yonah,
1680 //@}
1681
1682 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001683 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001684 //@{
1685 CK_Pentium4,
1686 CK_Pentium4M,
1687 CK_Prescott,
1688 CK_Nocona,
1689 //@}
1690
1691 /// \name Core
1692 /// Core microarchitecture based processors.
1693 //@{
1694 CK_Core2,
1695
1696 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1697 /// codename which GCC no longer accepts as an option to -march, but Clang
1698 /// has some logic for recognizing it.
1699 // FIXME: Warn, deprecate, and potentially remove this.
1700 CK_Penryn,
1701 //@}
1702
1703 /// \name Atom
1704 /// Atom processors
1705 //@{
1706 CK_Atom,
Preston Gurdc57ea682013-09-13 19:27:17 +00001707 CK_Silvermont,
Chandler Carruth499d9722011-09-28 08:55:34 +00001708 //@}
1709
1710 /// \name Nehalem
1711 /// Nehalem microarchitecture based processors.
1712 //@{
1713 CK_Corei7,
1714 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001715 CK_CoreAVXi,
Craig Topper2b03bb02011-12-17 19:55:21 +00001716 CK_CoreAVX2,
Chandler Carruth499d9722011-09-28 08:55:34 +00001717 //@}
1718
Craig Topper10c2c682013-08-20 07:09:39 +00001719 /// \name Knights Landing
1720 /// Knights Landing processor.
1721 CK_KNL,
1722
Chandler Carruth499d9722011-09-28 08:55:34 +00001723 /// \name K6
1724 /// K6 architecture processors.
1725 //@{
1726 CK_K6,
1727 CK_K6_2,
1728 CK_K6_3,
1729 //@}
1730
1731 /// \name K7
1732 /// K7 architecture processors.
1733 //@{
1734 CK_Athlon,
1735 CK_AthlonThunderbird,
1736 CK_Athlon4,
1737 CK_AthlonXP,
1738 CK_AthlonMP,
1739 //@}
1740
1741 /// \name K8
1742 /// K8 architecture processors.
1743 //@{
1744 CK_Athlon64,
1745 CK_Athlon64SSE3,
1746 CK_AthlonFX,
1747 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001748 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001749 CK_Opteron,
1750 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001751 CK_AMDFAM10,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001752 //@}
Chandler Carruth499d9722011-09-28 08:55:34 +00001753
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001754 /// \name Bobcat
1755 /// Bobcat architecture processors.
1756 //@{
1757 CK_BTVER1,
Benjamin Kramer63063f52013-05-03 10:47:15 +00001758 CK_BTVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001759 //@}
1760
1761 /// \name Bulldozer
1762 /// Bulldozer architecture processors.
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001763 //@{
1764 CK_BDVER1,
1765 CK_BDVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001766 //@}
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001767
Chandler Carruth499d9722011-09-28 08:55:34 +00001768 /// This specification is deprecated and will be removed in the future.
1769 /// Users should prefer \see CK_K8.
1770 // FIXME: Warn on this when the CPU is set to it.
1771 CK_x86_64,
1772 //@}
1773
1774 /// \name Geode
1775 /// Geode processors.
1776 //@{
1777 CK_Geode
1778 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001779 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001780
Rafael Espindola5389b842013-08-21 21:59:03 +00001781 enum FPMathKind {
1782 FP_Default,
1783 FP_SSE,
1784 FP_387
1785 } FPMath;
1786
Eli Friedman618234a2008-08-20 02:34:37 +00001787public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001788 X86TargetInfo(const llvm::Triple &Triple)
1789 : TargetInfo(Triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00001790 XOPLevel(NoXOP), HasAES(false), HasPCLMUL(false), HasLZCNT(false),
1791 HasRDRND(false), HasBMI(false), HasBMI2(false), HasPOPCNT(false),
Yunzhong Gaoa8f7d9d2013-09-24 19:00:58 +00001792 HasRTM(false), HasPRFCHW(false), HasRDSEED(false), HasTBM(false),
1793 HasFMA(false), HasF16C(false), HasAVX512CD(false), HasAVX512ER(false),
Nick Lewyckyaf945462013-10-05 20:14:27 +00001794 HasAVX512PF(false), HasSHA(false), HasCX16(false), CPU(CK_Generic),
1795 FPMath(FP_Default) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00001796 BigEndian = false;
Eli Friedman618234a2008-08-20 02:34:37 +00001797 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001798 }
Benjamin Kramerb4066692011-12-28 15:47:06 +00001799 virtual unsigned getFloatEvalMethod() const {
1800 // X87 evaluates with 80 bits "long double" precision.
1801 return SSELevel == NoSSE ? 2 : 0;
1802 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001803 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1804 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001805 Records = BuiltinInfo;
1806 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001807 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001808 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001809 unsigned &NumNames) const {
1810 Names = GCCRegNames;
1811 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001812 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001813 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001814 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001815 Aliases = 0;
1816 NumAliases = 0;
1817 }
1818 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
Eric Christopher825d3862012-11-14 22:08:59 +00001819 unsigned &NumNames) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001820 Names = AddlRegNames;
1821 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001822 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001823 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001824 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001825 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001826 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001827 return "~{dirflag},~{fpsr},~{flags}";
1828 }
Chris Lattner33328642009-03-20 15:52:06 +00001829 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001830 MacroBuilder &Builder) const;
Craig Topper319d81f2013-09-17 04:12:55 +00001831 static void setSSELevel(llvm::StringMap<bool> &Features, X86SSEEnum Level,
1832 bool Enabled);
1833 static void setMMXLevel(llvm::StringMap<bool> &Features, MMX3DNowEnum Level,
1834 bool Enabled);
1835 static void setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
1836 bool Enabled);
Rafael Espindolaade7cd42013-08-20 15:30:32 +00001837 virtual void setFeatureEnabled(llvm::StringMap<bool> &Features,
Craig Topper85bfef62013-09-17 04:51:29 +00001838 StringRef Name, bool Enabled) const {
1839 setFeatureEnabledImpl(Features, Name, Enabled);
1840 }
1841 // This exists purely to cut down on the number of virtual calls in
1842 // getDefaultFeatures which calls this repeatedly.
1843 static void setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
1844 StringRef Name, bool Enabled);
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001845 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Douglas Gregore727d212012-01-30 06:38:25 +00001846 virtual bool hasFeature(StringRef Feature) const;
Eric Christopher3d11ced2013-10-16 21:26:26 +00001847 virtual bool handleTargetFeatures(std::vector<std::string> &Features,
Rafael Espindola5389b842013-08-21 21:59:03 +00001848 DiagnosticsEngine &Diags);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001849 virtual const char* getABI() const {
Derek Schuffbabaf312012-10-11 15:52:22 +00001850 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001851 return "avx";
Derek Schuffbabaf312012-10-11 15:52:22 +00001852 else if (getTriple().getArch() == llvm::Triple::x86 &&
1853 MMX3DNowLevel == NoMMX3DNow)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001854 return "no-mmx";
1855 return "";
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001856 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001857 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001858 CPU = llvm::StringSwitch<CPUKind>(Name)
1859 .Case("i386", CK_i386)
1860 .Case("i486", CK_i486)
1861 .Case("winchip-c6", CK_WinChipC6)
1862 .Case("winchip2", CK_WinChip2)
1863 .Case("c3", CK_C3)
1864 .Case("i586", CK_i586)
1865 .Case("pentium", CK_Pentium)
1866 .Case("pentium-mmx", CK_PentiumMMX)
1867 .Case("i686", CK_i686)
1868 .Case("pentiumpro", CK_PentiumPro)
1869 .Case("pentium2", CK_Pentium2)
1870 .Case("pentium3", CK_Pentium3)
1871 .Case("pentium3m", CK_Pentium3M)
1872 .Case("pentium-m", CK_PentiumM)
1873 .Case("c3-2", CK_C3_2)
1874 .Case("yonah", CK_Yonah)
1875 .Case("pentium4", CK_Pentium4)
1876 .Case("pentium4m", CK_Pentium4M)
1877 .Case("prescott", CK_Prescott)
1878 .Case("nocona", CK_Nocona)
1879 .Case("core2", CK_Core2)
1880 .Case("penryn", CK_Penryn)
1881 .Case("atom", CK_Atom)
Preston Gurdc57ea682013-09-13 19:27:17 +00001882 .Case("slm", CK_Silvermont)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001883 .Case("corei7", CK_Corei7)
1884 .Case("corei7-avx", CK_Corei7AVX)
1885 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper2b03bb02011-12-17 19:55:21 +00001886 .Case("core-avx2", CK_CoreAVX2)
Craig Topper10c2c682013-08-20 07:09:39 +00001887 .Case("knl", CK_KNL)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001888 .Case("k6", CK_K6)
1889 .Case("k6-2", CK_K6_2)
1890 .Case("k6-3", CK_K6_3)
1891 .Case("athlon", CK_Athlon)
1892 .Case("athlon-tbird", CK_AthlonThunderbird)
1893 .Case("athlon-4", CK_Athlon4)
1894 .Case("athlon-xp", CK_AthlonXP)
1895 .Case("athlon-mp", CK_AthlonMP)
1896 .Case("athlon64", CK_Athlon64)
1897 .Case("athlon64-sse3", CK_Athlon64SSE3)
1898 .Case("athlon-fx", CK_AthlonFX)
1899 .Case("k8", CK_K8)
1900 .Case("k8-sse3", CK_K8SSE3)
1901 .Case("opteron", CK_Opteron)
1902 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001903 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001904 .Case("btver1", CK_BTVER1)
Benjamin Kramer63063f52013-05-03 10:47:15 +00001905 .Case("btver2", CK_BTVER2)
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001906 .Case("bdver1", CK_BDVER1)
1907 .Case("bdver2", CK_BDVER2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001908 .Case("x86-64", CK_x86_64)
1909 .Case("geode", CK_Geode)
1910 .Default(CK_Generic);
1911
Chandler Carruth26a39142011-09-28 09:45:08 +00001912 // Perform any per-CPU checks necessary to determine if this CPU is
1913 // acceptable.
1914 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1915 // invalid without explaining *why*.
1916 switch (CPU) {
1917 case CK_Generic:
1918 // No processor selected!
1919 return false;
1920
1921 case CK_i386:
1922 case CK_i486:
1923 case CK_WinChipC6:
1924 case CK_WinChip2:
1925 case CK_C3:
1926 case CK_i586:
1927 case CK_Pentium:
1928 case CK_PentiumMMX:
1929 case CK_i686:
1930 case CK_PentiumPro:
1931 case CK_Pentium2:
1932 case CK_Pentium3:
1933 case CK_Pentium3M:
1934 case CK_PentiumM:
1935 case CK_Yonah:
1936 case CK_C3_2:
1937 case CK_Pentium4:
1938 case CK_Pentium4M:
1939 case CK_Prescott:
1940 case CK_K6:
1941 case CK_K6_2:
1942 case CK_K6_3:
1943 case CK_Athlon:
1944 case CK_AthlonThunderbird:
1945 case CK_Athlon4:
1946 case CK_AthlonXP:
1947 case CK_AthlonMP:
1948 case CK_Geode:
1949 // Only accept certain architectures when compiling in 32-bit mode.
Derek Schuffbabaf312012-10-11 15:52:22 +00001950 if (getTriple().getArch() != llvm::Triple::x86)
Chandler Carruth26a39142011-09-28 09:45:08 +00001951 return false;
1952
1953 // Fallthrough
1954 case CK_Nocona:
1955 case CK_Core2:
1956 case CK_Penryn:
1957 case CK_Atom:
Preston Gurdc57ea682013-09-13 19:27:17 +00001958 case CK_Silvermont:
Chandler Carruth26a39142011-09-28 09:45:08 +00001959 case CK_Corei7:
1960 case CK_Corei7AVX:
1961 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001962 case CK_CoreAVX2:
Craig Topper10c2c682013-08-20 07:09:39 +00001963 case CK_KNL:
Chandler Carruth26a39142011-09-28 09:45:08 +00001964 case CK_Athlon64:
1965 case CK_Athlon64SSE3:
1966 case CK_AthlonFX:
1967 case CK_K8:
1968 case CK_K8SSE3:
1969 case CK_Opteron:
1970 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00001971 case CK_AMDFAM10:
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001972 case CK_BTVER1:
Benjamin Kramer63063f52013-05-03 10:47:15 +00001973 case CK_BTVER2:
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001974 case CK_BDVER1:
1975 case CK_BDVER2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001976 case CK_x86_64:
1977 return true;
1978 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001979 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001980 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00001981
Rafael Espindola5389b842013-08-21 21:59:03 +00001982 virtual bool setFPMath(StringRef Name);
1983
Aaron Ballman82bfa192012-10-02 14:26:08 +00001984 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
1985 // We accept all non-ARM calling conventions
1986 return (CC == CC_X86ThisCall ||
1987 CC == CC_X86FastCall ||
Peter Collingbourne7728cdd2013-02-23 00:06:18 +00001988 CC == CC_X86StdCall ||
1989 CC == CC_C ||
Guy Benyei38980082012-12-25 08:53:55 +00001990 CC == CC_X86Pascal ||
1991 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballman82bfa192012-10-02 14:26:08 +00001992 }
1993
Aaron Ballmanfff32482012-12-09 17:45:41 +00001994 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {
1995 return MT == CCMT_Member ? CC_X86ThisCall : CC_C;
Aaron Ballman82bfa192012-10-02 14:26:08 +00001996 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001997};
Chris Lattner3daed522009-03-02 22:20:04 +00001998
Rafael Espindola5389b842013-08-21 21:59:03 +00001999bool X86TargetInfo::setFPMath(StringRef Name) {
2000 if (Name == "387") {
2001 FPMath = FP_387;
2002 return true;
2003 }
2004 if (Name == "sse") {
2005 FPMath = FP_SSE;
2006 return true;
2007 }
2008 return false;
2009}
2010
Chandler Carruthc3a2e652011-09-28 05:56:05 +00002011void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002012 // FIXME: This *really* should not be here.
2013
2014 // X86_64 always has SSE2.
Derek Schuffbabaf312012-10-11 15:52:22 +00002015 if (getTriple().getArch() == llvm::Triple::x86_64)
Craig Topper85bfef62013-09-17 04:51:29 +00002016 setFeatureEnabledImpl(Features, "sse2", true);
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002017
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002018 switch (CPU) {
2019 case CK_Generic:
2020 case CK_i386:
2021 case CK_i486:
2022 case CK_i586:
2023 case CK_Pentium:
2024 case CK_i686:
2025 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002026 break;
2027 case CK_PentiumMMX:
2028 case CK_Pentium2:
Craig Topper85bfef62013-09-17 04:51:29 +00002029 setFeatureEnabledImpl(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002030 break;
2031 case CK_Pentium3:
2032 case CK_Pentium3M:
Craig Topper85bfef62013-09-17 04:51:29 +00002033 setFeatureEnabledImpl(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002034 break;
2035 case CK_PentiumM:
2036 case CK_Pentium4:
2037 case CK_Pentium4M:
2038 case CK_x86_64:
Craig Topper85bfef62013-09-17 04:51:29 +00002039 setFeatureEnabledImpl(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002040 break;
2041 case CK_Yonah:
2042 case CK_Prescott:
2043 case CK_Nocona:
Craig Topper85bfef62013-09-17 04:51:29 +00002044 setFeatureEnabledImpl(Features, "sse3", true);
Nick Lewyckyaf945462013-10-05 20:14:27 +00002045 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002046 break;
2047 case CK_Core2:
Craig Topper85bfef62013-09-17 04:51:29 +00002048 setFeatureEnabledImpl(Features, "ssse3", true);
Nick Lewyckyaf945462013-10-05 20:14:27 +00002049 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002050 break;
2051 case CK_Penryn:
Craig Topper85bfef62013-09-17 04:51:29 +00002052 setFeatureEnabledImpl(Features, "sse4.1", true);
Nick Lewyckyaf945462013-10-05 20:14:27 +00002053 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002054 break;
2055 case CK_Atom:
Craig Topper85bfef62013-09-17 04:51:29 +00002056 setFeatureEnabledImpl(Features, "ssse3", true);
Nick Lewyckyaf945462013-10-05 20:14:27 +00002057 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002058 break;
Preston Gurdc57ea682013-09-13 19:27:17 +00002059 case CK_Silvermont:
Craig Topper85bfef62013-09-17 04:51:29 +00002060 setFeatureEnabledImpl(Features, "sse4.2", true);
2061 setFeatureEnabledImpl(Features, "aes", true);
Nick Lewyckyaf945462013-10-05 20:14:27 +00002062 setFeatureEnabledImpl(Features, "cx16", true);
Craig Topper85bfef62013-09-17 04:51:29 +00002063 setFeatureEnabledImpl(Features, "pclmul", true);
Preston Gurdc57ea682013-09-13 19:27:17 +00002064 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002065 case CK_Corei7:
Craig Topper85bfef62013-09-17 04:51:29 +00002066 setFeatureEnabledImpl(Features, "sse4.2", true);
Nick Lewyckyaf945462013-10-05 20:14:27 +00002067 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002068 break;
2069 case CK_Corei7AVX:
Craig Topper85bfef62013-09-17 04:51:29 +00002070 setFeatureEnabledImpl(Features, "avx", true);
2071 setFeatureEnabledImpl(Features, "aes", true);
Nick Lewyckyaf945462013-10-05 20:14:27 +00002072 setFeatureEnabledImpl(Features, "cx16", true);
Craig Topper85bfef62013-09-17 04:51:29 +00002073 setFeatureEnabledImpl(Features, "pclmul", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00002074 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002075 case CK_CoreAVXi:
Craig Topper85bfef62013-09-17 04:51:29 +00002076 setFeatureEnabledImpl(Features, "avx", true);
2077 setFeatureEnabledImpl(Features, "aes", true);
2078 setFeatureEnabledImpl(Features, "pclmul", true);
2079 setFeatureEnabledImpl(Features, "rdrnd", true);
2080 setFeatureEnabledImpl(Features, "f16c", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002081 break;
Craig Topper2b03bb02011-12-17 19:55:21 +00002082 case CK_CoreAVX2:
Craig Topper85bfef62013-09-17 04:51:29 +00002083 setFeatureEnabledImpl(Features, "avx2", true);
2084 setFeatureEnabledImpl(Features, "aes", true);
2085 setFeatureEnabledImpl(Features, "pclmul", true);
2086 setFeatureEnabledImpl(Features, "lzcnt", true);
2087 setFeatureEnabledImpl(Features, "rdrnd", true);
2088 setFeatureEnabledImpl(Features, "f16c", true);
2089 setFeatureEnabledImpl(Features, "bmi", true);
2090 setFeatureEnabledImpl(Features, "bmi2", true);
2091 setFeatureEnabledImpl(Features, "rtm", true);
2092 setFeatureEnabledImpl(Features, "fma", true);
Nick Lewyckyaf945462013-10-05 20:14:27 +00002093 setFeatureEnabledImpl(Features, "cx16", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00002094 break;
Craig Topper10c2c682013-08-20 07:09:39 +00002095 case CK_KNL:
Craig Topper85bfef62013-09-17 04:51:29 +00002096 setFeatureEnabledImpl(Features, "avx512f", true);
2097 setFeatureEnabledImpl(Features, "avx512cd", true);
2098 setFeatureEnabledImpl(Features, "avx512er", true);
2099 setFeatureEnabledImpl(Features, "avx512pf", true);
2100 setFeatureEnabledImpl(Features, "aes", true);
2101 setFeatureEnabledImpl(Features, "pclmul", true);
2102 setFeatureEnabledImpl(Features, "lzcnt", true);
2103 setFeatureEnabledImpl(Features, "rdrnd", true);
2104 setFeatureEnabledImpl(Features, "f16c", true);
2105 setFeatureEnabledImpl(Features, "bmi", true);
2106 setFeatureEnabledImpl(Features, "bmi2", true);
2107 setFeatureEnabledImpl(Features, "rtm", true);
2108 setFeatureEnabledImpl(Features, "fma", true);
Craig Topper10c2c682013-08-20 07:09:39 +00002109 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002110 case CK_K6:
2111 case CK_WinChipC6:
Craig Topper85bfef62013-09-17 04:51:29 +00002112 setFeatureEnabledImpl(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002113 break;
2114 case CK_K6_2:
2115 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002116 case CK_WinChip2:
2117 case CK_C3:
Craig Topper85bfef62013-09-17 04:51:29 +00002118 setFeatureEnabledImpl(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002119 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00002120 case CK_Athlon:
2121 case CK_AthlonThunderbird:
2122 case CK_Geode:
Craig Topper85bfef62013-09-17 04:51:29 +00002123 setFeatureEnabledImpl(Features, "3dnowa", true);
Chandler Carruth49defe62011-09-28 10:36:46 +00002124 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002125 case CK_Athlon4:
2126 case CK_AthlonXP:
2127 case CK_AthlonMP:
Craig Topper85bfef62013-09-17 04:51:29 +00002128 setFeatureEnabledImpl(Features, "sse", true);
2129 setFeatureEnabledImpl(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002130 break;
2131 case CK_K8:
2132 case CK_Opteron:
2133 case CK_Athlon64:
2134 case CK_AthlonFX:
Craig Topper85bfef62013-09-17 04:51:29 +00002135 setFeatureEnabledImpl(Features, "sse2", true);
2136 setFeatureEnabledImpl(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002137 break;
2138 case CK_K8SSE3:
2139 case CK_OpteronSSE3:
2140 case CK_Athlon64SSE3:
Craig Topper85bfef62013-09-17 04:51:29 +00002141 setFeatureEnabledImpl(Features, "sse3", true);
2142 setFeatureEnabledImpl(Features, "3dnowa", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00002143 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002144 case CK_AMDFAM10:
Craig Topper85bfef62013-09-17 04:51:29 +00002145 setFeatureEnabledImpl(Features, "sse3", true);
2146 setFeatureEnabledImpl(Features, "sse4a", true);
2147 setFeatureEnabledImpl(Features, "3dnowa", true);
2148 setFeatureEnabledImpl(Features, "lzcnt", true);
2149 setFeatureEnabledImpl(Features, "popcnt", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002150 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002151 case CK_BTVER1:
Craig Topper85bfef62013-09-17 04:51:29 +00002152 setFeatureEnabledImpl(Features, "ssse3", true);
2153 setFeatureEnabledImpl(Features, "sse4a", true);
Nick Lewyckyaf945462013-10-05 20:14:27 +00002154 setFeatureEnabledImpl(Features, "cx16", true);
Craig Topper85bfef62013-09-17 04:51:29 +00002155 setFeatureEnabledImpl(Features, "lzcnt", true);
2156 setFeatureEnabledImpl(Features, "popcnt", true);
Yunzhong Gao15dbacc2013-10-16 19:07:02 +00002157 setFeatureEnabledImpl(Features, "prfchw", true);
Craig Topper90ea0362012-05-30 05:54:54 +00002158 break;
Benjamin Kramer63063f52013-05-03 10:47:15 +00002159 case CK_BTVER2:
Craig Topper85bfef62013-09-17 04:51:29 +00002160 setFeatureEnabledImpl(Features, "avx", true);
2161 setFeatureEnabledImpl(Features, "sse4a", true);
2162 setFeatureEnabledImpl(Features, "lzcnt", true);
2163 setFeatureEnabledImpl(Features, "aes", true);
2164 setFeatureEnabledImpl(Features, "pclmul", true);
Yunzhong Gao15dbacc2013-10-16 19:07:02 +00002165 setFeatureEnabledImpl(Features, "prfchw", true);
Craig Topper85bfef62013-09-17 04:51:29 +00002166 setFeatureEnabledImpl(Features, "bmi", true);
2167 setFeatureEnabledImpl(Features, "f16c", true);
Nick Lewyckyaf945462013-10-05 20:14:27 +00002168 setFeatureEnabledImpl(Features, "cx16", true);
Benjamin Kramer63063f52013-05-03 10:47:15 +00002169 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002170 case CK_BDVER1:
Craig Topper85bfef62013-09-17 04:51:29 +00002171 setFeatureEnabledImpl(Features, "xop", true);
2172 setFeatureEnabledImpl(Features, "lzcnt", true);
2173 setFeatureEnabledImpl(Features, "aes", true);
2174 setFeatureEnabledImpl(Features, "pclmul", true);
Yunzhong Gao15dbacc2013-10-16 19:07:02 +00002175 setFeatureEnabledImpl(Features, "prfchw", true);
Nick Lewyckyaf945462013-10-05 20:14:27 +00002176 setFeatureEnabledImpl(Features, "cx16", true);
Eli Friedmanf5824992012-11-26 21:57:28 +00002177 break;
Eli Friedmanfaf35382012-11-17 01:43:10 +00002178 case CK_BDVER2:
Craig Topper85bfef62013-09-17 04:51:29 +00002179 setFeatureEnabledImpl(Features, "xop", true);
2180 setFeatureEnabledImpl(Features, "lzcnt", true);
2181 setFeatureEnabledImpl(Features, "aes", true);
2182 setFeatureEnabledImpl(Features, "pclmul", true);
Yunzhong Gao15dbacc2013-10-16 19:07:02 +00002183 setFeatureEnabledImpl(Features, "prfchw", true);
Craig Topper85bfef62013-09-17 04:51:29 +00002184 setFeatureEnabledImpl(Features, "bmi", true);
2185 setFeatureEnabledImpl(Features, "fma", true);
2186 setFeatureEnabledImpl(Features, "f16c", true);
Yunzhong Gaoa8f7d9d2013-09-24 19:00:58 +00002187 setFeatureEnabledImpl(Features, "tbm", true);
Nick Lewyckyaf945462013-10-05 20:14:27 +00002188 setFeatureEnabledImpl(Features, "cx16", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002189 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002190 case CK_C3_2:
Craig Topper85bfef62013-09-17 04:51:29 +00002191 setFeatureEnabledImpl(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002192 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002193 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002194}
2195
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002196void X86TargetInfo::setSSELevel(llvm::StringMap<bool> &Features,
Craig Topper319d81f2013-09-17 04:12:55 +00002197 X86SSEEnum Level, bool Enabled) {
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002198 if (Enabled) {
2199 switch (Level) {
Craig Topperb7a95d22013-08-21 03:59:22 +00002200 case AVX512F:
2201 Features["avx512f"] = true;
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002202 case AVX2:
2203 Features["avx2"] = true;
2204 case AVX:
2205 Features["avx"] = true;
2206 case SSE42:
Craig Topper89a5e792013-09-10 06:55:47 +00002207 Features["sse4.2"] = true;
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002208 case SSE41:
Rafael Espindola81cde9e2013-08-23 20:21:37 +00002209 Features["sse4.1"] = true;
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002210 case SSSE3:
2211 Features["ssse3"] = true;
2212 case SSE3:
2213 Features["sse3"] = true;
2214 case SSE2:
2215 Features["sse2"] = true;
2216 case SSE1:
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002217 Features["sse"] = true;
2218 case NoSSE:
2219 break;
2220 }
2221 return;
2222 }
2223
2224 switch (Level) {
2225 case NoSSE:
2226 case SSE1:
2227 Features["sse"] = false;
2228 case SSE2:
Ben Langmuirb83f5a72013-09-19 13:22:04 +00002229 Features["sse2"] = Features["pclmul"] = Features["aes"] =
2230 Features["sha"] = false;
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002231 case SSE3:
2232 Features["sse3"] = false;
2233 setXOPLevel(Features, NoXOP, false);
2234 case SSSE3:
2235 Features["ssse3"] = false;
2236 case SSE41:
Rafael Espindola81cde9e2013-08-23 20:21:37 +00002237 Features["sse4.1"] = false;
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002238 case SSE42:
Craig Topper89a5e792013-09-10 06:55:47 +00002239 Features["sse4.2"] = false;
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002240 case AVX:
Craig Topper84f007b2013-09-16 04:54:13 +00002241 Features["fma"] = Features["avx"] = Features["f16c"] = false;
Rafael Espindola29f26de2013-08-21 13:28:02 +00002242 setXOPLevel(Features, FMA4, false);
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002243 case AVX2:
2244 Features["avx2"] = false;
Craig Topperb7a95d22013-08-21 03:59:22 +00002245 case AVX512F:
Craig Topperbca2c4f2013-08-21 05:29:10 +00002246 Features["avx512f"] = Features["avx512cd"] = Features["avx512er"] =
2247 Features["avx512pf"] = false;
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002248 }
2249}
2250
2251void X86TargetInfo::setMMXLevel(llvm::StringMap<bool> &Features,
Craig Topper319d81f2013-09-17 04:12:55 +00002252 MMX3DNowEnum Level, bool Enabled) {
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002253 if (Enabled) {
2254 switch (Level) {
2255 case AMD3DNowAthlon:
2256 Features["3dnowa"] = true;
2257 case AMD3DNow:
2258 Features["3dnow"] = true;
2259 case MMX:
2260 Features["mmx"] = true;
2261 case NoMMX3DNow:
2262 break;
2263 }
2264 return;
2265 }
2266
2267 switch (Level) {
2268 case NoMMX3DNow:
2269 case MMX:
2270 Features["mmx"] = false;
2271 case AMD3DNow:
2272 Features["3dnow"] = false;
2273 case AMD3DNowAthlon:
2274 Features["3dnowa"] = false;
2275 }
2276}
2277
2278void X86TargetInfo::setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
Craig Topper319d81f2013-09-17 04:12:55 +00002279 bool Enabled) {
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002280 if (Enabled) {
2281 switch (Level) {
2282 case XOP:
2283 Features["xop"] = true;
2284 case FMA4:
2285 Features["fma4"] = true;
2286 setSSELevel(Features, AVX, true);
2287 case SSE4A:
2288 Features["sse4a"] = true;
2289 setSSELevel(Features, SSE3, true);
2290 case NoXOP:
2291 break;
2292 }
2293 return;
2294 }
2295
2296 switch (Level) {
2297 case NoXOP:
2298 case SSE4A:
2299 Features["sse4a"] = false;
2300 case FMA4:
2301 Features["fma4"] = false;
2302 case XOP:
2303 Features["xop"] = false;
2304 }
2305}
2306
Craig Topper85bfef62013-09-17 04:51:29 +00002307void X86TargetInfo::setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
2308 StringRef Name, bool Enabled) {
Eric Christopherd39ebe22010-03-04 02:26:37 +00002309 // FIXME: This *really* should not be here. We need some way of translating
2310 // options into llvm subtarget features.
Rafael Espindola81cde9e2013-08-23 20:21:37 +00002311 if (Name == "sse4")
2312 Name = "sse4.2";
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002313
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002314 Features[Name] = Enabled;
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002315
Craig Topperb22352e2013-09-19 01:13:07 +00002316 if (Name == "mmx") {
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002317 setMMXLevel(Features, MMX, Enabled);
Craig Topperb22352e2013-09-19 01:13:07 +00002318 } else if (Name == "sse") {
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002319 setSSELevel(Features, SSE1, Enabled);
Craig Topperb22352e2013-09-19 01:13:07 +00002320 } else if (Name == "sse2") {
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002321 setSSELevel(Features, SSE2, Enabled);
Craig Topperb22352e2013-09-19 01:13:07 +00002322 } else if (Name == "sse3") {
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002323 setSSELevel(Features, SSE3, Enabled);
Craig Topperb22352e2013-09-19 01:13:07 +00002324 } else if (Name == "ssse3") {
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002325 setSSELevel(Features, SSSE3, Enabled);
Craig Topperb22352e2013-09-19 01:13:07 +00002326 } else if (Name == "sse4.2") {
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002327 setSSELevel(Features, SSE42, Enabled);
Craig Topperb22352e2013-09-19 01:13:07 +00002328 } else if (Name == "sse4.1") {
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002329 setSSELevel(Features, SSE41, Enabled);
Craig Topperb22352e2013-09-19 01:13:07 +00002330 } else if (Name == "3dnow") {
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002331 setMMXLevel(Features, AMD3DNow, Enabled);
Craig Topperb22352e2013-09-19 01:13:07 +00002332 } else if (Name == "3dnowa") {
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002333 setMMXLevel(Features, AMD3DNowAthlon, Enabled);
Craig Topperb22352e2013-09-19 01:13:07 +00002334 } else if (Name == "aes") {
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002335 if (Enabled)
2336 setSSELevel(Features, SSE2, Enabled);
2337 } else if (Name == "pclmul") {
2338 if (Enabled)
2339 setSSELevel(Features, SSE2, Enabled);
Craig Topperb22352e2013-09-19 01:13:07 +00002340 } else if (Name == "avx") {
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002341 setSSELevel(Features, AVX, Enabled);
Craig Topperb22352e2013-09-19 01:13:07 +00002342 } else if (Name == "avx2") {
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002343 setSSELevel(Features, AVX2, Enabled);
Craig Topperb22352e2013-09-19 01:13:07 +00002344 } else if (Name == "avx512f") {
Craig Topperb7a95d22013-08-21 03:59:22 +00002345 setSSELevel(Features, AVX512F, Enabled);
Craig Topperb22352e2013-09-19 01:13:07 +00002346 } else if (Name == "avx512cd" || Name == "avx512er" || Name == "avx512pf") {
Craig Topperbca2c4f2013-08-21 05:29:10 +00002347 if (Enabled)
2348 setSSELevel(Features, AVX512F, Enabled);
2349 } else if (Name == "fma") {
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002350 if (Enabled)
2351 setSSELevel(Features, AVX, Enabled);
2352 } else if (Name == "fma4") {
2353 setXOPLevel(Features, FMA4, Enabled);
2354 } else if (Name == "xop") {
2355 setXOPLevel(Features, XOP, Enabled);
2356 } else if (Name == "sse4a") {
2357 setXOPLevel(Features, SSE4A, Enabled);
Craig Topper84f007b2013-09-16 04:54:13 +00002358 } else if (Name == "f16c") {
2359 if (Enabled)
2360 setSSELevel(Features, AVX, Enabled);
Ben Langmuirb83f5a72013-09-19 13:22:04 +00002361 } else if (Name == "sha") {
2362 if (Enabled)
2363 setSSELevel(Features, SSE2, Enabled);
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002364 }
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002365}
2366
Eric Christopher3d11ced2013-10-16 21:26:26 +00002367/// handleTargetFeatures - Perform initialization based on the user
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002368/// configured set of features.
Eric Christopher3d11ced2013-10-16 21:26:26 +00002369bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
Rafael Espindola5389b842013-08-21 21:59:03 +00002370 DiagnosticsEngine &Diags) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002371 // Remember the maximum enabled sselevel.
2372 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
2373 // Ignore disabled features.
2374 if (Features[i][0] == '-')
2375 continue;
2376
Benjamin Kramer713575a2012-03-05 15:10:44 +00002377 StringRef Feature = StringRef(Features[i]).substr(1);
2378
2379 if (Feature == "aes") {
Eric Christophereea12d12010-04-02 23:50:19 +00002380 HasAES = true;
2381 continue;
2382 }
2383
Craig Topper3c0bc152012-05-31 05:18:48 +00002384 if (Feature == "pclmul") {
2385 HasPCLMUL = true;
2386 continue;
2387 }
2388
Benjamin Kramer713575a2012-03-05 15:10:44 +00002389 if (Feature == "lzcnt") {
Craig Topper31ceea02011-12-25 05:06:45 +00002390 HasLZCNT = true;
2391 continue;
2392 }
2393
Rafael Espindola81cde9e2013-08-23 20:21:37 +00002394 if (Feature == "rdrnd") {
Benjamin Kramer84f30802012-07-07 09:39:18 +00002395 HasRDRND = true;
2396 continue;
2397 }
2398
Benjamin Kramer713575a2012-03-05 15:10:44 +00002399 if (Feature == "bmi") {
Craig Topper31ceea02011-12-25 05:06:45 +00002400 HasBMI = true;
2401 continue;
2402 }
2403
Benjamin Kramer713575a2012-03-05 15:10:44 +00002404 if (Feature == "bmi2") {
Craig Topper31ceea02011-12-25 05:06:45 +00002405 HasBMI2 = true;
2406 continue;
2407 }
2408
Benjamin Kramer713575a2012-03-05 15:10:44 +00002409 if (Feature == "popcnt") {
Craig Toppere14e08b2011-12-29 16:10:46 +00002410 HasPOPCNT = true;
2411 continue;
2412 }
2413
Michael Liao463eb892012-11-10 05:17:46 +00002414 if (Feature == "rtm") {
2415 HasRTM = true;
2416 continue;
2417 }
2418
Michael Liao72339a02013-03-26 17:52:08 +00002419 if (Feature == "prfchw") {
2420 HasPRFCHW = true;
2421 continue;
2422 }
2423
Michael Liao1bfc28c2013-03-29 05:17:55 +00002424 if (Feature == "rdseed") {
2425 HasRDSEED = true;
2426 continue;
2427 }
2428
Yunzhong Gaoa8f7d9d2013-09-24 19:00:58 +00002429 if (Feature == "tbm") {
2430 HasTBM = true;
2431 continue;
2432 }
2433
Craig Topper2ae95072012-06-03 21:46:30 +00002434 if (Feature == "fma") {
2435 HasFMA = true;
2436 continue;
2437 }
2438
Manman Ren146e5a42012-10-11 00:59:55 +00002439 if (Feature == "f16c") {
2440 HasF16C = true;
2441 continue;
2442 }
2443
Craig Topperbca2c4f2013-08-21 05:29:10 +00002444 if (Feature == "avx512cd") {
2445 HasAVX512CD = true;
2446 continue;
2447 }
2448
2449 if (Feature == "avx512er") {
2450 HasAVX512ER = true;
2451 continue;
2452 }
2453
2454 if (Feature == "avx512pf") {
2455 HasAVX512PF = true;
2456 continue;
2457 }
2458
Ben Langmuirb83f5a72013-09-19 13:22:04 +00002459 if (Feature == "sha") {
2460 HasSHA = true;
2461 continue;
2462 }
2463
Nick Lewyckyaf945462013-10-05 20:14:27 +00002464 if (Feature == "cx16") {
2465 HasCX16 = true;
2466 continue;
2467 }
2468
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002469 assert(Features[i][0] == '+' && "Invalid target feature!");
Benjamin Kramer713575a2012-03-05 15:10:44 +00002470 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Craig Topperbca2c4f2013-08-21 05:29:10 +00002471 .Case("avx512f", AVX512F)
Craig Topper05fe4b52012-01-09 09:19:09 +00002472 .Case("avx2", AVX2)
2473 .Case("avx", AVX)
Rafael Espindola81cde9e2013-08-23 20:21:37 +00002474 .Case("sse4.2", SSE42)
2475 .Case("sse4.1", SSE41)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002476 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00002477 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002478 .Case("sse2", SSE2)
2479 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002480 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002481 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002482
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002483 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer713575a2012-03-05 15:10:44 +00002484 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002485 .Case("3dnowa", AMD3DNowAthlon)
2486 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002487 .Case("mmx", MMX)
2488 .Default(NoMMX3DNow);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002489 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002490
2491 XOPEnum XLevel = llvm::StringSwitch<XOPEnum>(Feature)
2492 .Case("xop", XOP)
2493 .Case("fma4", FMA4)
2494 .Case("sse4a", SSE4A)
2495 .Default(NoXOP);
2496 XOPLevel = std::max(XOPLevel, XLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002497 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002498
Craig Topper89a5e792013-09-10 06:55:47 +00002499 // Enable popcnt if sse4.2 is enabled and popcnt is not explicitly disabled.
2500 // Can't do this earlier because we need to be able to explicitly enable
2501 // popcnt and still disable sse4.2.
2502 if (!HasPOPCNT && SSELevel >= SSE42 &&
2503 std::find(Features.begin(), Features.end(), "-popcnt") == Features.end()){
2504 HasPOPCNT = true;
2505 Features.push_back("+popcnt");
2506 }
2507
Yunzhong Gao15dbacc2013-10-16 19:07:02 +00002508 // Enable prfchw if 3DNow! is enabled and prfchw is not explicitly disabled.
2509 if (!HasPRFCHW && MMX3DNowLevel >= AMD3DNow &&
2510 std::find(Features.begin(), Features.end(), "-prfchw") == Features.end()){
2511 HasPRFCHW = true;
2512 Features.push_back("+prfchw");
2513 }
2514
Rafael Espindola5389b842013-08-21 21:59:03 +00002515 // LLVM doesn't have a separate switch for fpmath, so only accept it if it
2516 // matches the selected sse level.
2517 if (FPMath == FP_SSE && SSELevel < SSE1) {
2518 Diags.Report(diag::err_target_unsupported_fpmath) << "sse";
2519 return false;
2520 } else if (FPMath == FP_387 && SSELevel >= SSE1) {
2521 Diags.Report(diag::err_target_unsupported_fpmath) << "387";
2522 return false;
2523 }
2524
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002525 // Don't tell the backend if we're turning off mmx; it will end up disabling
2526 // SSE, which we don't want.
Craig Topper56bed972013-09-11 06:48:53 +00002527 // Additionally, if SSE is enabled and mmx is not explicitly disabled,
2528 // then enable MMX.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002529 std::vector<std::string>::iterator it;
2530 it = std::find(Features.begin(), Features.end(), "-mmx");
2531 if (it != Features.end())
2532 Features.erase(it);
Craig Topper56bed972013-09-11 06:48:53 +00002533 else if (SSELevel > NoSSE)
2534 MMX3DNowLevel = std::max(MMX3DNowLevel, MMX);
Rafael Espindola5389b842013-08-21 21:59:03 +00002535 return true;
Chris Lattner3daed522009-03-02 22:20:04 +00002536}
Chris Lattnerc0f59212009-03-02 22:27:17 +00002537
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002538/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
2539/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00002540void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002541 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002542 // Target identification.
Derek Schuffbabaf312012-10-11 15:52:22 +00002543 if (getTriple().getArch() == llvm::Triple::x86_64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002544 Builder.defineMacro("__amd64__");
2545 Builder.defineMacro("__amd64");
2546 Builder.defineMacro("__x86_64");
2547 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002548 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00002549 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00002550 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002551
Chris Lattnerc0f59212009-03-02 22:27:17 +00002552 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002553 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
2554 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002555 switch (CPU) {
2556 case CK_Generic:
2557 break;
2558 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002559 // The rest are coming from the i386 define above.
2560 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002561 break;
2562 case CK_i486:
2563 case CK_WinChipC6:
2564 case CK_WinChip2:
2565 case CK_C3:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002566 defineCPUMacros(Builder, "i486");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002567 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00002568 case CK_PentiumMMX:
2569 Builder.defineMacro("__pentium_mmx__");
2570 Builder.defineMacro("__tune_pentium_mmx__");
2571 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002572 case CK_i586:
2573 case CK_Pentium:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002574 defineCPUMacros(Builder, "i586");
2575 defineCPUMacros(Builder, "pentium");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002576 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002577 case CK_Pentium3:
2578 case CK_Pentium3M:
2579 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002580 Builder.defineMacro("__tune_pentium3__");
2581 // Fallthrough
2582 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002583 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002584 Builder.defineMacro("__tune_pentium2__");
2585 // Fallthrough
2586 case CK_PentiumPro:
2587 Builder.defineMacro("__tune_i686__");
2588 Builder.defineMacro("__tune_pentiumpro__");
2589 // Fallthrough
2590 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002591 Builder.defineMacro("__i686");
2592 Builder.defineMacro("__i686__");
2593 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
2594 Builder.defineMacro("__pentiumpro");
2595 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002596 break;
2597 case CK_Pentium4:
2598 case CK_Pentium4M:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002599 defineCPUMacros(Builder, "pentium4");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002600 break;
2601 case CK_Yonah:
2602 case CK_Prescott:
2603 case CK_Nocona:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002604 defineCPUMacros(Builder, "nocona");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002605 break;
2606 case CK_Core2:
2607 case CK_Penryn:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002608 defineCPUMacros(Builder, "core2");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002609 break;
2610 case CK_Atom:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002611 defineCPUMacros(Builder, "atom");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002612 break;
Preston Gurdc57ea682013-09-13 19:27:17 +00002613 case CK_Silvermont:
Benjamin Kramerb98ce372013-08-30 14:05:34 +00002614 defineCPUMacros(Builder, "slm");
2615 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002616 case CK_Corei7:
2617 case CK_Corei7AVX:
2618 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00002619 case CK_CoreAVX2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002620 defineCPUMacros(Builder, "corei7");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002621 break;
Craig Topper10c2c682013-08-20 07:09:39 +00002622 case CK_KNL:
2623 defineCPUMacros(Builder, "knl");
2624 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002625 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002626 Builder.defineMacro("__k6_2__");
2627 Builder.defineMacro("__tune_k6_2__");
2628 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002629 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002630 if (CPU != CK_K6_2) { // In case of fallthrough
2631 // FIXME: GCC may be enabling these in cases where some other k6
2632 // architecture is specified but -m3dnow is explicitly provided. The
2633 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002634 Builder.defineMacro("__k6_3__");
2635 Builder.defineMacro("__tune_k6_3__");
2636 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00002637 // Fallthrough
2638 case CK_K6:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002639 defineCPUMacros(Builder, "k6");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002640 break;
2641 case CK_Athlon:
2642 case CK_AthlonThunderbird:
2643 case CK_Athlon4:
2644 case CK_AthlonXP:
2645 case CK_AthlonMP:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002646 defineCPUMacros(Builder, "athlon");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002647 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002648 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002649 Builder.defineMacro("__tune_athlon_sse__");
2650 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002651 break;
2652 case CK_K8:
2653 case CK_K8SSE3:
2654 case CK_x86_64:
2655 case CK_Opteron:
2656 case CK_OpteronSSE3:
2657 case CK_Athlon64:
2658 case CK_Athlon64SSE3:
2659 case CK_AthlonFX:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002660 defineCPUMacros(Builder, "k8");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002661 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002662 case CK_AMDFAM10:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002663 defineCPUMacros(Builder, "amdfam10");
Roman Divacky01c770d2011-10-30 07:48:46 +00002664 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002665 case CK_BTVER1:
2666 defineCPUMacros(Builder, "btver1");
2667 break;
Benjamin Kramer63063f52013-05-03 10:47:15 +00002668 case CK_BTVER2:
2669 defineCPUMacros(Builder, "btver2");
2670 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002671 case CK_BDVER1:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002672 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002673 break;
2674 case CK_BDVER2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002675 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002676 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002677 case CK_Geode:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002678 defineCPUMacros(Builder, "geode");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002679 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002680 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00002681
Chandler Carruth88c75b02011-09-28 09:54:07 +00002682 // Target properties.
2683 Builder.defineMacro("__LITTLE_ENDIAN__");
2684 Builder.defineMacro("__REGISTER_PREFIX__", "");
2685
Chris Lattner54175442009-04-19 17:32:33 +00002686 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2687 // functions in glibc header files that use FP Stack inline asm which the
2688 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00002689 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002690
Chandler Carruth88c75b02011-09-28 09:54:07 +00002691 if (HasAES)
2692 Builder.defineMacro("__AES__");
2693
Craig Topper3c0bc152012-05-31 05:18:48 +00002694 if (HasPCLMUL)
2695 Builder.defineMacro("__PCLMUL__");
2696
Craig Topper31ceea02011-12-25 05:06:45 +00002697 if (HasLZCNT)
2698 Builder.defineMacro("__LZCNT__");
2699
Benjamin Kramer84f30802012-07-07 09:39:18 +00002700 if (HasRDRND)
2701 Builder.defineMacro("__RDRND__");
2702
Craig Topper31ceea02011-12-25 05:06:45 +00002703 if (HasBMI)
2704 Builder.defineMacro("__BMI__");
2705
2706 if (HasBMI2)
2707 Builder.defineMacro("__BMI2__");
2708
Craig Toppere14e08b2011-12-29 16:10:46 +00002709 if (HasPOPCNT)
2710 Builder.defineMacro("__POPCNT__");
2711
Michael Liao463eb892012-11-10 05:17:46 +00002712 if (HasRTM)
2713 Builder.defineMacro("__RTM__");
2714
Michael Liao72339a02013-03-26 17:52:08 +00002715 if (HasPRFCHW)
2716 Builder.defineMacro("__PRFCHW__");
2717
Michael Liao1bfc28c2013-03-29 05:17:55 +00002718 if (HasRDSEED)
2719 Builder.defineMacro("__RDSEED__");
2720
Yunzhong Gaoa8f7d9d2013-09-24 19:00:58 +00002721 if (HasTBM)
2722 Builder.defineMacro("__TBM__");
2723
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002724 switch (XOPLevel) {
2725 case XOP:
2726 Builder.defineMacro("__XOP__");
2727 case FMA4:
Craig Topper6a511e12011-12-30 07:33:42 +00002728 Builder.defineMacro("__FMA4__");
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002729 case SSE4A:
2730 Builder.defineMacro("__SSE4A__");
2731 case NoXOP:
2732 break;
2733 }
Craig Topper6a511e12011-12-30 07:33:42 +00002734
Craig Topper2ae95072012-06-03 21:46:30 +00002735 if (HasFMA)
2736 Builder.defineMacro("__FMA__");
2737
Manman Ren146e5a42012-10-11 00:59:55 +00002738 if (HasF16C)
2739 Builder.defineMacro("__F16C__");
2740
Craig Topperbca2c4f2013-08-21 05:29:10 +00002741 if (HasAVX512CD)
2742 Builder.defineMacro("__AVX512CD__");
2743 if (HasAVX512ER)
2744 Builder.defineMacro("__AVX512ER__");
2745 if (HasAVX512PF)
2746 Builder.defineMacro("__AVX512PF__");
2747
Ben Langmuirb83f5a72013-09-19 13:22:04 +00002748 if (HasSHA)
2749 Builder.defineMacro("__SHA__");
2750
Nick Lewyckyaf945462013-10-05 20:14:27 +00002751 if (HasCX16)
2752 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
2753
Chris Lattner84f0ea82009-03-02 22:40:39 +00002754 // Each case falls through to the previous one here.
2755 switch (SSELevel) {
Craig Topperb7a95d22013-08-21 03:59:22 +00002756 case AVX512F:
Craig Topper42f98732013-08-20 07:39:54 +00002757 Builder.defineMacro("__AVX512F__");
Craig Topper05fe4b52012-01-09 09:19:09 +00002758 case AVX2:
2759 Builder.defineMacro("__AVX2__");
2760 case AVX:
2761 Builder.defineMacro("__AVX__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002762 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00002763 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002764 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00002765 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002766 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002767 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002768 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002769 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002770 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00002771 Builder.defineMacro("__SSE2__");
2772 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00002773 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00002774 Builder.defineMacro("__SSE__");
2775 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002776 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00002777 break;
2778 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002779
Derek Schuffbabaf312012-10-11 15:52:22 +00002780 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002781 switch (SSELevel) {
Craig Topperb7a95d22013-08-21 03:59:22 +00002782 case AVX512F:
Craig Topper05fe4b52012-01-09 09:19:09 +00002783 case AVX2:
2784 case AVX:
Michael J. Spencera764e832010-10-21 08:22:51 +00002785 case SSE42:
2786 case SSE41:
2787 case SSSE3:
2788 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002789 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002790 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002791 break;
2792 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002793 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002794 break;
2795 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002796 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002797 }
2798 }
2799
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002800 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002801 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002802 case AMD3DNowAthlon:
2803 Builder.defineMacro("__3dNOW_A__");
2804 case AMD3DNow:
2805 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002806 case MMX:
2807 Builder.defineMacro("__MMX__");
2808 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002809 break;
2810 }
Michael J. Spencerd1b33942013-04-04 23:53:43 +00002811
2812 if (CPU >= CK_i486) {
2813 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
2814 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
2815 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
2816 }
2817 if (CPU >= CK_i586)
2818 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002819}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002820
Douglas Gregore727d212012-01-30 06:38:25 +00002821bool X86TargetInfo::hasFeature(StringRef Feature) const {
2822 return llvm::StringSwitch<bool>(Feature)
2823 .Case("aes", HasAES)
2824 .Case("avx", SSELevel >= AVX)
2825 .Case("avx2", SSELevel >= AVX2)
Craig Topperb7a95d22013-08-21 03:59:22 +00002826 .Case("avx512f", SSELevel >= AVX512F)
Craig Topperbca2c4f2013-08-21 05:29:10 +00002827 .Case("avx512cd", HasAVX512CD)
2828 .Case("avx512er", HasAVX512ER)
2829 .Case("avx512pf", HasAVX512PF)
Douglas Gregore727d212012-01-30 06:38:25 +00002830 .Case("bmi", HasBMI)
2831 .Case("bmi2", HasBMI2)
Nick Lewyckyaf945462013-10-05 20:14:27 +00002832 .Case("cx16", HasCX16)
2833 .Case("f16c", HasF16C)
Craig Topper2ae95072012-06-03 21:46:30 +00002834 .Case("fma", HasFMA)
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002835 .Case("fma4", XOPLevel >= FMA4)
Yunzhong Gaoa8f7d9d2013-09-24 19:00:58 +00002836 .Case("tbm", HasTBM)
Douglas Gregore727d212012-01-30 06:38:25 +00002837 .Case("lzcnt", HasLZCNT)
Benjamin Kramer84f30802012-07-07 09:39:18 +00002838 .Case("rdrnd", HasRDRND)
Douglas Gregore727d212012-01-30 06:38:25 +00002839 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
2840 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
2841 .Case("mmx", MMX3DNowLevel >= MMX)
Craig Topper3c0bc152012-05-31 05:18:48 +00002842 .Case("pclmul", HasPCLMUL)
Douglas Gregore727d212012-01-30 06:38:25 +00002843 .Case("popcnt", HasPOPCNT)
Michael Liao463eb892012-11-10 05:17:46 +00002844 .Case("rtm", HasRTM)
Michael Liao72339a02013-03-26 17:52:08 +00002845 .Case("prfchw", HasPRFCHW)
Michael Liao1bfc28c2013-03-29 05:17:55 +00002846 .Case("rdseed", HasRDSEED)
Ben Langmuirb83f5a72013-09-19 13:22:04 +00002847 .Case("sha", HasSHA)
Douglas Gregore727d212012-01-30 06:38:25 +00002848 .Case("sse", SSELevel >= SSE1)
2849 .Case("sse2", SSELevel >= SSE2)
2850 .Case("sse3", SSELevel >= SSE3)
2851 .Case("ssse3", SSELevel >= SSSE3)
Rafael Espindola81cde9e2013-08-23 20:21:37 +00002852 .Case("sse4.1", SSELevel >= SSE41)
2853 .Case("sse4.2", SSELevel >= SSE42)
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002854 .Case("sse4a", XOPLevel >= SSE4A)
Douglas Gregore727d212012-01-30 06:38:25 +00002855 .Case("x86", true)
Derek Schuffbabaf312012-10-11 15:52:22 +00002856 .Case("x86_32", getTriple().getArch() == llvm::Triple::x86)
2857 .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64)
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002858 .Case("xop", XOPLevel >= XOP)
Douglas Gregore727d212012-01-30 06:38:25 +00002859 .Default(false);
2860}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002861
Eli Friedman618234a2008-08-20 02:34:37 +00002862bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002863X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002864 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002865 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00002866 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00002867 case 'Y': // first letter of a pair:
2868 switch (*(Name+1)) {
2869 default: return false;
2870 case '0': // First SSE register.
2871 case 't': // Any SSE register, when SSE2 is enabled.
2872 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2873 case 'm': // any MMX register, when inter-unit moves enabled.
2874 break; // falls through to setAllowsRegister.
2875 }
Eli Friedman618234a2008-08-20 02:34:37 +00002876 case 'a': // eax.
2877 case 'b': // ebx.
2878 case 'c': // ecx.
2879 case 'd': // edx.
2880 case 'S': // esi.
2881 case 'D': // edi.
2882 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00002883 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00002884 case 't': // top of floating point stack.
2885 case 'u': // second from top of floating point stack.
2886 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00002887 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00002888 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00002889 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00002890 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2891 case 'l': // "Index" registers: any general register that can be used as an
2892 // index in a base+index memory access.
2893 Info.setAllowsRegister();
2894 return true;
2895 case 'C': // SSE floating point constant.
2896 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002897 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002898 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002899 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002900 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00002901 return true;
2902 }
2903}
2904
Dale Johannesenf6e2c202010-10-29 23:12:32 +00002905
Eli Friedman618234a2008-08-20 02:34:37 +00002906std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00002907X86TargetInfo::convertConstraint(const char *&Constraint) const {
2908 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00002909 case 'a': return std::string("{ax}");
2910 case 'b': return std::string("{bx}");
2911 case 'c': return std::string("{cx}");
2912 case 'd': return std::string("{dx}");
2913 case 'S': return std::string("{si}");
2914 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00002915 case 'p': // address
2916 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00002917 case 't': // top of floating point stack.
2918 return std::string("{st}");
2919 case 'u': // second from top of floating point stack.
2920 return std::string("{st(1)}"); // second from top of floating point stack.
2921 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00002922 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00002923 }
2924}
Eli Friedman618234a2008-08-20 02:34:37 +00002925} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00002926
2927namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002928// X86-32 generic target
2929class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00002930public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002931 X86_32TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002932 DoubleAlign = LongLongAlign = 32;
2933 LongDoubleWidth = 96;
2934 LongDoubleAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00002935 SuitableAlign = 128;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002936 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2937 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00002938 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00002939 SizeType = UnsignedInt;
2940 PtrDiffType = SignedInt;
2941 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002942 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002943
2944 // Use fpret for all types.
2945 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2946 (1 << TargetInfo::Double) |
2947 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002948
2949 // x86-32 has atomics up to 8 bytes
2950 // FIXME: Check that we actually have cmpxchg8b before setting
2951 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2952 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002953 }
Meador Ingec5613b22012-06-16 03:34:49 +00002954 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2955 return TargetInfo::CharPtrBuiltinVaList;
Eli Friedman618234a2008-08-20 02:34:37 +00002956 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002957
Chris Lattner21fb98e2009-09-23 06:06:36 +00002958 int getEHDataRegisterNumber(unsigned RegNo) const {
2959 if (RegNo == 0) return 0;
2960 if (RegNo == 1) return 2;
2961 return -1;
2962 }
Bill Wendling68fd6082012-11-12 06:42:51 +00002963 virtual bool validateInputSize(StringRef Constraint,
2964 unsigned Size) const {
2965 switch (Constraint[0]) {
2966 default: break;
2967 case 'a':
2968 case 'b':
2969 case 'c':
2970 case 'd':
Bill Wendlingf634bdf2012-11-12 18:52:32 +00002971 return Size <= 32;
Bill Wendling68fd6082012-11-12 06:42:51 +00002972 }
2973
2974 return true;
2975 }
Eli Friedman618234a2008-08-20 02:34:37 +00002976};
2977} // end anonymous namespace
2978
2979namespace {
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002980class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
2981public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002982 NetBSDI386TargetInfo(const llvm::Triple &Triple)
2983 : NetBSDTargetInfo<X86_32TargetInfo>(Triple) {}
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002984
2985 virtual unsigned getFloatEvalMethod() const {
2986 // NetBSD defaults to "double" rounding
2987 return 1;
2988 }
2989};
2990} // end anonymous namespace
2991
2992namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002993class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2994public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002995 OpenBSDI386TargetInfo(const llvm::Triple &Triple)
2996 : OpenBSDTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman624c1462009-07-05 18:47:56 +00002997 SizeType = UnsignedLong;
2998 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002999 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00003000 }
3001};
3002} // end anonymous namespace
3003
3004namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00003005class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
3006public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003007 BitrigI386TargetInfo(const llvm::Triple &Triple)
3008 : BitrigTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman42f74f22012-08-08 23:57:20 +00003009 SizeType = UnsignedLong;
3010 IntPtrType = SignedLong;
3011 PtrDiffType = SignedLong;
3012 }
3013};
3014} // end anonymous namespace
3015
3016namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00003017class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00003018public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003019 DarwinI386TargetInfo(const llvm::Triple &Triple)
3020 : DarwinTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00003021 LongDoubleWidth = 128;
3022 LongDoubleAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003023 SuitableAlign = 128;
Chad Rosierf9e9af72012-07-13 23:57:43 +00003024 MaxVectorAlign = 256;
Eli Friedman1afabd92009-03-29 20:31:09 +00003025 SizeType = UnsignedLong;
3026 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00003027 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3028 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003029 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00003030 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00003031 }
3032
Eli Friedman618234a2008-08-20 02:34:37 +00003033};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00003034} // end anonymous namespace
3035
3036namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00003037// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003038class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00003039public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003040 WindowsX86_32TargetInfo(const llvm::Triple &Triple)
3041 : WindowsTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00003042 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00003043 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00003044 DoubleAlign = LongLongAlign = 64;
3045 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Anton Korobeynikovb3814412009-12-19 02:05:07 +00003046 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003047 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00003048 }
Michael J. Spencera764e832010-10-21 08:22:51 +00003049 virtual void getTargetDefines(const LangOptions &Opts,
3050 MacroBuilder &Builder) const {
3051 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
3052 }
3053};
3054} // end anonymous namespace
3055
3056namespace {
3057
3058// x86-32 Windows Visual Studio target
3059class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
3060public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003061 VisualStudioWindowsX86_32TargetInfo(const llvm::Triple &Triple)
3062 : WindowsX86_32TargetInfo(Triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00003063 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00003064 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
3065 }
3066 virtual void getTargetDefines(const LangOptions &Opts,
3067 MacroBuilder &Builder) const {
3068 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
3069 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
3070 // The value of the following reflects processor type.
3071 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
3072 // We lost the original triple, so we use the default.
3073 Builder.defineMacro("_M_IX86", "600");
3074 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003075};
3076} // end anonymous namespace
3077
3078namespace {
3079// x86-32 MinGW target
3080class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
3081public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003082 MinGWX86_32TargetInfo(const llvm::Triple &Triple)
3083 : WindowsX86_32TargetInfo(Triple) {}
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003084 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003085 MacroBuilder &Builder) const {
3086 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00003087 DefineStd(Builder, "WIN32", Opts);
3088 DefineStd(Builder, "WINNT", Opts);
3089 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00003090 Builder.defineMacro("__MSVCRT__");
3091 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003092
3093 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
3094 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00003095 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003096 // Provide "as-is" __declspec.
3097 Builder.defineMacro("__declspec", "__declspec");
3098 else
3099 // Provide alias of __attribute__ like mingw32-gcc.
3100 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003101 }
3102};
3103} // end anonymous namespace
3104
3105namespace {
3106// x86-32 Cygwin target
3107class CygwinX86_32TargetInfo : public X86_32TargetInfo {
3108public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003109 CygwinX86_32TargetInfo(const llvm::Triple &Triple)
3110 : X86_32TargetInfo(Triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003111 TLSSupported = false;
3112 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003113 DoubleAlign = LongLongAlign = 64;
3114 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3115 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003116 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003117 }
3118 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003119 MacroBuilder &Builder) const {
3120 X86_32TargetInfo::getTargetDefines(Opts, Builder);
NAKAMURA Takumie72f4d92012-12-14 10:17:26 +00003121 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00003122 Builder.defineMacro("__CYGWIN__");
3123 Builder.defineMacro("__CYGWIN32__");
3124 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00003125 if (Opts.CPlusPlus)
3126 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00003127 }
Eli Friedman29a30502008-08-21 01:40:19 +00003128};
3129} // end anonymous namespace
3130
3131namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00003132// x86-32 Haiku target
3133class HaikuX86_32TargetInfo : public X86_32TargetInfo {
3134public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003135 HaikuX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Chris Lattner86ed3a32010-04-11 19:29:39 +00003136 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00003137 IntPtrType = SignedLong;
3138 PtrDiffType = SignedLong;
Eli Friedman6902e412012-11-27 02:58:24 +00003139 ProcessIDType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00003140 this->UserLabelPrefix = "";
Benjamin Krameref7bcea2012-11-08 12:59:15 +00003141 this->TLSSupported = false;
Eli Friedmana7e68452010-08-22 01:00:03 +00003142 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00003143 virtual void getTargetDefines(const LangOptions &Opts,
3144 MacroBuilder &Builder) const {
3145 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3146 Builder.defineMacro("__INTEL__");
3147 Builder.defineMacro("__HAIKU__");
3148 }
3149};
3150} // end anonymous namespace
3151
Douglas Gregordca52262011-07-01 22:41:14 +00003152// RTEMS Target
3153template<typename Target>
3154class RTEMSTargetInfo : public OSTargetInfo<Target> {
3155protected:
3156 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
3157 MacroBuilder &Builder) const {
3158 // RTEMS defines; list based off of gcc output
3159
Douglas Gregordca52262011-07-01 22:41:14 +00003160 Builder.defineMacro("__rtems__");
3161 Builder.defineMacro("__ELF__");
3162 }
Benjamin Kramer9df08232013-06-29 16:37:14 +00003163
Douglas Gregordca52262011-07-01 22:41:14 +00003164public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003165 RTEMSTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
3166 this->UserLabelPrefix = "";
Douglas Gregordca52262011-07-01 22:41:14 +00003167
Benjamin Kramer9df08232013-06-29 16:37:14 +00003168 switch (Triple.getArch()) {
3169 default:
3170 case llvm::Triple::x86:
3171 // this->MCountName = ".mcount";
3172 break;
3173 case llvm::Triple::mips:
3174 case llvm::Triple::mipsel:
3175 case llvm::Triple::ppc:
3176 case llvm::Triple::ppc64:
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00003177 case llvm::Triple::ppc64le:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003178 // this->MCountName = "_mcount";
3179 break;
3180 case llvm::Triple::arm:
3181 // this->MCountName = "__mcount";
3182 break;
Douglas Gregordca52262011-07-01 22:41:14 +00003183 }
Benjamin Kramer9df08232013-06-29 16:37:14 +00003184 }
Douglas Gregordca52262011-07-01 22:41:14 +00003185};
3186
3187namespace {
3188// x86-32 RTEMS target
3189class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
3190public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003191 RTEMSX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Douglas Gregordca52262011-07-01 22:41:14 +00003192 SizeType = UnsignedLong;
3193 IntPtrType = SignedLong;
3194 PtrDiffType = SignedLong;
3195 this->UserLabelPrefix = "";
3196 }
3197 virtual void getTargetDefines(const LangOptions &Opts,
3198 MacroBuilder &Builder) const {
3199 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3200 Builder.defineMacro("__INTEL__");
3201 Builder.defineMacro("__rtems__");
3202 }
3203};
3204} // end anonymous namespace
3205
Chris Lattner86ed3a32010-04-11 19:29:39 +00003206namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00003207// x86-64 generic target
3208class X86_64TargetInfo : public X86TargetInfo {
3209public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003210 X86_64TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00003211 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00003212 LongDoubleWidth = 128;
3213 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00003214 LargeArrayMinWidth = 128;
3215 LargeArrayAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003216 SuitableAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00003217 IntMaxType = SignedLong;
3218 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003219 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00003220 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00003221
Eli Friedmaned855cb2008-08-21 00:13:15 +00003222 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3223 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003224 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00003225
3226 // Use fpret only for long double.
3227 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00003228
Anders Carlssoneea64802011-10-31 16:27:11 +00003229 // Use fp2ret for _Complex long double.
3230 ComplexLongDoubleUsesFP2Ret = true;
3231
Eli Friedman2be46072011-10-14 20:59:01 +00003232 // x86-64 has atomics up to 16 bytes.
3233 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
3234 // on CPUs with cmpxchg16b
3235 MaxAtomicPromoteWidth = 128;
3236 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00003237 }
Meador Ingec5613b22012-06-16 03:34:49 +00003238 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3239 return TargetInfo::X86_64ABIBuiltinVaList;
Anders Carlsson3346ae62007-11-24 23:38:12 +00003240 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00003241
Chris Lattner21fb98e2009-09-23 06:06:36 +00003242 int getEHDataRegisterNumber(unsigned RegNo) const {
3243 if (RegNo == 0) return 0;
3244 if (RegNo == 1) return 1;
3245 return -1;
3246 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00003247
3248 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
Charles Davise8519c32013-08-30 04:39:01 +00003249 return (CC == CC_C ||
3250 CC == CC_IntelOclBicc ||
3251 CC == CC_X86_64Win64) ? CCCR_OK : CCCR_Warning;
Aaron Ballman82bfa192012-10-02 14:26:08 +00003252 }
3253
Aaron Ballmanfff32482012-12-09 17:45:41 +00003254 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {
3255 return CC_C;
Aaron Ballman82bfa192012-10-02 14:26:08 +00003256 }
3257
Eli Friedman618234a2008-08-20 02:34:37 +00003258};
3259} // end anonymous namespace
3260
3261namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003262// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003263class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003264public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003265 WindowsX86_64TargetInfo(const llvm::Triple &Triple)
3266 : WindowsTargetInfo<X86_64TargetInfo>(Triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003267 TLSSupported = false;
3268 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00003269 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00003270 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00003271 IntMaxType = SignedLongLong;
3272 UIntMaxType = UnsignedLongLong;
3273 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00003274 SizeType = UnsignedLongLong;
3275 PtrDiffType = SignedLongLong;
3276 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00003277 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003278 }
3279 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003280 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003281 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003282 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00003283 }
Meador Ingec5613b22012-06-16 03:34:49 +00003284 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3285 return TargetInfo::CharPtrBuiltinVaList;
NAKAMURA Takumi79521992011-01-17 22:56:23 +00003286 }
Charles Davise8519c32013-08-30 04:39:01 +00003287 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
3288 return (CC == CC_C ||
3289 CC == CC_IntelOclBicc ||
3290 CC == CC_X86_64SysV) ? CCCR_OK : CCCR_Warning;
3291 }
Michael J. Spencera764e832010-10-21 08:22:51 +00003292};
3293} // end anonymous namespace
3294
3295namespace {
3296// x86-64 Windows Visual Studio target
3297class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
3298public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003299 VisualStudioWindowsX86_64TargetInfo(const llvm::Triple &Triple)
3300 : WindowsX86_64TargetInfo(Triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00003301 LongDoubleWidth = LongDoubleAlign = 64;
3302 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00003303 }
3304 virtual void getTargetDefines(const LangOptions &Opts,
3305 MacroBuilder &Builder) const {
3306 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
3307 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00003308 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003309 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003310 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003311};
3312} // end anonymous namespace
3313
3314namespace {
3315// x86-64 MinGW target
3316class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
3317public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003318 MinGWX86_64TargetInfo(const llvm::Triple &Triple)
3319 : WindowsX86_64TargetInfo(Triple) {}
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003320 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003321 MacroBuilder &Builder) const {
3322 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00003323 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00003324 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00003325 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00003326 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003327
3328 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
3329 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00003330 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003331 // Provide "as-is" __declspec.
3332 Builder.defineMacro("__declspec", "__declspec");
3333 else
3334 // Provide alias of __attribute__ like mingw32-gcc.
3335 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003336 }
3337};
3338} // end anonymous namespace
3339
3340namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003341class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
3342public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003343 DarwinX86_64TargetInfo(const llvm::Triple &Triple)
3344 : DarwinTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003345 Int64Type = SignedLongLong;
Chad Rosierf9e9af72012-07-13 23:57:43 +00003346 MaxVectorAlign = 256;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003347 }
3348};
3349} // end anonymous namespace
3350
3351namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00003352class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
3353public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003354 OpenBSDX86_64TargetInfo(const llvm::Triple &Triple)
3355 : OpenBSDTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman6036ebe2009-07-05 22:31:18 +00003356 IntMaxType = SignedLongLong;
3357 UIntMaxType = UnsignedLongLong;
3358 Int64Type = SignedLongLong;
3359 }
3360};
3361} // end anonymous namespace
3362
3363namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00003364class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
3365public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003366 BitrigX86_64TargetInfo(const llvm::Triple &Triple)
3367 : BitrigTargetInfo<X86_64TargetInfo>(Triple) {
3368 IntMaxType = SignedLongLong;
3369 UIntMaxType = UnsignedLongLong;
3370 Int64Type = SignedLongLong;
Eli Friedman42f74f22012-08-08 23:57:20 +00003371 }
3372};
Tim Northoverc264e162013-01-31 12:13:10 +00003373}
3374
3375namespace {
3376class AArch64TargetInfo : public TargetInfo {
3377 static const char * const GCCRegNames[];
3378 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Tim Northoverff920ee2013-05-04 07:15:13 +00003379
Tim Northoverb793f0d2013-08-01 09:23:19 +00003380 enum FPUModeEnum {
3381 FPUMode,
3382 NeonMode
3383 };
3384
3385 unsigned FPU;
Tim Northoverff920ee2013-05-04 07:15:13 +00003386 static const Builtin::Info BuiltinInfo[];
Tim Northoverb793f0d2013-08-01 09:23:19 +00003387
Tim Northoverc264e162013-01-31 12:13:10 +00003388public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003389 AArch64TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Tim Northoverc264e162013-01-31 12:13:10 +00003390 BigEndian = false;
3391 LongWidth = LongAlign = 64;
3392 LongDoubleWidth = LongDoubleAlign = 128;
3393 PointerWidth = PointerAlign = 64;
3394 SuitableAlign = 128;
3395 DescriptionString = "e-p:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3396 "i64:64:64-i128:128:128-f32:32:32-f64:64:64-"
3397 "f128:128:128-n32:64-S128";
3398
3399 WCharType = UnsignedInt;
3400 LongDoubleFormat = &llvm::APFloat::IEEEquad;
3401
Tim Northover6a93c862013-02-18 12:11:32 +00003402 // AArch64 backend supports 64-bit operations at the moment. In principle
3403 // 128-bit is possible if register-pairs are used.
3404 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
3405
Tim Northoverc264e162013-01-31 12:13:10 +00003406 TheCXXABI.set(TargetCXXABI::GenericAArch64);
3407 }
3408 virtual void getTargetDefines(const LangOptions &Opts,
3409 MacroBuilder &Builder) const {
3410 // GCC defines theses currently
3411 Builder.defineMacro("__aarch64__");
3412 Builder.defineMacro("__AARCH64EL__");
3413
3414 // ACLE predefines. Many can only have one possible value on v8 AArch64.
3415
3416 // FIXME: these were written based on an unreleased version of a 32-bit ACLE
3417 // which was intended to be compatible with a 64-bit implementation. They
3418 // will need updating when a real 64-bit ACLE exists. Particularly pressing
Tim Northoverdabcbf92013-04-05 14:08:55 +00003419 // instances are: __ARM_ARCH_ISA_ARM, __ARM_ARCH_ISA_THUMB, __ARM_PCS.
3420 Builder.defineMacro("__ARM_ACLE", "101");
3421 Builder.defineMacro("__ARM_ARCH", "8");
3422 Builder.defineMacro("__ARM_ARCH_PROFILE", "'A'");
Tim Northoverc264e162013-01-31 12:13:10 +00003423
Tim Northoverdabcbf92013-04-05 14:08:55 +00003424 Builder.defineMacro("__ARM_FEATURE_UNALIGNED");
3425 Builder.defineMacro("__ARM_FEATURE_CLZ");
3426 Builder.defineMacro("__ARM_FEATURE_FMA");
Tim Northoverc264e162013-01-31 12:13:10 +00003427
3428 // FIXME: ACLE 1.1 reserves bit 4. Will almost certainly come to mean
3429 // 128-bit LDXP present, at which point this becomes 0x1f.
Tim Northoverdabcbf92013-04-05 14:08:55 +00003430 Builder.defineMacro("__ARM_FEATURE_LDREX", "0xf");
Tim Northoverc264e162013-01-31 12:13:10 +00003431
3432 // 0xe implies support for half, single and double precision operations.
Tim Northoverdabcbf92013-04-05 14:08:55 +00003433 Builder.defineMacro("__ARM_FP", "0xe");
Tim Northoverc264e162013-01-31 12:13:10 +00003434
3435 // PCS specifies this for SysV variants, which is all we support. Other ABIs
Tim Northoverdabcbf92013-04-05 14:08:55 +00003436 // may choose __ARM_FP16_FORMAT_ALTERNATIVE.
3437 Builder.defineMacro("__ARM_FP16_FORMAT_IEEE");
Tim Northoverc264e162013-01-31 12:13:10 +00003438
3439 if (Opts.FastMath || Opts.FiniteMathOnly)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003440 Builder.defineMacro("__ARM_FP_FAST");
Tim Northoverc264e162013-01-31 12:13:10 +00003441
3442 if ((Opts.C99 || Opts.C11) && !Opts.Freestanding)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003443 Builder.defineMacro("__ARM_FP_FENV_ROUNDING");
Tim Northoverc264e162013-01-31 12:13:10 +00003444
Tim Northoverdabcbf92013-04-05 14:08:55 +00003445 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
Tim Northoverc264e162013-01-31 12:13:10 +00003446 Opts.ShortWChar ? "2" : "4");
3447
Tim Northoverdabcbf92013-04-05 14:08:55 +00003448 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
Tim Northoverc264e162013-01-31 12:13:10 +00003449 Opts.ShortEnums ? "1" : "4");
3450
3451 if (BigEndian)
Tim Northoverb793f0d2013-08-01 09:23:19 +00003452 Builder.defineMacro("__AARCH_BIG_ENDIAN");
3453
3454 if (FPU == NeonMode) {
3455 Builder.defineMacro("__AARCH_FEATURE_ADVSIMD");
3456
3457 // 64-bit NEON supports half, single and double precision operations.
3458 Builder.defineMacro("__AARCH_ADVSIMD_FP", "0xe");
3459 }
Tim Northoverc264e162013-01-31 12:13:10 +00003460 }
3461 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3462 unsigned &NumRecords) const {
Tim Northoverff920ee2013-05-04 07:15:13 +00003463 Records = BuiltinInfo;
3464 NumRecords = clang::AArch64::LastTSBuiltin-Builtin::FirstTSBuiltin;
Tim Northoverc264e162013-01-31 12:13:10 +00003465 }
3466 virtual bool hasFeature(StringRef Feature) const {
Tim Northoverb793f0d2013-08-01 09:23:19 +00003467 return Feature == "aarch64" || (Feature == "neon" && FPU == NeonMode);
Tim Northoverc264e162013-01-31 12:13:10 +00003468 }
Tim Northoverb793f0d2013-08-01 09:23:19 +00003469
Eric Christopher3d11ced2013-10-16 21:26:26 +00003470 virtual bool handleTargetFeatures(std::vector<std::string> &Features,
Rafael Espindola5389b842013-08-21 21:59:03 +00003471 DiagnosticsEngine &Diags) {
Tim Northoverb793f0d2013-08-01 09:23:19 +00003472 FPU = FPUMode;
3473 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
3474 if (Features[i] == "+neon")
3475 FPU = NeonMode;
3476 }
Rafael Espindola5389b842013-08-21 21:59:03 +00003477 return true;
Tim Northoverb793f0d2013-08-01 09:23:19 +00003478 }
3479
3480 virtual void getGCCRegNames(const char *const *&Names,
Tim Northoverc264e162013-01-31 12:13:10 +00003481 unsigned &NumNames) const;
3482 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3483 unsigned &NumAliases) const;
3484
3485 virtual bool isCLZForZeroUndef() const { return false; }
3486
3487 virtual bool validateAsmConstraint(const char *&Name,
3488 TargetInfo::ConstraintInfo &Info) const {
3489 switch (*Name) {
3490 default: return false;
3491 case 'w': // An FP/SIMD vector register
3492 Info.setAllowsRegister();
3493 return true;
3494 case 'I': // Constant that can be used with an ADD instruction
3495 case 'J': // Constant that can be used with a SUB instruction
3496 case 'K': // Constant that can be used with a 32-bit logical instruction
3497 case 'L': // Constant that can be used with a 64-bit logical instruction
3498 case 'M': // Constant that can be used as a 32-bit MOV immediate
3499 case 'N': // Constant that can be used as a 64-bit MOV immediate
3500 case 'Y': // Floating point constant zero
3501 case 'Z': // Integer constant zero
3502 return true;
3503 case 'Q': // A memory reference with base register and no offset
3504 Info.setAllowsMemory();
3505 return true;
3506 case 'S': // A symbolic address
3507 Info.setAllowsRegister();
3508 return true;
3509 case 'U':
3510 // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes, whatever they may be
3511 // Utf: A memory address suitable for ldp/stp in TF mode, whatever it may be
3512 // Usa: An absolute symbolic address
3513 // Ush: The high part (bits 32:12) of a pc-relative symbolic address
3514 llvm_unreachable("FIXME: Unimplemented support for bizarre constraints");
3515 }
3516 }
3517
3518 virtual const char *getClobbers() const {
3519 // There are no AArch64 clobbers shared by all asm statements.
3520 return "";
3521 }
3522
3523 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3524 return TargetInfo::AArch64ABIBuiltinVaList;
3525 }
3526};
3527
3528const char * const AArch64TargetInfo::GCCRegNames[] = {
3529 "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7",
3530 "w8", "w9", "w10", "w11", "w12", "w13", "w14", "w15",
3531 "w16", "w17", "w18", "w19", "w20", "w21", "w22", "w23",
3532 "w24", "w25", "w26", "w27", "w28", "w29", "w30", "wsp", "wzr",
3533
3534 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
3535 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
3536 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
3537 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp", "xzr",
3538
3539 "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7",
3540 "b8", "b9", "b10", "b11", "b12", "b13", "b14", "b15",
3541 "b16", "b17", "b18", "b19", "b20", "b21", "b22", "b23",
3542 "b24", "b25", "b26", "b27", "b28", "b29", "b30", "b31",
3543
3544 "h0", "h1", "h2", "h3", "h4", "h5", "h6", "h7",
3545 "h8", "h9", "h10", "h11", "h12", "h13", "h14", "h15",
3546 "h16", "h17", "h18", "h19", "h20", "h21", "h22", "h23",
3547 "h24", "h25", "h26", "h27", "h28", "h29", "h30", "h31",
3548
3549 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3550 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3551 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
3552 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
3553
3554 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3555 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
3556 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3557 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
3558
3559 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3560 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15",
3561 "q16", "q17", "q18", "q19", "q20", "q21", "q22", "q23",
3562 "q24", "q25", "q26", "q27", "q28", "q29", "q30", "q31"
3563};
3564
3565void AArch64TargetInfo::getGCCRegNames(const char * const *&Names,
3566 unsigned &NumNames) const {
3567 Names = GCCRegNames;
3568 NumNames = llvm::array_lengthof(GCCRegNames);
3569}
3570
3571const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = {
3572 { { "x16" }, "ip0"},
3573 { { "x17" }, "ip1"},
3574 { { "x29" }, "fp" },
3575 { { "x30" }, "lr" }
3576};
3577
3578void AArch64TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3579 unsigned &NumAliases) const {
3580 Aliases = GCCRegAliases;
3581 NumAliases = llvm::array_lengthof(GCCRegAliases);
3582
3583}
Tim Northoverff920ee2013-05-04 07:15:13 +00003584
3585const Builtin::Info AArch64TargetInfo::BuiltinInfo[] = {
3586#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3587#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3588 ALL_LANGUAGES },
3589#include "clang/Basic/BuiltinsAArch64.def"
3590};
3591
Eli Friedman42f74f22012-08-08 23:57:20 +00003592} // end anonymous namespace
3593
3594namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00003595class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003596 // Possible FPU choices.
3597 enum FPUMode {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003598 VFP2FPU = (1 << 0),
3599 VFP3FPU = (1 << 1),
3600 VFP4FPU = (1 << 2),
3601 NeonFPU = (1 << 3)
Daniel Dunbara91320b2009-12-21 23:28:17 +00003602 };
3603
Silviu Baranga1db2e272013-10-21 10:54:53 +00003604 // Possible HWDiv features.
3605 enum HWDivMode {
3606 HWDivThumb = (1 << 0),
3607 HWDivARM = (1 << 1)
3608 };
3609
Daniel Dunbara91320b2009-12-21 23:28:17 +00003610 static bool FPUModeIsVFP(FPUMode Mode) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003611 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU);
Daniel Dunbara91320b2009-12-21 23:28:17 +00003612 }
3613
3614 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3615 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003616
Daniel Dunbareac7c532009-12-18 18:42:37 +00003617 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003618
Rafael Espindola5389b842013-08-21 21:59:03 +00003619 enum {
3620 FP_Default,
3621 FP_VFP,
3622 FP_Neon
3623 } FPMath;
3624
Bob Wilsoncfaab002012-09-29 23:52:52 +00003625 unsigned FPU : 4;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003626
Logan Chieneae5a8202012-10-10 06:56:20 +00003627 unsigned IsAAPCS : 1;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003628 unsigned IsThumb : 1;
Silviu Baranga1db2e272013-10-21 10:54:53 +00003629 unsigned HWDiv : 2;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003630
3631 // Initialized via features.
3632 unsigned SoftFloat : 1;
3633 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003634
Chris Lattner2752c012010-03-03 19:03:45 +00003635 static const Builtin::Info BuiltinInfo[];
3636
Rafael Espindola620c0af2013-05-13 20:09:47 +00003637 static bool shouldUseInlineAtomic(const llvm::Triple &T) {
3638 // On linux, binaries targeting old cpus call functions in libgcc to
3639 // perform atomic operations. The implementation in libgcc then calls into
3640 // the kernel which on armv6 and newer uses ldrex and strex. The net result
3641 // is that if we assume the kernel is at least as recent as the hardware,
3642 // it is safe to use atomic instructions on armv6 and newer.
Cameron Esfahani57b1da12013-09-14 01:09:11 +00003643 if (!T.isOSLinux() &&
Rafael Espindolae1e03422013-06-17 20:00:15 +00003644 T.getOS() != llvm::Triple::FreeBSD &&
3645 T.getOS() != llvm::Triple::Bitrig)
Ed Schouten04491632013-06-15 09:40:14 +00003646 return false;
Rafael Espindola620c0af2013-05-13 20:09:47 +00003647 StringRef ArchName = T.getArchName();
Rafael Espindola69db5552013-05-14 00:44:24 +00003648 if (T.getArch() == llvm::Triple::arm) {
3649 if (!ArchName.startswith("armv"))
3650 return false;
3651 StringRef VersionStr = ArchName.substr(4);
3652 unsigned Version;
3653 if (VersionStr.getAsInteger(10, Version))
3654 return false;
3655 return Version >= 6;
3656 }
3657 assert(T.getArch() == llvm::Triple::thumb);
3658 if (!ArchName.startswith("thumbv"))
3659 return false;
3660 StringRef VersionStr = ArchName.substr(6);
3661 unsigned Version;
3662 if (VersionStr.getAsInteger(10, Version))
3663 return false;
3664 return Version >= 7;
Rafael Espindola620c0af2013-05-13 20:09:47 +00003665 }
3666
Chris Lattner393ff042008-04-21 18:56:49 +00003667public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003668 ARMTargetInfo(const llvm::Triple &Triple)
3669 : TargetInfo(Triple), ABI("aapcs-linux"), CPU("arm1136j-s"),
Rafael Espindola5389b842013-08-21 21:59:03 +00003670 FPMath(FP_Default), IsAAPCS(true) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003671 BigEndian = false;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003672 SizeType = UnsignedInt;
3673 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00003674 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
3675 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003676
Chris Lattner9bffb072010-04-23 16:29:58 +00003677 // {} in inline assembly are neon specifiers, not assembly variant
3678 // specifiers.
3679 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00003680
Daniel Dunbareac7c532009-12-18 18:42:37 +00003681 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00003682 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003683 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003684 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3685 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003686 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
3687 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003688 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003689 } else {
3690 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3691 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003692 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003693 }
John McCallee79a4c2010-08-21 22:46:04 +00003694
3695 // ARM targets default to using the ARM C++ ABI.
John McCallb8b2c9d2013-01-25 22:30:49 +00003696 TheCXXABI.set(TargetCXXABI::GenericARM);
Eli Friedman2be46072011-10-14 20:59:01 +00003697
3698 // ARM has atomics up to 8 bytes
Eli Friedman2be46072011-10-14 20:59:01 +00003699 MaxAtomicPromoteWidth = 64;
Rafael Espindola620c0af2013-05-13 20:09:47 +00003700 if (shouldUseInlineAtomic(getTriple()))
3701 MaxAtomicInlineWidth = 64;
James Molloye45b9b72012-03-12 09:14:10 +00003702
3703 // Do force alignment of members that follow zero length bitfields. If
3704 // the alignment of the zero-length bitfield is greater than the member
3705 // that follows it, `bar', `bar' will be aligned as the type of the
3706 // zero length bitfield.
3707 UseZeroLengthBitfieldAlignment = true;
Eli Friedman61538a72008-05-20 14:21:01 +00003708 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003709 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00003710 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003711 ABI = Name;
3712
Daniel Dunbara2a41612009-09-14 00:02:24 +00003713 // The defaults (above) are for AAPCS, check if we need to change them.
3714 //
3715 // FIXME: We need support for -meabi... we could just mangle it into the
3716 // name.
3717 if (Name == "apcs-gnu") {
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003718 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Rafael Espindola27fa2362012-12-13 04:17:14 +00003719 // size_t is unsigned int on FreeBSD.
3720 if (getTriple().getOS() != llvm::Triple::FreeBSD)
3721 SizeType = UnsignedLong;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003722
James Molloya6d81f92011-11-23 13:35:08 +00003723 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
3724 WCharType = SignedInt;
3725
Daniel Dunbar684de632010-04-22 16:14:54 +00003726 // Do not respect the alignment of bit-field types when laying out
3727 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
3728 UseBitFieldTypeAlignment = false;
3729
Chad Rosier61a62212011-08-04 01:21:14 +00003730 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00003731 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
3732 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00003733 ZeroLengthBitfieldBoundary = 32;
3734
Logan Chieneae5a8202012-10-10 06:56:20 +00003735 IsAAPCS = false;
3736
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003737 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003738 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3739 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003740 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
Bob Wilson949fd1a2011-06-29 16:09:20 +00003741 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003742 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003743 } else {
3744 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Bob Wilsoncd5ce092011-04-04 16:53:11 +00003745 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003746 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003747 }
3748
Chad Rosier9f1210c2011-07-26 07:03:04 +00003749 // FIXME: Override "preferred align" for double and long long.
David Tweedb16abb12012-10-25 13:33:01 +00003750 } else if (Name == "aapcs" || Name == "aapcs-vfp") {
Bob Wilsone4bce7a2013-06-18 05:36:04 +00003751 // size_t is unsigned long on Darwin.
3752 if (getTriple().isOSDarwin())
3753 SizeType = UnsignedLong;
Logan Chieneae5a8202012-10-10 06:56:20 +00003754 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003755 // FIXME: Enumerated types are variable width in straight AAPCS.
3756 } else if (Name == "aapcs-linux") {
Logan Chieneae5a8202012-10-10 06:56:20 +00003757 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003758 } else
3759 return false;
3760
3761 return true;
3762 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003763
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003764 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Silviu Barangac6c9cf42013-10-21 10:59:33 +00003765 StringRef ArchName = getTriple().getArchName();
Daniel Dunbara91320b2009-12-21 23:28:17 +00003766 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
3767 Features["vfp2"] = true;
Renato Golin1302f9f2013-09-13 17:02:45 +00003768 else if (CPU == "cortex-a8" || CPU == "cortex-a9" ||
3769 CPU == "cortex-a9-mp") {
3770 Features["vfp3"] = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003771 Features["neon"] = true;
Silviu Barangac6c9cf42013-10-21 10:59:33 +00003772 }
3773 else if (CPU == "cortex-a5") {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003774 Features["vfp4"] = true;
3775 Features["neon"] = true;
Silviu Barangac6c9cf42013-10-21 10:59:33 +00003776 } else if (CPU == "swift" || CPU == "cortex-a7" || CPU == "cortex-a15") {
3777 Features["vfp4"] = true;
3778 Features["neon"] = true;
3779 Features["hwdiv"] = true;
3780 Features["hwdiv-arm"] = true;
3781 } else if (CPU == "cortex-r5" || CPU == "cortex-a53"||
3782 CPU == "cortex-a57" || CPU == "cortex-m3" ||
3783 CPU == "cortex-m4" ||
3784 // Enable the hwdiv extension for all v8a AArch32 cores by
3785 // default.
3786 ArchName == "armv8a" || ArchName == "armv8" ||
3787 ArchName == "thumbv8a" || ArchName == "thumbv8") {
3788 Features["hwdiv"] = true;
3789 Features["hwdiv-arm"] = true;
Bob Wilsoncfaab002012-09-29 23:52:52 +00003790 }
Daniel Dunbara91320b2009-12-21 23:28:17 +00003791 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003792
Eric Christopher3d11ced2013-10-16 21:26:26 +00003793 virtual bool handleTargetFeatures(std::vector<std::string> &Features,
Rafael Espindola5389b842013-08-21 21:59:03 +00003794 DiagnosticsEngine &Diags) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003795 FPU = 0;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003796 SoftFloat = SoftFloatABI = false;
Silviu Baranga1db2e272013-10-21 10:54:53 +00003797 HWDiv = 0;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003798 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
3799 if (Features[i] == "+soft-float")
3800 SoftFloat = true;
3801 else if (Features[i] == "+soft-float-abi")
3802 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003803 else if (Features[i] == "+vfp2")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003804 FPU |= VFP2FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003805 else if (Features[i] == "+vfp3")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003806 FPU |= VFP3FPU;
3807 else if (Features[i] == "+vfp4")
3808 FPU |= VFP4FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003809 else if (Features[i] == "+neon")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003810 FPU |= NeonFPU;
Silviu Baranga1db2e272013-10-21 10:54:53 +00003811 else if (Features[i] == "+hwdiv")
3812 HWDiv |= HWDivThumb;
3813 else if (Features[i] == "+hwdiv-arm")
3814 HWDiv |= HWDivARM;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003815 }
3816
Rafael Espindola5389b842013-08-21 21:59:03 +00003817 if (!(FPU & NeonFPU) && FPMath == FP_Neon) {
3818 Diags.Report(diag::err_target_unsupported_fpmath) << "neon";
3819 return false;
3820 }
3821
3822 if (FPMath == FP_Neon)
3823 Features.push_back("+neonfp");
3824 else if (FPMath == FP_VFP)
3825 Features.push_back("-neonfp");
3826
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003827 // Remove front-end specific options which the backend handles differently.
3828 std::vector<std::string>::iterator it;
3829 it = std::find(Features.begin(), Features.end(), "+soft-float");
3830 if (it != Features.end())
3831 Features.erase(it);
3832 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
3833 if (it != Features.end())
3834 Features.erase(it);
Rafael Espindola5389b842013-08-21 21:59:03 +00003835 return true;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003836 }
3837
Douglas Gregore727d212012-01-30 06:38:25 +00003838 virtual bool hasFeature(StringRef Feature) const {
3839 return llvm::StringSwitch<bool>(Feature)
3840 .Case("arm", true)
3841 .Case("softfloat", SoftFloat)
3842 .Case("thumb", IsThumb)
Amara Emerson2440fb12013-09-16 18:07:35 +00003843 .Case("neon", (FPU & NeonFPU) && !SoftFloat)
Silviu Baranga1db2e272013-10-21 10:54:53 +00003844 .Case("hwdiv", HWDiv & HWDivThumb)
3845 .Case("hwdiv-arm", HWDiv & HWDivARM)
Douglas Gregore727d212012-01-30 06:38:25 +00003846 .Default(false);
3847 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003848 // FIXME: Should we actually have some table instead of these switches?
Chris Lattner5f9e2722011-07-23 10:55:15 +00003849 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00003850 return llvm::StringSwitch<const char*>(Name)
3851 .Cases("arm8", "arm810", "4")
3852 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
3853 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
3854 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
3855 .Case("ep9312", "4T")
3856 .Cases("arm10tdmi", "arm1020t", "5T")
3857 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
3858 .Case("arm926ej-s", "5TEJ")
3859 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
3860 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003861 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003862 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003863 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003864 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
Bob Wilsonfc553452013-03-04 22:37:46 +00003865 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "7A")
Renato Golin5df40452013-09-13 17:02:54 +00003866 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "7A")
3867 .Cases("cortex-r4", "cortex-r5", "7R")
Bob Wilson336bfa32012-09-29 23:52:50 +00003868 .Case("cortex-a9-mp", "7F")
3869 .Case("swift", "7S")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003870 .Cases("cortex-m3", "cortex-m4", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00003871 .Case("cortex-m0", "6M")
Bernard Ogdenc4272492013-10-24 18:32:36 +00003872 .Cases("cortex-a53", "cortex-a57", "8A")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003873 .Default(0);
3874 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003875 static const char *getCPUProfile(StringRef Name) {
3876 return llvm::StringSwitch<const char*>(Name)
Renato Golin5df40452013-09-13 17:02:54 +00003877 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "A")
3878 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "A")
Bernard Ogdenc4272492013-10-24 18:32:36 +00003879 .Cases("cortex-a53", "cortex-a57", "A")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003880 .Cases("cortex-m3", "cortex-m4", "cortex-m0", "M")
Renato Golin5df40452013-09-13 17:02:54 +00003881 .Cases("cortex-r4", "cortex-r5", "R")
Anton Korobeynikov8b0703d2012-09-08 08:22:13 +00003882 .Default("");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003883 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003884 virtual bool setCPU(const std::string &Name) {
3885 if (!getCPUDefineSuffix(Name))
3886 return false;
3887
3888 CPU = Name;
3889 return true;
3890 }
Rafael Espindola5389b842013-08-21 21:59:03 +00003891 virtual bool setFPMath(StringRef Name);
Chris Lattner33328642009-03-20 15:52:06 +00003892 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003893 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00003894 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00003895 Builder.defineMacro("__arm");
3896 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003897
Chris Lattnerc0f59212009-03-02 22:27:17 +00003898 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00003899 Builder.defineMacro("__ARMEL__");
3900 Builder.defineMacro("__LITTLE_ENDIAN__");
3901 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003902
Chris Lattner5f9e2722011-07-23 10:55:15 +00003903 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00003904 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003905 Builder.defineMacro("__ARM_ARCH", CPUArch.substr(0, 1));
3906 StringRef CPUProfile = getCPUProfile(CPU);
3907 if (!CPUProfile.empty())
3908 Builder.defineMacro("__ARM_ARCH_PROFILE", CPUProfile);
3909
Mike Stump437bb4b2009-04-08 02:07:04 +00003910 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003911
Daniel Dunbareac7c532009-12-18 18:42:37 +00003912 // FIXME: It's more complicated than this and we don't really support
3913 // interworking.
3914 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00003915 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003916
David Tweedb16abb12012-10-25 13:33:01 +00003917 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
Daniel Dunbar849289e2012-10-22 18:51:13 +00003918 // M-class CPUs on Darwin follow AAPCS, but not EABI.
Daniel Dunbar4d3ee9b2012-10-22 18:56:43 +00003919 if (!(getTriple().isOSDarwin() && CPUProfile == "M"))
Daniel Dunbar849289e2012-10-22 18:51:13 +00003920 Builder.defineMacro("__ARM_EABI__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003921 Builder.defineMacro("__ARM_PCS", "1");
3922
David Tweedb16abb12012-10-25 13:33:01 +00003923 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003924 Builder.defineMacro("__ARM_PCS_VFP", "1");
3925 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003926
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003927 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00003928 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003929
3930 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00003931 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003932
Bob Wilson84f95cf2011-05-13 18:56:03 +00003933 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003934 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003935 Builder.defineMacro("__THUMBEL__");
3936 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00003937 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003938 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003939 }
Silviu Baranga1db2e272013-10-21 10:54:53 +00003940 if (((HWDiv & HWDivThumb) && IsThumb) || ((HWDiv & HWDivARM) && !IsThumb))
3941 Builder.defineMacro("__ARM_ARCH_EXT_IDIV__", "1");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003942
3943 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00003944 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00003945
Bob Wilsoncfaab002012-09-29 23:52:52 +00003946 if (FPUModeIsVFP((FPUMode) FPU)) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003947 Builder.defineMacro("__VFP_FP__");
Bob Wilsoncfaab002012-09-29 23:52:52 +00003948 if (FPU & VFP2FPU)
3949 Builder.defineMacro("__ARM_VFPV2__");
3950 if (FPU & VFP3FPU)
3951 Builder.defineMacro("__ARM_VFPV3__");
3952 if (FPU & VFP4FPU)
3953 Builder.defineMacro("__ARM_VFPV4__");
3954 }
3955
Daniel Dunbara91320b2009-12-21 23:28:17 +00003956 // This only gets set when Neon instructions are actually available, unlike
3957 // the VFP define, hence the soft float and arch check. This is subtly
3958 // different from gcc, we follow the intent which was that it should be set
3959 // when Neon instructions are actually available.
Bob Wilsoncfaab002012-09-29 23:52:52 +00003960 if ((FPU & NeonFPU) && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003961 Builder.defineMacro("__ARM_NEON__");
Joey Gouly520ec1e2013-09-18 10:07:09 +00003962
3963 if (CPUArch.startswith("8"))
3964 Builder.defineMacro("__ARM_FEATURE_CRC32");
Weiming Zhao8712ded2013-09-30 22:51:32 +00003965
3966 if (CPUArch[0] >= '6' && CPUArch != "6M") {
3967 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
3968 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
3969 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
3970 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
3971 }
Chris Lattner393ff042008-04-21 18:56:49 +00003972 }
3973 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3974 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00003975 Records = BuiltinInfo;
3976 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00003977 }
Bob Wilson8b30a932012-01-26 22:14:27 +00003978 virtual bool isCLZForZeroUndef() const { return false; }
Meador Ingec5613b22012-06-16 03:34:49 +00003979 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Logan Chieneae5a8202012-10-10 06:56:20 +00003980 return IsAAPCS ? AAPCSABIBuiltinVaList : TargetInfo::VoidPtrBuiltinVaList;
Chris Lattner393ff042008-04-21 18:56:49 +00003981 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003982 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003983 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003984 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003985 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003986 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00003987 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003988 switch (*Name) {
Eric Christophera0dfca12012-08-16 23:50:41 +00003989 default: break;
Nate Begemanad487f42008-04-22 05:03:19 +00003990 case 'l': // r0-r7
3991 case 'h': // r8-r15
3992 case 'w': // VFP Floating point register single precision
3993 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00003994 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00003995 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00003996 case 'Q': // A memory address that is a single base register.
3997 Info.setAllowsMemory();
3998 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00003999 case 'U': // a memory reference...
4000 switch (Name[1]) {
4001 case 'q': // ...ARMV4 ldrsb
4002 case 'v': // ...VFP load/store (reg+constant offset)
4003 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00004004 case 't': // address valid for load/store opaque types wider
Eric Christopher825d3862012-11-14 22:08:59 +00004005 // than 128-bits
Eric Christopherdda231a2011-06-17 01:40:49 +00004006 case 'n': // valid address for Neon doubleword vector load/store
4007 case 'm': // valid address for Neon element and structure load/store
4008 case 's': // valid address for non-offset loads/stores of quad-word
Eric Christopher825d3862012-11-14 22:08:59 +00004009 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00004010 Info.setAllowsMemory();
4011 Name++;
4012 return true;
4013 }
Nate Begemanad487f42008-04-22 05:03:19 +00004014 }
Chris Lattner393ff042008-04-21 18:56:49 +00004015 return false;
4016 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00004017 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00004018 std::string R;
4019 switch (*Constraint) {
4020 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00004021 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00004022 Constraint++;
4023 break;
Eric Christopher283f4472011-06-17 00:40:18 +00004024 case 'p': // 'p' should be translated to 'r' by default.
4025 R = std::string("r");
4026 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00004027 default:
4028 return std::string(1, *Constraint);
4029 }
4030 return R;
4031 }
Bill Wendling50d46ca2012-10-25 23:28:48 +00004032 virtual bool validateConstraintModifier(StringRef Constraint,
4033 const char Modifier,
4034 unsigned Size) const {
Bill Wendlinge2dbaa92012-11-30 23:18:12 +00004035 bool isOutput = (Constraint[0] == '=');
Bill Wendling6e6330c2012-11-30 23:46:56 +00004036 bool isInOut = (Constraint[0] == '+');
Bill Wendlinge2dbaa92012-11-30 23:18:12 +00004037
Bill Wendling50d46ca2012-10-25 23:28:48 +00004038 // Strip off constraint modifiers.
4039 while (Constraint[0] == '=' ||
4040 Constraint[0] == '+' ||
4041 Constraint[0] == '&')
4042 Constraint = Constraint.substr(1);
4043
4044 switch (Constraint[0]) {
4045 default: break;
4046 case 'r': {
4047 switch (Modifier) {
4048 default:
Bob Wilson221a8902013-06-03 23:57:13 +00004049 return (isInOut || isOutput || Size <= 32);
Bill Wendling50d46ca2012-10-25 23:28:48 +00004050 case 'q':
4051 // A register of size 32 cannot fit a vector type.
4052 return false;
4053 }
4054 }
4055 }
4056
4057 return true;
4058 }
Chris Lattner393ff042008-04-21 18:56:49 +00004059 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00004060 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00004061 return "";
4062 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00004063
4064 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
4065 return (CC == CC_AAPCS || CC == CC_AAPCS_VFP) ? CCCR_OK : CCCR_Warning;
4066 }
Logan Chiena8f7a972013-02-23 04:24:36 +00004067
4068 virtual int getEHDataRegisterNumber(unsigned RegNo) const {
4069 if (RegNo == 0) return 0;
4070 if (RegNo == 1) return 1;
4071 return -1;
4072 }
Chris Lattner393ff042008-04-21 18:56:49 +00004073};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00004074
Rafael Espindola5389b842013-08-21 21:59:03 +00004075bool ARMTargetInfo::setFPMath(StringRef Name) {
4076 if (Name == "neon") {
4077 FPMath = FP_Neon;
4078 return true;
4079 } else if (Name == "vfp" || Name == "vfp2" || Name == "vfp3" ||
4080 Name == "vfp4") {
4081 FPMath = FP_VFP;
4082 return true;
4083 }
4084 return false;
4085}
4086
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00004087const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00004088 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00004089 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00004090 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
4091
4092 // Float registers
4093 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
4094 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
4095 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00004096 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00004097
Dale Johannesen20eb49b2010-10-27 23:34:42 +00004098 // Double registers
4099 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
4100 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00004101 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
4102 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00004103
4104 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00004105 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
4106 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00004107};
4108
4109void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00004110 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00004111 Names = GCCRegNames;
4112 NumNames = llvm::array_lengthof(GCCRegNames);
4113}
4114
4115const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00004116 { { "a1" }, "r0" },
4117 { { "a2" }, "r1" },
4118 { { "a3" }, "r2" },
4119 { { "a4" }, "r3" },
4120 { { "v1" }, "r4" },
4121 { { "v2" }, "r5" },
4122 { { "v3" }, "r6" },
4123 { { "v4" }, "r7" },
4124 { { "v5" }, "r8" },
4125 { { "v6", "rfp" }, "r9" },
4126 { { "sl" }, "r10" },
4127 { { "fp" }, "r11" },
4128 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00004129 { { "r13" }, "sp" },
4130 { { "r14" }, "lr" },
4131 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00004132 // The S, D and Q registers overlap, but aren't really aliases; we
4133 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00004134};
4135
4136void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4137 unsigned &NumAliases) const {
4138 Aliases = GCCRegAliases;
4139 NumAliases = llvm::array_lengthof(GCCRegAliases);
4140}
Chris Lattner2752c012010-03-03 19:03:45 +00004141
4142const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00004143#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00004144#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00004145 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00004146#include "clang/Basic/BuiltinsARM.def"
4147};
Chris Lattner393ff042008-04-21 18:56:49 +00004148} // end anonymous namespace.
4149
Eli Friedmana9f54962008-08-20 07:44:10 +00004150namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00004151class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00004152 public DarwinTargetInfo<ARMTargetInfo> {
4153protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00004154 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00004155 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00004156 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00004157 }
Eli Friedmana9f54962008-08-20 07:44:10 +00004158
Torok Edwin5f6c1942009-06-30 17:10:35 +00004159public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004160 DarwinARMTargetInfo(const llvm::Triple &Triple)
4161 : DarwinTargetInfo<ARMTargetInfo>(Triple) {
Daniel Dunbar350b9f32010-05-27 07:00:26 +00004162 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00004163 // iOS always has 64-bit atomic instructions.
4164 // FIXME: This should be based off of the target features in ARMTargetInfo.
4165 MaxAtomicInlineWidth = 64;
John McCallb8b2c9d2013-01-25 22:30:49 +00004166
4167 // Darwin on iOS uses a variant of the ARM C++ ABI.
4168 TheCXXABI.set(TargetCXXABI::iOS);
Daniel Dunbar350b9f32010-05-27 07:00:26 +00004169 }
Eli Friedmana9f54962008-08-20 07:44:10 +00004170};
4171} // end anonymous namespace.
4172
Tony Linthicum96319392011-12-12 21:14:55 +00004173
4174namespace {
4175// Hexagon abstract base class
4176class HexagonTargetInfo : public TargetInfo {
4177 static const Builtin::Info BuiltinInfo[];
4178 static const char * const GCCRegNames[];
4179 static const TargetInfo::GCCRegAlias GCCRegAliases[];
4180 std::string CPU;
4181public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004182 HexagonTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004183 BigEndian = false;
Tony Linthicum96319392011-12-12 21:14:55 +00004184 DescriptionString = ("e-p:32:32:32-"
Anshuman Dasgupta1a090f12013-01-02 21:25:57 +00004185 "i64:64:64-i32:32:32-i16:16:16-i1:32:32-"
Sirish Pande5f9688b2012-05-10 20:19:54 +00004186 "f64:64:64-f32:32:32-a0:0-n32");
Tony Linthicum96319392011-12-12 21:14:55 +00004187
4188 // {} in inline assembly are packet specifiers, not assembly variant
4189 // specifiers.
4190 NoAsmVariants = true;
4191 }
4192
4193 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4194 unsigned &NumRecords) const {
4195 Records = BuiltinInfo;
4196 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
4197 }
4198
4199 virtual bool validateAsmConstraint(const char *&Name,
4200 TargetInfo::ConstraintInfo &Info) const {
4201 return true;
4202 }
4203
4204 virtual void getTargetDefines(const LangOptions &Opts,
4205 MacroBuilder &Builder) const;
4206
Douglas Gregore727d212012-01-30 06:38:25 +00004207 virtual bool hasFeature(StringRef Feature) const {
4208 return Feature == "hexagon";
4209 }
4210
Meador Ingec5613b22012-06-16 03:34:49 +00004211 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4212 return TargetInfo::CharPtrBuiltinVaList;
Tony Linthicum96319392011-12-12 21:14:55 +00004213 }
4214 virtual void getGCCRegNames(const char * const *&Names,
4215 unsigned &NumNames) const;
4216 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4217 unsigned &NumAliases) const;
4218 virtual const char *getClobbers() const {
4219 return "";
4220 }
Sebastian Pop43115d42012-01-13 20:37:10 +00004221
4222 static const char *getHexagonCPUSuffix(StringRef Name) {
4223 return llvm::StringSwitch<const char*>(Name)
Sebastian Pop43115d42012-01-13 20:37:10 +00004224 .Case("hexagonv4", "4")
Sirish Pande5f9688b2012-05-10 20:19:54 +00004225 .Case("hexagonv5", "5")
Sebastian Pop43115d42012-01-13 20:37:10 +00004226 .Default(0);
4227 }
4228
Tony Linthicum96319392011-12-12 21:14:55 +00004229 virtual bool setCPU(const std::string &Name) {
Sebastian Pop43115d42012-01-13 20:37:10 +00004230 if (!getHexagonCPUSuffix(Name))
4231 return false;
4232
Tony Linthicum96319392011-12-12 21:14:55 +00004233 CPU = Name;
4234 return true;
4235 }
4236};
4237
4238void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
4239 MacroBuilder &Builder) const {
4240 Builder.defineMacro("qdsp6");
4241 Builder.defineMacro("__qdsp6", "1");
4242 Builder.defineMacro("__qdsp6__", "1");
4243
4244 Builder.defineMacro("hexagon");
4245 Builder.defineMacro("__hexagon", "1");
4246 Builder.defineMacro("__hexagon__", "1");
4247
4248 if(CPU == "hexagonv1") {
4249 Builder.defineMacro("__HEXAGON_V1__");
4250 Builder.defineMacro("__HEXAGON_ARCH__", "1");
4251 if(Opts.HexagonQdsp6Compat) {
4252 Builder.defineMacro("__QDSP6_V1__");
4253 Builder.defineMacro("__QDSP6_ARCH__", "1");
4254 }
4255 }
4256 else if(CPU == "hexagonv2") {
4257 Builder.defineMacro("__HEXAGON_V2__");
4258 Builder.defineMacro("__HEXAGON_ARCH__", "2");
4259 if(Opts.HexagonQdsp6Compat) {
4260 Builder.defineMacro("__QDSP6_V2__");
4261 Builder.defineMacro("__QDSP6_ARCH__", "2");
4262 }
4263 }
4264 else if(CPU == "hexagonv3") {
4265 Builder.defineMacro("__HEXAGON_V3__");
4266 Builder.defineMacro("__HEXAGON_ARCH__", "3");
4267 if(Opts.HexagonQdsp6Compat) {
4268 Builder.defineMacro("__QDSP6_V3__");
4269 Builder.defineMacro("__QDSP6_ARCH__", "3");
4270 }
4271 }
4272 else if(CPU == "hexagonv4") {
4273 Builder.defineMacro("__HEXAGON_V4__");
4274 Builder.defineMacro("__HEXAGON_ARCH__", "4");
4275 if(Opts.HexagonQdsp6Compat) {
4276 Builder.defineMacro("__QDSP6_V4__");
4277 Builder.defineMacro("__QDSP6_ARCH__", "4");
4278 }
4279 }
Sirish Pande5f9688b2012-05-10 20:19:54 +00004280 else if(CPU == "hexagonv5") {
4281 Builder.defineMacro("__HEXAGON_V5__");
4282 Builder.defineMacro("__HEXAGON_ARCH__", "5");
4283 if(Opts.HexagonQdsp6Compat) {
4284 Builder.defineMacro("__QDSP6_V5__");
4285 Builder.defineMacro("__QDSP6_ARCH__", "5");
4286 }
4287 }
Tony Linthicum96319392011-12-12 21:14:55 +00004288}
4289
4290const char * const HexagonTargetInfo::GCCRegNames[] = {
4291 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4292 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4293 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
4294 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
4295 "p0", "p1", "p2", "p3",
4296 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
4297};
4298
4299void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
4300 unsigned &NumNames) const {
4301 Names = GCCRegNames;
4302 NumNames = llvm::array_lengthof(GCCRegNames);
4303}
4304
4305
4306const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
4307 { { "sp" }, "r29" },
4308 { { "fp" }, "r30" },
4309 { { "lr" }, "r31" },
4310 };
4311
4312void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4313 unsigned &NumAliases) const {
4314 Aliases = GCCRegAliases;
4315 NumAliases = llvm::array_lengthof(GCCRegAliases);
4316}
4317
4318
4319const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
4320#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4321#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4322 ALL_LANGUAGES },
4323#include "clang/Basic/BuiltinsHexagon.def"
4324};
4325}
4326
4327
Reid Spencer5f016e22007-07-11 17:01:13 +00004328namespace {
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004329// Shared base class for SPARC v8 (32-bit) and SPARC v9 (64-bit).
4330class SparcTargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00004331 static const TargetInfo::GCCRegAlias GCCRegAliases[];
4332 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004333 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00004334public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004335 SparcTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {}
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004336
Eric Christopher3d11ced2013-10-16 21:26:26 +00004337 virtual bool handleTargetFeatures(std::vector<std::string> &Features,
Rafael Espindola5389b842013-08-21 21:59:03 +00004338 DiagnosticsEngine &Diags) {
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004339 SoftFloat = false;
4340 for (unsigned i = 0, e = Features.size(); i != e; ++i)
4341 if (Features[i] == "+soft-float")
4342 SoftFloat = true;
Rafael Espindola5389b842013-08-21 21:59:03 +00004343 return true;
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004344 }
Chris Lattner33328642009-03-20 15:52:06 +00004345 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004346 MacroBuilder &Builder) const {
4347 DefineStd(Builder, "sparc", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00004348 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004349
4350 if (SoftFloat)
4351 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00004352 }
Douglas Gregore727d212012-01-30 06:38:25 +00004353
4354 virtual bool hasFeature(StringRef Feature) const {
4355 return llvm::StringSwitch<bool>(Feature)
4356 .Case("softfloat", SoftFloat)
4357 .Case("sparc", true)
4358 .Default(false);
4359 }
4360
Gabor Greif26658672008-02-21 16:29:08 +00004361 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4362 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00004363 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00004364 }
Meador Ingec5613b22012-06-16 03:34:49 +00004365 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4366 return TargetInfo::VoidPtrBuiltinVaList;
Gabor Greif26658672008-02-21 16:29:08 +00004367 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004368 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00004369 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004370 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00004371 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00004372 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00004373 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00004374 // FIXME: Implement!
4375 return false;
Gabor Greif26658672008-02-21 16:29:08 +00004376 }
4377 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00004378 // FIXME: Implement!
4379 return "";
Gabor Greif26658672008-02-21 16:29:08 +00004380 }
4381};
4382
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004383const char * const SparcTargetInfo::GCCRegNames[] = {
Chris Lattnere957f532009-01-27 01:58:38 +00004384 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4385 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4386 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
4387 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
4388};
4389
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004390void SparcTargetInfo::getGCCRegNames(const char * const *&Names,
4391 unsigned &NumNames) const {
Chris Lattnere957f532009-01-27 01:58:38 +00004392 Names = GCCRegNames;
4393 NumNames = llvm::array_lengthof(GCCRegNames);
4394}
4395
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004396const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004397 { { "g0" }, "r0" },
4398 { { "g1" }, "r1" },
4399 { { "g2" }, "r2" },
4400 { { "g3" }, "r3" },
4401 { { "g4" }, "r4" },
4402 { { "g5" }, "r5" },
4403 { { "g6" }, "r6" },
4404 { { "g7" }, "r7" },
4405 { { "o0" }, "r8" },
4406 { { "o1" }, "r9" },
4407 { { "o2" }, "r10" },
4408 { { "o3" }, "r11" },
4409 { { "o4" }, "r12" },
4410 { { "o5" }, "r13" },
4411 { { "o6", "sp" }, "r14" },
4412 { { "o7" }, "r15" },
4413 { { "l0" }, "r16" },
4414 { { "l1" }, "r17" },
4415 { { "l2" }, "r18" },
4416 { { "l3" }, "r19" },
4417 { { "l4" }, "r20" },
4418 { { "l5" }, "r21" },
4419 { { "l6" }, "r22" },
4420 { { "l7" }, "r23" },
4421 { { "i0" }, "r24" },
4422 { { "i1" }, "r25" },
4423 { { "i2" }, "r26" },
4424 { { "i3" }, "r27" },
4425 { { "i4" }, "r28" },
4426 { { "i5" }, "r29" },
4427 { { "i6", "fp" }, "r30" },
4428 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00004429};
4430
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004431void SparcTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4432 unsigned &NumAliases) const {
Chris Lattnere957f532009-01-27 01:58:38 +00004433 Aliases = GCCRegAliases;
4434 NumAliases = llvm::array_lengthof(GCCRegAliases);
4435}
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004436
4437// SPARC v8 is the 32-bit mode selected by Triple::sparc.
4438class SparcV8TargetInfo : public SparcTargetInfo {
4439public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004440 SparcV8TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004441 // FIXME: Support Sparc quad-precision long double?
4442 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
4443 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
4444 }
4445
4446 virtual void getTargetDefines(const LangOptions &Opts,
4447 MacroBuilder &Builder) const {
4448 SparcTargetInfo::getTargetDefines(Opts, Builder);
4449 Builder.defineMacro("__sparcv8");
4450 }
4451};
4452
4453// SPARC v9 is the 64-bit mode selected by Triple::sparcv9.
4454class SparcV9TargetInfo : public SparcTargetInfo {
4455public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004456 SparcV9TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004457 // FIXME: Support Sparc quad-precision long double?
4458 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
4459 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32:64-S128";
Jakob Stoklund Olesenfcec0c92013-05-15 03:22:33 +00004460 // This is an LP64 platform.
4461 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Jakob Stoklund Olesen5ac8c4f2013-05-19 17:53:37 +00004462
4463 // OpenBSD uses long long for int64_t and intmax_t.
4464 if (getTriple().getOS() == llvm::Triple::OpenBSD) {
4465 IntMaxType = SignedLongLong;
4466 UIntMaxType = UnsignedLongLong;
4467 } else {
4468 IntMaxType = SignedLong;
4469 UIntMaxType = UnsignedLong;
4470 }
4471 Int64Type = IntMaxType;
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004472 }
4473
4474 virtual void getTargetDefines(const LangOptions &Opts,
4475 MacroBuilder &Builder) const {
4476 SparcTargetInfo::getTargetDefines(Opts, Builder);
4477 Builder.defineMacro("__sparcv9");
Jakob Stoklund Olesen44f72d32013-04-24 04:36:38 +00004478 Builder.defineMacro("__arch64__");
4479 // Solaris and its derivative AuroraUX don't need these variants, but the
4480 // BSDs do.
4481 if (getTriple().getOS() != llvm::Triple::Solaris &&
4482 getTriple().getOS() != llvm::Triple::AuroraUX) {
4483 Builder.defineMacro("__sparc64__");
4484 Builder.defineMacro("__sparc_v9__");
4485 Builder.defineMacro("__sparcv9__");
4486 }
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004487 }
4488};
4489
Gabor Greif26658672008-02-21 16:29:08 +00004490} // end anonymous namespace.
4491
Eli Friedman01b86682008-08-20 07:28:14 +00004492namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004493class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
4494public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004495 AuroraUXSparcV8TargetInfo(const llvm::Triple &Triple)
4496 : AuroraUXTargetInfo<SparcV8TargetInfo>(Triple) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004497 SizeType = UnsignedInt;
4498 PtrDiffType = SignedInt;
4499 }
4500};
Torok Edwin5f6c1942009-06-30 17:10:35 +00004501class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00004502public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004503 SolarisSparcV8TargetInfo(const llvm::Triple &Triple)
4504 : SolarisTargetInfo<SparcV8TargetInfo>(Triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00004505 SizeType = UnsignedInt;
4506 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00004507 }
4508};
4509} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00004510
Chris Lattner2621fd12008-05-08 05:58:21 +00004511namespace {
Ulrich Weigandb8409212013-05-06 16:26:41 +00004512 class SystemZTargetInfo : public TargetInfo {
4513 static const char *const GCCRegNames[];
4514
4515 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004516 SystemZTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Ulrich Weigandb8409212013-05-06 16:26:41 +00004517 TLSSupported = true;
4518 IntWidth = IntAlign = 32;
4519 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
4520 PointerWidth = PointerAlign = 64;
4521 LongDoubleWidth = 128;
4522 LongDoubleAlign = 64;
4523 LongDoubleFormat = &llvm::APFloat::IEEEquad;
4524 MinGlobalAlign = 16;
4525 DescriptionString = "E-p:64:64:64-i1:8:16-i8:8:16-i16:16-i32:32-i64:64"
4526 "-f32:32-f64:64-f128:64-a0:8:16-n32:64";
4527 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
4528 }
4529 virtual void getTargetDefines(const LangOptions &Opts,
4530 MacroBuilder &Builder) const {
4531 Builder.defineMacro("__s390__");
4532 Builder.defineMacro("__s390x__");
4533 Builder.defineMacro("__zarch__");
4534 Builder.defineMacro("__LONG_DOUBLE_128__");
4535 }
4536 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4537 unsigned &NumRecords) const {
4538 // FIXME: Implement.
4539 Records = 0;
4540 NumRecords = 0;
4541 }
4542
4543 virtual void getGCCRegNames(const char *const *&Names,
4544 unsigned &NumNames) const;
4545 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4546 unsigned &NumAliases) const {
4547 // No aliases.
4548 Aliases = 0;
4549 NumAliases = 0;
4550 }
4551 virtual bool validateAsmConstraint(const char *&Name,
4552 TargetInfo::ConstraintInfo &info) const;
4553 virtual const char *getClobbers() const {
4554 // FIXME: Is this really right?
4555 return "";
4556 }
4557 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4558 return TargetInfo::SystemZBuiltinVaList;
4559 }
Richard Sandiford5c92b9a2013-07-19 16:51:51 +00004560 virtual bool setCPU(const std::string &Name) {
4561 bool CPUKnown = llvm::StringSwitch<bool>(Name)
4562 .Case("z10", true)
4563 .Case("z196", true)
4564 .Case("zEC12", true)
4565 .Default(false);
4566
4567 // No need to store the CPU yet. There aren't any CPU-specific
4568 // macros to define.
4569 return CPUKnown;
4570 }
Ulrich Weigandb8409212013-05-06 16:26:41 +00004571 };
4572
4573 const char *const SystemZTargetInfo::GCCRegNames[] = {
4574 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4575 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4576 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
4577 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15"
4578 };
4579
4580 void SystemZTargetInfo::getGCCRegNames(const char *const *&Names,
4581 unsigned &NumNames) const {
4582 Names = GCCRegNames;
4583 NumNames = llvm::array_lengthof(GCCRegNames);
4584 }
4585
4586 bool SystemZTargetInfo::
4587 validateAsmConstraint(const char *&Name,
4588 TargetInfo::ConstraintInfo &Info) const {
4589 switch (*Name) {
4590 default:
4591 return false;
4592
4593 case 'a': // Address register
4594 case 'd': // Data register (equivalent to 'r')
4595 case 'f': // Floating-point register
4596 Info.setAllowsRegister();
4597 return true;
4598
4599 case 'I': // Unsigned 8-bit constant
4600 case 'J': // Unsigned 12-bit constant
4601 case 'K': // Signed 16-bit constant
4602 case 'L': // Signed 20-bit displacement (on all targets we support)
4603 case 'M': // 0x7fffffff
4604 return true;
4605
4606 case 'Q': // Memory with base and unsigned 12-bit displacement
4607 case 'R': // Likewise, plus an index
4608 case 'S': // Memory with base and signed 20-bit displacement
4609 case 'T': // Likewise, plus an index
4610 Info.setAllowsMemory();
4611 return true;
4612 }
4613 }
4614}
4615
4616namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004617 class MSP430TargetInfo : public TargetInfo {
4618 static const char * const GCCRegNames[];
4619 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004620 MSP430TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004621 BigEndian = false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004622 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00004623 IntWidth = 16; IntAlign = 16;
4624 LongWidth = 32; LongLongWidth = 64;
4625 LongAlign = LongLongAlign = 16;
4626 PointerWidth = 16; PointerAlign = 16;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004627 SuitableAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004628 SizeType = UnsignedInt;
Anton Korobeynikov18a295d2013-07-01 19:42:40 +00004629 IntMaxType = SignedLongLong;
4630 UIntMaxType = UnsignedLongLong;
4631 IntPtrType = SignedInt;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004632 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00004633 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00004634 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004635 }
4636 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004637 MacroBuilder &Builder) const {
4638 Builder.defineMacro("MSP430");
4639 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004640 // FIXME: defines for different 'flavours' of MCU
4641 }
4642 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4643 unsigned &NumRecords) const {
4644 // FIXME: Implement.
4645 Records = 0;
4646 NumRecords = 0;
4647 }
Douglas Gregore727d212012-01-30 06:38:25 +00004648 virtual bool hasFeature(StringRef Feature) const {
4649 return Feature == "msp430";
4650 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004651 virtual void getGCCRegNames(const char * const *&Names,
4652 unsigned &NumNames) const;
4653 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4654 unsigned &NumAliases) const {
4655 // No aliases.
4656 Aliases = 0;
4657 NumAliases = 0;
4658 }
4659 virtual bool validateAsmConstraint(const char *&Name,
4660 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00004661 // No target constraints for now.
4662 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004663 }
4664 virtual const char *getClobbers() const {
4665 // FIXME: Is this really right?
4666 return "";
4667 }
Meador Ingec5613b22012-06-16 03:34:49 +00004668 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004669 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00004670 return TargetInfo::CharPtrBuiltinVaList;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004671 }
4672 };
4673
4674 const char * const MSP430TargetInfo::GCCRegNames[] = {
4675 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4676 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
4677 };
4678
4679 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
4680 unsigned &NumNames) const {
4681 Names = GCCRegNames;
4682 NumNames = llvm::array_lengthof(GCCRegNames);
4683 }
4684}
4685
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00004686namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00004687
Mike Stump1eb44332009-09-09 15:08:12 +00004688 // LLVM and Clang cannot be used directly to output native binaries for
4689 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00004690 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00004691 //
4692 // TCE uses the llvm bitcode as input and uses it for generating customized
4693 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00004694 // publicly available in http://tce.cs.tut.fi
4695
Eli Friedman209f5bb2011-10-07 19:51:42 +00004696 static const unsigned TCEOpenCLAddrSpaceMap[] = {
4697 3, // opencl_global
4698 4, // opencl_local
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00004699 5, // opencl_constant
4700 0, // cuda_device
4701 0, // cuda_constant
4702 0 // cuda_shared
Eli Friedman209f5bb2011-10-07 19:51:42 +00004703 };
4704
Eli Friedmanb63decf2009-08-19 20:47:07 +00004705 class TCETargetInfo : public TargetInfo{
4706 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004707 TCETargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmanb63decf2009-08-19 20:47:07 +00004708 TLSSupported = false;
4709 IntWidth = 32;
4710 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004711 PointerWidth = 32;
4712 IntAlign = 32;
4713 LongAlign = LongLongAlign = 32;
4714 PointerAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004715 SuitableAlign = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004716 SizeType = UnsignedInt;
4717 IntMaxType = SignedLong;
4718 UIntMaxType = UnsignedLong;
4719 IntPtrType = SignedInt;
4720 PtrDiffType = SignedInt;
4721 FloatWidth = 32;
4722 FloatAlign = 32;
4723 DoubleWidth = 32;
4724 DoubleAlign = 32;
4725 LongDoubleWidth = 32;
4726 LongDoubleAlign = 32;
4727 FloatFormat = &llvm::APFloat::IEEEsingle;
4728 DoubleFormat = &llvm::APFloat::IEEEsingle;
4729 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00004730 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
4731 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00004732 "f32:32:32-f64:32:32-v64:32:32-"
4733 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00004734 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
David Tweed1eef8522013-09-13 12:04:22 +00004735 UseAddrSpaceMapMangling = true;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004736 }
4737
4738 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004739 MacroBuilder &Builder) const {
4740 DefineStd(Builder, "tce", Opts);
4741 Builder.defineMacro("__TCE__");
4742 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00004743 }
Douglas Gregore727d212012-01-30 06:38:25 +00004744 virtual bool hasFeature(StringRef Feature) const {
4745 return Feature == "tce";
4746 }
4747
Eli Friedmanb63decf2009-08-19 20:47:07 +00004748 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4749 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00004750 virtual const char *getClobbers() const {
4751 return "";
4752 }
Meador Ingec5613b22012-06-16 03:34:49 +00004753 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4754 return TargetInfo::VoidPtrBuiltinVaList;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004755 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00004756 virtual void getGCCRegNames(const char * const *&Names,
4757 unsigned &NumNames) const {}
4758 virtual bool validateAsmConstraint(const char *&Name,
4759 TargetInfo::ConstraintInfo &info) const {
4760 return true;
4761 }
4762 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4763 unsigned &NumAliases) const {}
4764 };
4765}
4766
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004767namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004768class MipsTargetInfoBase : public TargetInfo {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004769 static const Builtin::Info BuiltinInfo[];
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004770 std::string CPU;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004771 bool IsMips16;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004772 bool IsMicromips;
Simon Atanasyanfc12c4a2013-09-24 09:09:16 +00004773 bool IsNan2008;
Simon Atanasyand96e3152013-04-14 14:07:30 +00004774 bool IsSingleFloat;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004775 enum MipsFloatABI {
Simon Atanasyand96e3152013-04-14 14:07:30 +00004776 HardFloat, SoftFloat
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004777 } FloatABI;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004778 enum DspRevEnum {
4779 NoDSP, DSP1, DSP2
4780 } DspRev;
Jack Carterc613b672013-08-12 17:20:29 +00004781 bool HasMSA;
Simon Atanasyanddb2ad22013-10-18 13:13:53 +00004782 bool HasFP64;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004783
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004784protected:
4785 std::string ABI;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004786
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004787public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004788 MipsTargetInfoBase(const llvm::Triple &Triple, const std::string &ABIStr,
4789 const std::string &CPUStr)
4790 : TargetInfo(Triple), CPU(CPUStr), IsMips16(false), IsMicromips(false),
Simon Atanasyanfc12c4a2013-09-24 09:09:16 +00004791 IsNan2008(false), IsSingleFloat(false), FloatABI(HardFloat),
Simon Atanasyanddb2ad22013-10-18 13:13:53 +00004792 DspRev(NoDSP), HasMSA(false), HasFP64(false), ABI(ABIStr) {}
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004793
Eric Christophered734732010-03-02 02:41:08 +00004794 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004795 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00004796 virtual bool setCPU(const std::string &Name) {
4797 CPU = Name;
4798 return true;
4799 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004800 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00004801 Features[ABI] = true;
4802 Features[CPU] = true;
4803 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004804
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004805 virtual void getTargetDefines(const LangOptions &Opts,
4806 MacroBuilder &Builder) const {
Simon Atanasyand4935a02012-08-29 19:14:58 +00004807 DefineStd(Builder, "mips", Opts);
4808 Builder.defineMacro("_mips");
4809 Builder.defineMacro("__REGISTER_PREFIX__", "");
4810
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004811 switch (FloatABI) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004812 case HardFloat:
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00004813 Builder.defineMacro("__mips_hard_float", Twine(1));
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004814 break;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004815 case SoftFloat:
4816 Builder.defineMacro("__mips_soft_float", Twine(1));
4817 break;
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00004818 }
Simon Atanasyan90913892012-04-05 19:28:31 +00004819
Simon Atanasyand96e3152013-04-14 14:07:30 +00004820 if (IsSingleFloat)
4821 Builder.defineMacro("__mips_single_float", Twine(1));
4822
Simon Atanasyanddb2ad22013-10-18 13:13:53 +00004823 Builder.defineMacro("__mips_fpr", HasFP64 ? Twine(64) : Twine(32));
4824 Builder.defineMacro("_MIPS_FPSET",
4825 Twine(32 / (HasFP64 || IsSingleFloat ? 1 : 2)));
4826
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004827 if (IsMips16)
4828 Builder.defineMacro("__mips16", Twine(1));
4829
Simon Atanasyan321ae792013-04-14 14:07:51 +00004830 if (IsMicromips)
4831 Builder.defineMacro("__mips_micromips", Twine(1));
4832
Simon Atanasyanfc12c4a2013-09-24 09:09:16 +00004833 if (IsNan2008)
4834 Builder.defineMacro("__mips_nan2008", Twine(1));
4835
Simon Atanasyana1b62272012-07-05 20:16:22 +00004836 switch (DspRev) {
4837 default:
4838 break;
4839 case DSP1:
4840 Builder.defineMacro("__mips_dsp_rev", Twine(1));
4841 Builder.defineMacro("__mips_dsp", Twine(1));
4842 break;
4843 case DSP2:
4844 Builder.defineMacro("__mips_dsp_rev", Twine(2));
4845 Builder.defineMacro("__mips_dspr2", Twine(1));
4846 Builder.defineMacro("__mips_dsp", Twine(1));
4847 break;
4848 }
4849
Jack Carterc613b672013-08-12 17:20:29 +00004850 if (HasMSA)
4851 Builder.defineMacro("__mips_msa", Twine(1));
4852
Simon Atanasyan90913892012-04-05 19:28:31 +00004853 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
4854 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
4855 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
Simon Atanasyan260e5062012-08-29 15:17:29 +00004856
4857 Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
4858 Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004859 }
4860
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004861 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4862 unsigned &NumRecords) const {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004863 Records = BuiltinInfo;
4864 NumRecords = clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004865 }
Douglas Gregore727d212012-01-30 06:38:25 +00004866 virtual bool hasFeature(StringRef Feature) const {
4867 return Feature == "mips";
4868 }
Meador Ingec5613b22012-06-16 03:34:49 +00004869 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4870 return TargetInfo::VoidPtrBuiltinVaList;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004871 }
4872 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004873 unsigned &NumNames) const {
4874 static const char * const GCCRegNames[] = {
Eric Christopherd1f853d2012-03-27 19:56:11 +00004875 // CPU register names
4876 // Must match second column of GCCRegAliases
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004877 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
4878 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
4879 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004880 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",
4881 // Floating point register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004882 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
4883 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
4884 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
4885 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004886 // Hi/lo and condition register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004887 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
4888 "$fcc5","$fcc6","$fcc7"
4889 };
4890 Names = GCCRegNames;
4891 NumNames = llvm::array_lengthof(GCCRegNames);
4892 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004893 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004894 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004895 virtual bool validateAsmConstraint(const char *&Name,
4896 TargetInfo::ConstraintInfo &Info) const {
4897 switch (*Name) {
4898 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00004899 return false;
4900
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004901 case 'r': // CPU registers.
4902 case 'd': // Equivalent to "r" unless generating MIPS16 code.
4903 case 'y': // Equivalent to "r", backwards compatibility only.
4904 case 'f': // floating-point registers.
Eric Christopher0ea61642012-04-03 01:16:32 +00004905 case 'c': // $25 for indirect jumps
4906 case 'l': // lo register
4907 case 'x': // hilo register pair
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004908 Info.setAllowsRegister();
4909 return true;
Jack Carter97102302013-03-05 19:10:54 +00004910 case 'R': // An address that can be used in a non-macro load or store
Jack Carterd2ab6d32013-03-04 21:36:11 +00004911 Info.setAllowsMemory();
4912 return true;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004913 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004914 }
4915
4916 virtual const char *getClobbers() const {
4917 // FIXME: Implement!
4918 return "";
4919 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004920
Eric Christopher3d11ced2013-10-16 21:26:26 +00004921 virtual bool handleTargetFeatures(std::vector<std::string> &Features,
Rafael Espindola5389b842013-08-21 21:59:03 +00004922 DiagnosticsEngine &Diags) {
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004923 IsMips16 = false;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004924 IsMicromips = false;
Simon Atanasyanfc12c4a2013-09-24 09:09:16 +00004925 IsNan2008 = false;
Simon Atanasyand96e3152013-04-14 14:07:30 +00004926 IsSingleFloat = false;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004927 FloatABI = HardFloat;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004928 DspRev = NoDSP;
Simon Atanasyanddb2ad22013-10-18 13:13:53 +00004929 HasFP64 = ABI == "n32" || ABI == "n64" || ABI == "64";
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004930
4931 for (std::vector<std::string>::iterator it = Features.begin(),
4932 ie = Features.end(); it != ie; ++it) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004933 if (*it == "+single-float")
Simon Atanasyand96e3152013-04-14 14:07:30 +00004934 IsSingleFloat = true;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004935 else if (*it == "+soft-float")
4936 FloatABI = SoftFloat;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004937 else if (*it == "+mips16")
4938 IsMips16 = true;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004939 else if (*it == "+micromips")
4940 IsMicromips = true;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004941 else if (*it == "+dsp")
4942 DspRev = std::max(DspRev, DSP1);
4943 else if (*it == "+dspr2")
4944 DspRev = std::max(DspRev, DSP2);
Jack Carterc613b672013-08-12 17:20:29 +00004945 else if (*it == "+msa")
4946 HasMSA = true;
Simon Atanasyanddb2ad22013-10-18 13:13:53 +00004947 else if (*it == "+fp64")
4948 HasFP64 = true;
4949 else if (*it == "-fp64")
4950 HasFP64 = false;
Simon Atanasyanfc12c4a2013-09-24 09:09:16 +00004951 else if (*it == "+nan2008")
4952 IsNan2008 = true;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004953 }
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004954
Simon Atanasyanfc12c4a2013-09-24 09:09:16 +00004955 // Remove front-end specific options.
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004956 std::vector<std::string>::iterator it =
4957 std::find(Features.begin(), Features.end(), "+soft-float");
4958 if (it != Features.end())
4959 Features.erase(it);
Simon Atanasyanfc12c4a2013-09-24 09:09:16 +00004960 it = std::find(Features.begin(), Features.end(), "+nan2008");
4961 if (it != Features.end())
4962 Features.erase(it);
Rafael Espindola5389b842013-08-21 21:59:03 +00004963
4964 return true;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004965 }
Logan Chiena8f7a972013-02-23 04:24:36 +00004966
4967 virtual int getEHDataRegisterNumber(unsigned RegNo) const {
4968 if (RegNo == 0) return 4;
4969 if (RegNo == 1) return 5;
4970 return -1;
4971 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004972};
4973
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004974const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = {
4975#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4976#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4977 ALL_LANGUAGES },
4978#include "clang/Basic/BuiltinsMips.def"
4979};
4980
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004981class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004982public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004983 Mips32TargetInfoBase(const llvm::Triple &Triple)
4984 : MipsTargetInfoBase(Triple, "o32", "mips32") {
Akira Hatanaka148735e2011-11-05 01:48:34 +00004985 SizeType = UnsignedInt;
4986 PtrDiffType = SignedInt;
Akira Hatanakadbee9492013-01-18 21:58:11 +00004987 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Akira Hatanaka148735e2011-11-05 01:48:34 +00004988 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004989 virtual bool setABI(const std::string &Name) {
4990 if ((Name == "o32") || (Name == "eabi")) {
4991 ABI = Name;
4992 return true;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004993 } else if (Name == "32") {
4994 ABI = "o32";
4995 return true;
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004996 } else
4997 return false;
4998 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004999 virtual void getTargetDefines(const LangOptions &Opts,
5000 MacroBuilder &Builder) const {
5001 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00005002
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005003 if (ABI == "o32") {
5004 Builder.defineMacro("__mips_o32");
5005 Builder.defineMacro("_ABIO32", "1");
5006 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
5007 }
5008 else if (ABI == "eabi")
5009 Builder.defineMacro("__mips_eabi");
5010 else
David Blaikieb219cfc2011-09-23 05:06:16 +00005011 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005012 }
5013 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
5014 unsigned &NumAliases) const {
5015 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
5016 { { "at" }, "$1" },
5017 { { "v0" }, "$2" },
5018 { { "v1" }, "$3" },
5019 { { "a0" }, "$4" },
5020 { { "a1" }, "$5" },
5021 { { "a2" }, "$6" },
5022 { { "a3" }, "$7" },
5023 { { "t0" }, "$8" },
5024 { { "t1" }, "$9" },
5025 { { "t2" }, "$10" },
5026 { { "t3" }, "$11" },
5027 { { "t4" }, "$12" },
5028 { { "t5" }, "$13" },
5029 { { "t6" }, "$14" },
5030 { { "t7" }, "$15" },
5031 { { "s0" }, "$16" },
5032 { { "s1" }, "$17" },
5033 { { "s2" }, "$18" },
5034 { { "s3" }, "$19" },
5035 { { "s4" }, "$20" },
5036 { { "s5" }, "$21" },
5037 { { "s6" }, "$22" },
5038 { { "s7" }, "$23" },
5039 { { "t8" }, "$24" },
5040 { { "t9" }, "$25" },
5041 { { "k0" }, "$26" },
5042 { { "k1" }, "$27" },
5043 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00005044 { { "sp","$sp" }, "$29" },
5045 { { "fp","$fp" }, "$30" },
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005046 { { "ra" }, "$31" }
5047 };
5048 Aliases = GCCRegAliases;
5049 NumAliases = llvm::array_lengthof(GCCRegAliases);
5050 }
5051};
5052
5053class Mips32EBTargetInfo : public Mips32TargetInfoBase {
5054public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005055 Mips32EBTargetInfo(const llvm::Triple &Triple)
5056 : Mips32TargetInfoBase(Triple) {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005057 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00005058 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005059 }
5060 virtual void getTargetDefines(const LangOptions &Opts,
5061 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005062 DefineStd(Builder, "MIPSEB", Opts);
5063 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00005064 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005065 }
5066};
5067
5068class Mips32ELTargetInfo : public Mips32TargetInfoBase {
5069public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005070 Mips32ELTargetInfo(const llvm::Triple &Triple)
5071 : Mips32TargetInfoBase(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00005072 BigEndian = false;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005073 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00005074 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005075 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005076 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005077 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005078 DefineStd(Builder, "MIPSEL", Opts);
5079 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00005080 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005081 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005082};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005083
5084class Mips64TargetInfoBase : public MipsTargetInfoBase {
5085 virtual void SetDescriptionString(const std::string &Name) = 0;
5086public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005087 Mips64TargetInfoBase(const llvm::Triple &Triple)
5088 : MipsTargetInfoBase(Triple, "n64", "mips64") {
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00005089 LongWidth = LongAlign = 64;
5090 PointerWidth = PointerAlign = 64;
5091 LongDoubleWidth = LongDoubleAlign = 128;
5092 LongDoubleFormat = &llvm::APFloat::IEEEquad;
David Chisnall6e399b42012-12-08 09:06:08 +00005093 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
5094 LongDoubleWidth = LongDoubleAlign = 64;
5095 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
5096 }
Nick Lewycky7ec59c72011-12-16 22:34:14 +00005097 SuitableAlign = 128;
Akira Hatanakadbee9492013-01-18 21:58:11 +00005098 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00005099 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005100 virtual bool setABI(const std::string &Name) {
5101 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00005102 if (Name == "n32") {
5103 LongWidth = LongAlign = 32;
5104 PointerWidth = PointerAlign = 32;
Simon Atanasyane9616a42013-02-27 14:55:49 +00005105 ABI = Name;
5106 return true;
5107 } else if (Name == "n64") {
5108 ABI = Name;
5109 return true;
5110 } else if (Name == "64") {
5111 ABI = "n64";
5112 return true;
5113 } else
5114 return false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005115 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00005116 virtual void getTargetDefines(const LangOptions &Opts,
5117 MacroBuilder &Builder) const {
5118 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00005119
Simon Atanasyan600a5132012-08-29 20:50:11 +00005120 Builder.defineMacro("__mips64");
5121 Builder.defineMacro("__mips64__");
5122
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005123 if (ABI == "n32") {
5124 Builder.defineMacro("__mips_n32");
5125 Builder.defineMacro("_ABIN32", "2");
5126 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
5127 }
5128 else if (ABI == "n64") {
5129 Builder.defineMacro("__mips_n64");
5130 Builder.defineMacro("_ABI64", "3");
5131 Builder.defineMacro("_MIPS_SIM", "_ABI64");
5132 }
5133 else
David Blaikieb219cfc2011-09-23 05:06:16 +00005134 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005135 }
5136 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
5137 unsigned &NumAliases) const {
5138 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
5139 { { "at" }, "$1" },
5140 { { "v0" }, "$2" },
5141 { { "v1" }, "$3" },
5142 { { "a0" }, "$4" },
5143 { { "a1" }, "$5" },
5144 { { "a2" }, "$6" },
5145 { { "a3" }, "$7" },
5146 { { "a4" }, "$8" },
5147 { { "a5" }, "$9" },
5148 { { "a6" }, "$10" },
5149 { { "a7" }, "$11" },
5150 { { "t0" }, "$12" },
5151 { { "t1" }, "$13" },
5152 { { "t2" }, "$14" },
5153 { { "t3" }, "$15" },
5154 { { "s0" }, "$16" },
5155 { { "s1" }, "$17" },
5156 { { "s2" }, "$18" },
5157 { { "s3" }, "$19" },
5158 { { "s4" }, "$20" },
5159 { { "s5" }, "$21" },
5160 { { "s6" }, "$22" },
5161 { { "s7" }, "$23" },
5162 { { "t8" }, "$24" },
5163 { { "t9" }, "$25" },
5164 { { "k0" }, "$26" },
5165 { { "k1" }, "$27" },
5166 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00005167 { { "sp","$sp" }, "$29" },
5168 { { "fp","$fp" }, "$30" },
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005169 { { "ra" }, "$31" }
5170 };
5171 Aliases = GCCRegAliases;
5172 NumAliases = llvm::array_lengthof(GCCRegAliases);
5173 }
5174};
5175
5176class Mips64EBTargetInfo : public Mips64TargetInfoBase {
5177 virtual void SetDescriptionString(const std::string &Name) {
5178 // Change DescriptionString only if ABI is n32.
5179 if (Name == "n32")
5180 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00005181 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00005182 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005183 }
5184public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005185 Mips64EBTargetInfo(const llvm::Triple &Triple)
5186 : Mips64TargetInfoBase(Triple) {
5187 // Default ABI is n64.
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005188 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00005189 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00005190 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005191 }
5192 virtual void getTargetDefines(const LangOptions &Opts,
5193 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005194 DefineStd(Builder, "MIPSEB", Opts);
5195 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00005196 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005197 }
5198};
5199
5200class Mips64ELTargetInfo : public Mips64TargetInfoBase {
5201 virtual void SetDescriptionString(const std::string &Name) {
5202 // Change DescriptionString only if ABI is n32.
5203 if (Name == "n32")
5204 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00005205 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00005206 "-v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005207 }
5208public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005209 Mips64ELTargetInfo(const llvm::Triple &Triple)
5210 : Mips64TargetInfoBase(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00005211 // Default ABI is n64.
5212 BigEndian = false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005213 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00005214 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00005215 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005216 }
5217 virtual void getTargetDefines(const LangOptions &Opts,
5218 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005219 DefineStd(Builder, "MIPSEL", Opts);
5220 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00005221 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005222 }
5223};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005224} // end anonymous namespace.
5225
Ivan Krasinef05abd2011-08-24 20:22:22 +00005226namespace {
5227class PNaClTargetInfo : public TargetInfo {
5228public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005229 PNaClTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00005230 BigEndian = false;
Ivan Krasinef05abd2011-08-24 20:22:22 +00005231 this->UserLabelPrefix = "";
5232 this->LongAlign = 32;
5233 this->LongWidth = 32;
5234 this->PointerAlign = 32;
5235 this->PointerWidth = 32;
5236 this->IntMaxType = TargetInfo::SignedLongLong;
5237 this->UIntMaxType = TargetInfo::UnsignedLongLong;
5238 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00005239 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00005240 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00005241 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00005242 this->SizeType = TargetInfo::UnsignedInt;
5243 this->PtrDiffType = TargetInfo::SignedInt;
5244 this->IntPtrType = TargetInfo::SignedInt;
Eli Benderskyc0783dc2013-04-08 21:31:01 +00005245 this->RegParmMax = 0; // Disallow regparm
Ivan Krasinef05abd2011-08-24 20:22:22 +00005246 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
5247 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
5248 }
5249
Chandler Carruthc3a2e652011-09-28 05:56:05 +00005250 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00005251 }
5252 virtual void getArchDefines(const LangOptions &Opts,
5253 MacroBuilder &Builder) const {
5254 Builder.defineMacro("__le32__");
5255 Builder.defineMacro("__pnacl__");
5256 }
5257 virtual void getTargetDefines(const LangOptions &Opts,
5258 MacroBuilder &Builder) const {
Jan Wen Voungdde3bdb2012-03-29 00:05:59 +00005259 Builder.defineMacro("__LITTLE_ENDIAN__");
Ivan Krasinef05abd2011-08-24 20:22:22 +00005260 getArchDefines(Opts, Builder);
5261 }
Douglas Gregore727d212012-01-30 06:38:25 +00005262 virtual bool hasFeature(StringRef Feature) const {
5263 return Feature == "pnacl";
5264 }
Ivan Krasinef05abd2011-08-24 20:22:22 +00005265 virtual void getTargetBuiltins(const Builtin::Info *&Records,
5266 unsigned &NumRecords) const {
5267 }
Meador Ingec5613b22012-06-16 03:34:49 +00005268 virtual BuiltinVaListKind getBuiltinVaListKind() const {
5269 return TargetInfo::PNaClABIBuiltinVaList;
Ivan Krasinef05abd2011-08-24 20:22:22 +00005270 }
5271 virtual void getGCCRegNames(const char * const *&Names,
5272 unsigned &NumNames) const;
5273 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
5274 unsigned &NumAliases) const;
5275 virtual bool validateAsmConstraint(const char *&Name,
5276 TargetInfo::ConstraintInfo &Info) const {
5277 return false;
5278 }
5279
5280 virtual const char *getClobbers() const {
5281 return "";
5282 }
5283};
5284
5285void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
5286 unsigned &NumNames) const {
5287 Names = NULL;
5288 NumNames = 0;
5289}
5290
5291void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
5292 unsigned &NumAliases) const {
5293 Aliases = NULL;
5294 NumAliases = 0;
5295}
5296} // end anonymous namespace.
5297
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005298namespace {
5299 static const unsigned SPIRAddrSpaceMap[] = {
5300 1, // opencl_global
5301 3, // opencl_local
5302 2, // opencl_constant
5303 0, // cuda_device
5304 0, // cuda_constant
5305 0 // cuda_shared
5306 };
5307 class SPIRTargetInfo : public TargetInfo {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005308 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005309 SPIRTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005310 assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
5311 "SPIR target must use unknown OS");
5312 assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
5313 "SPIR target must use unknown environment type");
5314 BigEndian = false;
5315 TLSSupported = false;
5316 LongWidth = LongAlign = 64;
5317 AddrSpaceMap = &SPIRAddrSpaceMap;
David Tweed1eef8522013-09-13 12:04:22 +00005318 UseAddrSpaceMapMangling = true;
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005319 // Define available target features
5320 // These must be defined in sorted order!
5321 NoAsmVariants = true;
5322 }
5323 virtual void getTargetDefines(const LangOptions &Opts,
5324 MacroBuilder &Builder) const {
5325 DefineStd(Builder, "SPIR", Opts);
5326 }
5327 virtual bool hasFeature(StringRef Feature) const {
5328 return Feature == "spir";
5329 }
5330
5331 virtual void getTargetBuiltins(const Builtin::Info *&Records,
5332 unsigned &NumRecords) const {}
5333 virtual const char *getClobbers() const {
5334 return "";
5335 }
5336 virtual void getGCCRegNames(const char * const *&Names,
5337 unsigned &NumNames) const {}
5338 virtual bool validateAsmConstraint(const char *&Name,
5339 TargetInfo::ConstraintInfo &info) const {
5340 return true;
5341 }
5342 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
5343 unsigned &NumAliases) const {}
5344 virtual BuiltinVaListKind getBuiltinVaListKind() const {
5345 return TargetInfo::VoidPtrBuiltinVaList;
5346 }
5347 };
5348
5349
5350 class SPIR32TargetInfo : public SPIRTargetInfo {
5351 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005352 SPIR32TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005353 PointerWidth = PointerAlign = 32;
5354 SizeType = TargetInfo::UnsignedInt;
5355 PtrDiffType = IntPtrType = TargetInfo::SignedInt;
5356 DescriptionString
Guy Benyeif3ddf632013-03-07 13:06:10 +00005357 = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005358 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-"
5359 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-"
5360 "v512:512:512-v1024:1024:1024";
Guy Benyeif3ddf632013-03-07 13:06:10 +00005361 }
5362 virtual void getTargetDefines(const LangOptions &Opts,
5363 MacroBuilder &Builder) const {
5364 DefineStd(Builder, "SPIR32", Opts);
5365 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005366 };
5367
5368 class SPIR64TargetInfo : public SPIRTargetInfo {
5369 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005370 SPIR64TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005371 PointerWidth = PointerAlign = 64;
5372 SizeType = TargetInfo::UnsignedLong;
5373 PtrDiffType = IntPtrType = TargetInfo::SignedLong;
5374 DescriptionString
Guy Benyeif3ddf632013-03-07 13:06:10 +00005375 = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005376 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-"
5377 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-"
5378 "v512:512:512-v1024:1024:1024";
Guy Benyeif3ddf632013-03-07 13:06:10 +00005379 }
5380 virtual void getTargetDefines(const LangOptions &Opts,
5381 MacroBuilder &Builder) const {
5382 DefineStd(Builder, "SPIR64", Opts);
5383 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005384 };
5385}
5386
Robert Lytton5f15f4d2013-08-13 09:43:10 +00005387namespace {
5388class XCoreTargetInfo : public TargetInfo {
5389 static const Builtin::Info BuiltinInfo[];
5390public:
5391 XCoreTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
5392 BigEndian = false;
5393 NoAsmVariants = true;
5394 LongLongAlign = 32;
5395 SuitableAlign = 32;
5396 DoubleAlign = LongDoubleAlign = 32;
5397 UseZeroLengthBitfieldAlignment = true;
5398 DescriptionString = "e-p:32:32:32-a0:0:32-n32"
5399 "-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32"
5400 "-f16:16:32-f32:32:32-f64:32:32";
5401 }
5402 virtual void getTargetDefines(const LangOptions &Opts,
5403 MacroBuilder &Builder) const {
5404 Builder.defineMacro("__XS1B__");
5405 }
5406 virtual void getTargetBuiltins(const Builtin::Info *&Records,
5407 unsigned &NumRecords) const {
5408 Records = BuiltinInfo;
5409 NumRecords = clang::XCore::LastTSBuiltin-Builtin::FirstTSBuiltin;
5410 }
5411 virtual BuiltinVaListKind getBuiltinVaListKind() const {
5412 return TargetInfo::VoidPtrBuiltinVaList;
5413 }
5414 virtual const char *getClobbers() const {
5415 return "";
5416 }
5417 virtual void getGCCRegNames(const char * const *&Names,
5418 unsigned &NumNames) const {
5419 static const char * const GCCRegNames[] = {
5420 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5421 "r8", "r9", "r10", "r11", "cp", "dp", "sp", "lr"
5422 };
5423 Names = GCCRegNames;
5424 NumNames = llvm::array_lengthof(GCCRegNames);
5425 }
5426 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
5427 unsigned &NumAliases) const {
5428 Aliases = NULL;
5429 NumAliases = 0;
5430 }
5431 virtual bool validateAsmConstraint(const char *&Name,
5432 TargetInfo::ConstraintInfo &Info) const {
5433 return false;
5434 }
5435};
5436
5437const Builtin::Info XCoreTargetInfo::BuiltinInfo[] = {
5438#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
5439#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
5440 ALL_LANGUAGES },
5441#include "clang/Basic/BuiltinsXCore.def"
5442};
5443} // end anonymous namespace.
5444
Ivan Krasinef05abd2011-08-24 20:22:22 +00005445
Reid Spencer5f016e22007-07-11 17:01:13 +00005446//===----------------------------------------------------------------------===//
5447// Driver code
5448//===----------------------------------------------------------------------===//
5449
Benjamin Kramer9df08232013-06-29 16:37:14 +00005450static TargetInfo *AllocateTarget(const llvm::Triple &Triple) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005451 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00005452
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005453 switch (Triple.getArch()) {
5454 default:
5455 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00005456
Robert Lytton5f15f4d2013-08-13 09:43:10 +00005457 case llvm::Triple::xcore:
5458 return new XCoreTargetInfo(Triple);
5459
Tony Linthicum96319392011-12-12 21:14:55 +00005460 case llvm::Triple::hexagon:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005461 return new HexagonTargetInfo(Triple);
Tony Linthicum96319392011-12-12 21:14:55 +00005462
Tim Northoverc264e162013-01-31 12:13:10 +00005463 case llvm::Triple::aarch64:
5464 switch (os) {
5465 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005466 return new LinuxTargetInfo<AArch64TargetInfo>(Triple);
Tim Northoverc264e162013-01-31 12:13:10 +00005467 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005468 return new AArch64TargetInfo(Triple);
Tim Northoverc264e162013-01-31 12:13:10 +00005469 }
5470
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005471 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00005472 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005473 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005474 return new DarwinARMTargetInfo(Triple);
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005475
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005476 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00005477 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005478 return new LinuxTargetInfo<ARMTargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005479 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005480 return new FreeBSDTargetInfo<ARMTargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005481 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005482 return new NetBSDTargetInfo<ARMTargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005483 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005484 return new OpenBSDTargetInfo<ARMTargetInfo>(Triple);
Eli Friedman42f74f22012-08-08 23:57:20 +00005485 case llvm::Triple::Bitrig:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005486 return new BitrigTargetInfo<ARMTargetInfo>(Triple);
Douglas Gregordca52262011-07-01 22:41:14 +00005487 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005488 return new RTEMSTargetInfo<ARMTargetInfo>(Triple);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005489 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005490 return new NaClTargetInfo<ARMTargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005491 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005492 return new ARMTargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005493 }
Eli Friedman61538a72008-05-20 14:21:01 +00005494
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005495 case llvm::Triple::msp430:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005496 return new MSP430TargetInfo(Triple);
Eli Friedman61538a72008-05-20 14:21:01 +00005497
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005498 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005499 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005500 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005501 return new LinuxTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005502 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005503 return new RTEMSTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005504 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005505 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005506 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005507 return new NetBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005508 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005509 return new Mips32EBTargetInfo(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005510 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005511
5512 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005513 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005514 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005515 return new LinuxTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005516 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005517 return new RTEMSTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005518 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005519 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005520 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005521 return new NetBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Petar Jovanovicbbac9aa2013-09-21 01:27:01 +00005522 case llvm::Triple::NaCl:
5523 return new NaClTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005524 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005525 return new Mips32ELTargetInfo(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005526 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005527
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005528 case llvm::Triple::mips64:
5529 switch (os) {
5530 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005531 return new LinuxTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005532 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005533 return new RTEMSTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005534 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005535 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005536 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005537 return new NetBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005538 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005539 return new OpenBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005540 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005541 return new Mips64EBTargetInfo(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005542 }
5543
5544 case llvm::Triple::mips64el:
5545 switch (os) {
5546 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005547 return new LinuxTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005548 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005549 return new RTEMSTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005550 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005551 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005552 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005553 return new NetBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005554 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005555 return new OpenBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005556 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005557 return new Mips64ELTargetInfo(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005558 }
5559
Ivan Krasinef05abd2011-08-24 20:22:22 +00005560 case llvm::Triple::le32:
5561 switch (os) {
Eli Bendersky441d9f72012-12-04 18:38:10 +00005562 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005563 return new NaClTargetInfo<PNaClTargetInfo>(Triple);
Ivan Krasinef05abd2011-08-24 20:22:22 +00005564 default:
5565 return NULL;
5566 }
5567
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005568 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005569 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005570 return new DarwinPPC32TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005571 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005572 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005573 return new LinuxTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005574 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005575 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005576 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005577 return new NetBSDTargetInfo<PPC32TargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005578 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005579 return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005580 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005581 return new RTEMSTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005582 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005583 return new PPC32TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005584 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005585
5586 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005587 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005588 return new DarwinPPC64TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005589 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005590 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005591 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005592 case llvm::Triple::Lv2:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005593 return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005594 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005595 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005596 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005597 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005598 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005599 return new PPC64TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005600 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005601
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00005602 case llvm::Triple::ppc64le:
5603 switch (os) {
5604 case llvm::Triple::Linux:
5605 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
5606 default:
5607 return new PPC64TargetInfo(Triple);
5608 }
5609
Peter Collingbourneedb66f32012-05-20 23:28:41 +00005610 case llvm::Triple::nvptx:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005611 return new NVPTX32TargetInfo(Triple);
Peter Collingbourneedb66f32012-05-20 23:28:41 +00005612 case llvm::Triple::nvptx64:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005613 return new NVPTX64TargetInfo(Triple);
Peter Collingbourneedb66f32012-05-20 23:28:41 +00005614
Eli Friedman6505a292012-10-12 23:32:00 +00005615 case llvm::Triple::r600:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005616 return new R600TargetInfo(Triple);
Eli Friedman6505a292012-10-12 23:32:00 +00005617
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005618 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005619 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005620 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005621 return new LinuxTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005622 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005623 return new AuroraUXSparcV8TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005624 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005625 return new SolarisSparcV8TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005626 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005627 return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005628 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005629 return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005630 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005631 return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005632 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005633 return new SparcV8TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005634 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005635
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005636 case llvm::Triple::sparcv9:
5637 switch (os) {
5638 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005639 return new LinuxTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005640 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005641 return new AuroraUXTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005642 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005643 return new SolarisTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005644 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005645 return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005646 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005647 return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005648 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005649 return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005650 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005651 return new SparcV9TargetInfo(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005652 }
5653
Ulrich Weigandb8409212013-05-06 16:26:41 +00005654 case llvm::Triple::systemz:
5655 switch (os) {
5656 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005657 return new LinuxTargetInfo<SystemZTargetInfo>(Triple);
Ulrich Weigandb8409212013-05-06 16:26:41 +00005658 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005659 return new SystemZTargetInfo(Triple);
Ulrich Weigandb8409212013-05-06 16:26:41 +00005660 }
5661
Eli Friedmanb63decf2009-08-19 20:47:07 +00005662 case llvm::Triple::tce:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005663 return new TCETargetInfo(Triple);
Eli Friedmanb63decf2009-08-19 20:47:07 +00005664
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005665 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005666 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005667 return new DarwinI386TargetInfo(Triple);
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005668
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005669 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00005670 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005671 return new AuroraUXTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005672 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005673 return new LinuxTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005674 case llvm::Triple::DragonFly:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005675 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005676 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005677 return new NetBSDI386TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005678 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005679 return new OpenBSDI386TargetInfo(Triple);
Eli Friedman42f74f22012-08-08 23:57:20 +00005680 case llvm::Triple::Bitrig:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005681 return new BitrigI386TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005682 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005683 return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple);
Sylvestre Ledru3309a782013-09-05 13:47:07 +00005684 case llvm::Triple::KFreeBSD:
5685 return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple);
Chris Lattner38e317d2010-07-07 16:01:42 +00005686 case llvm::Triple::Minix:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005687 return new MinixTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005688 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005689 return new SolarisTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005690 case llvm::Triple::Cygwin:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005691 return new CygwinX86_32TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005692 case llvm::Triple::MinGW32:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005693 return new MinGWX86_32TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005694 case llvm::Triple::Win32:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005695 return new VisualStudioWindowsX86_32TargetInfo(Triple);
Chris Lattner86ed3a32010-04-11 19:29:39 +00005696 case llvm::Triple::Haiku:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005697 return new HaikuX86_32TargetInfo(Triple);
Douglas Gregordca52262011-07-01 22:41:14 +00005698 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005699 return new RTEMSX86_32TargetInfo(Triple);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005700 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005701 return new NaClTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005702 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005703 return new X86_32TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005704 }
5705
5706 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005707 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
Benjamin Kramer9df08232013-06-29 16:37:14 +00005708 return new DarwinX86_64TargetInfo(Triple);
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005709
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005710 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00005711 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005712 return new AuroraUXTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005713 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005714 return new LinuxTargetInfo<X86_64TargetInfo>(Triple);
Chris Lattner7a7ca282010-01-09 05:41:14 +00005715 case llvm::Triple::DragonFly:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005716 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005717 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005718 return new NetBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005719 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005720 return new OpenBSDX86_64TargetInfo(Triple);
Eli Friedman42f74f22012-08-08 23:57:20 +00005721 case llvm::Triple::Bitrig:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005722 return new BitrigX86_64TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005723 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005724 return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple);
Sylvestre Ledru3309a782013-09-05 13:47:07 +00005725 case llvm::Triple::KFreeBSD:
5726 return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005727 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005728 return new SolarisTargetInfo<X86_64TargetInfo>(Triple);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00005729 case llvm::Triple::MinGW32:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005730 return new MinGWX86_64TargetInfo(Triple);
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00005731 case llvm::Triple::Win32: // This is what Triple.h supports now.
Benjamin Kramer9df08232013-06-29 16:37:14 +00005732 return new VisualStudioWindowsX86_64TargetInfo(Triple);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005733 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005734 return new NaClTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005735 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005736 return new X86_64TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005737 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005738
5739 case llvm::Triple::spir: {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005740 if (Triple.getOS() != llvm::Triple::UnknownOS ||
Benjamin Kramer9df08232013-06-29 16:37:14 +00005741 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005742 return NULL;
Benjamin Kramer9df08232013-06-29 16:37:14 +00005743 return new SPIR32TargetInfo(Triple);
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005744 }
5745 case llvm::Triple::spir64: {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005746 if (Triple.getOS() != llvm::Triple::UnknownOS ||
Benjamin Kramer9df08232013-06-29 16:37:14 +00005747 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005748 return NULL;
Benjamin Kramer9df08232013-06-29 16:37:14 +00005749 return new SPIR64TargetInfo(Triple);
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005750 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005751 }
Reid Spencer5f016e22007-07-11 17:01:13 +00005752}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005753
5754/// CreateTargetInfo - Return the target info object for the specified target
5755/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00005756TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Douglas Gregor49a87542012-11-16 04:24:59 +00005757 TargetOptions *Opts) {
5758 llvm::Triple Triple(Opts->Triple);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005759
5760 // Construct the target
Benjamin Kramer9df08232013-06-29 16:37:14 +00005761 OwningPtr<TargetInfo> Target(AllocateTarget(Triple));
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005762 if (!Target) {
5763 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
5764 return 0;
5765 }
Douglas Gregor9a022bb2012-10-15 16:45:32 +00005766 Target->setTargetOpts(Opts);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005767
Daniel Dunbareac7c532009-12-18 18:42:37 +00005768 // Set the target CPU if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00005769 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
5770 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
Daniel Dunbareac7c532009-12-18 18:42:37 +00005771 return 0;
5772 }
5773
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005774 // Set the target ABI if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00005775 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
5776 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005777 return 0;
5778 }
5779
Charles Davis98b7c5c2010-06-11 01:06:47 +00005780 // Set the target C++ ABI.
Douglas Gregor49a87542012-11-16 04:24:59 +00005781 if (!Opts->CXXABI.empty() && !Target->setCXXABI(Opts->CXXABI)) {
5782 Diags.Report(diag::err_target_unknown_cxxabi) << Opts->CXXABI;
Charles Davis98b7c5c2010-06-11 01:06:47 +00005783 return 0;
5784 }
5785
Rafael Espindola5389b842013-08-21 21:59:03 +00005786 // Set the fp math unit.
5787 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
5788 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
5789 return 0;
5790 }
5791
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005792 // Compute the default target features, we need the target to handle this
5793 // because features may have dependencies on one another.
5794 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00005795 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005796
Rafael Espindolac84ed542013-08-20 18:57:55 +00005797 // Apply the user specified deltas.
5798 for (unsigned I = 0, N = Opts->FeaturesAsWritten.size();
5799 I < N; ++I) {
5800 const char *Name = Opts->FeaturesAsWritten[I].c_str();
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005801 // Apply the feature via the target.
Rafael Espindolac84ed542013-08-20 18:57:55 +00005802 bool Enabled = Name[0] == '+';
5803 Target->setFeatureEnabled(Features, Name + 1, Enabled);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005804 }
5805
5806 // Add the features to the compile options.
5807 //
5808 // FIXME: If we are completely confident that we have the right set, we only
5809 // need to pass the minuses.
Douglas Gregor49a87542012-11-16 04:24:59 +00005810 Opts->Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005811 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
5812 ie = Features.end(); it != ie; ++it)
Douglas Gregor49a87542012-11-16 04:24:59 +00005813 Opts->Features.push_back((it->second ? "+" : "-") + it->first().str());
Eric Christopher3d11ced2013-10-16 21:26:26 +00005814 if (!Target->handleTargetFeatures(Opts->Features, Diags))
Rafael Espindola5389b842013-08-21 21:59:03 +00005815 return 0;
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005816
5817 return Target.take();
5818}