blob: 596eb8cb1685abe4dc0ac48748b0e4e52020c2cf [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) {
Benjamin Kramera9992772010-01-09 17:55:51 +000091 Builder.defineMacro("__APPLE_CC__", "5621");
92 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.
Bob Wilson48b68a02012-01-31 23:52:58 +0000142 if (Triple.getOS() == llvm::Triple::IOS) {
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);
152 } else {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000153 // Note that the Driver allows versions which aren't representable in the
154 // define (because we only get a single digit for the minor and micro
155 // revision numbers). So, we limit them to the maximum representable
156 // version.
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000157 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000158 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000159 char Str[5];
160 Str[0] = '0' + (Maj / 10);
161 Str[1] = '0' + (Maj % 10);
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000162 Str[2] = '0' + std::min(Min, 9U);
163 Str[3] = '0' + std::min(Rev, 9U);
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000164 Str[4] = '\0';
165 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000166 }
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000167
168 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman618234a2008-08-20 02:34:37 +0000169}
Reid Spencer5f016e22007-07-11 17:01:13 +0000170
Chris Lattner797c3c42009-08-10 19:03:04 +0000171namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000172template<typename Target>
173class DarwinTargetInfo : public OSTargetInfo<Target> {
174protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000175 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000176 MacroBuilder &Builder) const {
Eric Christopher7c9adf92011-07-07 22:55:26 +0000177 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000178 this->PlatformMinVersion);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000179 }
Mike Stump1eb44332009-09-09 15:08:12 +0000180
Torok Edwin5f6c1942009-06-30 17:10:35 +0000181public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000182 DarwinTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
183 this->TLSSupported = Triple.isMacOSX() && !Triple.isMacOSXVersionLT(10, 7);
184 this->MCountName = "\01mcount";
185 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000186
Chris Lattner5f9e2722011-07-23 10:55:15 +0000187 virtual std::string isValidSectionSpecifier(StringRef SR) const {
Chris Lattner797c3c42009-08-10 19:03:04 +0000188 // Let MCSectionMachO validate this.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000189 StringRef Segment, Section;
Chris Lattner797c3c42009-08-10 19:03:04 +0000190 unsigned TAA, StubSize;
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000191 bool HasTAA;
Chris Lattner797c3c42009-08-10 19:03:04 +0000192 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000193 TAA, HasTAA, StubSize);
Chris Lattner797c3c42009-08-10 19:03:04 +0000194 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000195
Anders Carlsson18af3682010-06-08 22:47:50 +0000196 virtual const char *getStaticInitSectionSpecifier() const {
197 // FIXME: We should return 0 when building kexts.
198 return "__TEXT,__StaticInit,regular,pure_instructions";
199 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000200
John McCall41887602012-01-29 01:20:30 +0000201 /// Darwin does not support protected visibility. Darwin's "default"
202 /// is very similar to ELF's "protected"; Darwin requires a "weak"
203 /// attribute on declarations that can be dynamically replaced.
204 virtual bool hasProtectedVisibility() const {
205 return false;
206 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000207};
208
Chris Lattner797c3c42009-08-10 19:03:04 +0000209
Torok Edwin5f6c1942009-06-30 17:10:35 +0000210// DragonFlyBSD Target
211template<typename Target>
212class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
213protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000214 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000215 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000216 // DragonFly defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000217 Builder.defineMacro("__DragonFly__");
218 Builder.defineMacro("__DragonFly_cc_version", "100001");
219 Builder.defineMacro("__ELF__");
220 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
221 Builder.defineMacro("__tune_i386__");
222 DefineStd(Builder, "unix", Opts);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000223 }
224public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000225 DragonFlyBSDTargetInfo(const llvm::Triple &Triple)
226 : OSTargetInfo<Target>(Triple) {
227 this->UserLabelPrefix = "";
Eli Friedmanb089c4d2012-02-10 23:02:29 +0000228
Benjamin Kramer9df08232013-06-29 16:37:14 +0000229 switch (Triple.getArch()) {
230 default:
231 case llvm::Triple::x86:
232 case llvm::Triple::x86_64:
233 this->MCountName = ".mcount";
234 break;
235 }
Eli Friedmanb089c4d2012-02-10 23:02:29 +0000236 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000237};
238
239// FreeBSD Target
240template<typename Target>
241class FreeBSDTargetInfo : public OSTargetInfo<Target> {
242protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000243 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000244 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000245 // FreeBSD defines; list based off of gcc output
246
Benjamin Kramer474202f2011-10-18 10:10:08 +0000247 unsigned Release = Triple.getOSMajorVersion();
248 if (Release == 0U)
249 Release = 8;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000250
Benjamin Kramer474202f2011-10-18 10:10:08 +0000251 Builder.defineMacro("__FreeBSD__", Twine(Release));
252 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramera9992772010-01-09 17:55:51 +0000253 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
254 DefineStd(Builder, "unix", Opts);
255 Builder.defineMacro("__ELF__");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000256 }
257public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000258 FreeBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
259 this->UserLabelPrefix = "";
Roman Divackybe4c8702011-02-10 16:52:03 +0000260
Benjamin Kramer9df08232013-06-29 16:37:14 +0000261 switch (Triple.getArch()) {
262 default:
263 case llvm::Triple::x86:
264 case llvm::Triple::x86_64:
265 this->MCountName = ".mcount";
266 break;
267 case llvm::Triple::mips:
268 case llvm::Triple::mipsel:
269 case llvm::Triple::ppc:
270 case llvm::Triple::ppc64:
Bill Schmidtea7fb0c2013-07-26 01:36:11 +0000271 case llvm::Triple::ppc64le:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000272 this->MCountName = "_mcount";
273 break;
274 case llvm::Triple::arm:
275 this->MCountName = "__mcount";
276 break;
Duncan Sands1e90faf2009-07-08 13:55:08 +0000277 }
Benjamin Kramer9df08232013-06-29 16:37:14 +0000278 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000279};
280
Chris Lattner38e317d2010-07-07 16:01:42 +0000281// Minix Target
282template<typename Target>
283class MinixTargetInfo : public OSTargetInfo<Target> {
284protected:
285 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
286 MacroBuilder &Builder) const {
287 // Minix defines
288
289 Builder.defineMacro("__minix", "3");
290 Builder.defineMacro("_EM_WSIZE", "4");
291 Builder.defineMacro("_EM_PSIZE", "4");
292 Builder.defineMacro("_EM_SSIZE", "2");
293 Builder.defineMacro("_EM_LSIZE", "4");
294 Builder.defineMacro("_EM_FSIZE", "4");
295 Builder.defineMacro("_EM_DSIZE", "8");
Eli Friedman6d402dc2011-12-08 23:54:21 +0000296 Builder.defineMacro("__ELF__");
Chris Lattner38e317d2010-07-07 16:01:42 +0000297 DefineStd(Builder, "unix", Opts);
298 }
299public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000300 MinixTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
301 this->UserLabelPrefix = "";
302 }
Chris Lattner38e317d2010-07-07 16:01:42 +0000303};
304
Torok Edwin5f6c1942009-06-30 17:10:35 +0000305// Linux target
306template<typename Target>
307class LinuxTargetInfo : public OSTargetInfo<Target> {
308protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000309 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000310 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000311 // Linux defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000312 DefineStd(Builder, "unix", Opts);
313 DefineStd(Builder, "linux", Opts);
314 Builder.defineMacro("__gnu_linux__");
315 Builder.defineMacro("__ELF__");
Logan Chien94a71422012-09-02 09:30:11 +0000316 if (Triple.getEnvironment() == llvm::Triple::Android)
Evgeniy Stepanov32064032012-04-26 12:08:09 +0000317 Builder.defineMacro("__ANDROID__", "1");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000318 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000319 Builder.defineMacro("_REENTRANT");
Douglas Gregor2b003fd2010-04-21 05:52:38 +0000320 if (Opts.CPlusPlus)
321 Builder.defineMacro("_GNU_SOURCE");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000322 }
323public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000324 LinuxTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000325 this->UserLabelPrefix = "";
Douglas Gregor12e84642011-01-12 21:19:25 +0000326 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000327 }
Benjamin Kramer86d18c52011-10-15 17:53:33 +0000328
329 virtual const char *getStaticInitSectionSpecifier() const {
330 return ".text.startup";
331 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000332};
333
Chris Lattnerb62bb282009-07-13 20:29:08 +0000334// NetBSD Target
335template<typename Target>
336class NetBSDTargetInfo : public OSTargetInfo<Target> {
337protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000338 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000339 MacroBuilder &Builder) const {
Chris Lattnerb62bb282009-07-13 20:29:08 +0000340 // NetBSD defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000341 Builder.defineMacro("__NetBSD__");
342 Builder.defineMacro("__unix__");
343 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000344 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000345 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerb62bb282009-07-13 20:29:08 +0000346 }
347public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000348 NetBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
349 this->UserLabelPrefix = "";
350 }
Chris Lattnerb62bb282009-07-13 20:29:08 +0000351};
352
Torok Edwin5f6c1942009-06-30 17:10:35 +0000353// OpenBSD Target
354template<typename Target>
355class OpenBSDTargetInfo : public OSTargetInfo<Target> {
356protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000357 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000358 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000359 // OpenBSD defines; list based off of gcc output
360
Benjamin Kramera9992772010-01-09 17:55:51 +0000361 Builder.defineMacro("__OpenBSD__");
362 DefineStd(Builder, "unix", Opts);
363 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000364 if (Opts.POSIXThreads)
Chris Lattner4ddcf3b2012-04-25 06:12:24 +0000365 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000366 }
367public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000368 OpenBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
369 this->UserLabelPrefix = "";
370 this->TLSSupported = false;
Eli Friedman62d829a2011-12-15 02:15:56 +0000371
Eli Friedman62d829a2011-12-15 02:15:56 +0000372 switch (Triple.getArch()) {
373 default:
374 case llvm::Triple::x86:
375 case llvm::Triple::x86_64:
376 case llvm::Triple::arm:
Eric Christopher825d3862012-11-14 22:08:59 +0000377 case llvm::Triple::sparc:
Eli Friedman62d829a2011-12-15 02:15:56 +0000378 this->MCountName = "__mcount";
379 break;
380 case llvm::Triple::mips64:
381 case llvm::Triple::mips64el:
382 case llvm::Triple::ppc:
Eric Christopher825d3862012-11-14 22:08:59 +0000383 case llvm::Triple::sparcv9:
Eli Friedman62d829a2011-12-15 02:15:56 +0000384 this->MCountName = "_mcount";
385 break;
386 }
387 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000388};
389
Eli Friedman42f74f22012-08-08 23:57:20 +0000390// Bitrig Target
391template<typename Target>
392class BitrigTargetInfo : public OSTargetInfo<Target> {
393protected:
394 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
395 MacroBuilder &Builder) const {
396 // Bitrig defines; list based off of gcc output
397
398 Builder.defineMacro("__Bitrig__");
399 DefineStd(Builder, "unix", Opts);
400 Builder.defineMacro("__ELF__");
401 if (Opts.POSIXThreads)
402 Builder.defineMacro("_REENTRANT");
403 }
404public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000405 BitrigTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
406 this->UserLabelPrefix = "";
407 this->TLSSupported = false;
408 this->MCountName = "__mcount";
Eli Friedman42f74f22012-08-08 23:57:20 +0000409 }
410};
411
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000412// PSP Target
413template<typename Target>
414class PSPTargetInfo : public OSTargetInfo<Target> {
415protected:
416 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000417 MacroBuilder &Builder) const {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000418 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramera9992772010-01-09 17:55:51 +0000419 Builder.defineMacro("PSP");
420 Builder.defineMacro("_PSP");
421 Builder.defineMacro("__psp__");
422 Builder.defineMacro("__ELF__");
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000423 }
424public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000425 PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000426 this->UserLabelPrefix = "";
427 }
428};
429
John Thompson3f6918a2009-11-19 17:18:50 +0000430// PS3 PPU Target
431template<typename Target>
432class PS3PPUTargetInfo : public OSTargetInfo<Target> {
433protected:
434 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000435 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000436 // PS3 PPU defines.
John Thompsonfb457972010-03-25 16:18:32 +0000437 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000438 Builder.defineMacro("__PPU__");
439 Builder.defineMacro("__CELLOS_LV2__");
440 Builder.defineMacro("__ELF__");
441 Builder.defineMacro("__LP32__");
John Thompson8e6065a2010-06-24 22:44:13 +0000442 Builder.defineMacro("_ARCH_PPC64");
443 Builder.defineMacro("__powerpc64__");
John Thompson3f6918a2009-11-19 17:18:50 +0000444 }
445public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000446 PS3PPUTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
John Thompson3f6918a2009-11-19 17:18:50 +0000447 this->UserLabelPrefix = "";
Nick Lewycky99520702011-12-16 22:32:39 +0000448 this->LongWidth = this->LongAlign = 32;
449 this->PointerWidth = this->PointerAlign = 32;
John Thompson8e6065a2010-06-24 22:44:13 +0000450 this->IntMaxType = TargetInfo::SignedLongLong;
451 this->UIntMaxType = TargetInfo::UnsignedLongLong;
452 this->Int64Type = TargetInfo::SignedLongLong;
John Thompsonec387af2009-12-18 14:21:08 +0000453 this->SizeType = TargetInfo::UnsignedInt;
John Thompson8e6065a2010-06-24 22:44:13 +0000454 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 +0000455 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompson3f6918a2009-11-19 17:18:50 +0000456 }
457};
458
459// FIXME: Need a real SPU target.
460// PS3 SPU Target
461template<typename Target>
462class PS3SPUTargetInfo : 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.
Benjamin Kramera9992772010-01-09 17:55:51 +0000467 Builder.defineMacro("__SPU__");
468 Builder.defineMacro("__ELF__");
John Thompson3f6918a2009-11-19 17:18:50 +0000469 }
470public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000471 PS3SPUTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
John Thompson3f6918a2009-11-19 17:18:50 +0000472 this->UserLabelPrefix = "";
473 }
474};
475
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000476// AuroraUX target
477template<typename Target>
478class AuroraUXTargetInfo : public OSTargetInfo<Target> {
479protected:
480 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000481 MacroBuilder &Builder) const {
482 DefineStd(Builder, "sun", Opts);
483 DefineStd(Builder, "unix", Opts);
484 Builder.defineMacro("__ELF__");
485 Builder.defineMacro("__svr4__");
486 Builder.defineMacro("__SVR4");
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000487 }
488public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000489 AuroraUXTargetInfo(const llvm::Triple &Triple)
490 : OSTargetInfo<Target>(Triple) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000491 this->UserLabelPrefix = "";
492 this->WCharType = this->SignedLong;
493 // FIXME: WIntType should be SignedLong
494 }
495};
496
Torok Edwin5f6c1942009-06-30 17:10:35 +0000497// Solaris target
498template<typename Target>
499class SolarisTargetInfo : public OSTargetInfo<Target> {
500protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000501 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000502 MacroBuilder &Builder) const {
503 DefineStd(Builder, "sun", Opts);
504 DefineStd(Builder, "unix", Opts);
505 Builder.defineMacro("__ELF__");
506 Builder.defineMacro("__svr4__");
507 Builder.defineMacro("__SVR4");
David Chisnall165329c2012-02-28 17:10:04 +0000508 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
509 // newer, but to 500 for everything else. feature_test.h has a check to
510 // ensure that you are not using C99 with an old version of X/Open or C89
511 // with a new version.
512 if (Opts.C99 || Opts.C11)
513 Builder.defineMacro("_XOPEN_SOURCE", "600");
514 else
515 Builder.defineMacro("_XOPEN_SOURCE", "500");
David Chisnallb4f0bd62012-03-02 10:49:52 +0000516 if (Opts.CPlusPlus)
David Chisnall165329c2012-02-28 17:10:04 +0000517 Builder.defineMacro("__C99FEATURES__");
David Chisnall48fad492012-02-17 18:35:11 +0000518 Builder.defineMacro("_LARGEFILE_SOURCE");
519 Builder.defineMacro("_LARGEFILE64_SOURCE");
520 Builder.defineMacro("__EXTENSIONS__");
David Chisnall165329c2012-02-28 17:10:04 +0000521 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000522 }
523public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000524 SolarisTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000525 this->UserLabelPrefix = "";
David Chisnallfb027842012-03-28 18:04:14 +0000526 this->WCharType = this->SignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000527 // FIXME: WIntType should be SignedLong
528 }
529};
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000530
531// Windows target
532template<typename Target>
533class WindowsTargetInfo : public OSTargetInfo<Target> {
534protected:
535 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
536 MacroBuilder &Builder) const {
Michael J. Spencera764e832010-10-21 08:22:51 +0000537 Builder.defineMacro("_WIN32");
538 }
539 void getVisualStudioDefines(const LangOptions &Opts,
540 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000541 if (Opts.CPlusPlus) {
542 if (Opts.RTTI)
543 Builder.defineMacro("_CPPRTTI");
544
545 if (Opts.Exceptions)
546 Builder.defineMacro("_CPPUNWIND");
547 }
548
549 if (!Opts.CharIsSigned)
550 Builder.defineMacro("_CHAR_UNSIGNED");
551
552 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
553 // but it works for now.
554 if (Opts.POSIXThreads)
555 Builder.defineMacro("_MT");
Michael J. Spencera764e832010-10-21 08:22:51 +0000556
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000557 if (Opts.MSCVersion != 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000558 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000559
Francois Pichet62ec1f22011-09-17 17:15:52 +0000560 if (Opts.MicrosoftExt) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000561 Builder.defineMacro("_MSC_EXTENSIONS");
562
Richard Smith80ad52f2013-01-02 11:42:31 +0000563 if (Opts.CPlusPlus11) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000564 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
565 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
566 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
567 }
568 }
569
570 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000571 }
572
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000573public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000574 WindowsTargetInfo(const llvm::Triple &Triple)
575 : OSTargetInfo<Target>(Triple) {}
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000576};
577
Derek Schuff7da46f92012-10-11 16:55:58 +0000578template <typename Target>
579class NaClTargetInfo : public OSTargetInfo<Target> {
Benjamin Kramer9df08232013-06-29 16:37:14 +0000580protected:
Derek Schuff7da46f92012-10-11 16:55:58 +0000581 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
582 MacroBuilder &Builder) const {
583 if (Opts.POSIXThreads)
584 Builder.defineMacro("_REENTRANT");
585 if (Opts.CPlusPlus)
586 Builder.defineMacro("_GNU_SOURCE");
587
588 DefineStd(Builder, "unix", Opts);
589 Builder.defineMacro("__ELF__");
590 Builder.defineMacro("__native_client__");
591 }
Benjamin Kramer9df08232013-06-29 16:37:14 +0000592
593public:
594 NaClTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Derek Schuff7da46f92012-10-11 16:55:58 +0000595 this->UserLabelPrefix = "";
596 this->LongAlign = 32;
597 this->LongWidth = 32;
598 this->PointerAlign = 32;
599 this->PointerWidth = 32;
600 this->IntMaxType = TargetInfo::SignedLongLong;
601 this->UIntMaxType = TargetInfo::UnsignedLongLong;
602 this->Int64Type = TargetInfo::SignedLongLong;
603 this->DoubleAlign = 64;
604 this->LongDoubleWidth = 64;
605 this->LongDoubleAlign = 64;
606 this->SizeType = TargetInfo::UnsignedInt;
607 this->PtrDiffType = TargetInfo::SignedInt;
608 this->IntPtrType = TargetInfo::SignedInt;
Eli Benderskyc0783dc2013-04-08 21:31:01 +0000609 // RegParmMax is inherited from the underlying architecture
Derek Schuff7da46f92012-10-11 16:55:58 +0000610 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble;
611 this->DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
612 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
613 }
Derek Schuff263366f2012-10-16 22:30:41 +0000614 virtual typename Target::CallingConvCheckResult checkCallingConvention(
615 CallingConv CC) const {
616 return CC == CC_PnaclCall ? Target::CCCR_OK :
617 Target::checkCallingConvention(CC);
618 }
Derek Schuff7da46f92012-10-11 16:55:58 +0000619};
Mike Stump1eb44332009-09-09 15:08:12 +0000620} // end anonymous namespace.
Torok Edwin5f6c1942009-06-30 17:10:35 +0000621
Chris Lattnerd29b6302008-10-05 21:50:58 +0000622//===----------------------------------------------------------------------===//
Eli Friedmane4277982008-08-20 23:11:40 +0000623// Specific target implementations.
624//===----------------------------------------------------------------------===//
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +0000625
Eli Friedmane4277982008-08-20 23:11:40 +0000626namespace {
627// PPC abstract base class
628class PPCTargetInfo : public TargetInfo {
629 static const Builtin::Info BuiltinInfo[];
630 static const char * const GCCRegNames[];
631 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Hal Finkel02a84272012-06-11 22:35:19 +0000632 std::string CPU;
Eli Friedmane4277982008-08-20 23:11:40 +0000633public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000634 PPCTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Bill Schmidtea7fb0c2013-07-26 01:36:11 +0000635 BigEndian = (Triple.getArch() != llvm::Triple::ppc64le);
Nico Weber6e1d2ea2012-01-31 02:07:33 +0000636 LongDoubleWidth = LongDoubleAlign = 128;
637 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
638 }
Eli Friedman15b91762009-06-05 07:05:05 +0000639
Hal Finkel39d5fa12012-07-03 16:51:04 +0000640 /// \brief Flags for architecture specific defines.
641 typedef enum {
642 ArchDefineNone = 0,
643 ArchDefineName = 1 << 0, // <name> is substituted for arch name.
644 ArchDefinePpcgr = 1 << 1,
645 ArchDefinePpcsq = 1 << 2,
646 ArchDefine440 = 1 << 3,
647 ArchDefine603 = 1 << 4,
648 ArchDefine604 = 1 << 5,
649 ArchDefinePwr4 = 1 << 6,
Bill Schmidt2821e182013-02-01 20:23:10 +0000650 ArchDefinePwr5 = 1 << 7,
651 ArchDefinePwr5x = 1 << 8,
652 ArchDefinePwr6 = 1 << 9,
653 ArchDefinePwr6x = 1 << 10,
654 ArchDefinePwr7 = 1 << 11,
655 ArchDefineA2 = 1 << 12,
656 ArchDefineA2q = 1 << 13
Hal Finkel39d5fa12012-07-03 16:51:04 +0000657 } ArchDefineTypes;
658
Bill Schmidt2821e182013-02-01 20:23:10 +0000659 // Note: GCC recognizes the following additional cpus:
660 // 401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801,
661 // 821, 823, 8540, 8548, e300c2, e300c3, e500mc64, e6500, 860, cell,
662 // titan, rs64.
Hal Finkel02a84272012-06-11 22:35:19 +0000663 virtual bool setCPU(const std::string &Name) {
664 bool CPUKnown = llvm::StringSwitch<bool>(Name)
665 .Case("generic", true)
666 .Case("440", true)
667 .Case("450", true)
668 .Case("601", true)
669 .Case("602", true)
670 .Case("603", true)
671 .Case("603e", true)
672 .Case("603ev", true)
673 .Case("604", true)
674 .Case("604e", true)
675 .Case("620", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000676 .Case("630", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000677 .Case("g3", true)
678 .Case("7400", true)
679 .Case("g4", true)
680 .Case("7450", true)
681 .Case("g4+", true)
682 .Case("750", true)
683 .Case("970", true)
684 .Case("g5", true)
685 .Case("a2", true)
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000686 .Case("a2q", true)
Hal Finkel7de32962012-09-18 22:25:03 +0000687 .Case("e500mc", true)
688 .Case("e5500", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000689 .Case("power3", true)
690 .Case("pwr3", true)
691 .Case("power4", true)
692 .Case("pwr4", true)
693 .Case("power5", true)
694 .Case("pwr5", true)
695 .Case("power5x", true)
696 .Case("pwr5x", true)
697 .Case("power6", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000698 .Case("pwr6", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000699 .Case("power6x", true)
700 .Case("pwr6x", true)
701 .Case("power7", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000702 .Case("pwr7", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000703 .Case("powerpc", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000704 .Case("ppc", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000705 .Case("powerpc64", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000706 .Case("ppc64", true)
Bill Schmidtea7fb0c2013-07-26 01:36:11 +0000707 .Case("powerpc64le", true)
708 .Case("ppc64le", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000709 .Default(false);
710
711 if (CPUKnown)
712 CPU = Name;
713
714 return CPUKnown;
715 }
716
Eli Friedmane4277982008-08-20 23:11:40 +0000717 virtual void getTargetBuiltins(const Builtin::Info *&Records,
718 unsigned &NumRecords) const {
Reid Spencer5f016e22007-07-11 17:01:13 +0000719 Records = BuiltinInfo;
Eli Friedmane4277982008-08-20 23:11:40 +0000720 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +0000721 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000722
Bob Wilson9f1c49c2012-01-28 18:02:29 +0000723 virtual bool isCLZForZeroUndef() const { return false; }
724
Chris Lattner33328642009-03-20 15:52:06 +0000725 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000726 MacroBuilder &Builder) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000727
Bill Schmidt199402b2013-02-01 02:14:03 +0000728 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
729
730 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
731 StringRef Name,
732 bool Enabled) const;
733
Douglas Gregore727d212012-01-30 06:38:25 +0000734 virtual bool hasFeature(StringRef Feature) const;
735
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000736 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000737 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000738 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000739 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000740 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +0000741 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000742 switch (*Name) {
Anders Carlssond04c6e22007-11-27 04:11:28 +0000743 default: return false;
744 case 'O': // Zero
John Thompson8e6065a2010-06-24 22:44:13 +0000745 break;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000746 case 'b': // Base register
747 case 'f': // Floating point register
Chris Lattner44def072009-04-26 07:16:29 +0000748 Info.setAllowsRegister();
John Thompson8e6065a2010-06-24 22:44:13 +0000749 break;
750 // FIXME: The following are added to allow parsing.
751 // I just took a guess at what the actions should be.
752 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer20249a12010-10-21 03:16:25 +0000753 case 'd': // Floating point register (containing 64-bit value)
John Thompson8e6065a2010-06-24 22:44:13 +0000754 case 'v': // Altivec vector register
755 Info.setAllowsRegister();
756 break;
757 case 'w':
758 switch (Name[1]) {
Michael J. Spencer20249a12010-10-21 03:16:25 +0000759 case 'd':// VSX vector register to hold vector double data
760 case 'f':// VSX vector register to hold vector float data
761 case 's':// VSX vector register to hold scalar float data
762 case 'a':// Any VSX register
John Thompson8e6065a2010-06-24 22:44:13 +0000763 break;
764 default:
765 return false;
766 }
767 Info.setAllowsRegister();
768 Name++; // Skip over 'w'.
769 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000770 case 'h': // `MQ', `CTR', or `LINK' register
771 case 'q': // `MQ' register
772 case 'c': // `CTR' register
773 case 'l': // `LINK' register
774 case 'x': // `CR' register (condition register) number 0
775 case 'y': // `CR' register (condition register)
776 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson8e6065a2010-06-24 22:44:13 +0000777 Info.setAllowsRegister();
778 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000779 case 'I': // Signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000780 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer20249a12010-10-21 03:16:25 +0000781 // (use `L' instead for SImode constants)
782 case 'K': // Unsigned 16-bit constant
783 case 'L': // Signed 16-bit constant shifted left 16 bits
784 case 'M': // Constant larger than 31
785 case 'N': // Exact power of 2
786 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000787 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000788 // register with one instruction per word
John Thompson8e6065a2010-06-24 22:44:13 +0000789 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer20249a12010-10-21 03:16:25 +0000790 // into a register using three instructions
John Thompson8e6065a2010-06-24 22:44:13 +0000791 break;
792 case 'm': // Memory operand. Note that on PowerPC targets, m can
793 // include addresses that update the base register. It
794 // is therefore only safe to use `m' in an asm statement
795 // if that asm statement accesses the operand exactly once.
796 // The asm statement must also use `%U<opno>' as a
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000797 // placeholder for the "update" flag in the corresponding
Michael J. Spencer20249a12010-10-21 03:16:25 +0000798 // load or store instruction. For example:
John Thompson8e6065a2010-06-24 22:44:13 +0000799 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000800 // is correct but:
John Thompson8e6065a2010-06-24 22:44:13 +0000801 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
802 // is not. Use es rather than m if you don't want the base
Michael J. Spencer20249a12010-10-21 03:16:25 +0000803 // register to be updated.
804 case 'e':
John Thompson56b6eca2010-06-25 00:02:05 +0000805 if (Name[1] != 's')
806 return false;
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000807 // es: A "stable" memory operand; that is, one which does not
John Thompson8e6065a2010-06-24 22:44:13 +0000808 // include any automodification of the base register. Unlike
809 // `m', this constraint can be used in asm statements that
810 // might access the operand several times, or that might not
John Thompson56b6eca2010-06-25 00:02:05 +0000811 // access it at all.
John Thompson8e6065a2010-06-24 22:44:13 +0000812 Info.setAllowsMemory();
John Thompson56b6eca2010-06-25 00:02:05 +0000813 Name++; // Skip over 'e'.
John Thompson8e6065a2010-06-24 22:44:13 +0000814 break;
815 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer20249a12010-10-21 03:16:25 +0000816 // usually better to use `m' or `es' in asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000817 case 'Z': // Memory operand that is an indexed or indirect from a
818 // register (it is usually better to use `m' or `es' in
Michael J. Spencer20249a12010-10-21 03:16:25 +0000819 // asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000820 Info.setAllowsMemory();
821 Info.setAllowsRegister();
822 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000823 case 'R': // AIX TOC entry
John Thompson8e6065a2010-06-24 22:44:13 +0000824 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000825 // register (`p' is preferable for asm statements)
826 case 'S': // Constant suitable as a 64-bit mask operand
827 case 'T': // Constant suitable as a 32-bit mask operand
828 case 'U': // System V Release 4 small data area reference
John Thompson8e6065a2010-06-24 22:44:13 +0000829 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000830 // instructions
831 case 'W': // Vector constant that does not require memory
832 case 'j': // Vector constant that is all zeros.
John Thompson8e6065a2010-06-24 22:44:13 +0000833 break;
834 // End FIXME.
Anders Carlssond04c6e22007-11-27 04:11:28 +0000835 }
John Thompson8e6065a2010-06-24 22:44:13 +0000836 return true;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000837 }
Eli Friedmane4277982008-08-20 23:11:40 +0000838 virtual const char *getClobbers() const {
839 return "";
Anders Carlssond04c6e22007-11-27 04:11:28 +0000840 }
Adhemerval Zanellab0fc94c2013-01-22 20:02:45 +0000841 int getEHDataRegisterNumber(unsigned RegNo) const {
842 if (RegNo == 0) return 3;
843 if (RegNo == 1) return 4;
844 return -1;
845 }
Eli Friedmane4277982008-08-20 23:11:40 +0000846};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000847
Eli Friedmane4277982008-08-20 23:11:40 +0000848const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000849#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000850#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000851 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000852#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000853};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000854
855
Chris Lattnerc0f59212009-03-02 22:27:17 +0000856/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
857/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000858void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000859 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000860 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000861 Builder.defineMacro("__ppc__");
Chandler Carruthc6fa1152013-06-25 11:13:47 +0000862 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000863 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000864 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000865 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000866 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000867 Builder.defineMacro("_ARCH_PPC64");
Chris Lattnere03ae302010-02-16 18:14:57 +0000868 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000869 Builder.defineMacro("__ppc64__");
Chandler Carruthc6fa1152013-06-25 11:13:47 +0000870 Builder.defineMacro("__PPC64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000871 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000872
Chris Lattnerc0f59212009-03-02 22:27:17 +0000873 // Target properties.
Bill Schmidtea7fb0c2013-07-26 01:36:11 +0000874 if (getTriple().getArch() == llvm::Triple::ppc64le) {
875 Builder.defineMacro("_LITTLE_ENDIAN");
876 Builder.defineMacro("__LITTLE_ENDIAN__");
877 } else {
878 if (getTriple().getOS() != llvm::Triple::NetBSD &&
879 getTriple().getOS() != llvm::Triple::OpenBSD)
880 Builder.defineMacro("_BIG_ENDIAN");
881 Builder.defineMacro("__BIG_ENDIAN__");
882 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000883
Chris Lattnerc0f59212009-03-02 22:27:17 +0000884 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000885 Builder.defineMacro("__NATURAL_ALIGNMENT__");
886 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000887
Chris Lattnerc0f59212009-03-02 22:27:17 +0000888 // FIXME: Should be controlled by command line option.
Roman Divackyb2f6f472013-07-03 19:45:54 +0000889 if (LongDoubleWidth == 128)
890 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000891
John Thompson3f6918a2009-11-19 17:18:50 +0000892 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000893 Builder.defineMacro("__VEC__", "10206");
894 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000895 }
Hal Finkel02a84272012-06-11 22:35:19 +0000896
897 // CPU identification.
Hal Finkel39d5fa12012-07-03 16:51:04 +0000898 ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
899 .Case("440", ArchDefineName)
900 .Case("450", ArchDefineName | ArchDefine440)
901 .Case("601", ArchDefineName)
902 .Case("602", ArchDefineName | ArchDefinePpcgr)
903 .Case("603", ArchDefineName | ArchDefinePpcgr)
904 .Case("603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
905 .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
906 .Case("604", ArchDefineName | ArchDefinePpcgr)
907 .Case("604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
908 .Case("620", ArchDefineName | ArchDefinePpcgr)
Bill Schmidt2821e182013-02-01 20:23:10 +0000909 .Case("630", ArchDefineName | ArchDefinePpcgr)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000910 .Case("7400", ArchDefineName | ArchDefinePpcgr)
911 .Case("7450", ArchDefineName | ArchDefinePpcgr)
912 .Case("750", ArchDefineName | ArchDefinePpcgr)
913 .Case("970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
914 | ArchDefinePpcsq)
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000915 .Case("a2", ArchDefineA2)
916 .Case("a2q", ArchDefineName | ArchDefineA2 | ArchDefineA2q)
Bill Schmidt2821e182013-02-01 20:23:10 +0000917 .Case("pwr3", ArchDefinePpcgr)
918 .Case("pwr4", ArchDefineName | ArchDefinePpcgr | ArchDefinePpcsq)
919 .Case("pwr5", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
920 | ArchDefinePpcsq)
921 .Case("pwr5x", ArchDefineName | ArchDefinePwr5 | ArchDefinePwr4
922 | ArchDefinePpcgr | ArchDefinePpcsq)
923 .Case("pwr6", ArchDefineName | ArchDefinePwr5x | ArchDefinePwr5
924 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
925 .Case("pwr6x", ArchDefineName | ArchDefinePwr6 | ArchDefinePwr5x
926 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
927 | ArchDefinePpcsq)
928 .Case("pwr7", ArchDefineName | ArchDefinePwr6x | ArchDefinePwr6
929 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
930 | ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq)
931 .Case("power3", ArchDefinePpcgr)
932 .Case("power4", ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
933 .Case("power5", ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
934 | ArchDefinePpcsq)
935 .Case("power5x", ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
936 | ArchDefinePpcgr | ArchDefinePpcsq)
937 .Case("power6", ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
938 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
939 .Case("power6x", ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x
940 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
941 | ArchDefinePpcsq)
942 .Case("power7", ArchDefinePwr7 | ArchDefinePwr6x | ArchDefinePwr6
943 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
944 | ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000945 .Default(ArchDefineNone);
946
947 if (defs & ArchDefineName)
948 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
949 if (defs & ArchDefinePpcgr)
950 Builder.defineMacro("_ARCH_PPCGR");
951 if (defs & ArchDefinePpcsq)
952 Builder.defineMacro("_ARCH_PPCSQ");
953 if (defs & ArchDefine440)
Hal Finkel02a84272012-06-11 22:35:19 +0000954 Builder.defineMacro("_ARCH_440");
Hal Finkel39d5fa12012-07-03 16:51:04 +0000955 if (defs & ArchDefine603)
956 Builder.defineMacro("_ARCH_603");
957 if (defs & ArchDefine604)
958 Builder.defineMacro("_ARCH_604");
Bill Schmidt2821e182013-02-01 20:23:10 +0000959 if (defs & ArchDefinePwr4)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000960 Builder.defineMacro("_ARCH_PWR4");
Bill Schmidt2821e182013-02-01 20:23:10 +0000961 if (defs & ArchDefinePwr5)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000962 Builder.defineMacro("_ARCH_PWR5");
Bill Schmidt2821e182013-02-01 20:23:10 +0000963 if (defs & ArchDefinePwr5x)
964 Builder.defineMacro("_ARCH_PWR5X");
965 if (defs & ArchDefinePwr6)
Hal Finkel02a84272012-06-11 22:35:19 +0000966 Builder.defineMacro("_ARCH_PWR6");
Bill Schmidt2821e182013-02-01 20:23:10 +0000967 if (defs & ArchDefinePwr6x)
968 Builder.defineMacro("_ARCH_PWR6X");
969 if (defs & ArchDefinePwr7)
970 Builder.defineMacro("_ARCH_PWR7");
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000971 if (defs & ArchDefineA2)
972 Builder.defineMacro("_ARCH_A2");
973 if (defs & ArchDefineA2q) {
974 Builder.defineMacro("_ARCH_A2Q");
975 Builder.defineMacro("_ARCH_QP");
976 }
977
978 if (getTriple().getVendor() == llvm::Triple::BGQ) {
979 Builder.defineMacro("__bg__");
980 Builder.defineMacro("__THW_BLUEGENE__");
981 Builder.defineMacro("__bgq__");
982 Builder.defineMacro("__TOS_BGQ__");
983 }
Bill Schmidt2821e182013-02-01 20:23:10 +0000984
985 // FIXME: The following are not yet generated here by Clang, but are
986 // generated by GCC:
987 //
988 // _SOFT_FLOAT_
989 // __RECIP_PRECISION__
990 // __APPLE_ALTIVEC__
991 // __VSX__
992 // __RECIP__
993 // __RECIPF__
994 // __RSQRTE__
995 // __RSQRTEF__
996 // _SOFT_DOUBLE_
997 // __NO_LWSYNC__
998 // __HAVE_BSWAP__
999 // __LONGDOUBLE128
1000 // __CMODEL_MEDIUM__
1001 // __CMODEL_LARGE__
1002 // _CALL_SYSV
1003 // _CALL_DARWIN
1004 // __NO_FPRS__
Bill Schmidt199402b2013-02-01 02:14:03 +00001005}
1006
1007void PPCTargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
1008 Features["altivec"] = llvm::StringSwitch<bool>(CPU)
1009 .Case("7400", true)
1010 .Case("g4", true)
1011 .Case("7450", true)
1012 .Case("g4+", true)
1013 .Case("970", true)
1014 .Case("g5", true)
1015 .Case("pwr6", true)
1016 .Case("pwr7", true)
1017 .Case("ppc64", true)
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00001018 .Case("ppc64le", true)
Bill Schmidt199402b2013-02-01 02:14:03 +00001019 .Default(false);
Hal Finkel3c6aaeb2013-02-01 18:44:19 +00001020
1021 Features["qpx"] = (CPU == "a2q");
Bill Schmidt199402b2013-02-01 02:14:03 +00001022}
1023
1024bool PPCTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1025 StringRef Name,
1026 bool Enabled) const {
Hal Finkelfe6b2712013-03-30 13:47:44 +00001027 if (Name == "altivec" || Name == "fprnd" || Name == "mfocrf" ||
1028 Name == "popcntd" || Name == "qpx") {
Bill Schmidt199402b2013-02-01 02:14:03 +00001029 Features[Name] = Enabled;
1030 return true;
Hal Finkel02a84272012-06-11 22:35:19 +00001031 }
Bill Schmidt199402b2013-02-01 02:14:03 +00001032
1033 return false;
Chris Lattnerc0f59212009-03-02 22:27:17 +00001034}
1035
Douglas Gregore727d212012-01-30 06:38:25 +00001036bool PPCTargetInfo::hasFeature(StringRef Feature) const {
1037 return Feature == "powerpc";
1038}
Chris Lattner393ff042008-04-21 18:56:49 +00001039
Douglas Gregore727d212012-01-30 06:38:25 +00001040
Eli Friedmane4277982008-08-20 23:11:40 +00001041const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +00001042 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1043 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1044 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1045 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1046 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
1047 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
1048 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
1049 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +00001050 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +00001051 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +00001052 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +00001053 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1054 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
1055 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
1056 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +00001057 "vrsave", "vscr",
1058 "spe_acc", "spefscr",
1059 "sfp"
1060};
Reid Spencer5f016e22007-07-11 17:01:13 +00001061
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001062void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +00001063 unsigned &NumNames) const {
1064 Names = GCCRegNames;
1065 NumNames = llvm::array_lengthof(GCCRegNames);
1066}
Reid Spencer5f016e22007-07-11 17:01:13 +00001067
Eli Friedmane4277982008-08-20 23:11:40 +00001068const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
1069 // While some of these aliases do map to different registers
1070 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00001071 { { "0" }, "r0" },
1072 { { "1"}, "r1" },
1073 { { "2" }, "r2" },
1074 { { "3" }, "r3" },
1075 { { "4" }, "r4" },
1076 { { "5" }, "r5" },
1077 { { "6" }, "r6" },
1078 { { "7" }, "r7" },
1079 { { "8" }, "r8" },
1080 { { "9" }, "r9" },
1081 { { "10" }, "r10" },
1082 { { "11" }, "r11" },
1083 { { "12" }, "r12" },
1084 { { "13" }, "r13" },
1085 { { "14" }, "r14" },
1086 { { "15" }, "r15" },
1087 { { "16" }, "r16" },
1088 { { "17" }, "r17" },
1089 { { "18" }, "r18" },
1090 { { "19" }, "r19" },
1091 { { "20" }, "r20" },
1092 { { "21" }, "r21" },
1093 { { "22" }, "r22" },
1094 { { "23" }, "r23" },
1095 { { "24" }, "r24" },
1096 { { "25" }, "r25" },
1097 { { "26" }, "r26" },
1098 { { "27" }, "r27" },
1099 { { "28" }, "r28" },
1100 { { "29" }, "r29" },
1101 { { "30" }, "r30" },
1102 { { "31" }, "r31" },
1103 { { "fr0" }, "f0" },
1104 { { "fr1" }, "f1" },
1105 { { "fr2" }, "f2" },
1106 { { "fr3" }, "f3" },
1107 { { "fr4" }, "f4" },
1108 { { "fr5" }, "f5" },
1109 { { "fr6" }, "f6" },
1110 { { "fr7" }, "f7" },
1111 { { "fr8" }, "f8" },
1112 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +00001113 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00001114 { { "fr11" }, "f11" },
1115 { { "fr12" }, "f12" },
1116 { { "fr13" }, "f13" },
1117 { { "fr14" }, "f14" },
1118 { { "fr15" }, "f15" },
1119 { { "fr16" }, "f16" },
1120 { { "fr17" }, "f17" },
1121 { { "fr18" }, "f18" },
1122 { { "fr19" }, "f19" },
1123 { { "fr20" }, "f20" },
1124 { { "fr21" }, "f21" },
1125 { { "fr22" }, "f22" },
1126 { { "fr23" }, "f23" },
1127 { { "fr24" }, "f24" },
1128 { { "fr25" }, "f25" },
1129 { { "fr26" }, "f26" },
1130 { { "fr27" }, "f27" },
1131 { { "fr28" }, "f28" },
1132 { { "fr29" }, "f29" },
1133 { { "fr30" }, "f30" },
1134 { { "fr31" }, "f31" },
1135 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +00001136};
1137
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001138void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +00001139 unsigned &NumAliases) const {
1140 Aliases = GCCRegAliases;
1141 NumAliases = llvm::array_lengthof(GCCRegAliases);
1142}
1143} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00001144
1145namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001146class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001147public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001148 PPC32TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +00001149 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 +00001150 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +00001151
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001152 switch (getTriple().getOS()) {
Nico Weber6e1d2ea2012-01-31 02:07:33 +00001153 case llvm::Triple::Linux:
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001154 case llvm::Triple::FreeBSD:
1155 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001156 SizeType = UnsignedInt;
Hal Finkel178a9b82012-03-02 20:54:36 +00001157 PtrDiffType = SignedInt;
1158 IntPtrType = SignedInt;
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001159 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +00001160 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001161 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001162 }
Roman Divackye3d175d2012-03-13 16:53:54 +00001163
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001164 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1165 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001166 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001167 }
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001168
1169 // PPC32 supports atomics up to 4 bytes.
1170 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001171 }
1172
Meador Ingec5613b22012-06-16 03:34:49 +00001173 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001174 // This is the ELF definition, and is overridden by the Darwin sub-target
Meador Ingec5613b22012-06-16 03:34:49 +00001175 return TargetInfo::PowerABIBuiltinVaList;
Eli Friedmaned855cb2008-08-21 00:13:15 +00001176 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001177};
1178} // end anonymous namespace.
1179
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00001180// Note: ABI differences may eventually require us to have a separate
1181// TargetInfo for little endian.
Reid Spencer5f016e22007-07-11 17:01:13 +00001182namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001183class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001184public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001185 PPC64TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00001186 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00001187 IntMaxType = SignedLong;
1188 UIntMaxType = UnsignedLong;
1189 Int64Type = SignedLong;
Roman Divackye3d175d2012-03-13 16:53:54 +00001190
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001191 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1192 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001193 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001194 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 +00001195 "i64:64:64-f32:32:32-f64:64:64-"
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001196 "v128:128:128-n32:64";
1197 } else
1198 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1199 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
1200 "v128:128:128-n32:64";
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001201
1202 // PPC64 supports atomics up to 8 bytes.
1203 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Chris Lattnerf291b102008-05-09 06:17:04 +00001204 }
Meador Ingec5613b22012-06-16 03:34:49 +00001205 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1206 return TargetInfo::CharPtrBuiltinVaList;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001207 }
Eli Friedmane4277982008-08-20 23:11:40 +00001208};
1209} // end anonymous namespace.
1210
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001211
1212namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001213class DarwinPPC32TargetInfo :
1214 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001215public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001216 DarwinPPC32TargetInfo(const llvm::Triple &Triple)
1217 : DarwinTargetInfo<PPC32TargetInfo>(Triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001218 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001219 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
David Fangb5afadd2013-05-16 17:51:48 +00001220 PtrDiffType = SignedInt; // for http://llvm.org/bugs/show_bug.cgi?id=15726
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001221 LongLongAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001222 SuitableAlign = 128;
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001223 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1224 "i64:32:64-f32:32:32-f64:64:64-v128:128:128-n32";
Roman Divackyc81f2a22011-01-06 08:27:10 +00001225 }
Meador Ingec5613b22012-06-16 03:34:49 +00001226 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1227 return TargetInfo::CharPtrBuiltinVaList;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001228 }
1229};
1230
1231class DarwinPPC64TargetInfo :
1232 public DarwinTargetInfo<PPC64TargetInfo> {
1233public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001234 DarwinPPC64TargetInfo(const llvm::Triple &Triple)
1235 : DarwinTargetInfo<PPC64TargetInfo>(Triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001236 HasAlignMac68kSupport = true;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001237 SuitableAlign = 128;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001238 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1239 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001240 }
1241};
1242} // end anonymous namespace.
1243
Reid Spencer5f016e22007-07-11 17:01:13 +00001244namespace {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001245 static const unsigned NVPTXAddrSpaceMap[] = {
1246 1, // opencl_global
1247 3, // opencl_local
1248 4, // opencl_constant
1249 1, // cuda_device
1250 4, // cuda_constant
1251 3, // cuda_shared
1252 };
1253 class NVPTXTargetInfo : public TargetInfo {
1254 static const char * const GCCRegNames[];
Justin Holewinski2c585b92012-05-24 17:43:12 +00001255 static const Builtin::Info BuiltinInfo[];
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00001256 std::vector<StringRef> AvailableFeatures;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001257 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001258 NVPTXTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001259 BigEndian = false;
1260 TLSSupported = false;
1261 LongWidth = LongAlign = 64;
1262 AddrSpaceMap = &NVPTXAddrSpaceMap;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001263 // Define available target features
1264 // These must be defined in sorted order!
Justin Holewinski9903e942012-07-11 15:34:55 +00001265 NoAsmVariants = true;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001266 }
1267 virtual void getTargetDefines(const LangOptions &Opts,
1268 MacroBuilder &Builder) const {
1269 Builder.defineMacro("__PTX__");
Justin Holewinski2c585b92012-05-24 17:43:12 +00001270 Builder.defineMacro("__NVPTX__");
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001271 }
1272 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1273 unsigned &NumRecords) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001274 Records = BuiltinInfo;
1275 NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001276 }
1277 virtual bool hasFeature(StringRef Feature) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001278 return Feature == "ptx" || Feature == "nvptx";
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001279 }
1280
1281 virtual void getGCCRegNames(const char * const *&Names,
1282 unsigned &NumNames) const;
1283 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1284 unsigned &NumAliases) const {
1285 // No aliases.
1286 Aliases = 0;
1287 NumAliases = 0;
1288 }
1289 virtual bool validateAsmConstraint(const char *&Name,
Justin Holewinski0ac428e2013-06-21 18:51:24 +00001290 TargetInfo::ConstraintInfo &Info) const {
1291 switch (*Name) {
1292 default: return false;
1293 case 'c':
1294 case 'h':
1295 case 'r':
1296 case 'l':
1297 case 'f':
1298 case 'd':
1299 Info.setAllowsRegister();
1300 return true;
1301 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001302 }
1303 virtual const char *getClobbers() const {
1304 // FIXME: Is this really right?
1305 return "";
1306 }
Meador Ingec5613b22012-06-16 03:34:49 +00001307 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001308 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00001309 return TargetInfo::CharPtrBuiltinVaList;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001310 }
1311 virtual bool setCPU(const std::string &Name) {
Justin Holewinskiaffa3af2013-03-30 14:38:26 +00001312 bool Valid = llvm::StringSwitch<bool>(Name)
1313 .Case("sm_20", true)
1314 .Case("sm_21", true)
1315 .Case("sm_30", true)
1316 .Case("sm_35", true)
1317 .Default(false);
1318
1319 return Valid;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001320 }
Justin Holewinski2c585b92012-05-24 17:43:12 +00001321 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1322 StringRef Name,
1323 bool Enabled) const;
1324 };
1325
1326 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1327#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1328#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1329 ALL_LANGUAGES },
1330#include "clang/Basic/BuiltinsNVPTX.def"
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001331 };
1332
1333 const char * const NVPTXTargetInfo::GCCRegNames[] = {
1334 "r0"
1335 };
1336
1337 void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names,
1338 unsigned &NumNames) const {
1339 Names = GCCRegNames;
1340 NumNames = llvm::array_lengthof(GCCRegNames);
1341 }
1342
Justin Holewinski2c585b92012-05-24 17:43:12 +00001343 bool NVPTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1344 StringRef Name,
1345 bool Enabled) const {
1346 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
1347 Name)) {
1348 Features[Name] = Enabled;
1349 return true;
1350 } else {
1351 return false;
1352 }
1353 }
1354
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001355 class NVPTX32TargetInfo : public NVPTXTargetInfo {
1356 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001357 NVPTX32TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001358 PointerWidth = PointerAlign = 32;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001359 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001360 DescriptionString
1361 = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1362 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1363 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001364 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001365 };
1366
1367 class NVPTX64TargetInfo : public NVPTXTargetInfo {
1368 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001369 NVPTX64TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001370 PointerWidth = PointerAlign = 64;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001371 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001372 DescriptionString
1373 = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1374 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1375 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001376 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001377 };
1378}
1379
1380namespace {
Eli Friedman6505a292012-10-12 23:32:00 +00001381
1382static const unsigned R600AddrSpaceMap[] = {
1383 1, // opencl_global
1384 3, // opencl_local
1385 2, // opencl_constant
1386 1, // cuda_device
1387 2, // cuda_constant
1388 3 // cuda_shared
1389};
1390
Tom Stellardfd075912013-03-04 17:40:53 +00001391static const char *DescriptionStringR600 =
1392 "e"
1393 "-p:32:32:32"
1394 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32"
1395 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1396 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1397 "-n32:64";
1398
1399static const char *DescriptionStringR600DoubleOps =
1400 "e"
1401 "-p:32:32:32"
1402 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64"
1403 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1404 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1405 "-n32:64";
1406
1407static const char *DescriptionStringSI =
1408 "e"
1409 "-p:64:64:64"
1410 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64"
1411 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1412 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1413 "-n32:64";
1414
Eli Friedman6505a292012-10-12 23:32:00 +00001415class R600TargetInfo : public TargetInfo {
Tom Stellardfd075912013-03-04 17:40:53 +00001416 /// \brief The GPU profiles supported by the R600 target.
1417 enum GPUKind {
1418 GK_NONE,
1419 GK_R600,
1420 GK_R600_DOUBLE_OPS,
1421 GK_R700,
1422 GK_R700_DOUBLE_OPS,
1423 GK_EVERGREEN,
1424 GK_EVERGREEN_DOUBLE_OPS,
1425 GK_NORTHERN_ISLANDS,
1426 GK_CAYMAN,
1427 GK_SOUTHERN_ISLANDS
1428 } GPU;
1429
Eli Friedman6505a292012-10-12 23:32:00 +00001430public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001431 R600TargetInfo(const llvm::Triple &Triple)
1432 : TargetInfo(Triple), GPU(GK_R600) {
Tom Stellardfd075912013-03-04 17:40:53 +00001433 DescriptionString = DescriptionStringR600;
Eli Friedman6505a292012-10-12 23:32:00 +00001434 AddrSpaceMap = &R600AddrSpaceMap;
1435 }
1436
1437 virtual const char * getClobbers() const {
1438 return "";
1439 }
1440
1441 virtual void getGCCRegNames(const char * const *&Names,
1442 unsigned &numNames) const {
1443 Names = NULL;
1444 numNames = 0;
1445 }
1446
1447 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1448 unsigned &NumAliases) const {
1449 Aliases = NULL;
1450 NumAliases = 0;
1451 }
1452
1453 virtual bool validateAsmConstraint(const char *&Name,
1454 TargetInfo::ConstraintInfo &info) const {
1455 return true;
1456 }
1457
1458 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1459 unsigned &NumRecords) const {
1460 Records = NULL;
1461 NumRecords = 0;
1462 }
1463
1464
1465 virtual void getTargetDefines(const LangOptions &Opts,
1466 MacroBuilder &Builder) const {
1467 Builder.defineMacro("__R600__");
1468 }
1469
1470 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1471 return TargetInfo::CharPtrBuiltinVaList;
1472 }
1473
Tom Stellardfd075912013-03-04 17:40:53 +00001474 virtual bool setCPU(const std::string &Name) {
1475 GPU = llvm::StringSwitch<GPUKind>(Name)
1476 .Case("r600" , GK_R600)
1477 .Case("rv610", GK_R600)
1478 .Case("rv620", GK_R600)
1479 .Case("rv630", GK_R600)
1480 .Case("rv635", GK_R600)
1481 .Case("rs780", GK_R600)
1482 .Case("rs880", GK_R600)
1483 .Case("rv670", GK_R600_DOUBLE_OPS)
1484 .Case("rv710", GK_R700)
1485 .Case("rv730", GK_R700)
1486 .Case("rv740", GK_R700_DOUBLE_OPS)
1487 .Case("rv770", GK_R700_DOUBLE_OPS)
1488 .Case("palm", GK_EVERGREEN)
1489 .Case("cedar", GK_EVERGREEN)
1490 .Case("sumo", GK_EVERGREEN)
1491 .Case("sumo2", GK_EVERGREEN)
1492 .Case("redwood", GK_EVERGREEN)
1493 .Case("juniper", GK_EVERGREEN)
1494 .Case("hemlock", GK_EVERGREEN_DOUBLE_OPS)
1495 .Case("cypress", GK_EVERGREEN_DOUBLE_OPS)
1496 .Case("barts", GK_NORTHERN_ISLANDS)
1497 .Case("turks", GK_NORTHERN_ISLANDS)
1498 .Case("caicos", GK_NORTHERN_ISLANDS)
1499 .Case("cayman", GK_CAYMAN)
1500 .Case("aruba", GK_CAYMAN)
Tom Stellard3b848ec2013-04-01 20:56:49 +00001501 .Case("tahiti", GK_SOUTHERN_ISLANDS)
Tom Stellardfd075912013-03-04 17:40:53 +00001502 .Case("pitcairn", GK_SOUTHERN_ISLANDS)
1503 .Case("verde", GK_SOUTHERN_ISLANDS)
1504 .Case("oland", GK_SOUTHERN_ISLANDS)
1505 .Default(GK_NONE);
1506
1507 if (GPU == GK_NONE) {
1508 return false;
1509 }
1510
1511 // Set the correct data layout
1512 switch (GPU) {
1513 case GK_NONE:
1514 case GK_R600:
1515 case GK_R700:
1516 case GK_EVERGREEN:
1517 case GK_NORTHERN_ISLANDS:
1518 DescriptionString = DescriptionStringR600;
1519 break;
1520 case GK_R600_DOUBLE_OPS:
1521 case GK_R700_DOUBLE_OPS:
1522 case GK_EVERGREEN_DOUBLE_OPS:
1523 case GK_CAYMAN:
1524 DescriptionString = DescriptionStringR600DoubleOps;
1525 break;
1526 case GK_SOUTHERN_ISLANDS:
1527 DescriptionString = DescriptionStringSI;
1528 break;
1529 }
1530
1531 return true;
1532 }
Eli Friedman6505a292012-10-12 23:32:00 +00001533};
1534
1535} // end anonymous namespace
1536
1537namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001538// Namespace for x86 abstract base class
1539const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001540#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001541#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001542 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001543#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001544};
Eli Friedman61538a72008-05-20 14:21:01 +00001545
Nuno Lopes2550d702009-12-23 17:49:57 +00001546static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001547 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1548 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001549 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001550 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1551 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1552 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001553 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopherc5f9a012011-12-02 02:12:16 +00001554 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1555 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001556};
1557
Eric Christophercfd323d2011-06-21 00:05:20 +00001558const TargetInfo::AddlRegName AddlRegNames[] = {
1559 { { "al", "ah", "eax", "rax" }, 0 },
1560 { { "bl", "bh", "ebx", "rbx" }, 3 },
1561 { { "cl", "ch", "ecx", "rcx" }, 2 },
1562 { { "dl", "dh", "edx", "rdx" }, 1 },
1563 { { "esi", "rsi" }, 4 },
1564 { { "edi", "rdi" }, 5 },
1565 { { "esp", "rsp" }, 7 },
1566 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001567};
1568
1569// X86 target abstract base class; x86-32 and x86-64 are very close, so
1570// most of the implementation can be shared.
1571class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001572 enum X86SSEEnum {
Craig Topper05fe4b52012-01-09 09:19:09 +00001573 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2
Chris Lattner84f0ea82009-03-02 22:40:39 +00001574 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001575 enum MMX3DNowEnum {
1576 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1577 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001578
Eric Christophereea12d12010-04-02 23:50:19 +00001579 bool HasAES;
Craig Topper3c0bc152012-05-31 05:18:48 +00001580 bool HasPCLMUL;
Craig Topper31ceea02011-12-25 05:06:45 +00001581 bool HasLZCNT;
Benjamin Kramer84f30802012-07-07 09:39:18 +00001582 bool HasRDRND;
Craig Topper31ceea02011-12-25 05:06:45 +00001583 bool HasBMI;
1584 bool HasBMI2;
Craig Toppere14e08b2011-12-29 16:10:46 +00001585 bool HasPOPCNT;
Michael Liao463eb892012-11-10 05:17:46 +00001586 bool HasRTM;
Michael Liao72339a02013-03-26 17:52:08 +00001587 bool HasPRFCHW;
Michael Liao1bfc28c2013-03-29 05:17:55 +00001588 bool HasRDSEED;
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00001589 bool HasSSE4a;
Craig Topper6a511e12011-12-30 07:33:42 +00001590 bool HasFMA4;
Craig Topper2ae95072012-06-03 21:46:30 +00001591 bool HasFMA;
Craig Topperb6af69e2012-06-09 22:24:14 +00001592 bool HasXOP;
Manman Ren146e5a42012-10-11 00:59:55 +00001593 bool HasF16C;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001594
Chandler Carruth499d9722011-09-28 08:55:34 +00001595 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1596 ///
1597 /// Each enumeration represents a particular CPU supported by Clang. These
1598 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1599 enum CPUKind {
1600 CK_Generic,
1601
1602 /// \name i386
1603 /// i386-generation processors.
1604 //@{
1605 CK_i386,
1606 //@}
1607
1608 /// \name i486
1609 /// i486-generation processors.
1610 //@{
1611 CK_i486,
1612 CK_WinChipC6,
1613 CK_WinChip2,
1614 CK_C3,
1615 //@}
1616
1617 /// \name i586
1618 /// i586-generation processors, P5 microarchitecture based.
1619 //@{
1620 CK_i586,
1621 CK_Pentium,
1622 CK_PentiumMMX,
1623 //@}
1624
1625 /// \name i686
1626 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1627 //@{
1628 CK_i686,
1629 CK_PentiumPro,
1630 CK_Pentium2,
1631 CK_Pentium3,
1632 CK_Pentium3M,
1633 CK_PentiumM,
1634 CK_C3_2,
1635
1636 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1637 /// Clang however has some logic to suport this.
1638 // FIXME: Warn, deprecate, and potentially remove this.
1639 CK_Yonah,
1640 //@}
1641
1642 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001643 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001644 //@{
1645 CK_Pentium4,
1646 CK_Pentium4M,
1647 CK_Prescott,
1648 CK_Nocona,
1649 //@}
1650
1651 /// \name Core
1652 /// Core microarchitecture based processors.
1653 //@{
1654 CK_Core2,
1655
1656 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1657 /// codename which GCC no longer accepts as an option to -march, but Clang
1658 /// has some logic for recognizing it.
1659 // FIXME: Warn, deprecate, and potentially remove this.
1660 CK_Penryn,
1661 //@}
1662
1663 /// \name Atom
1664 /// Atom processors
1665 //@{
1666 CK_Atom,
1667 //@}
1668
1669 /// \name Nehalem
1670 /// Nehalem microarchitecture based processors.
1671 //@{
1672 CK_Corei7,
1673 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001674 CK_CoreAVXi,
Craig Topper2b03bb02011-12-17 19:55:21 +00001675 CK_CoreAVX2,
Chandler Carruth499d9722011-09-28 08:55:34 +00001676 //@}
1677
1678 /// \name K6
1679 /// K6 architecture processors.
1680 //@{
1681 CK_K6,
1682 CK_K6_2,
1683 CK_K6_3,
1684 //@}
1685
1686 /// \name K7
1687 /// K7 architecture processors.
1688 //@{
1689 CK_Athlon,
1690 CK_AthlonThunderbird,
1691 CK_Athlon4,
1692 CK_AthlonXP,
1693 CK_AthlonMP,
1694 //@}
1695
1696 /// \name K8
1697 /// K8 architecture processors.
1698 //@{
1699 CK_Athlon64,
1700 CK_Athlon64SSE3,
1701 CK_AthlonFX,
1702 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001703 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001704 CK_Opteron,
1705 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001706 CK_AMDFAM10,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001707 //@}
Chandler Carruth499d9722011-09-28 08:55:34 +00001708
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001709 /// \name Bobcat
1710 /// Bobcat architecture processors.
1711 //@{
1712 CK_BTVER1,
Benjamin Kramer63063f52013-05-03 10:47:15 +00001713 CK_BTVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001714 //@}
1715
1716 /// \name Bulldozer
1717 /// Bulldozer architecture processors.
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001718 //@{
1719 CK_BDVER1,
1720 CK_BDVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001721 //@}
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001722
Chandler Carruth499d9722011-09-28 08:55:34 +00001723 /// This specification is deprecated and will be removed in the future.
1724 /// Users should prefer \see CK_K8.
1725 // FIXME: Warn on this when the CPU is set to it.
1726 CK_x86_64,
1727 //@}
1728
1729 /// \name Geode
1730 /// Geode processors.
1731 //@{
1732 CK_Geode
1733 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001734 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001735
Eli Friedman618234a2008-08-20 02:34:37 +00001736public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001737 X86TargetInfo(const llvm::Triple &Triple)
1738 : TargetInfo(Triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
1739 HasAES(false), HasPCLMUL(false), HasLZCNT(false), HasRDRND(false),
1740 HasBMI(false), HasBMI2(false), HasPOPCNT(false), HasRTM(false),
1741 HasPRFCHW(false), HasRDSEED(false), HasSSE4a(false), HasFMA4(false),
1742 HasFMA(false), HasXOP(false), HasF16C(false), CPU(CK_Generic) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00001743 BigEndian = false;
Eli Friedman618234a2008-08-20 02:34:37 +00001744 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001745 }
Benjamin Kramerb4066692011-12-28 15:47:06 +00001746 virtual unsigned getFloatEvalMethod() const {
1747 // X87 evaluates with 80 bits "long double" precision.
1748 return SSELevel == NoSSE ? 2 : 0;
1749 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001750 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1751 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001752 Records = BuiltinInfo;
1753 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001754 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001755 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001756 unsigned &NumNames) const {
1757 Names = GCCRegNames;
1758 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001759 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001760 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001761 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001762 Aliases = 0;
1763 NumAliases = 0;
1764 }
1765 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
Eric Christopher825d3862012-11-14 22:08:59 +00001766 unsigned &NumNames) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001767 Names = AddlRegNames;
1768 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001769 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001770 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001771 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001772 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001773 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001774 return "~{dirflag},~{fpsr},~{flags}";
1775 }
Chris Lattner33328642009-03-20 15:52:06 +00001776 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001777 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001778 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001779 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001780 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001781 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Douglas Gregore727d212012-01-30 06:38:25 +00001782 virtual bool hasFeature(StringRef Feature) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001783 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001784 virtual const char* getABI() const {
Derek Schuffbabaf312012-10-11 15:52:22 +00001785 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001786 return "avx";
Derek Schuffbabaf312012-10-11 15:52:22 +00001787 else if (getTriple().getArch() == llvm::Triple::x86 &&
1788 MMX3DNowLevel == NoMMX3DNow)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001789 return "no-mmx";
1790 return "";
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001791 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001792 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001793 CPU = llvm::StringSwitch<CPUKind>(Name)
1794 .Case("i386", CK_i386)
1795 .Case("i486", CK_i486)
1796 .Case("winchip-c6", CK_WinChipC6)
1797 .Case("winchip2", CK_WinChip2)
1798 .Case("c3", CK_C3)
1799 .Case("i586", CK_i586)
1800 .Case("pentium", CK_Pentium)
1801 .Case("pentium-mmx", CK_PentiumMMX)
1802 .Case("i686", CK_i686)
1803 .Case("pentiumpro", CK_PentiumPro)
1804 .Case("pentium2", CK_Pentium2)
1805 .Case("pentium3", CK_Pentium3)
1806 .Case("pentium3m", CK_Pentium3M)
1807 .Case("pentium-m", CK_PentiumM)
1808 .Case("c3-2", CK_C3_2)
1809 .Case("yonah", CK_Yonah)
1810 .Case("pentium4", CK_Pentium4)
1811 .Case("pentium4m", CK_Pentium4M)
1812 .Case("prescott", CK_Prescott)
1813 .Case("nocona", CK_Nocona)
1814 .Case("core2", CK_Core2)
1815 .Case("penryn", CK_Penryn)
1816 .Case("atom", CK_Atom)
1817 .Case("corei7", CK_Corei7)
1818 .Case("corei7-avx", CK_Corei7AVX)
1819 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper2b03bb02011-12-17 19:55:21 +00001820 .Case("core-avx2", CK_CoreAVX2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001821 .Case("k6", CK_K6)
1822 .Case("k6-2", CK_K6_2)
1823 .Case("k6-3", CK_K6_3)
1824 .Case("athlon", CK_Athlon)
1825 .Case("athlon-tbird", CK_AthlonThunderbird)
1826 .Case("athlon-4", CK_Athlon4)
1827 .Case("athlon-xp", CK_AthlonXP)
1828 .Case("athlon-mp", CK_AthlonMP)
1829 .Case("athlon64", CK_Athlon64)
1830 .Case("athlon64-sse3", CK_Athlon64SSE3)
1831 .Case("athlon-fx", CK_AthlonFX)
1832 .Case("k8", CK_K8)
1833 .Case("k8-sse3", CK_K8SSE3)
1834 .Case("opteron", CK_Opteron)
1835 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001836 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001837 .Case("btver1", CK_BTVER1)
Benjamin Kramer63063f52013-05-03 10:47:15 +00001838 .Case("btver2", CK_BTVER2)
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001839 .Case("bdver1", CK_BDVER1)
1840 .Case("bdver2", CK_BDVER2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001841 .Case("x86-64", CK_x86_64)
1842 .Case("geode", CK_Geode)
1843 .Default(CK_Generic);
1844
Chandler Carruth26a39142011-09-28 09:45:08 +00001845 // Perform any per-CPU checks necessary to determine if this CPU is
1846 // acceptable.
1847 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1848 // invalid without explaining *why*.
1849 switch (CPU) {
1850 case CK_Generic:
1851 // No processor selected!
1852 return false;
1853
1854 case CK_i386:
1855 case CK_i486:
1856 case CK_WinChipC6:
1857 case CK_WinChip2:
1858 case CK_C3:
1859 case CK_i586:
1860 case CK_Pentium:
1861 case CK_PentiumMMX:
1862 case CK_i686:
1863 case CK_PentiumPro:
1864 case CK_Pentium2:
1865 case CK_Pentium3:
1866 case CK_Pentium3M:
1867 case CK_PentiumM:
1868 case CK_Yonah:
1869 case CK_C3_2:
1870 case CK_Pentium4:
1871 case CK_Pentium4M:
1872 case CK_Prescott:
1873 case CK_K6:
1874 case CK_K6_2:
1875 case CK_K6_3:
1876 case CK_Athlon:
1877 case CK_AthlonThunderbird:
1878 case CK_Athlon4:
1879 case CK_AthlonXP:
1880 case CK_AthlonMP:
1881 case CK_Geode:
1882 // Only accept certain architectures when compiling in 32-bit mode.
Derek Schuffbabaf312012-10-11 15:52:22 +00001883 if (getTriple().getArch() != llvm::Triple::x86)
Chandler Carruth26a39142011-09-28 09:45:08 +00001884 return false;
1885
1886 // Fallthrough
1887 case CK_Nocona:
1888 case CK_Core2:
1889 case CK_Penryn:
1890 case CK_Atom:
1891 case CK_Corei7:
1892 case CK_Corei7AVX:
1893 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001894 case CK_CoreAVX2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001895 case CK_Athlon64:
1896 case CK_Athlon64SSE3:
1897 case CK_AthlonFX:
1898 case CK_K8:
1899 case CK_K8SSE3:
1900 case CK_Opteron:
1901 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00001902 case CK_AMDFAM10:
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001903 case CK_BTVER1:
Benjamin Kramer63063f52013-05-03 10:47:15 +00001904 case CK_BTVER2:
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001905 case CK_BDVER1:
1906 case CK_BDVER2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001907 case CK_x86_64:
1908 return true;
1909 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001910 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001911 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00001912
1913 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
1914 // We accept all non-ARM calling conventions
1915 return (CC == CC_X86ThisCall ||
1916 CC == CC_X86FastCall ||
Peter Collingbourne7728cdd2013-02-23 00:06:18 +00001917 CC == CC_X86StdCall ||
1918 CC == CC_C ||
Guy Benyei38980082012-12-25 08:53:55 +00001919 CC == CC_X86Pascal ||
1920 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballman82bfa192012-10-02 14:26:08 +00001921 }
1922
Aaron Ballmanfff32482012-12-09 17:45:41 +00001923 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {
1924 return MT == CCMT_Member ? CC_X86ThisCall : CC_C;
Aaron Ballman82bfa192012-10-02 14:26:08 +00001925 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001926};
Chris Lattner3daed522009-03-02 22:20:04 +00001927
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001928void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001929 // FIXME: This should not be here.
1930 Features["3dnow"] = false;
1931 Features["3dnowa"] = false;
1932 Features["mmx"] = false;
1933 Features["sse"] = false;
1934 Features["sse2"] = false;
1935 Features["sse3"] = false;
1936 Features["ssse3"] = false;
1937 Features["sse41"] = false;
1938 Features["sse42"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001939 Features["sse4a"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001940 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00001941 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001942 Features["avx"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001943 Features["avx2"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001944 Features["lzcnt"] = false;
Benjamin Kramer84f30802012-07-07 09:39:18 +00001945 Features["rdrand"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001946 Features["bmi"] = false;
1947 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001948 Features["popcnt"] = false;
Michael Liao463eb892012-11-10 05:17:46 +00001949 Features["rtm"] = false;
Michael Liao72339a02013-03-26 17:52:08 +00001950 Features["prfchw"] = false;
Michael Liao1bfc28c2013-03-29 05:17:55 +00001951 Features["rdseed"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001952 Features["fma4"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00001953 Features["fma"] = false;
Craig Topperb6af69e2012-06-09 22:24:14 +00001954 Features["xop"] = false;
Manman Ren146e5a42012-10-11 00:59:55 +00001955 Features["f16c"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001956
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001957 // FIXME: This *really* should not be here.
1958
1959 // X86_64 always has SSE2.
Derek Schuffbabaf312012-10-11 15:52:22 +00001960 if (getTriple().getArch() == llvm::Triple::x86_64)
Eli Friedman612db2a2012-11-17 01:16:19 +00001961 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001962
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001963 switch (CPU) {
1964 case CK_Generic:
1965 case CK_i386:
1966 case CK_i486:
1967 case CK_i586:
1968 case CK_Pentium:
1969 case CK_i686:
1970 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001971 break;
1972 case CK_PentiumMMX:
1973 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001974 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001975 break;
1976 case CK_Pentium3:
1977 case CK_Pentium3M:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001978 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001979 break;
1980 case CK_PentiumM:
1981 case CK_Pentium4:
1982 case CK_Pentium4M:
1983 case CK_x86_64:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001984 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001985 break;
1986 case CK_Yonah:
1987 case CK_Prescott:
1988 case CK_Nocona:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001989 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001990 break;
1991 case CK_Core2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001992 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001993 break;
1994 case CK_Penryn:
Benjamin Kramerb3453a82012-01-04 14:36:57 +00001995 setFeatureEnabled(Features, "sse4.1", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001996 break;
1997 case CK_Atom:
Chandler Carruth49defe62011-09-28 10:36:46 +00001998 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001999 break;
2000 case CK_Corei7:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002001 setFeatureEnabled(Features, "sse4", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002002 break;
2003 case CK_Corei7AVX:
Benjamin Kramer84f30802012-07-07 09:39:18 +00002004 setFeatureEnabled(Features, "avx", true);
2005 setFeatureEnabled(Features, "aes", true);
2006 setFeatureEnabled(Features, "pclmul", true);
2007 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002008 case CK_CoreAVXi:
Craig Topperfd936302012-04-26 07:31:30 +00002009 setFeatureEnabled(Features, "avx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00002010 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00002011 setFeatureEnabled(Features, "pclmul", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00002012 setFeatureEnabled(Features, "rdrnd", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002013 setFeatureEnabled(Features, "f16c", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002014 break;
Craig Topper2b03bb02011-12-17 19:55:21 +00002015 case CK_CoreAVX2:
Craig Topperfd936302012-04-26 07:31:30 +00002016 setFeatureEnabled(Features, "avx2", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00002017 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00002018 setFeatureEnabled(Features, "pclmul", true);
Craig Topper31ceea02011-12-25 05:06:45 +00002019 setFeatureEnabled(Features, "lzcnt", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00002020 setFeatureEnabled(Features, "rdrnd", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002021 setFeatureEnabled(Features, "f16c", true);
Craig Topper31ceea02011-12-25 05:06:45 +00002022 setFeatureEnabled(Features, "bmi", true);
2023 setFeatureEnabled(Features, "bmi2", true);
Michael Liao463eb892012-11-10 05:17:46 +00002024 setFeatureEnabled(Features, "rtm", true);
Craig Topper2ae95072012-06-03 21:46:30 +00002025 setFeatureEnabled(Features, "fma", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00002026 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002027 case CK_K6:
2028 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002029 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002030 break;
2031 case CK_K6_2:
2032 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002033 case CK_WinChip2:
2034 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002035 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002036 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00002037 case CK_Athlon:
2038 case CK_AthlonThunderbird:
2039 case CK_Geode:
2040 setFeatureEnabled(Features, "3dnowa", true);
2041 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002042 case CK_Athlon4:
2043 case CK_AthlonXP:
2044 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002045 setFeatureEnabled(Features, "sse", true);
2046 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002047 break;
2048 case CK_K8:
2049 case CK_Opteron:
2050 case CK_Athlon64:
2051 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00002052 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002053 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002054 break;
2055 case CK_K8SSE3:
2056 case CK_OpteronSSE3:
2057 case CK_Athlon64SSE3:
Roman Divacky80b32b82011-10-30 13:47:56 +00002058 setFeatureEnabled(Features, "sse3", true);
2059 setFeatureEnabled(Features, "3dnowa", true);
2060 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002061 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00002062 setFeatureEnabled(Features, "sse3", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00002063 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00002064 setFeatureEnabled(Features, "3dnowa", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002065 setFeatureEnabled(Features, "lzcnt", true);
2066 setFeatureEnabled(Features, "popcnt", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002067 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002068 case CK_BTVER1:
2069 setFeatureEnabled(Features, "ssse3", true);
2070 setFeatureEnabled(Features, "sse4a", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002071 setFeatureEnabled(Features, "lzcnt", true);
2072 setFeatureEnabled(Features, "popcnt", true);
Craig Topper90ea0362012-05-30 05:54:54 +00002073 break;
Benjamin Kramer63063f52013-05-03 10:47:15 +00002074 case CK_BTVER2:
2075 setFeatureEnabled(Features, "avx", true);
2076 setFeatureEnabled(Features, "sse4a", true);
2077 setFeatureEnabled(Features, "lzcnt", true);
2078 setFeatureEnabled(Features, "aes", true);
2079 setFeatureEnabled(Features, "pclmul", true);
2080 setFeatureEnabled(Features, "bmi", true);
2081 setFeatureEnabled(Features, "f16c", true);
2082 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002083 case CK_BDVER1:
Craig Topperb6af69e2012-06-09 22:24:14 +00002084 setFeatureEnabled(Features, "xop", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002085 setFeatureEnabled(Features, "lzcnt", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002086 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00002087 setFeatureEnabled(Features, "pclmul", true);
Eli Friedmanf5824992012-11-26 21:57:28 +00002088 break;
Eli Friedmanfaf35382012-11-17 01:43:10 +00002089 case CK_BDVER2:
2090 setFeatureEnabled(Features, "xop", true);
2091 setFeatureEnabled(Features, "lzcnt", true);
2092 setFeatureEnabled(Features, "aes", true);
2093 setFeatureEnabled(Features, "pclmul", true);
2094 setFeatureEnabled(Features, "bmi", true);
2095 setFeatureEnabled(Features, "fma", true);
2096 setFeatureEnabled(Features, "f16c", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002097 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002098 case CK_C3_2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002099 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002100 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002101 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002102}
2103
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002104bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00002105 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002106 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00002107 // FIXME: This *really* should not be here. We need some way of translating
2108 // options into llvm subtarget features.
2109 if (!Features.count(Name) &&
Benjamin Kramer84f30802012-07-07 09:39:18 +00002110 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1" &&
2111 Name != "rdrnd"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002112 return false;
2113
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002114 // FIXME: this should probably use a switch with fall through.
2115
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002116 if (Enabled) {
2117 if (Name == "mmx")
2118 Features["mmx"] = true;
2119 else if (Name == "sse")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002120 Features["mmx"] = Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002121 else if (Name == "sse2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002122 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002123 else if (Name == "sse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002124 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2125 true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002126 else if (Name == "ssse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002127 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002128 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00002129 else if (Name == "sse4" || Name == "sse4.2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002130 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002131 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2132 Features["popcnt"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00002133 else if (Name == "sse4.1")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002134 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00002135 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002136 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002137 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002138 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002139 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00002140 else if (Name == "aes")
Craig Toppera7463c32012-06-03 21:56:22 +00002141 Features["sse"] = Features["sse2"] = Features["aes"] = true;
Craig Topper3c0bc152012-05-31 05:18:48 +00002142 else if (Name == "pclmul")
Craig Toppera7463c32012-06-03 21:56:22 +00002143 Features["sse"] = Features["sse2"] = Features["pclmul"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002144 else if (Name == "avx")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002145 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2146 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002147 Features["popcnt"] = Features["avx"] = true;
Craig Topper2b03bb02011-12-17 19:55:21 +00002148 else if (Name == "avx2")
2149 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2150 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002151 Features["popcnt"] = Features["avx"] = Features["avx2"] = true;
Craig Topper2ae95072012-06-03 21:46:30 +00002152 else if (Name == "fma")
2153 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2154 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2155 Features["popcnt"] = Features["avx"] = Features["fma"] = true;
Craig Topper6a511e12011-12-30 07:33:42 +00002156 else if (Name == "fma4")
Eli Friedman612db2a2012-11-17 01:16:19 +00002157 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00002158 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper90ea0362012-05-30 05:54:54 +00002159 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
2160 Features["fma4"] = true;
Craig Topperb6af69e2012-06-09 22:24:14 +00002161 else if (Name == "xop")
Eli Friedman612db2a2012-11-17 01:16:19 +00002162 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002163 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2164 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
2165 Features["fma4"] = Features["xop"] = true;
Roman Divacky80b32b82011-10-30 13:47:56 +00002166 else if (Name == "sse4a")
Craig Topper6a511e12011-12-30 07:33:42 +00002167 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper90ea0362012-05-30 05:54:54 +00002168 Features["sse4a"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00002169 else if (Name == "lzcnt")
2170 Features["lzcnt"] = true;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002171 else if (Name == "rdrnd")
2172 Features["rdrand"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00002173 else if (Name == "bmi")
2174 Features["bmi"] = true;
2175 else if (Name == "bmi2")
2176 Features["bmi2"] = true;
Craig Toppere14e08b2011-12-29 16:10:46 +00002177 else if (Name == "popcnt")
2178 Features["popcnt"] = true;
Manman Ren146e5a42012-10-11 00:59:55 +00002179 else if (Name == "f16c")
2180 Features["f16c"] = true;
Michael Liao463eb892012-11-10 05:17:46 +00002181 else if (Name == "rtm")
2182 Features["rtm"] = true;
Michael Liao72339a02013-03-26 17:52:08 +00002183 else if (Name == "prfchw")
2184 Features["prfchw"] = true;
Michael Liao1bfc28c2013-03-29 05:17:55 +00002185 else if (Name == "rdseed")
2186 Features["rdseed"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002187 } else {
2188 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002189 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002190 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00002191 Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00002192 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002193 Features["sse4a"] = Features["avx"] = Features["avx2"] =
2194 Features["fma"] = Features["fma4"] = Features["aes"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002195 Features["pclmul"] = Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002196 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00002197 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Craig Toppera7463c32012-06-03 21:56:22 +00002198 Features["sse41"] = Features["sse42"] = Features["sse4a"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002199 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002200 Features["fma4"] = Features["aes"] = Features["pclmul"] =
2201 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002202 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00002203 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002204 Features["sse42"] = Features["sse4a"] = Features["avx"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002205 Features["avx2"] = Features["fma"] = Features["fma4"] =
2206 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002207 else if (Name == "ssse3")
Craig Topper31380fb2012-06-03 22:23:42 +00002208 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2209 Features["avx"] = Features["avx2"] = Features["fma"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00002210 else if (Name == "sse4" || Name == "sse4.1")
Craig Topper31380fb2012-06-03 22:23:42 +00002211 Features["sse41"] = Features["sse42"] = Features["avx"] =
2212 Features["avx2"] = Features["fma"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00002213 else if (Name == "sse4.2")
Craig Topper31380fb2012-06-03 22:23:42 +00002214 Features["sse42"] = Features["avx"] = Features["avx2"] =
2215 Features["fma"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002216 else if (Name == "3dnow")
2217 Features["3dnow"] = Features["3dnowa"] = false;
2218 else if (Name == "3dnowa")
2219 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00002220 else if (Name == "aes")
2221 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00002222 else if (Name == "pclmul")
2223 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002224 else if (Name == "avx")
Craig Topper2ae95072012-06-03 21:46:30 +00002225 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002226 Features["fma4"] = Features["xop"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00002227 else if (Name == "avx2")
2228 Features["avx2"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00002229 else if (Name == "fma")
2230 Features["fma"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00002231 else if (Name == "sse4a")
Craig Topperb6af69e2012-06-09 22:24:14 +00002232 Features["sse4a"] = Features["fma4"] = Features["xop"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002233 else if (Name == "lzcnt")
2234 Features["lzcnt"] = false;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002235 else if (Name == "rdrnd")
2236 Features["rdrand"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002237 else if (Name == "bmi")
2238 Features["bmi"] = false;
2239 else if (Name == "bmi2")
2240 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00002241 else if (Name == "popcnt")
2242 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00002243 else if (Name == "fma4")
Craig Topperb6af69e2012-06-09 22:24:14 +00002244 Features["fma4"] = Features["xop"] = false;
2245 else if (Name == "xop")
2246 Features["xop"] = false;
Manman Ren146e5a42012-10-11 00:59:55 +00002247 else if (Name == "f16c")
2248 Features["f16c"] = false;
Michael Liao463eb892012-11-10 05:17:46 +00002249 else if (Name == "rtm")
2250 Features["rtm"] = false;
Michael Liao72339a02013-03-26 17:52:08 +00002251 else if (Name == "prfchw")
2252 Features["prfchw"] = false;
Michael Liao1bfc28c2013-03-29 05:17:55 +00002253 else if (Name == "rdseed")
2254 Features["rdseed"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002255 }
2256
2257 return true;
2258}
2259
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002260/// HandleTargetOptions - Perform initialization based on the user
2261/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00002262void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002263 // Remember the maximum enabled sselevel.
2264 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
2265 // Ignore disabled features.
2266 if (Features[i][0] == '-')
2267 continue;
2268
Benjamin Kramer713575a2012-03-05 15:10:44 +00002269 StringRef Feature = StringRef(Features[i]).substr(1);
2270
2271 if (Feature == "aes") {
Eric Christophereea12d12010-04-02 23:50:19 +00002272 HasAES = true;
2273 continue;
2274 }
2275
Craig Topper3c0bc152012-05-31 05:18:48 +00002276 if (Feature == "pclmul") {
2277 HasPCLMUL = true;
2278 continue;
2279 }
2280
Benjamin Kramer713575a2012-03-05 15:10:44 +00002281 if (Feature == "lzcnt") {
Craig Topper31ceea02011-12-25 05:06:45 +00002282 HasLZCNT = true;
2283 continue;
2284 }
2285
Benjamin Kramer84f30802012-07-07 09:39:18 +00002286 if (Feature == "rdrand") {
2287 HasRDRND = true;
2288 continue;
2289 }
2290
Benjamin Kramer713575a2012-03-05 15:10:44 +00002291 if (Feature == "bmi") {
Craig Topper31ceea02011-12-25 05:06:45 +00002292 HasBMI = true;
2293 continue;
2294 }
2295
Benjamin Kramer713575a2012-03-05 15:10:44 +00002296 if (Feature == "bmi2") {
Craig Topper31ceea02011-12-25 05:06:45 +00002297 HasBMI2 = true;
2298 continue;
2299 }
2300
Benjamin Kramer713575a2012-03-05 15:10:44 +00002301 if (Feature == "popcnt") {
Craig Toppere14e08b2011-12-29 16:10:46 +00002302 HasPOPCNT = true;
2303 continue;
2304 }
2305
Michael Liao463eb892012-11-10 05:17:46 +00002306 if (Feature == "rtm") {
2307 HasRTM = true;
2308 continue;
2309 }
2310
Michael Liao72339a02013-03-26 17:52:08 +00002311 if (Feature == "prfchw") {
2312 HasPRFCHW = true;
2313 continue;
2314 }
2315
Michael Liao1bfc28c2013-03-29 05:17:55 +00002316 if (Feature == "rdseed") {
2317 HasRDSEED = true;
2318 continue;
2319 }
2320
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002321 if (Feature == "sse4a") {
2322 HasSSE4a = true;
2323 continue;
2324 }
2325
Benjamin Kramer713575a2012-03-05 15:10:44 +00002326 if (Feature == "fma4") {
Craig Topper6a511e12011-12-30 07:33:42 +00002327 HasFMA4 = true;
2328 continue;
2329 }
2330
Craig Topper2ae95072012-06-03 21:46:30 +00002331 if (Feature == "fma") {
2332 HasFMA = true;
2333 continue;
2334 }
2335
Craig Topperb6af69e2012-06-09 22:24:14 +00002336 if (Feature == "xop") {
2337 HasXOP = true;
2338 continue;
2339 }
2340
Manman Ren146e5a42012-10-11 00:59:55 +00002341 if (Feature == "f16c") {
2342 HasF16C = true;
2343 continue;
2344 }
2345
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002346 assert(Features[i][0] == '+' && "Invalid target feature!");
Benjamin Kramer713575a2012-03-05 15:10:44 +00002347 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Craig Topper05fe4b52012-01-09 09:19:09 +00002348 .Case("avx2", AVX2)
2349 .Case("avx", AVX)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002350 .Case("sse42", SSE42)
2351 .Case("sse41", SSE41)
2352 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00002353 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002354 .Case("sse2", SSE2)
2355 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002356 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002357 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002358
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002359 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer713575a2012-03-05 15:10:44 +00002360 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002361 .Case("3dnowa", AMD3DNowAthlon)
2362 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002363 .Case("mmx", MMX)
2364 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002365
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002366 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002367 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002368
2369 // Don't tell the backend if we're turning off mmx; it will end up disabling
2370 // SSE, which we don't want.
2371 std::vector<std::string>::iterator it;
2372 it = std::find(Features.begin(), Features.end(), "-mmx");
2373 if (it != Features.end())
2374 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00002375}
Chris Lattnerc0f59212009-03-02 22:27:17 +00002376
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002377/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
2378/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00002379void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002380 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002381 // Target identification.
Derek Schuffbabaf312012-10-11 15:52:22 +00002382 if (getTriple().getArch() == llvm::Triple::x86_64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002383 Builder.defineMacro("__amd64__");
2384 Builder.defineMacro("__amd64");
2385 Builder.defineMacro("__x86_64");
2386 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002387 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00002388 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00002389 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002390
Chris Lattnerc0f59212009-03-02 22:27:17 +00002391 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002392 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
2393 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002394 switch (CPU) {
2395 case CK_Generic:
2396 break;
2397 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002398 // The rest are coming from the i386 define above.
2399 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002400 break;
2401 case CK_i486:
2402 case CK_WinChipC6:
2403 case CK_WinChip2:
2404 case CK_C3:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002405 defineCPUMacros(Builder, "i486");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002406 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00002407 case CK_PentiumMMX:
2408 Builder.defineMacro("__pentium_mmx__");
2409 Builder.defineMacro("__tune_pentium_mmx__");
2410 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002411 case CK_i586:
2412 case CK_Pentium:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002413 defineCPUMacros(Builder, "i586");
2414 defineCPUMacros(Builder, "pentium");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002415 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002416 case CK_Pentium3:
2417 case CK_Pentium3M:
2418 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002419 Builder.defineMacro("__tune_pentium3__");
2420 // Fallthrough
2421 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002422 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002423 Builder.defineMacro("__tune_pentium2__");
2424 // Fallthrough
2425 case CK_PentiumPro:
2426 Builder.defineMacro("__tune_i686__");
2427 Builder.defineMacro("__tune_pentiumpro__");
2428 // Fallthrough
2429 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002430 Builder.defineMacro("__i686");
2431 Builder.defineMacro("__i686__");
2432 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
2433 Builder.defineMacro("__pentiumpro");
2434 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002435 break;
2436 case CK_Pentium4:
2437 case CK_Pentium4M:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002438 defineCPUMacros(Builder, "pentium4");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002439 break;
2440 case CK_Yonah:
2441 case CK_Prescott:
2442 case CK_Nocona:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002443 defineCPUMacros(Builder, "nocona");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002444 break;
2445 case CK_Core2:
2446 case CK_Penryn:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002447 defineCPUMacros(Builder, "core2");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002448 break;
2449 case CK_Atom:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002450 defineCPUMacros(Builder, "atom");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002451 break;
2452 case CK_Corei7:
2453 case CK_Corei7AVX:
2454 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00002455 case CK_CoreAVX2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002456 defineCPUMacros(Builder, "corei7");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002457 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002458 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002459 Builder.defineMacro("__k6_2__");
2460 Builder.defineMacro("__tune_k6_2__");
2461 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002462 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002463 if (CPU != CK_K6_2) { // In case of fallthrough
2464 // FIXME: GCC may be enabling these in cases where some other k6
2465 // architecture is specified but -m3dnow is explicitly provided. The
2466 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002467 Builder.defineMacro("__k6_3__");
2468 Builder.defineMacro("__tune_k6_3__");
2469 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00002470 // Fallthrough
2471 case CK_K6:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002472 defineCPUMacros(Builder, "k6");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002473 break;
2474 case CK_Athlon:
2475 case CK_AthlonThunderbird:
2476 case CK_Athlon4:
2477 case CK_AthlonXP:
2478 case CK_AthlonMP:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002479 defineCPUMacros(Builder, "athlon");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002480 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002481 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002482 Builder.defineMacro("__tune_athlon_sse__");
2483 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002484 break;
2485 case CK_K8:
2486 case CK_K8SSE3:
2487 case CK_x86_64:
2488 case CK_Opteron:
2489 case CK_OpteronSSE3:
2490 case CK_Athlon64:
2491 case CK_Athlon64SSE3:
2492 case CK_AthlonFX:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002493 defineCPUMacros(Builder, "k8");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002494 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002495 case CK_AMDFAM10:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002496 defineCPUMacros(Builder, "amdfam10");
Roman Divacky01c770d2011-10-30 07:48:46 +00002497 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002498 case CK_BTVER1:
2499 defineCPUMacros(Builder, "btver1");
2500 break;
Benjamin Kramer63063f52013-05-03 10:47:15 +00002501 case CK_BTVER2:
2502 defineCPUMacros(Builder, "btver2");
2503 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002504 case CK_BDVER1:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002505 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002506 break;
2507 case CK_BDVER2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002508 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002509 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002510 case CK_Geode:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002511 defineCPUMacros(Builder, "geode");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002512 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002513 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00002514
Chandler Carruth88c75b02011-09-28 09:54:07 +00002515 // Target properties.
2516 Builder.defineMacro("__LITTLE_ENDIAN__");
2517 Builder.defineMacro("__REGISTER_PREFIX__", "");
2518
Chris Lattner54175442009-04-19 17:32:33 +00002519 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2520 // functions in glibc header files that use FP Stack inline asm which the
2521 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00002522 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002523
Chandler Carruth88c75b02011-09-28 09:54:07 +00002524 if (HasAES)
2525 Builder.defineMacro("__AES__");
2526
Craig Topper3c0bc152012-05-31 05:18:48 +00002527 if (HasPCLMUL)
2528 Builder.defineMacro("__PCLMUL__");
2529
Craig Topper31ceea02011-12-25 05:06:45 +00002530 if (HasLZCNT)
2531 Builder.defineMacro("__LZCNT__");
2532
Benjamin Kramer84f30802012-07-07 09:39:18 +00002533 if (HasRDRND)
2534 Builder.defineMacro("__RDRND__");
2535
Craig Topper31ceea02011-12-25 05:06:45 +00002536 if (HasBMI)
2537 Builder.defineMacro("__BMI__");
2538
2539 if (HasBMI2)
2540 Builder.defineMacro("__BMI2__");
2541
Craig Toppere14e08b2011-12-29 16:10:46 +00002542 if (HasPOPCNT)
2543 Builder.defineMacro("__POPCNT__");
2544
Michael Liao463eb892012-11-10 05:17:46 +00002545 if (HasRTM)
2546 Builder.defineMacro("__RTM__");
2547
Michael Liao72339a02013-03-26 17:52:08 +00002548 if (HasPRFCHW)
2549 Builder.defineMacro("__PRFCHW__");
2550
Michael Liao1bfc28c2013-03-29 05:17:55 +00002551 if (HasRDSEED)
2552 Builder.defineMacro("__RDSEED__");
2553
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002554 if (HasSSE4a)
2555 Builder.defineMacro("__SSE4A__");
2556
Craig Topper6a511e12011-12-30 07:33:42 +00002557 if (HasFMA4)
2558 Builder.defineMacro("__FMA4__");
2559
Craig Topper2ae95072012-06-03 21:46:30 +00002560 if (HasFMA)
2561 Builder.defineMacro("__FMA__");
2562
Craig Topperb6af69e2012-06-09 22:24:14 +00002563 if (HasXOP)
2564 Builder.defineMacro("__XOP__");
2565
Manman Ren146e5a42012-10-11 00:59:55 +00002566 if (HasF16C)
2567 Builder.defineMacro("__F16C__");
2568
Chris Lattner84f0ea82009-03-02 22:40:39 +00002569 // Each case falls through to the previous one here.
2570 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002571 case AVX2:
2572 Builder.defineMacro("__AVX2__");
2573 case AVX:
2574 Builder.defineMacro("__AVX__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002575 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00002576 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002577 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00002578 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002579 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002580 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002581 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002582 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002583 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00002584 Builder.defineMacro("__SSE2__");
2585 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00002586 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00002587 Builder.defineMacro("__SSE__");
2588 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002589 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00002590 break;
2591 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002592
Derek Schuffbabaf312012-10-11 15:52:22 +00002593 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002594 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002595 case AVX2:
2596 case AVX:
Michael J. Spencera764e832010-10-21 08:22:51 +00002597 case SSE42:
2598 case SSE41:
2599 case SSSE3:
2600 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002601 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002602 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002603 break;
2604 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002605 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002606 break;
2607 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002608 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002609 }
2610 }
2611
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002612 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002613 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002614 case AMD3DNowAthlon:
2615 Builder.defineMacro("__3dNOW_A__");
2616 case AMD3DNow:
2617 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002618 case MMX:
2619 Builder.defineMacro("__MMX__");
2620 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002621 break;
2622 }
Michael J. Spencerd1b33942013-04-04 23:53:43 +00002623
2624 if (CPU >= CK_i486) {
2625 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
2626 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
2627 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
2628 }
2629 if (CPU >= CK_i586)
2630 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002631}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002632
Douglas Gregore727d212012-01-30 06:38:25 +00002633bool X86TargetInfo::hasFeature(StringRef Feature) const {
2634 return llvm::StringSwitch<bool>(Feature)
2635 .Case("aes", HasAES)
2636 .Case("avx", SSELevel >= AVX)
2637 .Case("avx2", SSELevel >= AVX2)
2638 .Case("bmi", HasBMI)
2639 .Case("bmi2", HasBMI2)
Craig Topper2ae95072012-06-03 21:46:30 +00002640 .Case("fma", HasFMA)
Douglas Gregore727d212012-01-30 06:38:25 +00002641 .Case("fma4", HasFMA4)
2642 .Case("lzcnt", HasLZCNT)
Benjamin Kramer84f30802012-07-07 09:39:18 +00002643 .Case("rdrnd", HasRDRND)
Douglas Gregore727d212012-01-30 06:38:25 +00002644 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
2645 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
2646 .Case("mmx", MMX3DNowLevel >= MMX)
Craig Topper3c0bc152012-05-31 05:18:48 +00002647 .Case("pclmul", HasPCLMUL)
Douglas Gregore727d212012-01-30 06:38:25 +00002648 .Case("popcnt", HasPOPCNT)
Michael Liao463eb892012-11-10 05:17:46 +00002649 .Case("rtm", HasRTM)
Michael Liao72339a02013-03-26 17:52:08 +00002650 .Case("prfchw", HasPRFCHW)
Michael Liao1bfc28c2013-03-29 05:17:55 +00002651 .Case("rdseed", HasRDSEED)
Douglas Gregore727d212012-01-30 06:38:25 +00002652 .Case("sse", SSELevel >= SSE1)
2653 .Case("sse2", SSELevel >= SSE2)
2654 .Case("sse3", SSELevel >= SSE3)
2655 .Case("ssse3", SSELevel >= SSSE3)
2656 .Case("sse41", SSELevel >= SSE41)
2657 .Case("sse42", SSELevel >= SSE42)
Craig Topper3c0bc152012-05-31 05:18:48 +00002658 .Case("sse4a", HasSSE4a)
Douglas Gregore727d212012-01-30 06:38:25 +00002659 .Case("x86", true)
Derek Schuffbabaf312012-10-11 15:52:22 +00002660 .Case("x86_32", getTriple().getArch() == llvm::Triple::x86)
2661 .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64)
Craig Topperb6af69e2012-06-09 22:24:14 +00002662 .Case("xop", HasXOP)
Manman Ren146e5a42012-10-11 00:59:55 +00002663 .Case("f16c", HasF16C)
Douglas Gregore727d212012-01-30 06:38:25 +00002664 .Default(false);
2665}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002666
Eli Friedman618234a2008-08-20 02:34:37 +00002667bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002668X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002669 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002670 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00002671 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00002672 case 'Y': // first letter of a pair:
2673 switch (*(Name+1)) {
2674 default: return false;
2675 case '0': // First SSE register.
2676 case 't': // Any SSE register, when SSE2 is enabled.
2677 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2678 case 'm': // any MMX register, when inter-unit moves enabled.
2679 break; // falls through to setAllowsRegister.
2680 }
Eli Friedman618234a2008-08-20 02:34:37 +00002681 case 'a': // eax.
2682 case 'b': // ebx.
2683 case 'c': // ecx.
2684 case 'd': // edx.
2685 case 'S': // esi.
2686 case 'D': // edi.
2687 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00002688 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00002689 case 't': // top of floating point stack.
2690 case 'u': // second from top of floating point stack.
2691 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00002692 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00002693 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00002694 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00002695 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2696 case 'l': // "Index" registers: any general register that can be used as an
2697 // index in a base+index memory access.
2698 Info.setAllowsRegister();
2699 return true;
2700 case 'C': // SSE floating point constant.
2701 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002702 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002703 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002704 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002705 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00002706 return true;
2707 }
2708}
2709
Dale Johannesenf6e2c202010-10-29 23:12:32 +00002710
Eli Friedman618234a2008-08-20 02:34:37 +00002711std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00002712X86TargetInfo::convertConstraint(const char *&Constraint) const {
2713 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00002714 case 'a': return std::string("{ax}");
2715 case 'b': return std::string("{bx}");
2716 case 'c': return std::string("{cx}");
2717 case 'd': return std::string("{dx}");
2718 case 'S': return std::string("{si}");
2719 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00002720 case 'p': // address
2721 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00002722 case 't': // top of floating point stack.
2723 return std::string("{st}");
2724 case 'u': // second from top of floating point stack.
2725 return std::string("{st(1)}"); // second from top of floating point stack.
2726 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00002727 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00002728 }
2729}
Eli Friedman618234a2008-08-20 02:34:37 +00002730} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00002731
2732namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002733// X86-32 generic target
2734class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00002735public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002736 X86_32TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002737 DoubleAlign = LongLongAlign = 32;
2738 LongDoubleWidth = 96;
2739 LongDoubleAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00002740 SuitableAlign = 128;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002741 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2742 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00002743 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00002744 SizeType = UnsignedInt;
2745 PtrDiffType = SignedInt;
2746 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002747 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002748
2749 // Use fpret for all types.
2750 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2751 (1 << TargetInfo::Double) |
2752 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002753
2754 // x86-32 has atomics up to 8 bytes
2755 // FIXME: Check that we actually have cmpxchg8b before setting
2756 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2757 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002758 }
Meador Ingec5613b22012-06-16 03:34:49 +00002759 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2760 return TargetInfo::CharPtrBuiltinVaList;
Eli Friedman618234a2008-08-20 02:34:37 +00002761 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002762
Chris Lattner21fb98e2009-09-23 06:06:36 +00002763 int getEHDataRegisterNumber(unsigned RegNo) const {
2764 if (RegNo == 0) return 0;
2765 if (RegNo == 1) return 2;
2766 return -1;
2767 }
Bill Wendling68fd6082012-11-12 06:42:51 +00002768 virtual bool validateInputSize(StringRef Constraint,
2769 unsigned Size) const {
2770 switch (Constraint[0]) {
2771 default: break;
2772 case 'a':
2773 case 'b':
2774 case 'c':
2775 case 'd':
Bill Wendlingf634bdf2012-11-12 18:52:32 +00002776 return Size <= 32;
Bill Wendling68fd6082012-11-12 06:42:51 +00002777 }
2778
2779 return true;
2780 }
Eli Friedman618234a2008-08-20 02:34:37 +00002781};
2782} // end anonymous namespace
2783
2784namespace {
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002785class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
2786public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002787 NetBSDI386TargetInfo(const llvm::Triple &Triple)
2788 : NetBSDTargetInfo<X86_32TargetInfo>(Triple) {}
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002789
2790 virtual unsigned getFloatEvalMethod() const {
2791 // NetBSD defaults to "double" rounding
2792 return 1;
2793 }
2794};
2795} // end anonymous namespace
2796
2797namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002798class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2799public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002800 OpenBSDI386TargetInfo(const llvm::Triple &Triple)
2801 : OpenBSDTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman624c1462009-07-05 18:47:56 +00002802 SizeType = UnsignedLong;
2803 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002804 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002805 }
2806};
2807} // end anonymous namespace
2808
2809namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00002810class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
2811public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002812 BitrigI386TargetInfo(const llvm::Triple &Triple)
2813 : BitrigTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman42f74f22012-08-08 23:57:20 +00002814 SizeType = UnsignedLong;
2815 IntPtrType = SignedLong;
2816 PtrDiffType = SignedLong;
2817 }
2818};
2819} // end anonymous namespace
2820
2821namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002822class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002823public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002824 DarwinI386TargetInfo(const llvm::Triple &Triple)
2825 : DarwinTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002826 LongDoubleWidth = 128;
2827 LongDoubleAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002828 SuitableAlign = 128;
Chad Rosierf9e9af72012-07-13 23:57:43 +00002829 MaxVectorAlign = 256;
Eli Friedman1afabd92009-03-29 20:31:09 +00002830 SizeType = UnsignedLong;
2831 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002832 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2833 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002834 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002835 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002836 }
2837
Eli Friedman618234a2008-08-20 02:34:37 +00002838};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002839} // end anonymous namespace
2840
2841namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002842// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002843class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002844public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002845 WindowsX86_32TargetInfo(const llvm::Triple &Triple)
2846 : WindowsTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002847 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002848 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002849 DoubleAlign = LongLongAlign = 64;
2850 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 +00002851 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002852 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002853 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002854 virtual void getTargetDefines(const LangOptions &Opts,
2855 MacroBuilder &Builder) const {
2856 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2857 }
2858};
2859} // end anonymous namespace
2860
2861namespace {
2862
2863// x86-32 Windows Visual Studio target
2864class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2865public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002866 VisualStudioWindowsX86_32TargetInfo(const llvm::Triple &Triple)
2867 : WindowsX86_32TargetInfo(Triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002868 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002869 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2870 }
2871 virtual void getTargetDefines(const LangOptions &Opts,
2872 MacroBuilder &Builder) const {
2873 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2874 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2875 // The value of the following reflects processor type.
2876 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2877 // We lost the original triple, so we use the default.
2878 Builder.defineMacro("_M_IX86", "600");
2879 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002880};
2881} // end anonymous namespace
2882
2883namespace {
2884// x86-32 MinGW target
2885class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2886public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002887 MinGWX86_32TargetInfo(const llvm::Triple &Triple)
2888 : WindowsX86_32TargetInfo(Triple) {}
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002889 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002890 MacroBuilder &Builder) const {
2891 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002892 DefineStd(Builder, "WIN32", Opts);
2893 DefineStd(Builder, "WINNT", Opts);
2894 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002895 Builder.defineMacro("__MSVCRT__");
2896 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002897
2898 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2899 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002900 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002901 // Provide "as-is" __declspec.
2902 Builder.defineMacro("__declspec", "__declspec");
2903 else
2904 // Provide alias of __attribute__ like mingw32-gcc.
2905 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002906 }
2907};
2908} // end anonymous namespace
2909
2910namespace {
2911// x86-32 Cygwin target
2912class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2913public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002914 CygwinX86_32TargetInfo(const llvm::Triple &Triple)
2915 : X86_32TargetInfo(Triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002916 TLSSupported = false;
2917 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002918 DoubleAlign = LongLongAlign = 64;
2919 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2920 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002921 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002922 }
2923 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002924 MacroBuilder &Builder) const {
2925 X86_32TargetInfo::getTargetDefines(Opts, Builder);
NAKAMURA Takumie72f4d92012-12-14 10:17:26 +00002926 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002927 Builder.defineMacro("__CYGWIN__");
2928 Builder.defineMacro("__CYGWIN32__");
2929 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00002930 if (Opts.CPlusPlus)
2931 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00002932 }
Eli Friedman29a30502008-08-21 01:40:19 +00002933};
2934} // end anonymous namespace
2935
2936namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002937// x86-32 Haiku target
2938class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2939public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002940 HaikuX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002941 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00002942 IntPtrType = SignedLong;
2943 PtrDiffType = SignedLong;
Eli Friedman6902e412012-11-27 02:58:24 +00002944 ProcessIDType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00002945 this->UserLabelPrefix = "";
Benjamin Krameref7bcea2012-11-08 12:59:15 +00002946 this->TLSSupported = false;
Eli Friedmana7e68452010-08-22 01:00:03 +00002947 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00002948 virtual void getTargetDefines(const LangOptions &Opts,
2949 MacroBuilder &Builder) const {
2950 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2951 Builder.defineMacro("__INTEL__");
2952 Builder.defineMacro("__HAIKU__");
2953 }
2954};
2955} // end anonymous namespace
2956
Douglas Gregordca52262011-07-01 22:41:14 +00002957// RTEMS Target
2958template<typename Target>
2959class RTEMSTargetInfo : public OSTargetInfo<Target> {
2960protected:
2961 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2962 MacroBuilder &Builder) const {
2963 // RTEMS defines; list based off of gcc output
2964
Douglas Gregordca52262011-07-01 22:41:14 +00002965 Builder.defineMacro("__rtems__");
2966 Builder.defineMacro("__ELF__");
2967 }
Benjamin Kramer9df08232013-06-29 16:37:14 +00002968
Douglas Gregordca52262011-07-01 22:41:14 +00002969public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002970 RTEMSTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
2971 this->UserLabelPrefix = "";
Douglas Gregordca52262011-07-01 22:41:14 +00002972
Benjamin Kramer9df08232013-06-29 16:37:14 +00002973 switch (Triple.getArch()) {
2974 default:
2975 case llvm::Triple::x86:
2976 // this->MCountName = ".mcount";
2977 break;
2978 case llvm::Triple::mips:
2979 case llvm::Triple::mipsel:
2980 case llvm::Triple::ppc:
2981 case llvm::Triple::ppc64:
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00002982 case llvm::Triple::ppc64le:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002983 // this->MCountName = "_mcount";
2984 break;
2985 case llvm::Triple::arm:
2986 // this->MCountName = "__mcount";
2987 break;
Douglas Gregordca52262011-07-01 22:41:14 +00002988 }
Benjamin Kramer9df08232013-06-29 16:37:14 +00002989 }
Douglas Gregordca52262011-07-01 22:41:14 +00002990};
2991
2992namespace {
2993// x86-32 RTEMS target
2994class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2995public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002996 RTEMSX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Douglas Gregordca52262011-07-01 22:41:14 +00002997 SizeType = UnsignedLong;
2998 IntPtrType = SignedLong;
2999 PtrDiffType = SignedLong;
3000 this->UserLabelPrefix = "";
3001 }
3002 virtual void getTargetDefines(const LangOptions &Opts,
3003 MacroBuilder &Builder) const {
3004 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3005 Builder.defineMacro("__INTEL__");
3006 Builder.defineMacro("__rtems__");
3007 }
3008};
3009} // end anonymous namespace
3010
Chris Lattner86ed3a32010-04-11 19:29:39 +00003011namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00003012// x86-64 generic target
3013class X86_64TargetInfo : public X86TargetInfo {
3014public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003015 X86_64TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00003016 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00003017 LongDoubleWidth = 128;
3018 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00003019 LargeArrayMinWidth = 128;
3020 LargeArrayAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003021 SuitableAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00003022 IntMaxType = SignedLong;
3023 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003024 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00003025 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00003026
Eli Friedmaned855cb2008-08-21 00:13:15 +00003027 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3028 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003029 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00003030
3031 // Use fpret only for long double.
3032 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00003033
Anders Carlssoneea64802011-10-31 16:27:11 +00003034 // Use fp2ret for _Complex long double.
3035 ComplexLongDoubleUsesFP2Ret = true;
3036
Eli Friedman2be46072011-10-14 20:59:01 +00003037 // x86-64 has atomics up to 16 bytes.
3038 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
3039 // on CPUs with cmpxchg16b
3040 MaxAtomicPromoteWidth = 128;
3041 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00003042 }
Meador Ingec5613b22012-06-16 03:34:49 +00003043 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3044 return TargetInfo::X86_64ABIBuiltinVaList;
Anders Carlsson3346ae62007-11-24 23:38:12 +00003045 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00003046
Chris Lattner21fb98e2009-09-23 06:06:36 +00003047 int getEHDataRegisterNumber(unsigned RegNo) const {
3048 if (RegNo == 0) return 0;
3049 if (RegNo == 1) return 1;
3050 return -1;
3051 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00003052
3053 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
Peter Collingbourne7728cdd2013-02-23 00:06:18 +00003054 return (CC == CC_Default ||
3055 CC == CC_C ||
3056 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballman82bfa192012-10-02 14:26:08 +00003057 }
3058
Aaron Ballmanfff32482012-12-09 17:45:41 +00003059 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {
3060 return CC_C;
Aaron Ballman82bfa192012-10-02 14:26:08 +00003061 }
3062
Eli Friedman618234a2008-08-20 02:34:37 +00003063};
3064} // end anonymous namespace
3065
3066namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003067// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003068class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003069public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003070 WindowsX86_64TargetInfo(const llvm::Triple &Triple)
3071 : WindowsTargetInfo<X86_64TargetInfo>(Triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003072 TLSSupported = false;
3073 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00003074 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00003075 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00003076 IntMaxType = SignedLongLong;
3077 UIntMaxType = UnsignedLongLong;
3078 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00003079 SizeType = UnsignedLongLong;
3080 PtrDiffType = SignedLongLong;
3081 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00003082 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003083 }
3084 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003085 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003086 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003087 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00003088 }
Meador Ingec5613b22012-06-16 03:34:49 +00003089 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3090 return TargetInfo::CharPtrBuiltinVaList;
NAKAMURA Takumi79521992011-01-17 22:56:23 +00003091 }
Michael J. Spencera764e832010-10-21 08:22:51 +00003092};
3093} // end anonymous namespace
3094
3095namespace {
3096// x86-64 Windows Visual Studio target
3097class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
3098public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003099 VisualStudioWindowsX86_64TargetInfo(const llvm::Triple &Triple)
3100 : WindowsX86_64TargetInfo(Triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00003101 LongDoubleWidth = LongDoubleAlign = 64;
3102 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00003103 }
3104 virtual void getTargetDefines(const LangOptions &Opts,
3105 MacroBuilder &Builder) const {
3106 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
3107 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00003108 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003109 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003110 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003111};
3112} // end anonymous namespace
3113
3114namespace {
3115// x86-64 MinGW target
3116class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
3117public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003118 MinGWX86_64TargetInfo(const llvm::Triple &Triple)
3119 : WindowsX86_64TargetInfo(Triple) {}
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003120 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003121 MacroBuilder &Builder) const {
3122 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00003123 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00003124 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00003125 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00003126 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003127
3128 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
3129 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00003130 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003131 // Provide "as-is" __declspec.
3132 Builder.defineMacro("__declspec", "__declspec");
3133 else
3134 // Provide alias of __attribute__ like mingw32-gcc.
3135 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003136 }
3137};
3138} // end anonymous namespace
3139
3140namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003141class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
3142public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003143 DarwinX86_64TargetInfo(const llvm::Triple &Triple)
3144 : DarwinTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003145 Int64Type = SignedLongLong;
Chad Rosierf9e9af72012-07-13 23:57:43 +00003146 MaxVectorAlign = 256;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003147 }
3148};
3149} // end anonymous namespace
3150
3151namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00003152class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
3153public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003154 OpenBSDX86_64TargetInfo(const llvm::Triple &Triple)
3155 : OpenBSDTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman6036ebe2009-07-05 22:31:18 +00003156 IntMaxType = SignedLongLong;
3157 UIntMaxType = UnsignedLongLong;
3158 Int64Type = SignedLongLong;
3159 }
3160};
3161} // end anonymous namespace
3162
3163namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00003164class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
3165public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003166 BitrigX86_64TargetInfo(const llvm::Triple &Triple)
3167 : BitrigTargetInfo<X86_64TargetInfo>(Triple) {
3168 IntMaxType = SignedLongLong;
3169 UIntMaxType = UnsignedLongLong;
3170 Int64Type = SignedLongLong;
Eli Friedman42f74f22012-08-08 23:57:20 +00003171 }
3172};
Tim Northoverc264e162013-01-31 12:13:10 +00003173}
3174
3175namespace {
3176class AArch64TargetInfo : public TargetInfo {
3177 static const char * const GCCRegNames[];
3178 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Tim Northoverff920ee2013-05-04 07:15:13 +00003179
3180 static const Builtin::Info BuiltinInfo[];
Tim Northoverc264e162013-01-31 12:13:10 +00003181public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003182 AArch64TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Tim Northoverc264e162013-01-31 12:13:10 +00003183 BigEndian = false;
3184 LongWidth = LongAlign = 64;
3185 LongDoubleWidth = LongDoubleAlign = 128;
3186 PointerWidth = PointerAlign = 64;
3187 SuitableAlign = 128;
3188 DescriptionString = "e-p:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3189 "i64:64:64-i128:128:128-f32:32:32-f64:64:64-"
3190 "f128:128:128-n32:64-S128";
3191
3192 WCharType = UnsignedInt;
3193 LongDoubleFormat = &llvm::APFloat::IEEEquad;
3194
Tim Northover6a93c862013-02-18 12:11:32 +00003195 // AArch64 backend supports 64-bit operations at the moment. In principle
3196 // 128-bit is possible if register-pairs are used.
3197 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
3198
Tim Northoverc264e162013-01-31 12:13:10 +00003199 TheCXXABI.set(TargetCXXABI::GenericAArch64);
3200 }
3201 virtual void getTargetDefines(const LangOptions &Opts,
3202 MacroBuilder &Builder) const {
3203 // GCC defines theses currently
3204 Builder.defineMacro("__aarch64__");
3205 Builder.defineMacro("__AARCH64EL__");
3206
3207 // ACLE predefines. Many can only have one possible value on v8 AArch64.
3208
3209 // FIXME: these were written based on an unreleased version of a 32-bit ACLE
3210 // which was intended to be compatible with a 64-bit implementation. They
3211 // will need updating when a real 64-bit ACLE exists. Particularly pressing
Tim Northoverdabcbf92013-04-05 14:08:55 +00003212 // instances are: __ARM_ARCH_ISA_ARM, __ARM_ARCH_ISA_THUMB, __ARM_PCS.
3213 Builder.defineMacro("__ARM_ACLE", "101");
3214 Builder.defineMacro("__ARM_ARCH", "8");
3215 Builder.defineMacro("__ARM_ARCH_PROFILE", "'A'");
Tim Northoverc264e162013-01-31 12:13:10 +00003216
Tim Northoverdabcbf92013-04-05 14:08:55 +00003217 Builder.defineMacro("__ARM_FEATURE_UNALIGNED");
3218 Builder.defineMacro("__ARM_FEATURE_CLZ");
3219 Builder.defineMacro("__ARM_FEATURE_FMA");
Tim Northoverc264e162013-01-31 12:13:10 +00003220
3221 // FIXME: ACLE 1.1 reserves bit 4. Will almost certainly come to mean
3222 // 128-bit LDXP present, at which point this becomes 0x1f.
Tim Northoverdabcbf92013-04-05 14:08:55 +00003223 Builder.defineMacro("__ARM_FEATURE_LDREX", "0xf");
Tim Northoverc264e162013-01-31 12:13:10 +00003224
3225 // 0xe implies support for half, single and double precision operations.
Tim Northoverdabcbf92013-04-05 14:08:55 +00003226 Builder.defineMacro("__ARM_FP", "0xe");
Tim Northoverc264e162013-01-31 12:13:10 +00003227
3228 // PCS specifies this for SysV variants, which is all we support. Other ABIs
Tim Northoverdabcbf92013-04-05 14:08:55 +00003229 // may choose __ARM_FP16_FORMAT_ALTERNATIVE.
3230 Builder.defineMacro("__ARM_FP16_FORMAT_IEEE");
Tim Northoverc264e162013-01-31 12:13:10 +00003231
3232 if (Opts.FastMath || Opts.FiniteMathOnly)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003233 Builder.defineMacro("__ARM_FP_FAST");
Tim Northoverc264e162013-01-31 12:13:10 +00003234
3235 if ((Opts.C99 || Opts.C11) && !Opts.Freestanding)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003236 Builder.defineMacro("__ARM_FP_FENV_ROUNDING");
Tim Northoverc264e162013-01-31 12:13:10 +00003237
Tim Northoverdabcbf92013-04-05 14:08:55 +00003238 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
Tim Northoverc264e162013-01-31 12:13:10 +00003239 Opts.ShortWChar ? "2" : "4");
3240
Tim Northoverdabcbf92013-04-05 14:08:55 +00003241 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
Tim Northoverc264e162013-01-31 12:13:10 +00003242 Opts.ShortEnums ? "1" : "4");
3243
3244 if (BigEndian)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003245 Builder.defineMacro("__ARM_BIG_ENDIAN");
Tim Northoverc264e162013-01-31 12:13:10 +00003246 }
3247 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3248 unsigned &NumRecords) const {
Tim Northoverff920ee2013-05-04 07:15:13 +00003249 Records = BuiltinInfo;
3250 NumRecords = clang::AArch64::LastTSBuiltin-Builtin::FirstTSBuiltin;
Tim Northoverc264e162013-01-31 12:13:10 +00003251 }
3252 virtual bool hasFeature(StringRef Feature) const {
3253 return Feature == "aarch64";
3254 }
3255 virtual void getGCCRegNames(const char * const *&Names,
3256 unsigned &NumNames) const;
3257 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3258 unsigned &NumAliases) const;
3259
3260 virtual bool isCLZForZeroUndef() const { return false; }
3261
3262 virtual bool validateAsmConstraint(const char *&Name,
3263 TargetInfo::ConstraintInfo &Info) const {
3264 switch (*Name) {
3265 default: return false;
3266 case 'w': // An FP/SIMD vector register
3267 Info.setAllowsRegister();
3268 return true;
3269 case 'I': // Constant that can be used with an ADD instruction
3270 case 'J': // Constant that can be used with a SUB instruction
3271 case 'K': // Constant that can be used with a 32-bit logical instruction
3272 case 'L': // Constant that can be used with a 64-bit logical instruction
3273 case 'M': // Constant that can be used as a 32-bit MOV immediate
3274 case 'N': // Constant that can be used as a 64-bit MOV immediate
3275 case 'Y': // Floating point constant zero
3276 case 'Z': // Integer constant zero
3277 return true;
3278 case 'Q': // A memory reference with base register and no offset
3279 Info.setAllowsMemory();
3280 return true;
3281 case 'S': // A symbolic address
3282 Info.setAllowsRegister();
3283 return true;
3284 case 'U':
3285 // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes, whatever they may be
3286 // Utf: A memory address suitable for ldp/stp in TF mode, whatever it may be
3287 // Usa: An absolute symbolic address
3288 // Ush: The high part (bits 32:12) of a pc-relative symbolic address
3289 llvm_unreachable("FIXME: Unimplemented support for bizarre constraints");
3290 }
3291 }
3292
3293 virtual const char *getClobbers() const {
3294 // There are no AArch64 clobbers shared by all asm statements.
3295 return "";
3296 }
3297
3298 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3299 return TargetInfo::AArch64ABIBuiltinVaList;
3300 }
3301};
3302
3303const char * const AArch64TargetInfo::GCCRegNames[] = {
3304 "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7",
3305 "w8", "w9", "w10", "w11", "w12", "w13", "w14", "w15",
3306 "w16", "w17", "w18", "w19", "w20", "w21", "w22", "w23",
3307 "w24", "w25", "w26", "w27", "w28", "w29", "w30", "wsp", "wzr",
3308
3309 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
3310 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
3311 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
3312 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp", "xzr",
3313
3314 "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7",
3315 "b8", "b9", "b10", "b11", "b12", "b13", "b14", "b15",
3316 "b16", "b17", "b18", "b19", "b20", "b21", "b22", "b23",
3317 "b24", "b25", "b26", "b27", "b28", "b29", "b30", "b31",
3318
3319 "h0", "h1", "h2", "h3", "h4", "h5", "h6", "h7",
3320 "h8", "h9", "h10", "h11", "h12", "h13", "h14", "h15",
3321 "h16", "h17", "h18", "h19", "h20", "h21", "h22", "h23",
3322 "h24", "h25", "h26", "h27", "h28", "h29", "h30", "h31",
3323
3324 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3325 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3326 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
3327 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
3328
3329 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3330 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
3331 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3332 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
3333
3334 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3335 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15",
3336 "q16", "q17", "q18", "q19", "q20", "q21", "q22", "q23",
3337 "q24", "q25", "q26", "q27", "q28", "q29", "q30", "q31"
3338};
3339
3340void AArch64TargetInfo::getGCCRegNames(const char * const *&Names,
3341 unsigned &NumNames) const {
3342 Names = GCCRegNames;
3343 NumNames = llvm::array_lengthof(GCCRegNames);
3344}
3345
3346const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = {
3347 { { "x16" }, "ip0"},
3348 { { "x17" }, "ip1"},
3349 { { "x29" }, "fp" },
3350 { { "x30" }, "lr" }
3351};
3352
3353void AArch64TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3354 unsigned &NumAliases) const {
3355 Aliases = GCCRegAliases;
3356 NumAliases = llvm::array_lengthof(GCCRegAliases);
3357
3358}
Tim Northoverff920ee2013-05-04 07:15:13 +00003359
3360const Builtin::Info AArch64TargetInfo::BuiltinInfo[] = {
3361#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3362#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3363 ALL_LANGUAGES },
3364#include "clang/Basic/BuiltinsAArch64.def"
3365};
3366
Eli Friedman42f74f22012-08-08 23:57:20 +00003367} // end anonymous namespace
3368
3369namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00003370class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003371 // Possible FPU choices.
3372 enum FPUMode {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003373 VFP2FPU = (1 << 0),
3374 VFP3FPU = (1 << 1),
3375 VFP4FPU = (1 << 2),
3376 NeonFPU = (1 << 3)
Daniel Dunbara91320b2009-12-21 23:28:17 +00003377 };
3378
3379 static bool FPUModeIsVFP(FPUMode Mode) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003380 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU);
Daniel Dunbara91320b2009-12-21 23:28:17 +00003381 }
3382
3383 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3384 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003385
Daniel Dunbareac7c532009-12-18 18:42:37 +00003386 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003387
Bob Wilsoncfaab002012-09-29 23:52:52 +00003388 unsigned FPU : 4;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003389
Logan Chieneae5a8202012-10-10 06:56:20 +00003390 unsigned IsAAPCS : 1;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003391 unsigned IsThumb : 1;
3392
3393 // Initialized via features.
3394 unsigned SoftFloat : 1;
3395 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003396
Chris Lattner2752c012010-03-03 19:03:45 +00003397 static const Builtin::Info BuiltinInfo[];
3398
Rafael Espindola620c0af2013-05-13 20:09:47 +00003399 static bool shouldUseInlineAtomic(const llvm::Triple &T) {
3400 // On linux, binaries targeting old cpus call functions in libgcc to
3401 // perform atomic operations. The implementation in libgcc then calls into
3402 // the kernel which on armv6 and newer uses ldrex and strex. The net result
3403 // is that if we assume the kernel is at least as recent as the hardware,
3404 // it is safe to use atomic instructions on armv6 and newer.
Rafael Espindolae1e03422013-06-17 20:00:15 +00003405 if (T.getOS() != llvm::Triple::Linux &&
3406 T.getOS() != llvm::Triple::FreeBSD &&
3407 T.getOS() != llvm::Triple::Bitrig)
Ed Schouten04491632013-06-15 09:40:14 +00003408 return false;
Rafael Espindola620c0af2013-05-13 20:09:47 +00003409 StringRef ArchName = T.getArchName();
Rafael Espindola69db5552013-05-14 00:44:24 +00003410 if (T.getArch() == llvm::Triple::arm) {
3411 if (!ArchName.startswith("armv"))
3412 return false;
3413 StringRef VersionStr = ArchName.substr(4);
3414 unsigned Version;
3415 if (VersionStr.getAsInteger(10, Version))
3416 return false;
3417 return Version >= 6;
3418 }
3419 assert(T.getArch() == llvm::Triple::thumb);
3420 if (!ArchName.startswith("thumbv"))
3421 return false;
3422 StringRef VersionStr = ArchName.substr(6);
3423 unsigned Version;
3424 if (VersionStr.getAsInteger(10, Version))
3425 return false;
3426 return Version >= 7;
Rafael Espindola620c0af2013-05-13 20:09:47 +00003427 }
3428
Chris Lattner393ff042008-04-21 18:56:49 +00003429public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003430 ARMTargetInfo(const llvm::Triple &Triple)
3431 : TargetInfo(Triple), ABI("aapcs-linux"), CPU("arm1136j-s"),
3432 IsAAPCS(true) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003433 BigEndian = false;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003434 SizeType = UnsignedInt;
3435 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00003436 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
3437 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003438
Chris Lattner9bffb072010-04-23 16:29:58 +00003439 // {} in inline assembly are neon specifiers, not assembly variant
3440 // specifiers.
3441 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00003442
Daniel Dunbareac7c532009-12-18 18:42:37 +00003443 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00003444 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003445 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003446 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3447 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003448 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
3449 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003450 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003451 } else {
3452 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3453 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003454 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003455 }
John McCallee79a4c2010-08-21 22:46:04 +00003456
3457 // ARM targets default to using the ARM C++ ABI.
John McCallb8b2c9d2013-01-25 22:30:49 +00003458 TheCXXABI.set(TargetCXXABI::GenericARM);
Eli Friedman2be46072011-10-14 20:59:01 +00003459
3460 // ARM has atomics up to 8 bytes
Eli Friedman2be46072011-10-14 20:59:01 +00003461 MaxAtomicPromoteWidth = 64;
Rafael Espindola620c0af2013-05-13 20:09:47 +00003462 if (shouldUseInlineAtomic(getTriple()))
3463 MaxAtomicInlineWidth = 64;
James Molloye45b9b72012-03-12 09:14:10 +00003464
3465 // Do force alignment of members that follow zero length bitfields. If
3466 // the alignment of the zero-length bitfield is greater than the member
3467 // that follows it, `bar', `bar' will be aligned as the type of the
3468 // zero length bitfield.
3469 UseZeroLengthBitfieldAlignment = true;
Eli Friedman61538a72008-05-20 14:21:01 +00003470 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003471 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00003472 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003473 ABI = Name;
3474
Daniel Dunbara2a41612009-09-14 00:02:24 +00003475 // The defaults (above) are for AAPCS, check if we need to change them.
3476 //
3477 // FIXME: We need support for -meabi... we could just mangle it into the
3478 // name.
3479 if (Name == "apcs-gnu") {
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003480 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Rafael Espindola27fa2362012-12-13 04:17:14 +00003481 // size_t is unsigned int on FreeBSD.
3482 if (getTriple().getOS() != llvm::Triple::FreeBSD)
3483 SizeType = UnsignedLong;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003484
James Molloya6d81f92011-11-23 13:35:08 +00003485 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
3486 WCharType = SignedInt;
3487
Daniel Dunbar684de632010-04-22 16:14:54 +00003488 // Do not respect the alignment of bit-field types when laying out
3489 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
3490 UseBitFieldTypeAlignment = false;
3491
Chad Rosier61a62212011-08-04 01:21:14 +00003492 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00003493 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
3494 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00003495 ZeroLengthBitfieldBoundary = 32;
3496
Logan Chieneae5a8202012-10-10 06:56:20 +00003497 IsAAPCS = false;
3498
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003499 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003500 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3501 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003502 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 +00003503 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003504 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003505 } else {
3506 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 +00003507 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003508 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003509 }
3510
Chad Rosier9f1210c2011-07-26 07:03:04 +00003511 // FIXME: Override "preferred align" for double and long long.
David Tweedb16abb12012-10-25 13:33:01 +00003512 } else if (Name == "aapcs" || Name == "aapcs-vfp") {
Bob Wilsone4bce7a2013-06-18 05:36:04 +00003513 // size_t is unsigned long on Darwin.
3514 if (getTriple().isOSDarwin())
3515 SizeType = UnsignedLong;
Logan Chieneae5a8202012-10-10 06:56:20 +00003516 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003517 // FIXME: Enumerated types are variable width in straight AAPCS.
3518 } else if (Name == "aapcs-linux") {
Logan Chieneae5a8202012-10-10 06:56:20 +00003519 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003520 } else
3521 return false;
3522
3523 return true;
3524 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003525
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003526 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003527 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
3528 Features["vfp2"] = true;
Bob Wilsoncfaab002012-09-29 23:52:52 +00003529 else if (CPU == "cortex-a8" || CPU == "cortex-a15" ||
3530 CPU == "cortex-a9" || CPU == "cortex-a9-mp")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003531 Features["neon"] = true;
Bob Wilsonfc553452013-03-04 22:37:46 +00003532 else if (CPU == "swift" || CPU == "cortex-a7") {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003533 Features["vfp4"] = true;
3534 Features["neon"] = true;
3535 }
Daniel Dunbara91320b2009-12-21 23:28:17 +00003536 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003537
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003538 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00003539 StringRef Name,
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003540 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00003541 if (Name == "soft-float" || Name == "soft-float-abi" ||
Bob Wilsoncfaab002012-09-29 23:52:52 +00003542 Name == "vfp2" || Name == "vfp3" || Name == "vfp4" || Name == "neon" ||
Joey Goulycbed3bf2013-06-27 13:19:54 +00003543 Name == "d16" || Name == "neonfp" || Name == "v8fp") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003544 Features[Name] = Enabled;
3545 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003546 return false;
3547
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003548 return true;
3549 }
3550
3551 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003552 FPU = 0;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003553 SoftFloat = SoftFloatABI = false;
3554 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
3555 if (Features[i] == "+soft-float")
3556 SoftFloat = true;
3557 else if (Features[i] == "+soft-float-abi")
3558 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003559 else if (Features[i] == "+vfp2")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003560 FPU |= VFP2FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003561 else if (Features[i] == "+vfp3")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003562 FPU |= VFP3FPU;
3563 else if (Features[i] == "+vfp4")
3564 FPU |= VFP4FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003565 else if (Features[i] == "+neon")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003566 FPU |= NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003567 }
3568
3569 // Remove front-end specific options which the backend handles differently.
3570 std::vector<std::string>::iterator it;
3571 it = std::find(Features.begin(), Features.end(), "+soft-float");
3572 if (it != Features.end())
3573 Features.erase(it);
3574 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
3575 if (it != Features.end())
3576 Features.erase(it);
3577 }
3578
Douglas Gregore727d212012-01-30 06:38:25 +00003579 virtual bool hasFeature(StringRef Feature) const {
3580 return llvm::StringSwitch<bool>(Feature)
3581 .Case("arm", true)
3582 .Case("softfloat", SoftFloat)
3583 .Case("thumb", IsThumb)
3584 .Case("neon", FPU == NeonFPU && !SoftFloat &&
3585 StringRef(getCPUDefineSuffix(CPU)).startswith("7"))
3586 .Default(false);
3587 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003588 // FIXME: Should we actually have some table instead of these switches?
Chris Lattner5f9e2722011-07-23 10:55:15 +00003589 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00003590 return llvm::StringSwitch<const char*>(Name)
3591 .Cases("arm8", "arm810", "4")
3592 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
3593 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
3594 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
3595 .Case("ep9312", "4T")
3596 .Cases("arm10tdmi", "arm1020t", "5T")
3597 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
3598 .Case("arm926ej-s", "5TEJ")
3599 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
3600 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003601 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003602 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003603 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003604 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
Bob Wilsonfc553452013-03-04 22:37:46 +00003605 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "7A")
3606 .Cases("cortex-a9", "cortex-a15", "7A")
Quentin Colombetab137512012-12-21 17:57:47 +00003607 .Case("cortex-r5", "7R")
Bob Wilson336bfa32012-09-29 23:52:50 +00003608 .Case("cortex-a9-mp", "7F")
3609 .Case("swift", "7S")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003610 .Cases("cortex-m3", "cortex-m4", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00003611 .Case("cortex-m0", "6M")
Joey Gouly4ec8d5b2013-06-26 17:19:48 +00003612 .Case("cortex-a53", "8A")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003613 .Default(0);
3614 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003615 static const char *getCPUProfile(StringRef Name) {
3616 return llvm::StringSwitch<const char*>(Name)
3617 .Cases("cortex-a8", "cortex-a9", "A")
3618 .Cases("cortex-m3", "cortex-m4", "cortex-m0", "M")
Quentin Colombetab137512012-12-21 17:57:47 +00003619 .Case("cortex-r5", "R")
Anton Korobeynikov8b0703d2012-09-08 08:22:13 +00003620 .Default("");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003621 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003622 virtual bool setCPU(const std::string &Name) {
3623 if (!getCPUDefineSuffix(Name))
3624 return false;
3625
3626 CPU = Name;
3627 return true;
3628 }
Chris Lattner33328642009-03-20 15:52:06 +00003629 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003630 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00003631 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00003632 Builder.defineMacro("__arm");
3633 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003634
Chris Lattnerc0f59212009-03-02 22:27:17 +00003635 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00003636 Builder.defineMacro("__ARMEL__");
3637 Builder.defineMacro("__LITTLE_ENDIAN__");
3638 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003639
Chris Lattner5f9e2722011-07-23 10:55:15 +00003640 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00003641 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003642 Builder.defineMacro("__ARM_ARCH", CPUArch.substr(0, 1));
3643 StringRef CPUProfile = getCPUProfile(CPU);
3644 if (!CPUProfile.empty())
3645 Builder.defineMacro("__ARM_ARCH_PROFILE", CPUProfile);
3646
Mike Stump437bb4b2009-04-08 02:07:04 +00003647 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003648
Daniel Dunbareac7c532009-12-18 18:42:37 +00003649 // FIXME: It's more complicated than this and we don't really support
3650 // interworking.
3651 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00003652 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003653
David Tweedb16abb12012-10-25 13:33:01 +00003654 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
Daniel Dunbar849289e2012-10-22 18:51:13 +00003655 // M-class CPUs on Darwin follow AAPCS, but not EABI.
Daniel Dunbar4d3ee9b2012-10-22 18:56:43 +00003656 if (!(getTriple().isOSDarwin() && CPUProfile == "M"))
Daniel Dunbar849289e2012-10-22 18:51:13 +00003657 Builder.defineMacro("__ARM_EABI__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003658 Builder.defineMacro("__ARM_PCS", "1");
3659
David Tweedb16abb12012-10-25 13:33:01 +00003660 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003661 Builder.defineMacro("__ARM_PCS_VFP", "1");
3662 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003663
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003664 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00003665 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003666
3667 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00003668 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003669
Bob Wilson84f95cf2011-05-13 18:56:03 +00003670 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003671 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003672 Builder.defineMacro("__THUMBEL__");
3673 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00003674 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003675 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003676 }
3677
3678 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00003679 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00003680
Bob Wilsoncfaab002012-09-29 23:52:52 +00003681 if (FPUModeIsVFP((FPUMode) FPU)) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003682 Builder.defineMacro("__VFP_FP__");
Bob Wilsoncfaab002012-09-29 23:52:52 +00003683 if (FPU & VFP2FPU)
3684 Builder.defineMacro("__ARM_VFPV2__");
3685 if (FPU & VFP3FPU)
3686 Builder.defineMacro("__ARM_VFPV3__");
3687 if (FPU & VFP4FPU)
3688 Builder.defineMacro("__ARM_VFPV4__");
3689 }
3690
Daniel Dunbara91320b2009-12-21 23:28:17 +00003691 // This only gets set when Neon instructions are actually available, unlike
3692 // the VFP define, hence the soft float and arch check. This is subtly
3693 // different from gcc, we follow the intent which was that it should be set
3694 // when Neon instructions are actually available.
Bob Wilsoncfaab002012-09-29 23:52:52 +00003695 if ((FPU & NeonFPU) && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003696 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00003697 }
3698 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3699 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00003700 Records = BuiltinInfo;
3701 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00003702 }
Bob Wilson8b30a932012-01-26 22:14:27 +00003703 virtual bool isCLZForZeroUndef() const { return false; }
Meador Ingec5613b22012-06-16 03:34:49 +00003704 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Logan Chieneae5a8202012-10-10 06:56:20 +00003705 return IsAAPCS ? AAPCSABIBuiltinVaList : TargetInfo::VoidPtrBuiltinVaList;
Chris Lattner393ff042008-04-21 18:56:49 +00003706 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003707 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003708 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003709 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003710 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003711 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00003712 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003713 switch (*Name) {
Eric Christophera0dfca12012-08-16 23:50:41 +00003714 default: break;
Nate Begemanad487f42008-04-22 05:03:19 +00003715 case 'l': // r0-r7
3716 case 'h': // r8-r15
3717 case 'w': // VFP Floating point register single precision
3718 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00003719 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00003720 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00003721 case 'Q': // A memory address that is a single base register.
3722 Info.setAllowsMemory();
3723 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00003724 case 'U': // a memory reference...
3725 switch (Name[1]) {
3726 case 'q': // ...ARMV4 ldrsb
3727 case 'v': // ...VFP load/store (reg+constant offset)
3728 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00003729 case 't': // address valid for load/store opaque types wider
Eric Christopher825d3862012-11-14 22:08:59 +00003730 // than 128-bits
Eric Christopherdda231a2011-06-17 01:40:49 +00003731 case 'n': // valid address for Neon doubleword vector load/store
3732 case 'm': // valid address for Neon element and structure load/store
3733 case 's': // valid address for non-offset loads/stores of quad-word
Eric Christopher825d3862012-11-14 22:08:59 +00003734 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00003735 Info.setAllowsMemory();
3736 Name++;
3737 return true;
3738 }
Nate Begemanad487f42008-04-22 05:03:19 +00003739 }
Chris Lattner393ff042008-04-21 18:56:49 +00003740 return false;
3741 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00003742 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00003743 std::string R;
3744 switch (*Constraint) {
3745 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00003746 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00003747 Constraint++;
3748 break;
Eric Christopher283f4472011-06-17 00:40:18 +00003749 case 'p': // 'p' should be translated to 'r' by default.
3750 R = std::string("r");
3751 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00003752 default:
3753 return std::string(1, *Constraint);
3754 }
3755 return R;
3756 }
Bill Wendling50d46ca2012-10-25 23:28:48 +00003757 virtual bool validateConstraintModifier(StringRef Constraint,
3758 const char Modifier,
3759 unsigned Size) const {
Bill Wendlinge2dbaa92012-11-30 23:18:12 +00003760 bool isOutput = (Constraint[0] == '=');
Bill Wendling6e6330c2012-11-30 23:46:56 +00003761 bool isInOut = (Constraint[0] == '+');
Bill Wendlinge2dbaa92012-11-30 23:18:12 +00003762
Bill Wendling50d46ca2012-10-25 23:28:48 +00003763 // Strip off constraint modifiers.
3764 while (Constraint[0] == '=' ||
3765 Constraint[0] == '+' ||
3766 Constraint[0] == '&')
3767 Constraint = Constraint.substr(1);
3768
3769 switch (Constraint[0]) {
3770 default: break;
3771 case 'r': {
3772 switch (Modifier) {
3773 default:
Bob Wilson221a8902013-06-03 23:57:13 +00003774 return (isInOut || isOutput || Size <= 32);
Bill Wendling50d46ca2012-10-25 23:28:48 +00003775 case 'q':
3776 // A register of size 32 cannot fit a vector type.
3777 return false;
3778 }
3779 }
3780 }
3781
3782 return true;
3783 }
Chris Lattner393ff042008-04-21 18:56:49 +00003784 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00003785 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00003786 return "";
3787 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00003788
3789 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
3790 return (CC == CC_AAPCS || CC == CC_AAPCS_VFP) ? CCCR_OK : CCCR_Warning;
3791 }
Logan Chiena8f7a972013-02-23 04:24:36 +00003792
3793 virtual int getEHDataRegisterNumber(unsigned RegNo) const {
3794 if (RegNo == 0) return 0;
3795 if (RegNo == 1) return 1;
3796 return -1;
3797 }
Chris Lattner393ff042008-04-21 18:56:49 +00003798};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003799
3800const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003801 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003802 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003803 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
3804
3805 // Float registers
3806 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3807 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3808 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003809 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003810
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003811 // Double registers
3812 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3813 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00003814 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3815 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003816
3817 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00003818 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3819 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003820};
3821
3822void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003823 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003824 Names = GCCRegNames;
3825 NumNames = llvm::array_lengthof(GCCRegNames);
3826}
3827
3828const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003829 { { "a1" }, "r0" },
3830 { { "a2" }, "r1" },
3831 { { "a3" }, "r2" },
3832 { { "a4" }, "r3" },
3833 { { "v1" }, "r4" },
3834 { { "v2" }, "r5" },
3835 { { "v3" }, "r6" },
3836 { { "v4" }, "r7" },
3837 { { "v5" }, "r8" },
3838 { { "v6", "rfp" }, "r9" },
3839 { { "sl" }, "r10" },
3840 { { "fp" }, "r11" },
3841 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003842 { { "r13" }, "sp" },
3843 { { "r14" }, "lr" },
3844 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003845 // The S, D and Q registers overlap, but aren't really aliases; we
3846 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003847};
3848
3849void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3850 unsigned &NumAliases) const {
3851 Aliases = GCCRegAliases;
3852 NumAliases = llvm::array_lengthof(GCCRegAliases);
3853}
Chris Lattner2752c012010-03-03 19:03:45 +00003854
3855const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00003856#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00003857#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00003858 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00003859#include "clang/Basic/BuiltinsARM.def"
3860};
Chris Lattner393ff042008-04-21 18:56:49 +00003861} // end anonymous namespace.
3862
Eli Friedmana9f54962008-08-20 07:44:10 +00003863namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00003864class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003865 public DarwinTargetInfo<ARMTargetInfo> {
3866protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00003867 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00003868 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00003869 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00003870 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003871
Torok Edwin5f6c1942009-06-30 17:10:35 +00003872public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003873 DarwinARMTargetInfo(const llvm::Triple &Triple)
3874 : DarwinTargetInfo<ARMTargetInfo>(Triple) {
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003875 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00003876 // iOS always has 64-bit atomic instructions.
3877 // FIXME: This should be based off of the target features in ARMTargetInfo.
3878 MaxAtomicInlineWidth = 64;
John McCallb8b2c9d2013-01-25 22:30:49 +00003879
3880 // Darwin on iOS uses a variant of the ARM C++ ABI.
3881 TheCXXABI.set(TargetCXXABI::iOS);
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003882 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003883};
3884} // end anonymous namespace.
3885
Tony Linthicum96319392011-12-12 21:14:55 +00003886
3887namespace {
3888// Hexagon abstract base class
3889class HexagonTargetInfo : public TargetInfo {
3890 static const Builtin::Info BuiltinInfo[];
3891 static const char * const GCCRegNames[];
3892 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3893 std::string CPU;
3894public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003895 HexagonTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003896 BigEndian = false;
Tony Linthicum96319392011-12-12 21:14:55 +00003897 DescriptionString = ("e-p:32:32:32-"
Anshuman Dasgupta1a090f12013-01-02 21:25:57 +00003898 "i64:64:64-i32:32:32-i16:16:16-i1:32:32-"
Sirish Pande5f9688b2012-05-10 20:19:54 +00003899 "f64:64:64-f32:32:32-a0:0-n32");
Tony Linthicum96319392011-12-12 21:14:55 +00003900
3901 // {} in inline assembly are packet specifiers, not assembly variant
3902 // specifiers.
3903 NoAsmVariants = true;
3904 }
3905
3906 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3907 unsigned &NumRecords) const {
3908 Records = BuiltinInfo;
3909 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
3910 }
3911
3912 virtual bool validateAsmConstraint(const char *&Name,
3913 TargetInfo::ConstraintInfo &Info) const {
3914 return true;
3915 }
3916
3917 virtual void getTargetDefines(const LangOptions &Opts,
3918 MacroBuilder &Builder) const;
3919
Douglas Gregore727d212012-01-30 06:38:25 +00003920 virtual bool hasFeature(StringRef Feature) const {
3921 return Feature == "hexagon";
3922 }
3923
Meador Ingec5613b22012-06-16 03:34:49 +00003924 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3925 return TargetInfo::CharPtrBuiltinVaList;
Tony Linthicum96319392011-12-12 21:14:55 +00003926 }
3927 virtual void getGCCRegNames(const char * const *&Names,
3928 unsigned &NumNames) const;
3929 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3930 unsigned &NumAliases) const;
3931 virtual const char *getClobbers() const {
3932 return "";
3933 }
Sebastian Pop43115d42012-01-13 20:37:10 +00003934
3935 static const char *getHexagonCPUSuffix(StringRef Name) {
3936 return llvm::StringSwitch<const char*>(Name)
Sebastian Pop43115d42012-01-13 20:37:10 +00003937 .Case("hexagonv4", "4")
Sirish Pande5f9688b2012-05-10 20:19:54 +00003938 .Case("hexagonv5", "5")
Sebastian Pop43115d42012-01-13 20:37:10 +00003939 .Default(0);
3940 }
3941
Tony Linthicum96319392011-12-12 21:14:55 +00003942 virtual bool setCPU(const std::string &Name) {
Sebastian Pop43115d42012-01-13 20:37:10 +00003943 if (!getHexagonCPUSuffix(Name))
3944 return false;
3945
Tony Linthicum96319392011-12-12 21:14:55 +00003946 CPU = Name;
3947 return true;
3948 }
3949};
3950
3951void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
3952 MacroBuilder &Builder) const {
3953 Builder.defineMacro("qdsp6");
3954 Builder.defineMacro("__qdsp6", "1");
3955 Builder.defineMacro("__qdsp6__", "1");
3956
3957 Builder.defineMacro("hexagon");
3958 Builder.defineMacro("__hexagon", "1");
3959 Builder.defineMacro("__hexagon__", "1");
3960
3961 if(CPU == "hexagonv1") {
3962 Builder.defineMacro("__HEXAGON_V1__");
3963 Builder.defineMacro("__HEXAGON_ARCH__", "1");
3964 if(Opts.HexagonQdsp6Compat) {
3965 Builder.defineMacro("__QDSP6_V1__");
3966 Builder.defineMacro("__QDSP6_ARCH__", "1");
3967 }
3968 }
3969 else if(CPU == "hexagonv2") {
3970 Builder.defineMacro("__HEXAGON_V2__");
3971 Builder.defineMacro("__HEXAGON_ARCH__", "2");
3972 if(Opts.HexagonQdsp6Compat) {
3973 Builder.defineMacro("__QDSP6_V2__");
3974 Builder.defineMacro("__QDSP6_ARCH__", "2");
3975 }
3976 }
3977 else if(CPU == "hexagonv3") {
3978 Builder.defineMacro("__HEXAGON_V3__");
3979 Builder.defineMacro("__HEXAGON_ARCH__", "3");
3980 if(Opts.HexagonQdsp6Compat) {
3981 Builder.defineMacro("__QDSP6_V3__");
3982 Builder.defineMacro("__QDSP6_ARCH__", "3");
3983 }
3984 }
3985 else if(CPU == "hexagonv4") {
3986 Builder.defineMacro("__HEXAGON_V4__");
3987 Builder.defineMacro("__HEXAGON_ARCH__", "4");
3988 if(Opts.HexagonQdsp6Compat) {
3989 Builder.defineMacro("__QDSP6_V4__");
3990 Builder.defineMacro("__QDSP6_ARCH__", "4");
3991 }
3992 }
Sirish Pande5f9688b2012-05-10 20:19:54 +00003993 else if(CPU == "hexagonv5") {
3994 Builder.defineMacro("__HEXAGON_V5__");
3995 Builder.defineMacro("__HEXAGON_ARCH__", "5");
3996 if(Opts.HexagonQdsp6Compat) {
3997 Builder.defineMacro("__QDSP6_V5__");
3998 Builder.defineMacro("__QDSP6_ARCH__", "5");
3999 }
4000 }
Tony Linthicum96319392011-12-12 21:14:55 +00004001}
4002
4003const char * const HexagonTargetInfo::GCCRegNames[] = {
4004 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4005 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4006 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
4007 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
4008 "p0", "p1", "p2", "p3",
4009 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
4010};
4011
4012void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
4013 unsigned &NumNames) const {
4014 Names = GCCRegNames;
4015 NumNames = llvm::array_lengthof(GCCRegNames);
4016}
4017
4018
4019const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
4020 { { "sp" }, "r29" },
4021 { { "fp" }, "r30" },
4022 { { "lr" }, "r31" },
4023 };
4024
4025void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4026 unsigned &NumAliases) const {
4027 Aliases = GCCRegAliases;
4028 NumAliases = llvm::array_lengthof(GCCRegAliases);
4029}
4030
4031
4032const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
4033#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4034#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4035 ALL_LANGUAGES },
4036#include "clang/Basic/BuiltinsHexagon.def"
4037};
4038}
4039
4040
Reid Spencer5f016e22007-07-11 17:01:13 +00004041namespace {
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004042// Shared base class for SPARC v8 (32-bit) and SPARC v9 (64-bit).
4043class SparcTargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00004044 static const TargetInfo::GCCRegAlias GCCRegAliases[];
4045 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004046 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00004047public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004048 SparcTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {}
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004049
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004050 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00004051 StringRef Name,
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004052 bool Enabled) const {
4053 if (Name == "soft-float")
4054 Features[Name] = Enabled;
4055 else
4056 return false;
4057
4058 return true;
4059 }
4060 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
4061 SoftFloat = false;
4062 for (unsigned i = 0, e = Features.size(); i != e; ++i)
4063 if (Features[i] == "+soft-float")
4064 SoftFloat = true;
4065 }
Chris Lattner33328642009-03-20 15:52:06 +00004066 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004067 MacroBuilder &Builder) const {
4068 DefineStd(Builder, "sparc", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00004069 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004070
4071 if (SoftFloat)
4072 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00004073 }
Douglas Gregore727d212012-01-30 06:38:25 +00004074
4075 virtual bool hasFeature(StringRef Feature) const {
4076 return llvm::StringSwitch<bool>(Feature)
4077 .Case("softfloat", SoftFloat)
4078 .Case("sparc", true)
4079 .Default(false);
4080 }
4081
Gabor Greif26658672008-02-21 16:29:08 +00004082 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4083 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00004084 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00004085 }
Meador Ingec5613b22012-06-16 03:34:49 +00004086 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4087 return TargetInfo::VoidPtrBuiltinVaList;
Gabor Greif26658672008-02-21 16:29:08 +00004088 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004089 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00004090 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004091 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00004092 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00004093 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00004094 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00004095 // FIXME: Implement!
4096 return false;
Gabor Greif26658672008-02-21 16:29:08 +00004097 }
4098 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00004099 // FIXME: Implement!
4100 return "";
Gabor Greif26658672008-02-21 16:29:08 +00004101 }
4102};
4103
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004104const char * const SparcTargetInfo::GCCRegNames[] = {
Chris Lattnere957f532009-01-27 01:58:38 +00004105 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4106 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4107 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
4108 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
4109};
4110
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004111void SparcTargetInfo::getGCCRegNames(const char * const *&Names,
4112 unsigned &NumNames) const {
Chris Lattnere957f532009-01-27 01:58:38 +00004113 Names = GCCRegNames;
4114 NumNames = llvm::array_lengthof(GCCRegNames);
4115}
4116
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004117const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004118 { { "g0" }, "r0" },
4119 { { "g1" }, "r1" },
4120 { { "g2" }, "r2" },
4121 { { "g3" }, "r3" },
4122 { { "g4" }, "r4" },
4123 { { "g5" }, "r5" },
4124 { { "g6" }, "r6" },
4125 { { "g7" }, "r7" },
4126 { { "o0" }, "r8" },
4127 { { "o1" }, "r9" },
4128 { { "o2" }, "r10" },
4129 { { "o3" }, "r11" },
4130 { { "o4" }, "r12" },
4131 { { "o5" }, "r13" },
4132 { { "o6", "sp" }, "r14" },
4133 { { "o7" }, "r15" },
4134 { { "l0" }, "r16" },
4135 { { "l1" }, "r17" },
4136 { { "l2" }, "r18" },
4137 { { "l3" }, "r19" },
4138 { { "l4" }, "r20" },
4139 { { "l5" }, "r21" },
4140 { { "l6" }, "r22" },
4141 { { "l7" }, "r23" },
4142 { { "i0" }, "r24" },
4143 { { "i1" }, "r25" },
4144 { { "i2" }, "r26" },
4145 { { "i3" }, "r27" },
4146 { { "i4" }, "r28" },
4147 { { "i5" }, "r29" },
4148 { { "i6", "fp" }, "r30" },
4149 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00004150};
4151
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004152void SparcTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4153 unsigned &NumAliases) const {
Chris Lattnere957f532009-01-27 01:58:38 +00004154 Aliases = GCCRegAliases;
4155 NumAliases = llvm::array_lengthof(GCCRegAliases);
4156}
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004157
4158// SPARC v8 is the 32-bit mode selected by Triple::sparc.
4159class SparcV8TargetInfo : public SparcTargetInfo {
4160public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004161 SparcV8TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004162 // FIXME: Support Sparc quad-precision long double?
4163 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
4164 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
4165 }
4166
4167 virtual void getTargetDefines(const LangOptions &Opts,
4168 MacroBuilder &Builder) const {
4169 SparcTargetInfo::getTargetDefines(Opts, Builder);
4170 Builder.defineMacro("__sparcv8");
4171 }
4172};
4173
4174// SPARC v9 is the 64-bit mode selected by Triple::sparcv9.
4175class SparcV9TargetInfo : public SparcTargetInfo {
4176public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004177 SparcV9TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004178 // FIXME: Support Sparc quad-precision long double?
4179 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
4180 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32:64-S128";
Jakob Stoklund Olesenfcec0c92013-05-15 03:22:33 +00004181 // This is an LP64 platform.
4182 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Jakob Stoklund Olesen5ac8c4f2013-05-19 17:53:37 +00004183
4184 // OpenBSD uses long long for int64_t and intmax_t.
4185 if (getTriple().getOS() == llvm::Triple::OpenBSD) {
4186 IntMaxType = SignedLongLong;
4187 UIntMaxType = UnsignedLongLong;
4188 } else {
4189 IntMaxType = SignedLong;
4190 UIntMaxType = UnsignedLong;
4191 }
4192 Int64Type = IntMaxType;
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004193 }
4194
4195 virtual void getTargetDefines(const LangOptions &Opts,
4196 MacroBuilder &Builder) const {
4197 SparcTargetInfo::getTargetDefines(Opts, Builder);
4198 Builder.defineMacro("__sparcv9");
Jakob Stoklund Olesen44f72d32013-04-24 04:36:38 +00004199 Builder.defineMacro("__arch64__");
4200 // Solaris and its derivative AuroraUX don't need these variants, but the
4201 // BSDs do.
4202 if (getTriple().getOS() != llvm::Triple::Solaris &&
4203 getTriple().getOS() != llvm::Triple::AuroraUX) {
4204 Builder.defineMacro("__sparc64__");
4205 Builder.defineMacro("__sparc_v9__");
4206 Builder.defineMacro("__sparcv9__");
4207 }
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004208 }
4209};
4210
Gabor Greif26658672008-02-21 16:29:08 +00004211} // end anonymous namespace.
4212
Eli Friedman01b86682008-08-20 07:28:14 +00004213namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004214class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
4215public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004216 AuroraUXSparcV8TargetInfo(const llvm::Triple &Triple)
4217 : AuroraUXTargetInfo<SparcV8TargetInfo>(Triple) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004218 SizeType = UnsignedInt;
4219 PtrDiffType = SignedInt;
4220 }
4221};
Torok Edwin5f6c1942009-06-30 17:10:35 +00004222class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00004223public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004224 SolarisSparcV8TargetInfo(const llvm::Triple &Triple)
4225 : SolarisTargetInfo<SparcV8TargetInfo>(Triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00004226 SizeType = UnsignedInt;
4227 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00004228 }
4229};
4230} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00004231
Chris Lattner2621fd12008-05-08 05:58:21 +00004232namespace {
Ulrich Weigandb8409212013-05-06 16:26:41 +00004233 class SystemZTargetInfo : public TargetInfo {
4234 static const char *const GCCRegNames[];
4235
4236 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004237 SystemZTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Ulrich Weigandb8409212013-05-06 16:26:41 +00004238 TLSSupported = true;
4239 IntWidth = IntAlign = 32;
4240 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
4241 PointerWidth = PointerAlign = 64;
4242 LongDoubleWidth = 128;
4243 LongDoubleAlign = 64;
4244 LongDoubleFormat = &llvm::APFloat::IEEEquad;
4245 MinGlobalAlign = 16;
4246 DescriptionString = "E-p:64:64:64-i1:8:16-i8:8:16-i16:16-i32:32-i64:64"
4247 "-f32:32-f64:64-f128:64-a0:8:16-n32:64";
4248 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
4249 }
4250 virtual void getTargetDefines(const LangOptions &Opts,
4251 MacroBuilder &Builder) const {
4252 Builder.defineMacro("__s390__");
4253 Builder.defineMacro("__s390x__");
4254 Builder.defineMacro("__zarch__");
4255 Builder.defineMacro("__LONG_DOUBLE_128__");
4256 }
4257 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4258 unsigned &NumRecords) const {
4259 // FIXME: Implement.
4260 Records = 0;
4261 NumRecords = 0;
4262 }
4263
4264 virtual void getGCCRegNames(const char *const *&Names,
4265 unsigned &NumNames) const;
4266 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4267 unsigned &NumAliases) const {
4268 // No aliases.
4269 Aliases = 0;
4270 NumAliases = 0;
4271 }
4272 virtual bool validateAsmConstraint(const char *&Name,
4273 TargetInfo::ConstraintInfo &info) const;
4274 virtual const char *getClobbers() const {
4275 // FIXME: Is this really right?
4276 return "";
4277 }
4278 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4279 return TargetInfo::SystemZBuiltinVaList;
4280 }
Richard Sandiford5c92b9a2013-07-19 16:51:51 +00004281 virtual bool setCPU(const std::string &Name) {
4282 bool CPUKnown = llvm::StringSwitch<bool>(Name)
4283 .Case("z10", true)
4284 .Case("z196", true)
4285 .Case("zEC12", true)
4286 .Default(false);
4287
4288 // No need to store the CPU yet. There aren't any CPU-specific
4289 // macros to define.
4290 return CPUKnown;
4291 }
Ulrich Weigandb8409212013-05-06 16:26:41 +00004292 };
4293
4294 const char *const SystemZTargetInfo::GCCRegNames[] = {
4295 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4296 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4297 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
4298 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15"
4299 };
4300
4301 void SystemZTargetInfo::getGCCRegNames(const char *const *&Names,
4302 unsigned &NumNames) const {
4303 Names = GCCRegNames;
4304 NumNames = llvm::array_lengthof(GCCRegNames);
4305 }
4306
4307 bool SystemZTargetInfo::
4308 validateAsmConstraint(const char *&Name,
4309 TargetInfo::ConstraintInfo &Info) const {
4310 switch (*Name) {
4311 default:
4312 return false;
4313
4314 case 'a': // Address register
4315 case 'd': // Data register (equivalent to 'r')
4316 case 'f': // Floating-point register
4317 Info.setAllowsRegister();
4318 return true;
4319
4320 case 'I': // Unsigned 8-bit constant
4321 case 'J': // Unsigned 12-bit constant
4322 case 'K': // Signed 16-bit constant
4323 case 'L': // Signed 20-bit displacement (on all targets we support)
4324 case 'M': // 0x7fffffff
4325 return true;
4326
4327 case 'Q': // Memory with base and unsigned 12-bit displacement
4328 case 'R': // Likewise, plus an index
4329 case 'S': // Memory with base and signed 20-bit displacement
4330 case 'T': // Likewise, plus an index
4331 Info.setAllowsMemory();
4332 return true;
4333 }
4334 }
4335}
4336
4337namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004338 class MSP430TargetInfo : public TargetInfo {
4339 static const char * const GCCRegNames[];
4340 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004341 MSP430TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004342 BigEndian = false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004343 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00004344 IntWidth = 16; IntAlign = 16;
4345 LongWidth = 32; LongLongWidth = 64;
4346 LongAlign = LongLongAlign = 16;
4347 PointerWidth = 16; PointerAlign = 16;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004348 SuitableAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004349 SizeType = UnsignedInt;
Anton Korobeynikov18a295d2013-07-01 19:42:40 +00004350 IntMaxType = SignedLongLong;
4351 UIntMaxType = UnsignedLongLong;
4352 IntPtrType = SignedInt;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004353 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00004354 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00004355 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004356 }
4357 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004358 MacroBuilder &Builder) const {
4359 Builder.defineMacro("MSP430");
4360 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004361 // FIXME: defines for different 'flavours' of MCU
4362 }
4363 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4364 unsigned &NumRecords) const {
4365 // FIXME: Implement.
4366 Records = 0;
4367 NumRecords = 0;
4368 }
Douglas Gregore727d212012-01-30 06:38:25 +00004369 virtual bool hasFeature(StringRef Feature) const {
4370 return Feature == "msp430";
4371 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004372 virtual void getGCCRegNames(const char * const *&Names,
4373 unsigned &NumNames) const;
4374 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4375 unsigned &NumAliases) const {
4376 // No aliases.
4377 Aliases = 0;
4378 NumAliases = 0;
4379 }
4380 virtual bool validateAsmConstraint(const char *&Name,
4381 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00004382 // No target constraints for now.
4383 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004384 }
4385 virtual const char *getClobbers() const {
4386 // FIXME: Is this really right?
4387 return "";
4388 }
Meador Ingec5613b22012-06-16 03:34:49 +00004389 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004390 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00004391 return TargetInfo::CharPtrBuiltinVaList;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004392 }
4393 };
4394
4395 const char * const MSP430TargetInfo::GCCRegNames[] = {
4396 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4397 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
4398 };
4399
4400 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
4401 unsigned &NumNames) const {
4402 Names = GCCRegNames;
4403 NumNames = llvm::array_lengthof(GCCRegNames);
4404 }
4405}
4406
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00004407namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00004408
Mike Stump1eb44332009-09-09 15:08:12 +00004409 // LLVM and Clang cannot be used directly to output native binaries for
4410 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00004411 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00004412 //
4413 // TCE uses the llvm bitcode as input and uses it for generating customized
4414 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00004415 // publicly available in http://tce.cs.tut.fi
4416
Eli Friedman209f5bb2011-10-07 19:51:42 +00004417 static const unsigned TCEOpenCLAddrSpaceMap[] = {
4418 3, // opencl_global
4419 4, // opencl_local
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00004420 5, // opencl_constant
4421 0, // cuda_device
4422 0, // cuda_constant
4423 0 // cuda_shared
Eli Friedman209f5bb2011-10-07 19:51:42 +00004424 };
4425
Eli Friedmanb63decf2009-08-19 20:47:07 +00004426 class TCETargetInfo : public TargetInfo{
4427 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004428 TCETargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmanb63decf2009-08-19 20:47:07 +00004429 TLSSupported = false;
4430 IntWidth = 32;
4431 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004432 PointerWidth = 32;
4433 IntAlign = 32;
4434 LongAlign = LongLongAlign = 32;
4435 PointerAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004436 SuitableAlign = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004437 SizeType = UnsignedInt;
4438 IntMaxType = SignedLong;
4439 UIntMaxType = UnsignedLong;
4440 IntPtrType = SignedInt;
4441 PtrDiffType = SignedInt;
4442 FloatWidth = 32;
4443 FloatAlign = 32;
4444 DoubleWidth = 32;
4445 DoubleAlign = 32;
4446 LongDoubleWidth = 32;
4447 LongDoubleAlign = 32;
4448 FloatFormat = &llvm::APFloat::IEEEsingle;
4449 DoubleFormat = &llvm::APFloat::IEEEsingle;
4450 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00004451 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
4452 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00004453 "f32:32:32-f64:32:32-v64:32:32-"
4454 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00004455 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004456 }
4457
4458 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004459 MacroBuilder &Builder) const {
4460 DefineStd(Builder, "tce", Opts);
4461 Builder.defineMacro("__TCE__");
4462 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00004463 }
Douglas Gregore727d212012-01-30 06:38:25 +00004464 virtual bool hasFeature(StringRef Feature) const {
4465 return Feature == "tce";
4466 }
4467
Eli Friedmanb63decf2009-08-19 20:47:07 +00004468 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4469 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00004470 virtual const char *getClobbers() const {
4471 return "";
4472 }
Meador Ingec5613b22012-06-16 03:34:49 +00004473 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4474 return TargetInfo::VoidPtrBuiltinVaList;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004475 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00004476 virtual void getGCCRegNames(const char * const *&Names,
4477 unsigned &NumNames) const {}
4478 virtual bool validateAsmConstraint(const char *&Name,
4479 TargetInfo::ConstraintInfo &info) const {
4480 return true;
4481 }
4482 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4483 unsigned &NumAliases) const {}
4484 };
4485}
4486
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004487namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004488class MipsTargetInfoBase : public TargetInfo {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004489 static const Builtin::Info BuiltinInfo[];
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004490 std::string CPU;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004491 bool IsMips16;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004492 bool IsMicromips;
Simon Atanasyand96e3152013-04-14 14:07:30 +00004493 bool IsSingleFloat;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004494 enum MipsFloatABI {
Simon Atanasyand96e3152013-04-14 14:07:30 +00004495 HardFloat, SoftFloat
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004496 } FloatABI;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004497 enum DspRevEnum {
4498 NoDSP, DSP1, DSP2
4499 } DspRev;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004500
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004501protected:
4502 std::string ABI;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004503
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004504public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004505 MipsTargetInfoBase(const llvm::Triple &Triple, const std::string &ABIStr,
4506 const std::string &CPUStr)
4507 : TargetInfo(Triple), CPU(CPUStr), IsMips16(false), IsMicromips(false),
4508 IsSingleFloat(false), FloatABI(HardFloat), DspRev(NoDSP), ABI(ABIStr) {}
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004509
Eric Christophered734732010-03-02 02:41:08 +00004510 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004511 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00004512 virtual bool setCPU(const std::string &Name) {
4513 CPU = Name;
4514 return true;
4515 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004516 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00004517 Features[ABI] = true;
4518 Features[CPU] = true;
4519 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004520
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004521 virtual void getTargetDefines(const LangOptions &Opts,
4522 MacroBuilder &Builder) const {
Simon Atanasyand4935a02012-08-29 19:14:58 +00004523 DefineStd(Builder, "mips", Opts);
4524 Builder.defineMacro("_mips");
4525 Builder.defineMacro("__REGISTER_PREFIX__", "");
4526
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004527 switch (FloatABI) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004528 case HardFloat:
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00004529 Builder.defineMacro("__mips_hard_float", Twine(1));
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004530 break;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004531 case SoftFloat:
4532 Builder.defineMacro("__mips_soft_float", Twine(1));
4533 break;
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00004534 }
Simon Atanasyan90913892012-04-05 19:28:31 +00004535
Simon Atanasyand96e3152013-04-14 14:07:30 +00004536 if (IsSingleFloat)
4537 Builder.defineMacro("__mips_single_float", Twine(1));
4538
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004539 if (IsMips16)
4540 Builder.defineMacro("__mips16", Twine(1));
4541
Simon Atanasyan321ae792013-04-14 14:07:51 +00004542 if (IsMicromips)
4543 Builder.defineMacro("__mips_micromips", Twine(1));
4544
Simon Atanasyana1b62272012-07-05 20:16:22 +00004545 switch (DspRev) {
4546 default:
4547 break;
4548 case DSP1:
4549 Builder.defineMacro("__mips_dsp_rev", Twine(1));
4550 Builder.defineMacro("__mips_dsp", Twine(1));
4551 break;
4552 case DSP2:
4553 Builder.defineMacro("__mips_dsp_rev", Twine(2));
4554 Builder.defineMacro("__mips_dspr2", Twine(1));
4555 Builder.defineMacro("__mips_dsp", Twine(1));
4556 break;
4557 }
4558
Simon Atanasyan90913892012-04-05 19:28:31 +00004559 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
4560 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
4561 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
Simon Atanasyan260e5062012-08-29 15:17:29 +00004562
4563 Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
4564 Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004565 }
4566
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004567 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4568 unsigned &NumRecords) const {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004569 Records = BuiltinInfo;
4570 NumRecords = clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004571 }
Douglas Gregore727d212012-01-30 06:38:25 +00004572 virtual bool hasFeature(StringRef Feature) const {
4573 return Feature == "mips";
4574 }
Meador Ingec5613b22012-06-16 03:34:49 +00004575 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4576 return TargetInfo::VoidPtrBuiltinVaList;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004577 }
4578 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004579 unsigned &NumNames) const {
4580 static const char * const GCCRegNames[] = {
Eric Christopherd1f853d2012-03-27 19:56:11 +00004581 // CPU register names
4582 // Must match second column of GCCRegAliases
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004583 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
4584 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
4585 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004586 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",
4587 // Floating point register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004588 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
4589 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
4590 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
4591 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004592 // Hi/lo and condition register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004593 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
4594 "$fcc5","$fcc6","$fcc7"
4595 };
4596 Names = GCCRegNames;
4597 NumNames = llvm::array_lengthof(GCCRegNames);
4598 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004599 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004600 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004601 virtual bool validateAsmConstraint(const char *&Name,
4602 TargetInfo::ConstraintInfo &Info) const {
4603 switch (*Name) {
4604 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00004605 return false;
4606
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004607 case 'r': // CPU registers.
4608 case 'd': // Equivalent to "r" unless generating MIPS16 code.
4609 case 'y': // Equivalent to "r", backwards compatibility only.
4610 case 'f': // floating-point registers.
Eric Christopher0ea61642012-04-03 01:16:32 +00004611 case 'c': // $25 for indirect jumps
4612 case 'l': // lo register
4613 case 'x': // hilo register pair
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004614 Info.setAllowsRegister();
4615 return true;
Jack Carter97102302013-03-05 19:10:54 +00004616 case 'R': // An address that can be used in a non-macro load or store
Jack Carterd2ab6d32013-03-04 21:36:11 +00004617 Info.setAllowsMemory();
4618 return true;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004619 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004620 }
4621
4622 virtual const char *getClobbers() const {
4623 // FIXME: Implement!
4624 return "";
4625 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004626
4627 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
4628 StringRef Name,
4629 bool Enabled) const {
Simon Atanasyan8b2a5d22012-04-18 12:00:11 +00004630 if (Name == "soft-float" || Name == "single-float" ||
4631 Name == "o32" || Name == "n32" || Name == "n64" || Name == "eabi" ||
4632 Name == "mips32" || Name == "mips32r2" ||
Simon Atanasyan0b273ef2012-07-05 14:19:39 +00004633 Name == "mips64" || Name == "mips64r2" ||
Simon Atanasyan321ae792013-04-14 14:07:51 +00004634 Name == "mips16" || Name == "micromips" ||
4635 Name == "dsp" || Name == "dspr2") {
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004636 Features[Name] = Enabled;
4637 return true;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004638 } else if (Name == "32") {
4639 Features["o32"] = Enabled;
4640 return true;
4641 } else if (Name == "64") {
4642 Features["n64"] = Enabled;
4643 return true;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004644 }
4645 return false;
4646 }
4647
4648 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004649 IsMips16 = false;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004650 IsMicromips = false;
Simon Atanasyand96e3152013-04-14 14:07:30 +00004651 IsSingleFloat = false;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004652 FloatABI = HardFloat;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004653 DspRev = NoDSP;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004654
4655 for (std::vector<std::string>::iterator it = Features.begin(),
4656 ie = Features.end(); it != ie; ++it) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004657 if (*it == "+single-float")
Simon Atanasyand96e3152013-04-14 14:07:30 +00004658 IsSingleFloat = true;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004659 else if (*it == "+soft-float")
4660 FloatABI = SoftFloat;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004661 else if (*it == "+mips16")
4662 IsMips16 = true;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004663 else if (*it == "+micromips")
4664 IsMicromips = true;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004665 else if (*it == "+dsp")
4666 DspRev = std::max(DspRev, DSP1);
4667 else if (*it == "+dspr2")
4668 DspRev = std::max(DspRev, DSP2);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004669 }
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004670
4671 // Remove front-end specific option.
4672 std::vector<std::string>::iterator it =
4673 std::find(Features.begin(), Features.end(), "+soft-float");
4674 if (it != Features.end())
4675 Features.erase(it);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004676 }
Logan Chiena8f7a972013-02-23 04:24:36 +00004677
4678 virtual int getEHDataRegisterNumber(unsigned RegNo) const {
4679 if (RegNo == 0) return 4;
4680 if (RegNo == 1) return 5;
4681 return -1;
4682 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004683};
4684
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004685const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = {
4686#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4687#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4688 ALL_LANGUAGES },
4689#include "clang/Basic/BuiltinsMips.def"
4690};
4691
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004692class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004693public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004694 Mips32TargetInfoBase(const llvm::Triple &Triple)
4695 : MipsTargetInfoBase(Triple, "o32", "mips32") {
Akira Hatanaka148735e2011-11-05 01:48:34 +00004696 SizeType = UnsignedInt;
4697 PtrDiffType = SignedInt;
Akira Hatanakadbee9492013-01-18 21:58:11 +00004698 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Akira Hatanaka148735e2011-11-05 01:48:34 +00004699 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004700 virtual bool setABI(const std::string &Name) {
4701 if ((Name == "o32") || (Name == "eabi")) {
4702 ABI = Name;
4703 return true;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004704 } else if (Name == "32") {
4705 ABI = "o32";
4706 return true;
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004707 } else
4708 return false;
4709 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004710 virtual void getTargetDefines(const LangOptions &Opts,
4711 MacroBuilder &Builder) const {
4712 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004713
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004714 if (ABI == "o32") {
4715 Builder.defineMacro("__mips_o32");
4716 Builder.defineMacro("_ABIO32", "1");
4717 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
4718 }
4719 else if (ABI == "eabi")
4720 Builder.defineMacro("__mips_eabi");
4721 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004722 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004723 }
4724 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4725 unsigned &NumAliases) const {
4726 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4727 { { "at" }, "$1" },
4728 { { "v0" }, "$2" },
4729 { { "v1" }, "$3" },
4730 { { "a0" }, "$4" },
4731 { { "a1" }, "$5" },
4732 { { "a2" }, "$6" },
4733 { { "a3" }, "$7" },
4734 { { "t0" }, "$8" },
4735 { { "t1" }, "$9" },
4736 { { "t2" }, "$10" },
4737 { { "t3" }, "$11" },
4738 { { "t4" }, "$12" },
4739 { { "t5" }, "$13" },
4740 { { "t6" }, "$14" },
4741 { { "t7" }, "$15" },
4742 { { "s0" }, "$16" },
4743 { { "s1" }, "$17" },
4744 { { "s2" }, "$18" },
4745 { { "s3" }, "$19" },
4746 { { "s4" }, "$20" },
4747 { { "s5" }, "$21" },
4748 { { "s6" }, "$22" },
4749 { { "s7" }, "$23" },
4750 { { "t8" }, "$24" },
4751 { { "t9" }, "$25" },
4752 { { "k0" }, "$26" },
4753 { { "k1" }, "$27" },
4754 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004755 { { "sp","$sp" }, "$29" },
4756 { { "fp","$fp" }, "$30" },
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004757 { { "ra" }, "$31" }
4758 };
4759 Aliases = GCCRegAliases;
4760 NumAliases = llvm::array_lengthof(GCCRegAliases);
4761 }
4762};
4763
4764class Mips32EBTargetInfo : public Mips32TargetInfoBase {
4765public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004766 Mips32EBTargetInfo(const llvm::Triple &Triple)
4767 : Mips32TargetInfoBase(Triple) {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004768 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 +00004769 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004770 }
4771 virtual void getTargetDefines(const LangOptions &Opts,
4772 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004773 DefineStd(Builder, "MIPSEB", Opts);
4774 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004775 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004776 }
4777};
4778
4779class Mips32ELTargetInfo : public Mips32TargetInfoBase {
4780public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004781 Mips32ELTargetInfo(const llvm::Triple &Triple)
4782 : Mips32TargetInfoBase(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004783 BigEndian = false;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004784 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 +00004785 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004786 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004787 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004788 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004789 DefineStd(Builder, "MIPSEL", Opts);
4790 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004791 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004792 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004793};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004794
4795class Mips64TargetInfoBase : public MipsTargetInfoBase {
4796 virtual void SetDescriptionString(const std::string &Name) = 0;
4797public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004798 Mips64TargetInfoBase(const llvm::Triple &Triple)
4799 : MipsTargetInfoBase(Triple, "n64", "mips64") {
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004800 LongWidth = LongAlign = 64;
4801 PointerWidth = PointerAlign = 64;
4802 LongDoubleWidth = LongDoubleAlign = 128;
4803 LongDoubleFormat = &llvm::APFloat::IEEEquad;
David Chisnall6e399b42012-12-08 09:06:08 +00004804 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
4805 LongDoubleWidth = LongDoubleAlign = 64;
4806 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
4807 }
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004808 SuitableAlign = 128;
Akira Hatanakadbee9492013-01-18 21:58:11 +00004809 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004810 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004811 virtual bool setABI(const std::string &Name) {
4812 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004813 if (Name == "n32") {
4814 LongWidth = LongAlign = 32;
4815 PointerWidth = PointerAlign = 32;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004816 ABI = Name;
4817 return true;
4818 } else if (Name == "n64") {
4819 ABI = Name;
4820 return true;
4821 } else if (Name == "64") {
4822 ABI = "n64";
4823 return true;
4824 } else
4825 return false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004826 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004827 virtual void getTargetDefines(const LangOptions &Opts,
4828 MacroBuilder &Builder) const {
4829 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004830
Simon Atanasyan600a5132012-08-29 20:50:11 +00004831 Builder.defineMacro("__mips64");
4832 Builder.defineMacro("__mips64__");
4833
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004834 if (ABI == "n32") {
4835 Builder.defineMacro("__mips_n32");
4836 Builder.defineMacro("_ABIN32", "2");
4837 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
4838 }
4839 else if (ABI == "n64") {
4840 Builder.defineMacro("__mips_n64");
4841 Builder.defineMacro("_ABI64", "3");
4842 Builder.defineMacro("_MIPS_SIM", "_ABI64");
4843 }
4844 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004845 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004846 }
4847 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4848 unsigned &NumAliases) const {
4849 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4850 { { "at" }, "$1" },
4851 { { "v0" }, "$2" },
4852 { { "v1" }, "$3" },
4853 { { "a0" }, "$4" },
4854 { { "a1" }, "$5" },
4855 { { "a2" }, "$6" },
4856 { { "a3" }, "$7" },
4857 { { "a4" }, "$8" },
4858 { { "a5" }, "$9" },
4859 { { "a6" }, "$10" },
4860 { { "a7" }, "$11" },
4861 { { "t0" }, "$12" },
4862 { { "t1" }, "$13" },
4863 { { "t2" }, "$14" },
4864 { { "t3" }, "$15" },
4865 { { "s0" }, "$16" },
4866 { { "s1" }, "$17" },
4867 { { "s2" }, "$18" },
4868 { { "s3" }, "$19" },
4869 { { "s4" }, "$20" },
4870 { { "s5" }, "$21" },
4871 { { "s6" }, "$22" },
4872 { { "s7" }, "$23" },
4873 { { "t8" }, "$24" },
4874 { { "t9" }, "$25" },
4875 { { "k0" }, "$26" },
4876 { { "k1" }, "$27" },
4877 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004878 { { "sp","$sp" }, "$29" },
4879 { { "fp","$fp" }, "$30" },
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004880 { { "ra" }, "$31" }
4881 };
4882 Aliases = GCCRegAliases;
4883 NumAliases = llvm::array_lengthof(GCCRegAliases);
4884 }
4885};
4886
4887class Mips64EBTargetInfo : public Mips64TargetInfoBase {
4888 virtual void SetDescriptionString(const std::string &Name) {
4889 // Change DescriptionString only if ABI is n32.
4890 if (Name == "n32")
4891 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 +00004892 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004893 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004894 }
4895public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004896 Mips64EBTargetInfo(const llvm::Triple &Triple)
4897 : Mips64TargetInfoBase(Triple) {
4898 // Default ABI is n64.
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004899 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 +00004900 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004901 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004902 }
4903 virtual void getTargetDefines(const LangOptions &Opts,
4904 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004905 DefineStd(Builder, "MIPSEB", Opts);
4906 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004907 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004908 }
4909};
4910
4911class Mips64ELTargetInfo : public Mips64TargetInfoBase {
4912 virtual void SetDescriptionString(const std::string &Name) {
4913 // Change DescriptionString only if ABI is n32.
4914 if (Name == "n32")
4915 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 +00004916 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004917 "-v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004918 }
4919public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004920 Mips64ELTargetInfo(const llvm::Triple &Triple)
4921 : Mips64TargetInfoBase(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004922 // Default ABI is n64.
4923 BigEndian = false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004924 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 +00004925 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004926 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004927 }
4928 virtual void getTargetDefines(const LangOptions &Opts,
4929 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004930 DefineStd(Builder, "MIPSEL", Opts);
4931 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004932 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004933 }
4934};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004935} // end anonymous namespace.
4936
Ivan Krasinef05abd2011-08-24 20:22:22 +00004937namespace {
4938class PNaClTargetInfo : public TargetInfo {
4939public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004940 PNaClTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004941 BigEndian = false;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004942 this->UserLabelPrefix = "";
4943 this->LongAlign = 32;
4944 this->LongWidth = 32;
4945 this->PointerAlign = 32;
4946 this->PointerWidth = 32;
4947 this->IntMaxType = TargetInfo::SignedLongLong;
4948 this->UIntMaxType = TargetInfo::UnsignedLongLong;
4949 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00004950 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00004951 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00004952 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00004953 this->SizeType = TargetInfo::UnsignedInt;
4954 this->PtrDiffType = TargetInfo::SignedInt;
4955 this->IntPtrType = TargetInfo::SignedInt;
Eli Benderskyc0783dc2013-04-08 21:31:01 +00004956 this->RegParmMax = 0; // Disallow regparm
Ivan Krasinef05abd2011-08-24 20:22:22 +00004957 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
4958 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
4959 }
4960
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004961 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00004962 }
4963 virtual void getArchDefines(const LangOptions &Opts,
4964 MacroBuilder &Builder) const {
4965 Builder.defineMacro("__le32__");
4966 Builder.defineMacro("__pnacl__");
4967 }
4968 virtual void getTargetDefines(const LangOptions &Opts,
4969 MacroBuilder &Builder) const {
Jan Wen Voungdde3bdb2012-03-29 00:05:59 +00004970 Builder.defineMacro("__LITTLE_ENDIAN__");
Ivan Krasinef05abd2011-08-24 20:22:22 +00004971 getArchDefines(Opts, Builder);
4972 }
Douglas Gregore727d212012-01-30 06:38:25 +00004973 virtual bool hasFeature(StringRef Feature) const {
4974 return Feature == "pnacl";
4975 }
Ivan Krasinef05abd2011-08-24 20:22:22 +00004976 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4977 unsigned &NumRecords) const {
4978 }
Meador Ingec5613b22012-06-16 03:34:49 +00004979 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4980 return TargetInfo::PNaClABIBuiltinVaList;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004981 }
4982 virtual void getGCCRegNames(const char * const *&Names,
4983 unsigned &NumNames) const;
4984 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4985 unsigned &NumAliases) const;
4986 virtual bool validateAsmConstraint(const char *&Name,
4987 TargetInfo::ConstraintInfo &Info) const {
4988 return false;
4989 }
4990
4991 virtual const char *getClobbers() const {
4992 return "";
4993 }
4994};
4995
4996void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
4997 unsigned &NumNames) const {
4998 Names = NULL;
4999 NumNames = 0;
5000}
5001
5002void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
5003 unsigned &NumAliases) const {
5004 Aliases = NULL;
5005 NumAliases = 0;
5006}
5007} // end anonymous namespace.
5008
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005009namespace {
5010 static const unsigned SPIRAddrSpaceMap[] = {
5011 1, // opencl_global
5012 3, // opencl_local
5013 2, // opencl_constant
5014 0, // cuda_device
5015 0, // cuda_constant
5016 0 // cuda_shared
5017 };
5018 class SPIRTargetInfo : public TargetInfo {
5019 static const char * const GCCRegNames[];
5020 static const Builtin::Info BuiltinInfo[];
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00005021 std::vector<StringRef> AvailableFeatures;
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005022 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005023 SPIRTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005024 assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
5025 "SPIR target must use unknown OS");
5026 assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
5027 "SPIR target must use unknown environment type");
5028 BigEndian = false;
5029 TLSSupported = false;
5030 LongWidth = LongAlign = 64;
5031 AddrSpaceMap = &SPIRAddrSpaceMap;
5032 // Define available target features
5033 // These must be defined in sorted order!
5034 NoAsmVariants = true;
5035 }
5036 virtual void getTargetDefines(const LangOptions &Opts,
5037 MacroBuilder &Builder) const {
5038 DefineStd(Builder, "SPIR", Opts);
5039 }
5040 virtual bool hasFeature(StringRef Feature) const {
5041 return Feature == "spir";
5042 }
5043
5044 virtual void getTargetBuiltins(const Builtin::Info *&Records,
5045 unsigned &NumRecords) const {}
5046 virtual const char *getClobbers() const {
5047 return "";
5048 }
5049 virtual void getGCCRegNames(const char * const *&Names,
5050 unsigned &NumNames) const {}
5051 virtual bool validateAsmConstraint(const char *&Name,
5052 TargetInfo::ConstraintInfo &info) const {
5053 return true;
5054 }
5055 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
5056 unsigned &NumAliases) const {}
5057 virtual BuiltinVaListKind getBuiltinVaListKind() const {
5058 return TargetInfo::VoidPtrBuiltinVaList;
5059 }
5060 };
5061
5062
5063 class SPIR32TargetInfo : public SPIRTargetInfo {
5064 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005065 SPIR32TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005066 PointerWidth = PointerAlign = 32;
5067 SizeType = TargetInfo::UnsignedInt;
5068 PtrDiffType = IntPtrType = TargetInfo::SignedInt;
5069 DescriptionString
Guy Benyeif3ddf632013-03-07 13:06:10 +00005070 = "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 +00005071 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-"
5072 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-"
5073 "v512:512:512-v1024:1024:1024";
Guy Benyeif3ddf632013-03-07 13:06:10 +00005074 }
5075 virtual void getTargetDefines(const LangOptions &Opts,
5076 MacroBuilder &Builder) const {
5077 DefineStd(Builder, "SPIR32", Opts);
5078 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005079 };
5080
5081 class SPIR64TargetInfo : public SPIRTargetInfo {
5082 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005083 SPIR64TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005084 PointerWidth = PointerAlign = 64;
5085 SizeType = TargetInfo::UnsignedLong;
5086 PtrDiffType = IntPtrType = TargetInfo::SignedLong;
5087 DescriptionString
Guy Benyeif3ddf632013-03-07 13:06:10 +00005088 = "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 +00005089 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-"
5090 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-"
5091 "v512:512:512-v1024:1024:1024";
Guy Benyeif3ddf632013-03-07 13:06:10 +00005092 }
5093 virtual void getTargetDefines(const LangOptions &Opts,
5094 MacroBuilder &Builder) const {
5095 DefineStd(Builder, "SPIR64", Opts);
5096 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005097 };
5098}
5099
Ivan Krasinef05abd2011-08-24 20:22:22 +00005100
Reid Spencer5f016e22007-07-11 17:01:13 +00005101//===----------------------------------------------------------------------===//
5102// Driver code
5103//===----------------------------------------------------------------------===//
5104
Benjamin Kramer9df08232013-06-29 16:37:14 +00005105static TargetInfo *AllocateTarget(const llvm::Triple &Triple) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005106 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00005107
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005108 switch (Triple.getArch()) {
5109 default:
5110 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00005111
Tony Linthicum96319392011-12-12 21:14:55 +00005112 case llvm::Triple::hexagon:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005113 return new HexagonTargetInfo(Triple);
Tony Linthicum96319392011-12-12 21:14:55 +00005114
Tim Northoverc264e162013-01-31 12:13:10 +00005115 case llvm::Triple::aarch64:
5116 switch (os) {
5117 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005118 return new LinuxTargetInfo<AArch64TargetInfo>(Triple);
Tim Northoverc264e162013-01-31 12:13:10 +00005119 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005120 return new AArch64TargetInfo(Triple);
Tim Northoverc264e162013-01-31 12:13:10 +00005121 }
5122
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005123 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00005124 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005125 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005126 return new DarwinARMTargetInfo(Triple);
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005127
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005128 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00005129 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005130 return new LinuxTargetInfo<ARMTargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005131 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005132 return new FreeBSDTargetInfo<ARMTargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005133 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005134 return new NetBSDTargetInfo<ARMTargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005135 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005136 return new OpenBSDTargetInfo<ARMTargetInfo>(Triple);
Eli Friedman42f74f22012-08-08 23:57:20 +00005137 case llvm::Triple::Bitrig:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005138 return new BitrigTargetInfo<ARMTargetInfo>(Triple);
Douglas Gregordca52262011-07-01 22:41:14 +00005139 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005140 return new RTEMSTargetInfo<ARMTargetInfo>(Triple);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005141 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005142 return new NaClTargetInfo<ARMTargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005143 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005144 return new ARMTargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005145 }
Eli Friedman61538a72008-05-20 14:21:01 +00005146
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005147 case llvm::Triple::msp430:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005148 return new MSP430TargetInfo(Triple);
Eli Friedman61538a72008-05-20 14:21:01 +00005149
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005150 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005151 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005152 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005153 return new LinuxTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005154 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005155 return new RTEMSTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005156 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005157 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005158 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005159 return new NetBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005160 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005161 return new Mips32EBTargetInfo(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005162 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005163
5164 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005165 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005166 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005167 return new LinuxTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005168 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005169 return new RTEMSTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005170 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005171 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005172 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005173 return new NetBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005174 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005175 return new Mips32ELTargetInfo(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005176 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005177
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005178 case llvm::Triple::mips64:
5179 switch (os) {
5180 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005181 return new LinuxTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005182 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005183 return new RTEMSTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005184 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005185 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005186 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005187 return new NetBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005188 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005189 return new OpenBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005190 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005191 return new Mips64EBTargetInfo(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005192 }
5193
5194 case llvm::Triple::mips64el:
5195 switch (os) {
5196 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005197 return new LinuxTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005198 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005199 return new RTEMSTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005200 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005201 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005202 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005203 return new NetBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005204 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005205 return new OpenBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005206 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005207 return new Mips64ELTargetInfo(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005208 }
5209
Ivan Krasinef05abd2011-08-24 20:22:22 +00005210 case llvm::Triple::le32:
5211 switch (os) {
Eli Bendersky441d9f72012-12-04 18:38:10 +00005212 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005213 return new NaClTargetInfo<PNaClTargetInfo>(Triple);
Ivan Krasinef05abd2011-08-24 20:22:22 +00005214 default:
5215 return NULL;
5216 }
5217
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005218 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005219 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005220 return new DarwinPPC32TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005221 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005222 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005223 return new LinuxTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005224 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005225 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005226 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005227 return new NetBSDTargetInfo<PPC32TargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005228 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005229 return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005230 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005231 return new RTEMSTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005232 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005233 return new PPC32TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005234 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005235
5236 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005237 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005238 return new DarwinPPC64TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005239 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005240 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005241 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005242 case llvm::Triple::Lv2:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005243 return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005244 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005245 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005246 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005247 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005248 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005249 return new PPC64TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005250 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005251
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00005252 case llvm::Triple::ppc64le:
5253 switch (os) {
5254 case llvm::Triple::Linux:
5255 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
5256 default:
5257 return new PPC64TargetInfo(Triple);
5258 }
5259
Peter Collingbourneedb66f32012-05-20 23:28:41 +00005260 case llvm::Triple::nvptx:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005261 return new NVPTX32TargetInfo(Triple);
Peter Collingbourneedb66f32012-05-20 23:28:41 +00005262 case llvm::Triple::nvptx64:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005263 return new NVPTX64TargetInfo(Triple);
Peter Collingbourneedb66f32012-05-20 23:28:41 +00005264
Eli Friedman6505a292012-10-12 23:32:00 +00005265 case llvm::Triple::r600:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005266 return new R600TargetInfo(Triple);
Eli Friedman6505a292012-10-12 23:32:00 +00005267
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005268 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005269 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005270 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005271 return new LinuxTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005272 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005273 return new AuroraUXSparcV8TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005274 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005275 return new SolarisSparcV8TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005276 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005277 return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005278 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005279 return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005280 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005281 return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005282 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005283 return new SparcV8TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005284 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005285
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005286 case llvm::Triple::sparcv9:
5287 switch (os) {
5288 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005289 return new LinuxTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005290 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005291 return new AuroraUXTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005292 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005293 return new SolarisTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005294 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005295 return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005296 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005297 return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005298 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005299 return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005300 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005301 return new SparcV9TargetInfo(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005302 }
5303
Ulrich Weigandb8409212013-05-06 16:26:41 +00005304 case llvm::Triple::systemz:
5305 switch (os) {
5306 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005307 return new LinuxTargetInfo<SystemZTargetInfo>(Triple);
Ulrich Weigandb8409212013-05-06 16:26:41 +00005308 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005309 return new SystemZTargetInfo(Triple);
Ulrich Weigandb8409212013-05-06 16:26:41 +00005310 }
5311
Eli Friedmanb63decf2009-08-19 20:47:07 +00005312 case llvm::Triple::tce:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005313 return new TCETargetInfo(Triple);
Eli Friedmanb63decf2009-08-19 20:47:07 +00005314
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005315 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005316 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005317 return new DarwinI386TargetInfo(Triple);
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005318
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005319 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00005320 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005321 return new AuroraUXTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005322 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005323 return new LinuxTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005324 case llvm::Triple::DragonFly:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005325 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005326 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005327 return new NetBSDI386TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005328 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005329 return new OpenBSDI386TargetInfo(Triple);
Eli Friedman42f74f22012-08-08 23:57:20 +00005330 case llvm::Triple::Bitrig:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005331 return new BitrigI386TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005332 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005333 return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple);
Chris Lattner38e317d2010-07-07 16:01:42 +00005334 case llvm::Triple::Minix:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005335 return new MinixTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005336 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005337 return new SolarisTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005338 case llvm::Triple::Cygwin:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005339 return new CygwinX86_32TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005340 case llvm::Triple::MinGW32:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005341 return new MinGWX86_32TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005342 case llvm::Triple::Win32:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005343 return new VisualStudioWindowsX86_32TargetInfo(Triple);
Chris Lattner86ed3a32010-04-11 19:29:39 +00005344 case llvm::Triple::Haiku:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005345 return new HaikuX86_32TargetInfo(Triple);
Douglas Gregordca52262011-07-01 22:41:14 +00005346 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005347 return new RTEMSX86_32TargetInfo(Triple);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005348 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005349 return new NaClTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005350 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005351 return new X86_32TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005352 }
5353
5354 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005355 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
Benjamin Kramer9df08232013-06-29 16:37:14 +00005356 return new DarwinX86_64TargetInfo(Triple);
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005357
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005358 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00005359 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005360 return new AuroraUXTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005361 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005362 return new LinuxTargetInfo<X86_64TargetInfo>(Triple);
Chris Lattner7a7ca282010-01-09 05:41:14 +00005363 case llvm::Triple::DragonFly:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005364 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005365 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005366 return new NetBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005367 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005368 return new OpenBSDX86_64TargetInfo(Triple);
Eli Friedman42f74f22012-08-08 23:57:20 +00005369 case llvm::Triple::Bitrig:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005370 return new BitrigX86_64TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005371 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005372 return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005373 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005374 return new SolarisTargetInfo<X86_64TargetInfo>(Triple);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00005375 case llvm::Triple::MinGW32:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005376 return new MinGWX86_64TargetInfo(Triple);
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00005377 case llvm::Triple::Win32: // This is what Triple.h supports now.
Benjamin Kramer9df08232013-06-29 16:37:14 +00005378 return new VisualStudioWindowsX86_64TargetInfo(Triple);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005379 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005380 return new NaClTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005381 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005382 return new X86_64TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005383 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005384
5385 case llvm::Triple::spir: {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005386 if (Triple.getOS() != llvm::Triple::UnknownOS ||
Benjamin Kramer9df08232013-06-29 16:37:14 +00005387 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005388 return NULL;
Benjamin Kramer9df08232013-06-29 16:37:14 +00005389 return new SPIR32TargetInfo(Triple);
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005390 }
5391 case llvm::Triple::spir64: {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005392 if (Triple.getOS() != llvm::Triple::UnknownOS ||
Benjamin Kramer9df08232013-06-29 16:37:14 +00005393 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005394 return NULL;
Benjamin Kramer9df08232013-06-29 16:37:14 +00005395 return new SPIR64TargetInfo(Triple);
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005396 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005397 }
Reid Spencer5f016e22007-07-11 17:01:13 +00005398}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005399
5400/// CreateTargetInfo - Return the target info object for the specified target
5401/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00005402TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Douglas Gregor49a87542012-11-16 04:24:59 +00005403 TargetOptions *Opts) {
5404 llvm::Triple Triple(Opts->Triple);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005405
5406 // Construct the target
Benjamin Kramer9df08232013-06-29 16:37:14 +00005407 OwningPtr<TargetInfo> Target(AllocateTarget(Triple));
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005408 if (!Target) {
5409 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
5410 return 0;
5411 }
Douglas Gregor9a022bb2012-10-15 16:45:32 +00005412 Target->setTargetOpts(Opts);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005413
Daniel Dunbareac7c532009-12-18 18:42:37 +00005414 // Set the target CPU if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00005415 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
5416 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
Daniel Dunbareac7c532009-12-18 18:42:37 +00005417 return 0;
5418 }
5419
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005420 // Set the target ABI if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00005421 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
5422 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005423 return 0;
5424 }
5425
Charles Davis98b7c5c2010-06-11 01:06:47 +00005426 // Set the target C++ ABI.
Douglas Gregor49a87542012-11-16 04:24:59 +00005427 if (!Opts->CXXABI.empty() && !Target->setCXXABI(Opts->CXXABI)) {
5428 Diags.Report(diag::err_target_unknown_cxxabi) << Opts->CXXABI;
Charles Davis98b7c5c2010-06-11 01:06:47 +00005429 return 0;
5430 }
5431
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005432 // Compute the default target features, we need the target to handle this
5433 // because features may have dependencies on one another.
5434 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00005435 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005436
5437 // Apply the user specified deltas.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005438 // First the enables.
Douglas Gregor57016dd2012-10-16 23:40:58 +00005439 for (std::vector<std::string>::const_iterator
Douglas Gregor49a87542012-11-16 04:24:59 +00005440 it = Opts->FeaturesAsWritten.begin(),
5441 ie = Opts->FeaturesAsWritten.end();
Douglas Gregor57016dd2012-10-16 23:40:58 +00005442 it != ie; ++it) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005443 const char *Name = it->c_str();
5444
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005445 if (Name[0] != '+')
5446 continue;
5447
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005448 // Apply the feature via the target.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005449 if (!Target->setFeatureEnabled(Features, Name + 1, true)) {
5450 Diags.Report(diag::err_target_invalid_feature) << Name;
5451 return 0;
5452 }
5453 }
5454
5455 // Then the disables.
Douglas Gregor57016dd2012-10-16 23:40:58 +00005456 for (std::vector<std::string>::const_iterator
Douglas Gregor49a87542012-11-16 04:24:59 +00005457 it = Opts->FeaturesAsWritten.begin(),
5458 ie = Opts->FeaturesAsWritten.end();
Douglas Gregor57016dd2012-10-16 23:40:58 +00005459 it != ie; ++it) {
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005460 const char *Name = it->c_str();
5461
5462 if (Name[0] == '+')
5463 continue;
5464
5465 // Apply the feature via the target.
5466 if (Name[0] != '-' ||
5467 !Target->setFeatureEnabled(Features, Name + 1, false)) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005468 Diags.Report(diag::err_target_invalid_feature) << Name;
5469 return 0;
5470 }
5471 }
5472
5473 // Add the features to the compile options.
5474 //
5475 // FIXME: If we are completely confident that we have the right set, we only
5476 // need to pass the minuses.
Douglas Gregor49a87542012-11-16 04:24:59 +00005477 Opts->Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005478 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
5479 ie = Features.end(); it != ie; ++it)
Douglas Gregor49a87542012-11-16 04:24:59 +00005480 Opts->Features.push_back((it->second ? "+" : "-") + it->first().str());
5481 Target->HandleTargetFeatures(Opts->Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005482
5483 return Target.take();
5484}