blob: cabdffa68c27c4614419fa4c0399fc6c1bad76fc [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:
Douglas Gregora3844922009-07-01 15:12:53 +000076 OSTargetInfo(const std::string& 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:
182 DarwinTargetInfo(const std::string& triple) :
183 OSTargetInfo<Target>(triple) {
Eric Christopheraa7333c2011-07-02 00:20:22 +0000184 llvm::Triple T = llvm::Triple(triple);
185 this->TLSSupported = T.isMacOSX() && !T.isMacOSXVersionLT(10,7);
Daniel Dunbare177d3b2011-02-21 23:12:51 +0000186 this->MCountName = "\01mcount";
Torok Edwin5f6c1942009-06-30 17:10:35 +0000187 }
188
Chris Lattner5f9e2722011-07-23 10:55:15 +0000189 virtual std::string isValidSectionSpecifier(StringRef SR) const {
Chris Lattner797c3c42009-08-10 19:03:04 +0000190 // Let MCSectionMachO validate this.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000191 StringRef Segment, Section;
Chris Lattner797c3c42009-08-10 19:03:04 +0000192 unsigned TAA, StubSize;
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000193 bool HasTAA;
Chris Lattner797c3c42009-08-10 19:03:04 +0000194 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000195 TAA, HasTAA, StubSize);
Chris Lattner797c3c42009-08-10 19:03:04 +0000196 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000197
Anders Carlsson18af3682010-06-08 22:47:50 +0000198 virtual const char *getStaticInitSectionSpecifier() const {
199 // FIXME: We should return 0 when building kexts.
200 return "__TEXT,__StaticInit,regular,pure_instructions";
201 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000202
John McCall41887602012-01-29 01:20:30 +0000203 /// Darwin does not support protected visibility. Darwin's "default"
204 /// is very similar to ELF's "protected"; Darwin requires a "weak"
205 /// attribute on declarations that can be dynamically replaced.
206 virtual bool hasProtectedVisibility() const {
207 return false;
208 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000209};
210
Chris Lattner797c3c42009-08-10 19:03:04 +0000211
Torok Edwin5f6c1942009-06-30 17:10:35 +0000212// DragonFlyBSD Target
213template<typename Target>
214class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
215protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000216 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000217 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000218 // DragonFly defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000219 Builder.defineMacro("__DragonFly__");
220 Builder.defineMacro("__DragonFly_cc_version", "100001");
221 Builder.defineMacro("__ELF__");
222 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
223 Builder.defineMacro("__tune_i386__");
224 DefineStd(Builder, "unix", Opts);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000225 }
226public:
Mike Stump1eb44332009-09-09 15:08:12 +0000227 DragonFlyBSDTargetInfo(const std::string &triple)
Eli Friedmanb089c4d2012-02-10 23:02:29 +0000228 : OSTargetInfo<Target>(triple) {
229 this->UserLabelPrefix = "";
230
231 llvm::Triple Triple(triple);
232 switch (Triple.getArch()) {
233 default:
234 case llvm::Triple::x86:
235 case llvm::Triple::x86_64:
236 this->MCountName = ".mcount";
237 break;
238 }
239 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000240};
241
242// FreeBSD Target
243template<typename Target>
244class FreeBSDTargetInfo : public OSTargetInfo<Target> {
245protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000246 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000247 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000248 // FreeBSD defines; list based off of gcc output
249
Benjamin Kramer474202f2011-10-18 10:10:08 +0000250 unsigned Release = Triple.getOSMajorVersion();
251 if (Release == 0U)
252 Release = 8;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000253
Benjamin Kramer474202f2011-10-18 10:10:08 +0000254 Builder.defineMacro("__FreeBSD__", Twine(Release));
255 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramera9992772010-01-09 17:55:51 +0000256 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
257 DefineStd(Builder, "unix", Opts);
258 Builder.defineMacro("__ELF__");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000259 }
260public:
Mike Stump1eb44332009-09-09 15:08:12 +0000261 FreeBSDTargetInfo(const std::string &triple)
Duncan Sands1e90faf2009-07-08 13:55:08 +0000262 : OSTargetInfo<Target>(triple) {
263 this->UserLabelPrefix = "";
Roman Divackybe4c8702011-02-10 16:52:03 +0000264
265 llvm::Triple Triple(triple);
266 switch (Triple.getArch()) {
267 default:
268 case llvm::Triple::x86:
269 case llvm::Triple::x86_64:
270 this->MCountName = ".mcount";
271 break;
272 case llvm::Triple::mips:
273 case llvm::Triple::mipsel:
274 case llvm::Triple::ppc:
275 case llvm::Triple::ppc64:
276 this->MCountName = "_mcount";
277 break;
278 case llvm::Triple::arm:
279 this->MCountName = "__mcount";
280 break;
281 }
282
Duncan Sands1e90faf2009-07-08 13:55:08 +0000283 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000284};
285
Chris Lattner38e317d2010-07-07 16:01:42 +0000286// Minix Target
287template<typename Target>
288class MinixTargetInfo : public OSTargetInfo<Target> {
289protected:
290 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
291 MacroBuilder &Builder) const {
292 // Minix defines
293
294 Builder.defineMacro("__minix", "3");
295 Builder.defineMacro("_EM_WSIZE", "4");
296 Builder.defineMacro("_EM_PSIZE", "4");
297 Builder.defineMacro("_EM_SSIZE", "2");
298 Builder.defineMacro("_EM_LSIZE", "4");
299 Builder.defineMacro("_EM_FSIZE", "4");
300 Builder.defineMacro("_EM_DSIZE", "8");
Eli Friedman6d402dc2011-12-08 23:54:21 +0000301 Builder.defineMacro("__ELF__");
Chris Lattner38e317d2010-07-07 16:01:42 +0000302 DefineStd(Builder, "unix", Opts);
303 }
304public:
305 MinixTargetInfo(const std::string &triple)
306 : OSTargetInfo<Target>(triple) {
307 this->UserLabelPrefix = "";
308 }
309};
310
Torok Edwin5f6c1942009-06-30 17:10:35 +0000311// Linux target
312template<typename Target>
313class LinuxTargetInfo : public OSTargetInfo<Target> {
314protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000315 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000316 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000317 // Linux defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000318 DefineStd(Builder, "unix", Opts);
319 DefineStd(Builder, "linux", Opts);
320 Builder.defineMacro("__gnu_linux__");
321 Builder.defineMacro("__ELF__");
Logan Chien94a71422012-09-02 09:30:11 +0000322 if (Triple.getEnvironment() == llvm::Triple::Android)
Evgeniy Stepanov32064032012-04-26 12:08:09 +0000323 Builder.defineMacro("__ANDROID__", "1");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000324 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000325 Builder.defineMacro("_REENTRANT");
Douglas Gregor2b003fd2010-04-21 05:52:38 +0000326 if (Opts.CPlusPlus)
327 Builder.defineMacro("_GNU_SOURCE");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000328 }
329public:
Mike Stump1eb44332009-09-09 15:08:12 +0000330 LinuxTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000331 : OSTargetInfo<Target>(triple) {
332 this->UserLabelPrefix = "";
Douglas Gregor12e84642011-01-12 21:19:25 +0000333 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000334 }
Benjamin Kramer86d18c52011-10-15 17:53:33 +0000335
336 virtual const char *getStaticInitSectionSpecifier() const {
337 return ".text.startup";
338 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000339};
340
Chris Lattnerb62bb282009-07-13 20:29:08 +0000341// NetBSD Target
342template<typename Target>
343class NetBSDTargetInfo : public OSTargetInfo<Target> {
344protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000345 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000346 MacroBuilder &Builder) const {
Chris Lattnerb62bb282009-07-13 20:29:08 +0000347 // NetBSD defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000348 Builder.defineMacro("__NetBSD__");
349 Builder.defineMacro("__unix__");
350 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000351 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000352 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerb62bb282009-07-13 20:29:08 +0000353 }
354public:
Mike Stump1eb44332009-09-09 15:08:12 +0000355 NetBSDTargetInfo(const std::string &triple)
Chris Lattnerb62bb282009-07-13 20:29:08 +0000356 : OSTargetInfo<Target>(triple) {
357 this->UserLabelPrefix = "";
358 }
359};
360
Torok Edwin5f6c1942009-06-30 17:10:35 +0000361// OpenBSD Target
362template<typename Target>
363class OpenBSDTargetInfo : public OSTargetInfo<Target> {
364protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000365 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000366 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000367 // OpenBSD defines; list based off of gcc output
368
Benjamin Kramera9992772010-01-09 17:55:51 +0000369 Builder.defineMacro("__OpenBSD__");
370 DefineStd(Builder, "unix", Opts);
371 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000372 if (Opts.POSIXThreads)
Chris Lattner4ddcf3b2012-04-25 06:12:24 +0000373 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000374 }
375public:
Mike Stump1eb44332009-09-09 15:08:12 +0000376 OpenBSDTargetInfo(const std::string &triple)
Eli Friedman62d829a2011-12-15 02:15:56 +0000377 : OSTargetInfo<Target>(triple) {
378 this->UserLabelPrefix = "";
Hans Wennborge48667f2012-08-01 18:53:19 +0000379 this->TLSSupported = false;
Eli Friedman62d829a2011-12-15 02:15:56 +0000380
381 llvm::Triple Triple(triple);
382 switch (Triple.getArch()) {
383 default:
384 case llvm::Triple::x86:
385 case llvm::Triple::x86_64:
386 case llvm::Triple::arm:
Eric Christopher825d3862012-11-14 22:08:59 +0000387 case llvm::Triple::sparc:
Eli Friedman62d829a2011-12-15 02:15:56 +0000388 this->MCountName = "__mcount";
389 break;
390 case llvm::Triple::mips64:
391 case llvm::Triple::mips64el:
392 case llvm::Triple::ppc:
Eric Christopher825d3862012-11-14 22:08:59 +0000393 case llvm::Triple::sparcv9:
Eli Friedman62d829a2011-12-15 02:15:56 +0000394 this->MCountName = "_mcount";
395 break;
396 }
397 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000398};
399
Eli Friedman42f74f22012-08-08 23:57:20 +0000400// Bitrig Target
401template<typename Target>
402class BitrigTargetInfo : public OSTargetInfo<Target> {
403protected:
404 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
405 MacroBuilder &Builder) const {
406 // Bitrig defines; list based off of gcc output
407
408 Builder.defineMacro("__Bitrig__");
409 DefineStd(Builder, "unix", Opts);
410 Builder.defineMacro("__ELF__");
411 if (Opts.POSIXThreads)
412 Builder.defineMacro("_REENTRANT");
413 }
414public:
415 BitrigTargetInfo(const std::string &triple)
416 : OSTargetInfo<Target>(triple) {
417 this->UserLabelPrefix = "";
418 this->TLSSupported = false;
419 this->MCountName = "__mcount";
420 }
421};
422
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000423// PSP Target
424template<typename Target>
425class PSPTargetInfo : public OSTargetInfo<Target> {
426protected:
427 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000428 MacroBuilder &Builder) const {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000429 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramera9992772010-01-09 17:55:51 +0000430 Builder.defineMacro("PSP");
431 Builder.defineMacro("_PSP");
432 Builder.defineMacro("__psp__");
433 Builder.defineMacro("__ELF__");
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000434 }
435public:
436 PSPTargetInfo(const std::string& triple)
437 : OSTargetInfo<Target>(triple) {
438 this->UserLabelPrefix = "";
439 }
440};
441
John Thompson3f6918a2009-11-19 17:18:50 +0000442// PS3 PPU Target
443template<typename Target>
444class PS3PPUTargetInfo : public OSTargetInfo<Target> {
445protected:
446 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000447 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000448 // PS3 PPU defines.
John Thompsonfb457972010-03-25 16:18:32 +0000449 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000450 Builder.defineMacro("__PPU__");
451 Builder.defineMacro("__CELLOS_LV2__");
452 Builder.defineMacro("__ELF__");
453 Builder.defineMacro("__LP32__");
John Thompson8e6065a2010-06-24 22:44:13 +0000454 Builder.defineMacro("_ARCH_PPC64");
455 Builder.defineMacro("__powerpc64__");
John Thompson3f6918a2009-11-19 17:18:50 +0000456 }
457public:
458 PS3PPUTargetInfo(const std::string& triple)
459 : OSTargetInfo<Target>(triple) {
460 this->UserLabelPrefix = "";
Nick Lewycky99520702011-12-16 22:32:39 +0000461 this->LongWidth = this->LongAlign = 32;
462 this->PointerWidth = this->PointerAlign = 32;
John Thompson8e6065a2010-06-24 22:44:13 +0000463 this->IntMaxType = TargetInfo::SignedLongLong;
464 this->UIntMaxType = TargetInfo::UnsignedLongLong;
465 this->Int64Type = TargetInfo::SignedLongLong;
John Thompsonec387af2009-12-18 14:21:08 +0000466 this->SizeType = TargetInfo::UnsignedInt;
John Thompson8e6065a2010-06-24 22:44:13 +0000467 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 +0000468 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompson3f6918a2009-11-19 17:18:50 +0000469 }
470};
471
472// FIXME: Need a real SPU target.
473// PS3 SPU Target
474template<typename Target>
475class PS3SPUTargetInfo : public OSTargetInfo<Target> {
476protected:
477 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000478 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000479 // PS3 PPU defines.
Benjamin Kramera9992772010-01-09 17:55:51 +0000480 Builder.defineMacro("__SPU__");
481 Builder.defineMacro("__ELF__");
John Thompson3f6918a2009-11-19 17:18:50 +0000482 }
483public:
484 PS3SPUTargetInfo(const std::string& triple)
485 : OSTargetInfo<Target>(triple) {
486 this->UserLabelPrefix = "";
487 }
488};
489
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000490// AuroraUX target
491template<typename Target>
492class AuroraUXTargetInfo : public OSTargetInfo<Target> {
493protected:
494 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000495 MacroBuilder &Builder) const {
496 DefineStd(Builder, "sun", Opts);
497 DefineStd(Builder, "unix", Opts);
498 Builder.defineMacro("__ELF__");
499 Builder.defineMacro("__svr4__");
500 Builder.defineMacro("__SVR4");
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000501 }
502public:
503 AuroraUXTargetInfo(const std::string& triple)
504 : OSTargetInfo<Target>(triple) {
505 this->UserLabelPrefix = "";
506 this->WCharType = this->SignedLong;
507 // FIXME: WIntType should be SignedLong
508 }
509};
510
Torok Edwin5f6c1942009-06-30 17:10:35 +0000511// Solaris target
512template<typename Target>
513class SolarisTargetInfo : public OSTargetInfo<Target> {
514protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000515 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000516 MacroBuilder &Builder) const {
517 DefineStd(Builder, "sun", Opts);
518 DefineStd(Builder, "unix", Opts);
519 Builder.defineMacro("__ELF__");
520 Builder.defineMacro("__svr4__");
521 Builder.defineMacro("__SVR4");
David Chisnall165329c2012-02-28 17:10:04 +0000522 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
523 // newer, but to 500 for everything else. feature_test.h has a check to
524 // ensure that you are not using C99 with an old version of X/Open or C89
525 // with a new version.
526 if (Opts.C99 || Opts.C11)
527 Builder.defineMacro("_XOPEN_SOURCE", "600");
528 else
529 Builder.defineMacro("_XOPEN_SOURCE", "500");
David Chisnallb4f0bd62012-03-02 10:49:52 +0000530 if (Opts.CPlusPlus)
David Chisnall165329c2012-02-28 17:10:04 +0000531 Builder.defineMacro("__C99FEATURES__");
David Chisnall48fad492012-02-17 18:35:11 +0000532 Builder.defineMacro("_LARGEFILE_SOURCE");
533 Builder.defineMacro("_LARGEFILE64_SOURCE");
534 Builder.defineMacro("__EXTENSIONS__");
David Chisnall165329c2012-02-28 17:10:04 +0000535 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000536 }
537public:
Mike Stump1eb44332009-09-09 15:08:12 +0000538 SolarisTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000539 : OSTargetInfo<Target>(triple) {
540 this->UserLabelPrefix = "";
David Chisnallfb027842012-03-28 18:04:14 +0000541 this->WCharType = this->SignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000542 // FIXME: WIntType should be SignedLong
543 }
544};
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000545
546// Windows target
547template<typename Target>
548class WindowsTargetInfo : public OSTargetInfo<Target> {
549protected:
550 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
551 MacroBuilder &Builder) const {
Michael J. Spencera764e832010-10-21 08:22:51 +0000552 Builder.defineMacro("_WIN32");
553 }
554 void getVisualStudioDefines(const LangOptions &Opts,
555 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000556 if (Opts.CPlusPlus) {
557 if (Opts.RTTI)
558 Builder.defineMacro("_CPPRTTI");
559
560 if (Opts.Exceptions)
561 Builder.defineMacro("_CPPUNWIND");
562 }
563
564 if (!Opts.CharIsSigned)
565 Builder.defineMacro("_CHAR_UNSIGNED");
566
567 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
568 // but it works for now.
569 if (Opts.POSIXThreads)
570 Builder.defineMacro("_MT");
Michael J. Spencera764e832010-10-21 08:22:51 +0000571
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000572 if (Opts.MSCVersion != 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000573 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000574
Francois Pichet62ec1f22011-09-17 17:15:52 +0000575 if (Opts.MicrosoftExt) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000576 Builder.defineMacro("_MSC_EXTENSIONS");
577
Richard Smith80ad52f2013-01-02 11:42:31 +0000578 if (Opts.CPlusPlus11) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000579 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
580 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
581 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
582 }
583 }
584
585 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000586 }
587
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000588public:
589 WindowsTargetInfo(const std::string &triple)
590 : OSTargetInfo<Target>(triple) {}
591};
592
Derek Schuff7da46f92012-10-11 16:55:58 +0000593template <typename Target>
594class NaClTargetInfo : public OSTargetInfo<Target> {
595 protected:
596 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
597 MacroBuilder &Builder) const {
598 if (Opts.POSIXThreads)
599 Builder.defineMacro("_REENTRANT");
600 if (Opts.CPlusPlus)
601 Builder.defineMacro("_GNU_SOURCE");
602
603 DefineStd(Builder, "unix", Opts);
604 Builder.defineMacro("__ELF__");
605 Builder.defineMacro("__native_client__");
606 }
607 public:
608 NaClTargetInfo(const std::string &triple)
609 : OSTargetInfo<Target>(triple) {
610 this->UserLabelPrefix = "";
611 this->LongAlign = 32;
612 this->LongWidth = 32;
613 this->PointerAlign = 32;
614 this->PointerWidth = 32;
615 this->IntMaxType = TargetInfo::SignedLongLong;
616 this->UIntMaxType = TargetInfo::UnsignedLongLong;
617 this->Int64Type = TargetInfo::SignedLongLong;
618 this->DoubleAlign = 64;
619 this->LongDoubleWidth = 64;
620 this->LongDoubleAlign = 64;
621 this->SizeType = TargetInfo::UnsignedInt;
622 this->PtrDiffType = TargetInfo::SignedInt;
623 this->IntPtrType = TargetInfo::SignedInt;
Eli Benderskyc0783dc2013-04-08 21:31:01 +0000624 // RegParmMax is inherited from the underlying architecture
Derek Schuff7da46f92012-10-11 16:55:58 +0000625 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble;
626 this->DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
627 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
628 }
Derek Schuff263366f2012-10-16 22:30:41 +0000629 virtual typename Target::CallingConvCheckResult checkCallingConvention(
630 CallingConv CC) const {
631 return CC == CC_PnaclCall ? Target::CCCR_OK :
632 Target::checkCallingConvention(CC);
633 }
Derek Schuff7da46f92012-10-11 16:55:58 +0000634};
Mike Stump1eb44332009-09-09 15:08:12 +0000635} // end anonymous namespace.
Torok Edwin5f6c1942009-06-30 17:10:35 +0000636
Chris Lattnerd29b6302008-10-05 21:50:58 +0000637//===----------------------------------------------------------------------===//
Eli Friedmane4277982008-08-20 23:11:40 +0000638// Specific target implementations.
639//===----------------------------------------------------------------------===//
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +0000640
Eli Friedmane4277982008-08-20 23:11:40 +0000641namespace {
642// PPC abstract base class
643class PPCTargetInfo : public TargetInfo {
644 static const Builtin::Info BuiltinInfo[];
645 static const char * const GCCRegNames[];
646 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Hal Finkel02a84272012-06-11 22:35:19 +0000647 std::string CPU;
Eli Friedmane4277982008-08-20 23:11:40 +0000648public:
Nico Weber6e1d2ea2012-01-31 02:07:33 +0000649 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {
650 LongDoubleWidth = LongDoubleAlign = 128;
651 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
652 }
Eli Friedman15b91762009-06-05 07:05:05 +0000653
Hal Finkel39d5fa12012-07-03 16:51:04 +0000654 /// \brief Flags for architecture specific defines.
655 typedef enum {
656 ArchDefineNone = 0,
657 ArchDefineName = 1 << 0, // <name> is substituted for arch name.
658 ArchDefinePpcgr = 1 << 1,
659 ArchDefinePpcsq = 1 << 2,
660 ArchDefine440 = 1 << 3,
661 ArchDefine603 = 1 << 4,
662 ArchDefine604 = 1 << 5,
663 ArchDefinePwr4 = 1 << 6,
Bill Schmidt2821e182013-02-01 20:23:10 +0000664 ArchDefinePwr5 = 1 << 7,
665 ArchDefinePwr5x = 1 << 8,
666 ArchDefinePwr6 = 1 << 9,
667 ArchDefinePwr6x = 1 << 10,
668 ArchDefinePwr7 = 1 << 11,
669 ArchDefineA2 = 1 << 12,
670 ArchDefineA2q = 1 << 13
Hal Finkel39d5fa12012-07-03 16:51:04 +0000671 } ArchDefineTypes;
672
Bill Schmidt2821e182013-02-01 20:23:10 +0000673 // Note: GCC recognizes the following additional cpus:
674 // 401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801,
675 // 821, 823, 8540, 8548, e300c2, e300c3, e500mc64, e6500, 860, cell,
676 // titan, rs64.
Hal Finkel02a84272012-06-11 22:35:19 +0000677 virtual bool setCPU(const std::string &Name) {
678 bool CPUKnown = llvm::StringSwitch<bool>(Name)
679 .Case("generic", true)
680 .Case("440", true)
681 .Case("450", true)
682 .Case("601", true)
683 .Case("602", true)
684 .Case("603", true)
685 .Case("603e", true)
686 .Case("603ev", true)
687 .Case("604", true)
688 .Case("604e", true)
689 .Case("620", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000690 .Case("630", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000691 .Case("g3", true)
692 .Case("7400", true)
693 .Case("g4", true)
694 .Case("7450", true)
695 .Case("g4+", true)
696 .Case("750", true)
697 .Case("970", true)
698 .Case("g5", true)
699 .Case("a2", true)
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000700 .Case("a2q", true)
Hal Finkel7de32962012-09-18 22:25:03 +0000701 .Case("e500mc", true)
702 .Case("e5500", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000703 .Case("power3", true)
704 .Case("pwr3", true)
705 .Case("power4", true)
706 .Case("pwr4", true)
707 .Case("power5", true)
708 .Case("pwr5", true)
709 .Case("power5x", true)
710 .Case("pwr5x", true)
711 .Case("power6", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000712 .Case("pwr6", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000713 .Case("power6x", true)
714 .Case("pwr6x", true)
715 .Case("power7", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000716 .Case("pwr7", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000717 .Case("powerpc", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000718 .Case("ppc", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000719 .Case("powerpc64", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000720 .Case("ppc64", true)
721 .Default(false);
722
723 if (CPUKnown)
724 CPU = Name;
725
726 return CPUKnown;
727 }
728
Eli Friedmane4277982008-08-20 23:11:40 +0000729 virtual void getTargetBuiltins(const Builtin::Info *&Records,
730 unsigned &NumRecords) const {
Reid Spencer5f016e22007-07-11 17:01:13 +0000731 Records = BuiltinInfo;
Eli Friedmane4277982008-08-20 23:11:40 +0000732 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +0000733 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000734
Bob Wilson9f1c49c2012-01-28 18:02:29 +0000735 virtual bool isCLZForZeroUndef() const { return false; }
736
Chris Lattner33328642009-03-20 15:52:06 +0000737 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000738 MacroBuilder &Builder) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000739
Bill Schmidt199402b2013-02-01 02:14:03 +0000740 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
741
742 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
743 StringRef Name,
744 bool Enabled) const;
745
Douglas Gregore727d212012-01-30 06:38:25 +0000746 virtual bool hasFeature(StringRef Feature) const;
747
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000748 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000749 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000750 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000751 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000752 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +0000753 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000754 switch (*Name) {
Anders Carlssond04c6e22007-11-27 04:11:28 +0000755 default: return false;
756 case 'O': // Zero
John Thompson8e6065a2010-06-24 22:44:13 +0000757 break;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000758 case 'b': // Base register
759 case 'f': // Floating point register
Chris Lattner44def072009-04-26 07:16:29 +0000760 Info.setAllowsRegister();
John Thompson8e6065a2010-06-24 22:44:13 +0000761 break;
762 // FIXME: The following are added to allow parsing.
763 // I just took a guess at what the actions should be.
764 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer20249a12010-10-21 03:16:25 +0000765 case 'd': // Floating point register (containing 64-bit value)
John Thompson8e6065a2010-06-24 22:44:13 +0000766 case 'v': // Altivec vector register
767 Info.setAllowsRegister();
768 break;
769 case 'w':
770 switch (Name[1]) {
Michael J. Spencer20249a12010-10-21 03:16:25 +0000771 case 'd':// VSX vector register to hold vector double data
772 case 'f':// VSX vector register to hold vector float data
773 case 's':// VSX vector register to hold scalar float data
774 case 'a':// Any VSX register
John Thompson8e6065a2010-06-24 22:44:13 +0000775 break;
776 default:
777 return false;
778 }
779 Info.setAllowsRegister();
780 Name++; // Skip over 'w'.
781 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000782 case 'h': // `MQ', `CTR', or `LINK' register
783 case 'q': // `MQ' register
784 case 'c': // `CTR' register
785 case 'l': // `LINK' register
786 case 'x': // `CR' register (condition register) number 0
787 case 'y': // `CR' register (condition register)
788 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson8e6065a2010-06-24 22:44:13 +0000789 Info.setAllowsRegister();
790 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000791 case 'I': // Signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000792 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer20249a12010-10-21 03:16:25 +0000793 // (use `L' instead for SImode constants)
794 case 'K': // Unsigned 16-bit constant
795 case 'L': // Signed 16-bit constant shifted left 16 bits
796 case 'M': // Constant larger than 31
797 case 'N': // Exact power of 2
798 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000799 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000800 // register with one instruction per word
John Thompson8e6065a2010-06-24 22:44:13 +0000801 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer20249a12010-10-21 03:16:25 +0000802 // into a register using three instructions
John Thompson8e6065a2010-06-24 22:44:13 +0000803 break;
804 case 'm': // Memory operand. Note that on PowerPC targets, m can
805 // include addresses that update the base register. It
806 // is therefore only safe to use `m' in an asm statement
807 // if that asm statement accesses the operand exactly once.
808 // The asm statement must also use `%U<opno>' as a
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000809 // placeholder for the "update" flag in the corresponding
Michael J. Spencer20249a12010-10-21 03:16:25 +0000810 // load or store instruction. For example:
John Thompson8e6065a2010-06-24 22:44:13 +0000811 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000812 // is correct but:
John Thompson8e6065a2010-06-24 22:44:13 +0000813 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
814 // is not. Use es rather than m if you don't want the base
Michael J. Spencer20249a12010-10-21 03:16:25 +0000815 // register to be updated.
816 case 'e':
John Thompson56b6eca2010-06-25 00:02:05 +0000817 if (Name[1] != 's')
818 return false;
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000819 // es: A "stable" memory operand; that is, one which does not
John Thompson8e6065a2010-06-24 22:44:13 +0000820 // include any automodification of the base register. Unlike
821 // `m', this constraint can be used in asm statements that
822 // might access the operand several times, or that might not
John Thompson56b6eca2010-06-25 00:02:05 +0000823 // access it at all.
John Thompson8e6065a2010-06-24 22:44:13 +0000824 Info.setAllowsMemory();
John Thompson56b6eca2010-06-25 00:02:05 +0000825 Name++; // Skip over 'e'.
John Thompson8e6065a2010-06-24 22:44:13 +0000826 break;
827 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer20249a12010-10-21 03:16:25 +0000828 // usually better to use `m' or `es' in asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000829 case 'Z': // Memory operand that is an indexed or indirect from a
830 // register (it is usually better to use `m' or `es' in
Michael J. Spencer20249a12010-10-21 03:16:25 +0000831 // asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000832 Info.setAllowsMemory();
833 Info.setAllowsRegister();
834 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000835 case 'R': // AIX TOC entry
John Thompson8e6065a2010-06-24 22:44:13 +0000836 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000837 // register (`p' is preferable for asm statements)
838 case 'S': // Constant suitable as a 64-bit mask operand
839 case 'T': // Constant suitable as a 32-bit mask operand
840 case 'U': // System V Release 4 small data area reference
John Thompson8e6065a2010-06-24 22:44:13 +0000841 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000842 // instructions
843 case 'W': // Vector constant that does not require memory
844 case 'j': // Vector constant that is all zeros.
John Thompson8e6065a2010-06-24 22:44:13 +0000845 break;
846 // End FIXME.
Anders Carlssond04c6e22007-11-27 04:11:28 +0000847 }
John Thompson8e6065a2010-06-24 22:44:13 +0000848 return true;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000849 }
Eli Friedmane4277982008-08-20 23:11:40 +0000850 virtual const char *getClobbers() const {
851 return "";
Anders Carlssond04c6e22007-11-27 04:11:28 +0000852 }
Adhemerval Zanellab0fc94c2013-01-22 20:02:45 +0000853 int getEHDataRegisterNumber(unsigned RegNo) const {
854 if (RegNo == 0) return 3;
855 if (RegNo == 1) return 4;
856 return -1;
857 }
Eli Friedmane4277982008-08-20 23:11:40 +0000858};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000859
Eli Friedmane4277982008-08-20 23:11:40 +0000860const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000861#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000862#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000863 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000864#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000865};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000866
867
Chris Lattnerc0f59212009-03-02 22:27:17 +0000868/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
869/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000870void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000871 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000872 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000873 Builder.defineMacro("__ppc__");
874 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000875 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000876 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000877 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000878 Builder.defineMacro("_ARCH_PPC64");
Chris Lattnere03ae302010-02-16 18:14:57 +0000879 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000880 Builder.defineMacro("__ppc64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000881 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +0000882 Builder.defineMacro("__ppc__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000883 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000884
Chris Lattnerc0f59212009-03-02 22:27:17 +0000885 // Target properties.
Hans Wennborg5e601dc2012-08-02 13:45:48 +0000886 if (getTriple().getOS() != llvm::Triple::NetBSD &&
887 getTriple().getOS() != llvm::Triple::OpenBSD)
Joerg Sonnenberger7cd1de52011-07-05 14:56:12 +0000888 Builder.defineMacro("_BIG_ENDIAN");
Benjamin Kramera9992772010-01-09 17:55:51 +0000889 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000890
Chris Lattnerc0f59212009-03-02 22:27:17 +0000891 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000892 Builder.defineMacro("__NATURAL_ALIGNMENT__");
893 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000894
Chris Lattnerc0f59212009-03-02 22:27:17 +0000895 // FIXME: Should be controlled by command line option.
Benjamin Kramera9992772010-01-09 17:55:51 +0000896 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000897
John Thompson3f6918a2009-11-19 17:18:50 +0000898 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000899 Builder.defineMacro("__VEC__", "10206");
900 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000901 }
Hal Finkel02a84272012-06-11 22:35:19 +0000902
903 // CPU identification.
Hal Finkel39d5fa12012-07-03 16:51:04 +0000904 ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
905 .Case("440", ArchDefineName)
906 .Case("450", ArchDefineName | ArchDefine440)
907 .Case("601", ArchDefineName)
908 .Case("602", ArchDefineName | ArchDefinePpcgr)
909 .Case("603", ArchDefineName | ArchDefinePpcgr)
910 .Case("603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
911 .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
912 .Case("604", ArchDefineName | ArchDefinePpcgr)
913 .Case("604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
914 .Case("620", ArchDefineName | ArchDefinePpcgr)
Bill Schmidt2821e182013-02-01 20:23:10 +0000915 .Case("630", ArchDefineName | ArchDefinePpcgr)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000916 .Case("7400", ArchDefineName | ArchDefinePpcgr)
917 .Case("7450", ArchDefineName | ArchDefinePpcgr)
918 .Case("750", ArchDefineName | ArchDefinePpcgr)
919 .Case("970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
920 | ArchDefinePpcsq)
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000921 .Case("a2", ArchDefineA2)
922 .Case("a2q", ArchDefineName | ArchDefineA2 | ArchDefineA2q)
Bill Schmidt2821e182013-02-01 20:23:10 +0000923 .Case("pwr3", ArchDefinePpcgr)
924 .Case("pwr4", ArchDefineName | ArchDefinePpcgr | ArchDefinePpcsq)
925 .Case("pwr5", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
926 | ArchDefinePpcsq)
927 .Case("pwr5x", ArchDefineName | ArchDefinePwr5 | ArchDefinePwr4
928 | ArchDefinePpcgr | ArchDefinePpcsq)
929 .Case("pwr6", ArchDefineName | ArchDefinePwr5x | ArchDefinePwr5
930 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
931 .Case("pwr6x", ArchDefineName | ArchDefinePwr6 | ArchDefinePwr5x
932 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
933 | ArchDefinePpcsq)
934 .Case("pwr7", ArchDefineName | ArchDefinePwr6x | ArchDefinePwr6
935 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
936 | ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq)
937 .Case("power3", ArchDefinePpcgr)
938 .Case("power4", ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
939 .Case("power5", ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
940 | ArchDefinePpcsq)
941 .Case("power5x", ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
942 | ArchDefinePpcgr | ArchDefinePpcsq)
943 .Case("power6", ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
944 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
945 .Case("power6x", ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x
946 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
947 | ArchDefinePpcsq)
948 .Case("power7", ArchDefinePwr7 | ArchDefinePwr6x | ArchDefinePwr6
949 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
950 | ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000951 .Default(ArchDefineNone);
952
953 if (defs & ArchDefineName)
954 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
955 if (defs & ArchDefinePpcgr)
956 Builder.defineMacro("_ARCH_PPCGR");
957 if (defs & ArchDefinePpcsq)
958 Builder.defineMacro("_ARCH_PPCSQ");
959 if (defs & ArchDefine440)
Hal Finkel02a84272012-06-11 22:35:19 +0000960 Builder.defineMacro("_ARCH_440");
Hal Finkel39d5fa12012-07-03 16:51:04 +0000961 if (defs & ArchDefine603)
962 Builder.defineMacro("_ARCH_603");
963 if (defs & ArchDefine604)
964 Builder.defineMacro("_ARCH_604");
Bill Schmidt2821e182013-02-01 20:23:10 +0000965 if (defs & ArchDefinePwr4)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000966 Builder.defineMacro("_ARCH_PWR4");
Bill Schmidt2821e182013-02-01 20:23:10 +0000967 if (defs & ArchDefinePwr5)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000968 Builder.defineMacro("_ARCH_PWR5");
Bill Schmidt2821e182013-02-01 20:23:10 +0000969 if (defs & ArchDefinePwr5x)
970 Builder.defineMacro("_ARCH_PWR5X");
971 if (defs & ArchDefinePwr6)
Hal Finkel02a84272012-06-11 22:35:19 +0000972 Builder.defineMacro("_ARCH_PWR6");
Bill Schmidt2821e182013-02-01 20:23:10 +0000973 if (defs & ArchDefinePwr6x)
974 Builder.defineMacro("_ARCH_PWR6X");
975 if (defs & ArchDefinePwr7)
976 Builder.defineMacro("_ARCH_PWR7");
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000977 if (defs & ArchDefineA2)
978 Builder.defineMacro("_ARCH_A2");
979 if (defs & ArchDefineA2q) {
980 Builder.defineMacro("_ARCH_A2Q");
981 Builder.defineMacro("_ARCH_QP");
982 }
983
984 if (getTriple().getVendor() == llvm::Triple::BGQ) {
985 Builder.defineMacro("__bg__");
986 Builder.defineMacro("__THW_BLUEGENE__");
987 Builder.defineMacro("__bgq__");
988 Builder.defineMacro("__TOS_BGQ__");
989 }
Bill Schmidt2821e182013-02-01 20:23:10 +0000990
991 // FIXME: The following are not yet generated here by Clang, but are
992 // generated by GCC:
993 //
994 // _SOFT_FLOAT_
995 // __RECIP_PRECISION__
996 // __APPLE_ALTIVEC__
997 // __VSX__
998 // __RECIP__
999 // __RECIPF__
1000 // __RSQRTE__
1001 // __RSQRTEF__
1002 // _SOFT_DOUBLE_
1003 // __NO_LWSYNC__
1004 // __HAVE_BSWAP__
1005 // __LONGDOUBLE128
1006 // __CMODEL_MEDIUM__
1007 // __CMODEL_LARGE__
1008 // _CALL_SYSV
1009 // _CALL_DARWIN
1010 // __NO_FPRS__
Bill Schmidt199402b2013-02-01 02:14:03 +00001011}
1012
1013void PPCTargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
1014 Features["altivec"] = llvm::StringSwitch<bool>(CPU)
1015 .Case("7400", true)
1016 .Case("g4", true)
1017 .Case("7450", true)
1018 .Case("g4+", true)
1019 .Case("970", true)
1020 .Case("g5", true)
1021 .Case("pwr6", true)
1022 .Case("pwr7", true)
1023 .Case("ppc64", true)
1024 .Default(false);
Hal Finkel3c6aaeb2013-02-01 18:44:19 +00001025
1026 Features["qpx"] = (CPU == "a2q");
Bill Schmidt199402b2013-02-01 02:14:03 +00001027}
1028
1029bool PPCTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1030 StringRef Name,
1031 bool Enabled) const {
Hal Finkelfe6b2712013-03-30 13:47:44 +00001032 if (Name == "altivec" || Name == "fprnd" || Name == "mfocrf" ||
1033 Name == "popcntd" || Name == "qpx") {
Bill Schmidt199402b2013-02-01 02:14:03 +00001034 Features[Name] = Enabled;
1035 return true;
Hal Finkel02a84272012-06-11 22:35:19 +00001036 }
Bill Schmidt199402b2013-02-01 02:14:03 +00001037
1038 return false;
Chris Lattnerc0f59212009-03-02 22:27:17 +00001039}
1040
Douglas Gregore727d212012-01-30 06:38:25 +00001041bool PPCTargetInfo::hasFeature(StringRef Feature) const {
1042 return Feature == "powerpc";
1043}
Chris Lattner393ff042008-04-21 18:56:49 +00001044
Douglas Gregore727d212012-01-30 06:38:25 +00001045
Eli Friedmane4277982008-08-20 23:11:40 +00001046const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +00001047 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1048 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1049 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1050 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1051 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
1052 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
1053 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
1054 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +00001055 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +00001056 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +00001057 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +00001058 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1059 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
1060 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
1061 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +00001062 "vrsave", "vscr",
1063 "spe_acc", "spefscr",
1064 "sfp"
1065};
Reid Spencer5f016e22007-07-11 17:01:13 +00001066
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001067void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +00001068 unsigned &NumNames) const {
1069 Names = GCCRegNames;
1070 NumNames = llvm::array_lengthof(GCCRegNames);
1071}
Reid Spencer5f016e22007-07-11 17:01:13 +00001072
Eli Friedmane4277982008-08-20 23:11:40 +00001073const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
1074 // While some of these aliases do map to different registers
1075 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00001076 { { "0" }, "r0" },
1077 { { "1"}, "r1" },
1078 { { "2" }, "r2" },
1079 { { "3" }, "r3" },
1080 { { "4" }, "r4" },
1081 { { "5" }, "r5" },
1082 { { "6" }, "r6" },
1083 { { "7" }, "r7" },
1084 { { "8" }, "r8" },
1085 { { "9" }, "r9" },
1086 { { "10" }, "r10" },
1087 { { "11" }, "r11" },
1088 { { "12" }, "r12" },
1089 { { "13" }, "r13" },
1090 { { "14" }, "r14" },
1091 { { "15" }, "r15" },
1092 { { "16" }, "r16" },
1093 { { "17" }, "r17" },
1094 { { "18" }, "r18" },
1095 { { "19" }, "r19" },
1096 { { "20" }, "r20" },
1097 { { "21" }, "r21" },
1098 { { "22" }, "r22" },
1099 { { "23" }, "r23" },
1100 { { "24" }, "r24" },
1101 { { "25" }, "r25" },
1102 { { "26" }, "r26" },
1103 { { "27" }, "r27" },
1104 { { "28" }, "r28" },
1105 { { "29" }, "r29" },
1106 { { "30" }, "r30" },
1107 { { "31" }, "r31" },
1108 { { "fr0" }, "f0" },
1109 { { "fr1" }, "f1" },
1110 { { "fr2" }, "f2" },
1111 { { "fr3" }, "f3" },
1112 { { "fr4" }, "f4" },
1113 { { "fr5" }, "f5" },
1114 { { "fr6" }, "f6" },
1115 { { "fr7" }, "f7" },
1116 { { "fr8" }, "f8" },
1117 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +00001118 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00001119 { { "fr11" }, "f11" },
1120 { { "fr12" }, "f12" },
1121 { { "fr13" }, "f13" },
1122 { { "fr14" }, "f14" },
1123 { { "fr15" }, "f15" },
1124 { { "fr16" }, "f16" },
1125 { { "fr17" }, "f17" },
1126 { { "fr18" }, "f18" },
1127 { { "fr19" }, "f19" },
1128 { { "fr20" }, "f20" },
1129 { { "fr21" }, "f21" },
1130 { { "fr22" }, "f22" },
1131 { { "fr23" }, "f23" },
1132 { { "fr24" }, "f24" },
1133 { { "fr25" }, "f25" },
1134 { { "fr26" }, "f26" },
1135 { { "fr27" }, "f27" },
1136 { { "fr28" }, "f28" },
1137 { { "fr29" }, "f29" },
1138 { { "fr30" }, "f30" },
1139 { { "fr31" }, "f31" },
1140 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +00001141};
1142
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001143void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +00001144 unsigned &NumAliases) const {
1145 Aliases = GCCRegAliases;
1146 NumAliases = llvm::array_lengthof(GCCRegAliases);
1147}
1148} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00001149
1150namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001151class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001152public:
Chris Lattnere03ae302010-02-16 18:14:57 +00001153 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +00001154 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 +00001155 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +00001156
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001157 switch (getTriple().getOS()) {
Nico Weber6e1d2ea2012-01-31 02:07:33 +00001158 case llvm::Triple::Linux:
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001159 case llvm::Triple::FreeBSD:
1160 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001161 SizeType = UnsignedInt;
Hal Finkel178a9b82012-03-02 20:54:36 +00001162 PtrDiffType = SignedInt;
1163 IntPtrType = SignedInt;
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001164 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +00001165 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001166 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001167 }
Roman Divackye3d175d2012-03-13 16:53:54 +00001168
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001169 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1170 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001171 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001172 }
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001173
1174 // PPC32 supports atomics up to 4 bytes.
1175 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001176 }
1177
Meador Ingec5613b22012-06-16 03:34:49 +00001178 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001179 // This is the ELF definition, and is overridden by the Darwin sub-target
Meador Ingec5613b22012-06-16 03:34:49 +00001180 return TargetInfo::PowerABIBuiltinVaList;
Eli Friedmaned855cb2008-08-21 00:13:15 +00001181 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001182};
1183} // end anonymous namespace.
1184
1185namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001186class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001187public:
Eli Friedmane4277982008-08-20 23:11:40 +00001188 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00001189 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00001190 IntMaxType = SignedLong;
1191 UIntMaxType = UnsignedLong;
1192 Int64Type = SignedLong;
Roman Divackye3d175d2012-03-13 16:53:54 +00001193
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001194 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1195 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001196 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001197 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1198 "i64:64:64-f32:32:32-f64:64:64-f128:64:64-"
1199 "v128:128:128-n32:64";
1200 } else
1201 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1202 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
1203 "v128:128:128-n32:64";
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001204
1205 // PPC64 supports atomics up to 8 bytes.
1206 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Chris Lattnerf291b102008-05-09 06:17:04 +00001207 }
Meador Ingec5613b22012-06-16 03:34:49 +00001208 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1209 return TargetInfo::CharPtrBuiltinVaList;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001210 }
Eli Friedmane4277982008-08-20 23:11:40 +00001211};
1212} // end anonymous namespace.
1213
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001214
1215namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001216class DarwinPPC32TargetInfo :
1217 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001218public:
Roman Divackyc81f2a22011-01-06 08:27:10 +00001219 DarwinPPC32TargetInfo(const std::string& triple)
1220 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001221 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001222 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001223 LongLongAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001224 SuitableAlign = 128;
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001225 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1226 "i64:32:64-f32:32:32-f64:64:64-v128:128:128-n32";
Roman Divackyc81f2a22011-01-06 08:27:10 +00001227 }
Meador Ingec5613b22012-06-16 03:34:49 +00001228 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1229 return TargetInfo::CharPtrBuiltinVaList;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001230 }
1231};
1232
1233class DarwinPPC64TargetInfo :
1234 public DarwinTargetInfo<PPC64TargetInfo> {
1235public:
1236 DarwinPPC64TargetInfo(const std::string& triple)
1237 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
1238 HasAlignMac68kSupport = true;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001239 SuitableAlign = 128;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001240 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1241 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001242 }
1243};
1244} // end anonymous namespace.
1245
Reid Spencer5f016e22007-07-11 17:01:13 +00001246namespace {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001247 static const unsigned NVPTXAddrSpaceMap[] = {
1248 1, // opencl_global
1249 3, // opencl_local
1250 4, // opencl_constant
1251 1, // cuda_device
1252 4, // cuda_constant
1253 3, // cuda_shared
1254 };
1255 class NVPTXTargetInfo : public TargetInfo {
1256 static const char * const GCCRegNames[];
Justin Holewinski2c585b92012-05-24 17:43:12 +00001257 static const Builtin::Info BuiltinInfo[];
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00001258 std::vector<StringRef> AvailableFeatures;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001259 public:
1260 NVPTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
1261 BigEndian = false;
1262 TLSSupported = false;
1263 LongWidth = LongAlign = 64;
1264 AddrSpaceMap = &NVPTXAddrSpaceMap;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001265 // Define available target features
1266 // These must be defined in sorted order!
Justin Holewinski9903e942012-07-11 15:34:55 +00001267 NoAsmVariants = true;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001268 }
1269 virtual void getTargetDefines(const LangOptions &Opts,
1270 MacroBuilder &Builder) const {
1271 Builder.defineMacro("__PTX__");
Justin Holewinski2c585b92012-05-24 17:43:12 +00001272 Builder.defineMacro("__NVPTX__");
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001273 }
1274 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1275 unsigned &NumRecords) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001276 Records = BuiltinInfo;
1277 NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001278 }
1279 virtual bool hasFeature(StringRef Feature) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001280 return Feature == "ptx" || Feature == "nvptx";
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001281 }
1282
1283 virtual void getGCCRegNames(const char * const *&Names,
1284 unsigned &NumNames) const;
1285 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1286 unsigned &NumAliases) const {
1287 // No aliases.
1288 Aliases = 0;
1289 NumAliases = 0;
1290 }
1291 virtual bool validateAsmConstraint(const char *&Name,
1292 TargetInfo::ConstraintInfo &info) const {
1293 // FIXME: implement
1294 return true;
1295 }
1296 virtual const char *getClobbers() const {
1297 // FIXME: Is this really right?
1298 return "";
1299 }
Meador Ingec5613b22012-06-16 03:34:49 +00001300 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001301 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00001302 return TargetInfo::CharPtrBuiltinVaList;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001303 }
1304 virtual bool setCPU(const std::string &Name) {
Justin Holewinskiaffa3af2013-03-30 14:38:26 +00001305 bool Valid = llvm::StringSwitch<bool>(Name)
1306 .Case("sm_20", true)
1307 .Case("sm_21", true)
1308 .Case("sm_30", true)
1309 .Case("sm_35", true)
1310 .Default(false);
1311
1312 return Valid;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001313 }
Justin Holewinski2c585b92012-05-24 17:43:12 +00001314 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1315 StringRef Name,
1316 bool Enabled) const;
1317 };
1318
1319 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1320#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1321#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1322 ALL_LANGUAGES },
1323#include "clang/Basic/BuiltinsNVPTX.def"
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001324 };
1325
1326 const char * const NVPTXTargetInfo::GCCRegNames[] = {
1327 "r0"
1328 };
1329
1330 void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names,
1331 unsigned &NumNames) const {
1332 Names = GCCRegNames;
1333 NumNames = llvm::array_lengthof(GCCRegNames);
1334 }
1335
Justin Holewinski2c585b92012-05-24 17:43:12 +00001336 bool NVPTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1337 StringRef Name,
1338 bool Enabled) const {
1339 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
1340 Name)) {
1341 Features[Name] = Enabled;
1342 return true;
1343 } else {
1344 return false;
1345 }
1346 }
1347
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001348 class NVPTX32TargetInfo : public NVPTXTargetInfo {
1349 public:
Justin Holewinski2c585b92012-05-24 17:43:12 +00001350 NVPTX32TargetInfo(const std::string& triple) : NVPTXTargetInfo(triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001351 PointerWidth = PointerAlign = 32;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001352 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001353 DescriptionString
1354 = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1355 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1356 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001357 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001358 };
1359
1360 class NVPTX64TargetInfo : public NVPTXTargetInfo {
1361 public:
Justin Holewinski2c585b92012-05-24 17:43:12 +00001362 NVPTX64TargetInfo(const std::string& triple) : NVPTXTargetInfo(triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001363 PointerWidth = PointerAlign = 64;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001364 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001365 DescriptionString
1366 = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1367 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1368 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001369 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001370 };
1371}
1372
1373namespace {
Eli Friedman6505a292012-10-12 23:32:00 +00001374
1375static const unsigned R600AddrSpaceMap[] = {
1376 1, // opencl_global
1377 3, // opencl_local
1378 2, // opencl_constant
1379 1, // cuda_device
1380 2, // cuda_constant
1381 3 // cuda_shared
1382};
1383
Tom Stellardfd075912013-03-04 17:40:53 +00001384static const char *DescriptionStringR600 =
1385 "e"
1386 "-p:32:32:32"
1387 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32"
1388 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1389 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1390 "-n32:64";
1391
1392static const char *DescriptionStringR600DoubleOps =
1393 "e"
1394 "-p:32:32:32"
1395 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64"
1396 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1397 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1398 "-n32:64";
1399
1400static const char *DescriptionStringSI =
1401 "e"
1402 "-p:64:64:64"
1403 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64"
1404 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1405 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1406 "-n32:64";
1407
Eli Friedman6505a292012-10-12 23:32:00 +00001408class R600TargetInfo : public TargetInfo {
Tom Stellardfd075912013-03-04 17:40:53 +00001409 /// \brief The GPU profiles supported by the R600 target.
1410 enum GPUKind {
1411 GK_NONE,
1412 GK_R600,
1413 GK_R600_DOUBLE_OPS,
1414 GK_R700,
1415 GK_R700_DOUBLE_OPS,
1416 GK_EVERGREEN,
1417 GK_EVERGREEN_DOUBLE_OPS,
1418 GK_NORTHERN_ISLANDS,
1419 GK_CAYMAN,
1420 GK_SOUTHERN_ISLANDS
1421 } GPU;
1422
Eli Friedman6505a292012-10-12 23:32:00 +00001423public:
Tom Stellardfd075912013-03-04 17:40:53 +00001424 R600TargetInfo(const std::string& triple)
1425 : TargetInfo(triple),
1426 GPU(GK_R600) {
1427 DescriptionString = DescriptionStringR600;
Eli Friedman6505a292012-10-12 23:32:00 +00001428 AddrSpaceMap = &R600AddrSpaceMap;
1429 }
1430
1431 virtual const char * getClobbers() const {
1432 return "";
1433 }
1434
1435 virtual void getGCCRegNames(const char * const *&Names,
1436 unsigned &numNames) const {
1437 Names = NULL;
1438 numNames = 0;
1439 }
1440
1441 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1442 unsigned &NumAliases) const {
1443 Aliases = NULL;
1444 NumAliases = 0;
1445 }
1446
1447 virtual bool validateAsmConstraint(const char *&Name,
1448 TargetInfo::ConstraintInfo &info) const {
1449 return true;
1450 }
1451
1452 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1453 unsigned &NumRecords) const {
1454 Records = NULL;
1455 NumRecords = 0;
1456 }
1457
1458
1459 virtual void getTargetDefines(const LangOptions &Opts,
1460 MacroBuilder &Builder) const {
1461 Builder.defineMacro("__R600__");
1462 }
1463
1464 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1465 return TargetInfo::CharPtrBuiltinVaList;
1466 }
1467
Tom Stellardfd075912013-03-04 17:40:53 +00001468 virtual bool setCPU(const std::string &Name) {
1469 GPU = llvm::StringSwitch<GPUKind>(Name)
1470 .Case("r600" , GK_R600)
1471 .Case("rv610", GK_R600)
1472 .Case("rv620", GK_R600)
1473 .Case("rv630", GK_R600)
1474 .Case("rv635", GK_R600)
1475 .Case("rs780", GK_R600)
1476 .Case("rs880", GK_R600)
1477 .Case("rv670", GK_R600_DOUBLE_OPS)
1478 .Case("rv710", GK_R700)
1479 .Case("rv730", GK_R700)
1480 .Case("rv740", GK_R700_DOUBLE_OPS)
1481 .Case("rv770", GK_R700_DOUBLE_OPS)
1482 .Case("palm", GK_EVERGREEN)
1483 .Case("cedar", GK_EVERGREEN)
1484 .Case("sumo", GK_EVERGREEN)
1485 .Case("sumo2", GK_EVERGREEN)
1486 .Case("redwood", GK_EVERGREEN)
1487 .Case("juniper", GK_EVERGREEN)
1488 .Case("hemlock", GK_EVERGREEN_DOUBLE_OPS)
1489 .Case("cypress", GK_EVERGREEN_DOUBLE_OPS)
1490 .Case("barts", GK_NORTHERN_ISLANDS)
1491 .Case("turks", GK_NORTHERN_ISLANDS)
1492 .Case("caicos", GK_NORTHERN_ISLANDS)
1493 .Case("cayman", GK_CAYMAN)
1494 .Case("aruba", GK_CAYMAN)
Tom Stellard3b848ec2013-04-01 20:56:49 +00001495 .Case("tahiti", GK_SOUTHERN_ISLANDS)
Tom Stellardfd075912013-03-04 17:40:53 +00001496 .Case("pitcairn", GK_SOUTHERN_ISLANDS)
1497 .Case("verde", GK_SOUTHERN_ISLANDS)
1498 .Case("oland", GK_SOUTHERN_ISLANDS)
1499 .Default(GK_NONE);
1500
1501 if (GPU == GK_NONE) {
1502 return false;
1503 }
1504
1505 // Set the correct data layout
1506 switch (GPU) {
1507 case GK_NONE:
1508 case GK_R600:
1509 case GK_R700:
1510 case GK_EVERGREEN:
1511 case GK_NORTHERN_ISLANDS:
1512 DescriptionString = DescriptionStringR600;
1513 break;
1514 case GK_R600_DOUBLE_OPS:
1515 case GK_R700_DOUBLE_OPS:
1516 case GK_EVERGREEN_DOUBLE_OPS:
1517 case GK_CAYMAN:
1518 DescriptionString = DescriptionStringR600DoubleOps;
1519 break;
1520 case GK_SOUTHERN_ISLANDS:
1521 DescriptionString = DescriptionStringSI;
1522 break;
1523 }
1524
1525 return true;
1526 }
Eli Friedman6505a292012-10-12 23:32:00 +00001527};
1528
1529} // end anonymous namespace
1530
1531namespace {
Chris Lattner9cbeb632010-03-06 21:21:27 +00001532// MBlaze abstract base class
1533class MBlazeTargetInfo : public TargetInfo {
1534 static const char * const GCCRegNames[];
1535 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1536
1537public:
1538 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +00001539 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner9cbeb632010-03-06 21:21:27 +00001540 }
1541
1542 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1543 unsigned &NumRecords) const {
1544 // FIXME: Implement.
1545 Records = 0;
1546 NumRecords = 0;
1547 }
1548
1549 virtual void getTargetDefines(const LangOptions &Opts,
1550 MacroBuilder &Builder) const;
1551
Douglas Gregore727d212012-01-30 06:38:25 +00001552 virtual bool hasFeature(StringRef Feature) const {
1553 return Feature == "mblaze";
1554 }
1555
Meador Ingec5613b22012-06-16 03:34:49 +00001556 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1557 return TargetInfo::CharPtrBuiltinVaList;
Chris Lattner9cbeb632010-03-06 21:21:27 +00001558 }
1559 virtual const char *getTargetPrefix() const {
1560 return "mblaze";
1561 }
1562 virtual void getGCCRegNames(const char * const *&Names,
1563 unsigned &NumNames) const;
1564 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1565 unsigned &NumAliases) const;
1566 virtual bool validateAsmConstraint(const char *&Name,
1567 TargetInfo::ConstraintInfo &Info) const {
1568 switch (*Name) {
1569 default: return false;
1570 case 'O': // Zero
1571 return true;
1572 case 'b': // Base register
1573 case 'f': // Floating point register
1574 Info.setAllowsRegister();
1575 return true;
1576 }
1577 }
1578 virtual const char *getClobbers() const {
1579 return "";
1580 }
1581};
1582
1583/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1584/// #defines that are not tied to a specific subtarget.
1585void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1586 MacroBuilder &Builder) const {
1587 // Target identification.
1588 Builder.defineMacro("__microblaze__");
1589 Builder.defineMacro("_ARCH_MICROBLAZE");
1590 Builder.defineMacro("__MICROBLAZE__");
1591
1592 // Target properties.
1593 Builder.defineMacro("_BIG_ENDIAN");
1594 Builder.defineMacro("__BIG_ENDIAN__");
1595
1596 // Subtarget options.
1597 Builder.defineMacro("__REGISTER_PREFIX__", "");
1598}
1599
1600
1601const char * const MBlazeTargetInfo::GCCRegNames[] = {
1602 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1603 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1604 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1605 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1606 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1607 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1608 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1609 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1610 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1611 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1612};
1613
1614void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1615 unsigned &NumNames) const {
1616 Names = GCCRegNames;
1617 NumNames = llvm::array_lengthof(GCCRegNames);
1618}
1619
1620const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1621 { {"f0"}, "r0" },
1622 { {"f1"}, "r1" },
1623 { {"f2"}, "r2" },
1624 { {"f3"}, "r3" },
1625 { {"f4"}, "r4" },
1626 { {"f5"}, "r5" },
1627 { {"f6"}, "r6" },
1628 { {"f7"}, "r7" },
1629 { {"f8"}, "r8" },
1630 { {"f9"}, "r9" },
1631 { {"f10"}, "r10" },
1632 { {"f11"}, "r11" },
1633 { {"f12"}, "r12" },
1634 { {"f13"}, "r13" },
1635 { {"f14"}, "r14" },
1636 { {"f15"}, "r15" },
1637 { {"f16"}, "r16" },
1638 { {"f17"}, "r17" },
1639 { {"f18"}, "r18" },
1640 { {"f19"}, "r19" },
1641 { {"f20"}, "r20" },
1642 { {"f21"}, "r21" },
1643 { {"f22"}, "r22" },
1644 { {"f23"}, "r23" },
1645 { {"f24"}, "r24" },
1646 { {"f25"}, "r25" },
1647 { {"f26"}, "r26" },
1648 { {"f27"}, "r27" },
1649 { {"f28"}, "r28" },
1650 { {"f29"}, "r29" },
1651 { {"f30"}, "r30" },
1652 { {"f31"}, "r31" },
1653};
1654
1655void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1656 unsigned &NumAliases) const {
1657 Aliases = GCCRegAliases;
1658 NumAliases = llvm::array_lengthof(GCCRegAliases);
1659}
1660} // end anonymous namespace.
1661
1662namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001663// Namespace for x86 abstract base class
1664const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001665#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001666#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001667 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001668#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001669};
Eli Friedman61538a72008-05-20 14:21:01 +00001670
Nuno Lopes2550d702009-12-23 17:49:57 +00001671static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001672 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1673 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001674 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001675 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1676 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1677 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001678 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopherc5f9a012011-12-02 02:12:16 +00001679 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1680 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001681};
1682
Eric Christophercfd323d2011-06-21 00:05:20 +00001683const TargetInfo::AddlRegName AddlRegNames[] = {
1684 { { "al", "ah", "eax", "rax" }, 0 },
1685 { { "bl", "bh", "ebx", "rbx" }, 3 },
1686 { { "cl", "ch", "ecx", "rcx" }, 2 },
1687 { { "dl", "dh", "edx", "rdx" }, 1 },
1688 { { "esi", "rsi" }, 4 },
1689 { { "edi", "rdi" }, 5 },
1690 { { "esp", "rsp" }, 7 },
1691 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001692};
1693
1694// X86 target abstract base class; x86-32 and x86-64 are very close, so
1695// most of the implementation can be shared.
1696class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001697 enum X86SSEEnum {
Craig Topper05fe4b52012-01-09 09:19:09 +00001698 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2
Chris Lattner84f0ea82009-03-02 22:40:39 +00001699 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001700 enum MMX3DNowEnum {
1701 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1702 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001703
Eric Christophereea12d12010-04-02 23:50:19 +00001704 bool HasAES;
Craig Topper3c0bc152012-05-31 05:18:48 +00001705 bool HasPCLMUL;
Craig Topper31ceea02011-12-25 05:06:45 +00001706 bool HasLZCNT;
Benjamin Kramer84f30802012-07-07 09:39:18 +00001707 bool HasRDRND;
Craig Topper31ceea02011-12-25 05:06:45 +00001708 bool HasBMI;
1709 bool HasBMI2;
Craig Toppere14e08b2011-12-29 16:10:46 +00001710 bool HasPOPCNT;
Michael Liao463eb892012-11-10 05:17:46 +00001711 bool HasRTM;
Michael Liao72339a02013-03-26 17:52:08 +00001712 bool HasPRFCHW;
Michael Liao1bfc28c2013-03-29 05:17:55 +00001713 bool HasRDSEED;
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00001714 bool HasSSE4a;
Craig Topper6a511e12011-12-30 07:33:42 +00001715 bool HasFMA4;
Craig Topper2ae95072012-06-03 21:46:30 +00001716 bool HasFMA;
Craig Topperb6af69e2012-06-09 22:24:14 +00001717 bool HasXOP;
Manman Ren146e5a42012-10-11 00:59:55 +00001718 bool HasF16C;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001719
Chandler Carruth499d9722011-09-28 08:55:34 +00001720 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1721 ///
1722 /// Each enumeration represents a particular CPU supported by Clang. These
1723 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1724 enum CPUKind {
1725 CK_Generic,
1726
1727 /// \name i386
1728 /// i386-generation processors.
1729 //@{
1730 CK_i386,
1731 //@}
1732
1733 /// \name i486
1734 /// i486-generation processors.
1735 //@{
1736 CK_i486,
1737 CK_WinChipC6,
1738 CK_WinChip2,
1739 CK_C3,
1740 //@}
1741
1742 /// \name i586
1743 /// i586-generation processors, P5 microarchitecture based.
1744 //@{
1745 CK_i586,
1746 CK_Pentium,
1747 CK_PentiumMMX,
1748 //@}
1749
1750 /// \name i686
1751 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1752 //@{
1753 CK_i686,
1754 CK_PentiumPro,
1755 CK_Pentium2,
1756 CK_Pentium3,
1757 CK_Pentium3M,
1758 CK_PentiumM,
1759 CK_C3_2,
1760
1761 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1762 /// Clang however has some logic to suport this.
1763 // FIXME: Warn, deprecate, and potentially remove this.
1764 CK_Yonah,
1765 //@}
1766
1767 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001768 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001769 //@{
1770 CK_Pentium4,
1771 CK_Pentium4M,
1772 CK_Prescott,
1773 CK_Nocona,
1774 //@}
1775
1776 /// \name Core
1777 /// Core microarchitecture based processors.
1778 //@{
1779 CK_Core2,
1780
1781 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1782 /// codename which GCC no longer accepts as an option to -march, but Clang
1783 /// has some logic for recognizing it.
1784 // FIXME: Warn, deprecate, and potentially remove this.
1785 CK_Penryn,
1786 //@}
1787
1788 /// \name Atom
1789 /// Atom processors
1790 //@{
1791 CK_Atom,
1792 //@}
1793
1794 /// \name Nehalem
1795 /// Nehalem microarchitecture based processors.
1796 //@{
1797 CK_Corei7,
1798 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001799 CK_CoreAVXi,
Craig Topper2b03bb02011-12-17 19:55:21 +00001800 CK_CoreAVX2,
Chandler Carruth499d9722011-09-28 08:55:34 +00001801 //@}
1802
1803 /// \name K6
1804 /// K6 architecture processors.
1805 //@{
1806 CK_K6,
1807 CK_K6_2,
1808 CK_K6_3,
1809 //@}
1810
1811 /// \name K7
1812 /// K7 architecture processors.
1813 //@{
1814 CK_Athlon,
1815 CK_AthlonThunderbird,
1816 CK_Athlon4,
1817 CK_AthlonXP,
1818 CK_AthlonMP,
1819 //@}
1820
1821 /// \name K8
1822 /// K8 architecture processors.
1823 //@{
1824 CK_Athlon64,
1825 CK_Athlon64SSE3,
1826 CK_AthlonFX,
1827 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001828 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001829 CK_Opteron,
1830 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001831 CK_AMDFAM10,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001832 //@}
Chandler Carruth499d9722011-09-28 08:55:34 +00001833
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001834 /// \name Bobcat
1835 /// Bobcat architecture processors.
1836 //@{
1837 CK_BTVER1,
Benjamin Kramer63063f52013-05-03 10:47:15 +00001838 CK_BTVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001839 //@}
1840
1841 /// \name Bulldozer
1842 /// Bulldozer architecture processors.
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001843 //@{
1844 CK_BDVER1,
1845 CK_BDVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001846 //@}
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001847
Chandler Carruth499d9722011-09-28 08:55:34 +00001848 /// This specification is deprecated and will be removed in the future.
1849 /// Users should prefer \see CK_K8.
1850 // FIXME: Warn on this when the CPU is set to it.
1851 CK_x86_64,
1852 //@}
1853
1854 /// \name Geode
1855 /// Geode processors.
1856 //@{
1857 CK_Geode
1858 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001859 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001860
Eli Friedman618234a2008-08-20 02:34:37 +00001861public:
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001862 X86TargetInfo(const std::string& triple)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001863 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Benjamin Kramer84f30802012-07-07 09:39:18 +00001864 HasAES(false), HasPCLMUL(false), HasLZCNT(false), HasRDRND(false),
Michael Liao463eb892012-11-10 05:17:46 +00001865 HasBMI(false), HasBMI2(false), HasPOPCNT(false), HasRTM(false),
Michael Liao1bfc28c2013-03-29 05:17:55 +00001866 HasPRFCHW(false), HasRDSEED(false), HasSSE4a(false), HasFMA4(false),
Michael Liao72339a02013-03-26 17:52:08 +00001867 HasFMA(false), HasXOP(false), HasF16C(false), CPU(CK_Generic) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00001868 BigEndian = false;
Eli Friedman618234a2008-08-20 02:34:37 +00001869 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001870 }
Benjamin Kramerb4066692011-12-28 15:47:06 +00001871 virtual unsigned getFloatEvalMethod() const {
1872 // X87 evaluates with 80 bits "long double" precision.
1873 return SSELevel == NoSSE ? 2 : 0;
1874 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001875 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1876 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001877 Records = BuiltinInfo;
1878 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001879 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001880 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001881 unsigned &NumNames) const {
1882 Names = GCCRegNames;
1883 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001884 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001885 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001886 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001887 Aliases = 0;
1888 NumAliases = 0;
1889 }
1890 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
Eric Christopher825d3862012-11-14 22:08:59 +00001891 unsigned &NumNames) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001892 Names = AddlRegNames;
1893 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001894 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001895 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001896 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001897 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001898 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001899 return "~{dirflag},~{fpsr},~{flags}";
1900 }
Chris Lattner33328642009-03-20 15:52:06 +00001901 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001902 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001903 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001904 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001905 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001906 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Douglas Gregore727d212012-01-30 06:38:25 +00001907 virtual bool hasFeature(StringRef Feature) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001908 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001909 virtual const char* getABI() const {
Derek Schuffbabaf312012-10-11 15:52:22 +00001910 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001911 return "avx";
Derek Schuffbabaf312012-10-11 15:52:22 +00001912 else if (getTriple().getArch() == llvm::Triple::x86 &&
1913 MMX3DNowLevel == NoMMX3DNow)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001914 return "no-mmx";
1915 return "";
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001916 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001917 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001918 CPU = llvm::StringSwitch<CPUKind>(Name)
1919 .Case("i386", CK_i386)
1920 .Case("i486", CK_i486)
1921 .Case("winchip-c6", CK_WinChipC6)
1922 .Case("winchip2", CK_WinChip2)
1923 .Case("c3", CK_C3)
1924 .Case("i586", CK_i586)
1925 .Case("pentium", CK_Pentium)
1926 .Case("pentium-mmx", CK_PentiumMMX)
1927 .Case("i686", CK_i686)
1928 .Case("pentiumpro", CK_PentiumPro)
1929 .Case("pentium2", CK_Pentium2)
1930 .Case("pentium3", CK_Pentium3)
1931 .Case("pentium3m", CK_Pentium3M)
1932 .Case("pentium-m", CK_PentiumM)
1933 .Case("c3-2", CK_C3_2)
1934 .Case("yonah", CK_Yonah)
1935 .Case("pentium4", CK_Pentium4)
1936 .Case("pentium4m", CK_Pentium4M)
1937 .Case("prescott", CK_Prescott)
1938 .Case("nocona", CK_Nocona)
1939 .Case("core2", CK_Core2)
1940 .Case("penryn", CK_Penryn)
1941 .Case("atom", CK_Atom)
1942 .Case("corei7", CK_Corei7)
1943 .Case("corei7-avx", CK_Corei7AVX)
1944 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper2b03bb02011-12-17 19:55:21 +00001945 .Case("core-avx2", CK_CoreAVX2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001946 .Case("k6", CK_K6)
1947 .Case("k6-2", CK_K6_2)
1948 .Case("k6-3", CK_K6_3)
1949 .Case("athlon", CK_Athlon)
1950 .Case("athlon-tbird", CK_AthlonThunderbird)
1951 .Case("athlon-4", CK_Athlon4)
1952 .Case("athlon-xp", CK_AthlonXP)
1953 .Case("athlon-mp", CK_AthlonMP)
1954 .Case("athlon64", CK_Athlon64)
1955 .Case("athlon64-sse3", CK_Athlon64SSE3)
1956 .Case("athlon-fx", CK_AthlonFX)
1957 .Case("k8", CK_K8)
1958 .Case("k8-sse3", CK_K8SSE3)
1959 .Case("opteron", CK_Opteron)
1960 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001961 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001962 .Case("btver1", CK_BTVER1)
Benjamin Kramer63063f52013-05-03 10:47:15 +00001963 .Case("btver2", CK_BTVER2)
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001964 .Case("bdver1", CK_BDVER1)
1965 .Case("bdver2", CK_BDVER2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001966 .Case("x86-64", CK_x86_64)
1967 .Case("geode", CK_Geode)
1968 .Default(CK_Generic);
1969
Chandler Carruth26a39142011-09-28 09:45:08 +00001970 // Perform any per-CPU checks necessary to determine if this CPU is
1971 // acceptable.
1972 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1973 // invalid without explaining *why*.
1974 switch (CPU) {
1975 case CK_Generic:
1976 // No processor selected!
1977 return false;
1978
1979 case CK_i386:
1980 case CK_i486:
1981 case CK_WinChipC6:
1982 case CK_WinChip2:
1983 case CK_C3:
1984 case CK_i586:
1985 case CK_Pentium:
1986 case CK_PentiumMMX:
1987 case CK_i686:
1988 case CK_PentiumPro:
1989 case CK_Pentium2:
1990 case CK_Pentium3:
1991 case CK_Pentium3M:
1992 case CK_PentiumM:
1993 case CK_Yonah:
1994 case CK_C3_2:
1995 case CK_Pentium4:
1996 case CK_Pentium4M:
1997 case CK_Prescott:
1998 case CK_K6:
1999 case CK_K6_2:
2000 case CK_K6_3:
2001 case CK_Athlon:
2002 case CK_AthlonThunderbird:
2003 case CK_Athlon4:
2004 case CK_AthlonXP:
2005 case CK_AthlonMP:
2006 case CK_Geode:
2007 // Only accept certain architectures when compiling in 32-bit mode.
Derek Schuffbabaf312012-10-11 15:52:22 +00002008 if (getTriple().getArch() != llvm::Triple::x86)
Chandler Carruth26a39142011-09-28 09:45:08 +00002009 return false;
2010
2011 // Fallthrough
2012 case CK_Nocona:
2013 case CK_Core2:
2014 case CK_Penryn:
2015 case CK_Atom:
2016 case CK_Corei7:
2017 case CK_Corei7AVX:
2018 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00002019 case CK_CoreAVX2:
Chandler Carruth26a39142011-09-28 09:45:08 +00002020 case CK_Athlon64:
2021 case CK_Athlon64SSE3:
2022 case CK_AthlonFX:
2023 case CK_K8:
2024 case CK_K8SSE3:
2025 case CK_Opteron:
2026 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00002027 case CK_AMDFAM10:
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002028 case CK_BTVER1:
Benjamin Kramer63063f52013-05-03 10:47:15 +00002029 case CK_BTVER2:
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002030 case CK_BDVER1:
2031 case CK_BDVER2:
Chandler Carruth26a39142011-09-28 09:45:08 +00002032 case CK_x86_64:
2033 return true;
2034 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00002035 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002036 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00002037
2038 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
2039 // We accept all non-ARM calling conventions
2040 return (CC == CC_X86ThisCall ||
2041 CC == CC_X86FastCall ||
Peter Collingbourne7728cdd2013-02-23 00:06:18 +00002042 CC == CC_X86StdCall ||
2043 CC == CC_C ||
Guy Benyei38980082012-12-25 08:53:55 +00002044 CC == CC_X86Pascal ||
2045 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballman82bfa192012-10-02 14:26:08 +00002046 }
2047
Aaron Ballmanfff32482012-12-09 17:45:41 +00002048 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {
2049 return MT == CCMT_Member ? CC_X86ThisCall : CC_C;
Aaron Ballman82bfa192012-10-02 14:26:08 +00002050 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002051};
Chris Lattner3daed522009-03-02 22:20:04 +00002052
Chandler Carruthc3a2e652011-09-28 05:56:05 +00002053void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002054 // FIXME: This should not be here.
2055 Features["3dnow"] = false;
2056 Features["3dnowa"] = false;
2057 Features["mmx"] = false;
2058 Features["sse"] = false;
2059 Features["sse2"] = false;
2060 Features["sse3"] = false;
2061 Features["ssse3"] = false;
2062 Features["sse41"] = false;
2063 Features["sse42"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00002064 Features["sse4a"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00002065 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00002066 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002067 Features["avx"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00002068 Features["avx2"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002069 Features["lzcnt"] = false;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002070 Features["rdrand"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002071 Features["bmi"] = false;
2072 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00002073 Features["popcnt"] = false;
Michael Liao463eb892012-11-10 05:17:46 +00002074 Features["rtm"] = false;
Michael Liao72339a02013-03-26 17:52:08 +00002075 Features["prfchw"] = false;
Michael Liao1bfc28c2013-03-29 05:17:55 +00002076 Features["rdseed"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00002077 Features["fma4"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00002078 Features["fma"] = false;
Craig Topperb6af69e2012-06-09 22:24:14 +00002079 Features["xop"] = false;
Manman Ren146e5a42012-10-11 00:59:55 +00002080 Features["f16c"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002081
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002082 // FIXME: This *really* should not be here.
2083
2084 // X86_64 always has SSE2.
Derek Schuffbabaf312012-10-11 15:52:22 +00002085 if (getTriple().getArch() == llvm::Triple::x86_64)
Eli Friedman612db2a2012-11-17 01:16:19 +00002086 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002087
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002088 switch (CPU) {
2089 case CK_Generic:
2090 case CK_i386:
2091 case CK_i486:
2092 case CK_i586:
2093 case CK_Pentium:
2094 case CK_i686:
2095 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002096 break;
2097 case CK_PentiumMMX:
2098 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002099 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002100 break;
2101 case CK_Pentium3:
2102 case CK_Pentium3M:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002103 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002104 break;
2105 case CK_PentiumM:
2106 case CK_Pentium4:
2107 case CK_Pentium4M:
2108 case CK_x86_64:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002109 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002110 break;
2111 case CK_Yonah:
2112 case CK_Prescott:
2113 case CK_Nocona:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002114 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002115 break;
2116 case CK_Core2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002117 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002118 break;
2119 case CK_Penryn:
Benjamin Kramerb3453a82012-01-04 14:36:57 +00002120 setFeatureEnabled(Features, "sse4.1", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002121 break;
2122 case CK_Atom:
Chandler Carruth49defe62011-09-28 10:36:46 +00002123 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002124 break;
2125 case CK_Corei7:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002126 setFeatureEnabled(Features, "sse4", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002127 break;
2128 case CK_Corei7AVX:
Benjamin Kramer84f30802012-07-07 09:39:18 +00002129 setFeatureEnabled(Features, "avx", true);
2130 setFeatureEnabled(Features, "aes", true);
2131 setFeatureEnabled(Features, "pclmul", true);
2132 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002133 case CK_CoreAVXi:
Craig Topperfd936302012-04-26 07:31:30 +00002134 setFeatureEnabled(Features, "avx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00002135 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00002136 setFeatureEnabled(Features, "pclmul", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00002137 setFeatureEnabled(Features, "rdrnd", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002138 setFeatureEnabled(Features, "f16c", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002139 break;
Craig Topper2b03bb02011-12-17 19:55:21 +00002140 case CK_CoreAVX2:
Craig Topperfd936302012-04-26 07:31:30 +00002141 setFeatureEnabled(Features, "avx2", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00002142 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00002143 setFeatureEnabled(Features, "pclmul", true);
Craig Topper31ceea02011-12-25 05:06:45 +00002144 setFeatureEnabled(Features, "lzcnt", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00002145 setFeatureEnabled(Features, "rdrnd", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002146 setFeatureEnabled(Features, "f16c", true);
Craig Topper31ceea02011-12-25 05:06:45 +00002147 setFeatureEnabled(Features, "bmi", true);
2148 setFeatureEnabled(Features, "bmi2", true);
Michael Liao463eb892012-11-10 05:17:46 +00002149 setFeatureEnabled(Features, "rtm", true);
Craig Topper2ae95072012-06-03 21:46:30 +00002150 setFeatureEnabled(Features, "fma", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00002151 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002152 case CK_K6:
2153 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002154 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002155 break;
2156 case CK_K6_2:
2157 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002158 case CK_WinChip2:
2159 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002160 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002161 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00002162 case CK_Athlon:
2163 case CK_AthlonThunderbird:
2164 case CK_Geode:
2165 setFeatureEnabled(Features, "3dnowa", true);
2166 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002167 case CK_Athlon4:
2168 case CK_AthlonXP:
2169 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002170 setFeatureEnabled(Features, "sse", true);
2171 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002172 break;
2173 case CK_K8:
2174 case CK_Opteron:
2175 case CK_Athlon64:
2176 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00002177 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002178 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002179 break;
2180 case CK_K8SSE3:
2181 case CK_OpteronSSE3:
2182 case CK_Athlon64SSE3:
Roman Divacky80b32b82011-10-30 13:47:56 +00002183 setFeatureEnabled(Features, "sse3", true);
2184 setFeatureEnabled(Features, "3dnowa", true);
2185 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002186 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00002187 setFeatureEnabled(Features, "sse3", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00002188 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00002189 setFeatureEnabled(Features, "3dnowa", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002190 setFeatureEnabled(Features, "lzcnt", true);
2191 setFeatureEnabled(Features, "popcnt", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002192 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002193 case CK_BTVER1:
2194 setFeatureEnabled(Features, "ssse3", true);
2195 setFeatureEnabled(Features, "sse4a", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002196 setFeatureEnabled(Features, "lzcnt", true);
2197 setFeatureEnabled(Features, "popcnt", true);
Craig Topper90ea0362012-05-30 05:54:54 +00002198 break;
Benjamin Kramer63063f52013-05-03 10:47:15 +00002199 case CK_BTVER2:
2200 setFeatureEnabled(Features, "avx", true);
2201 setFeatureEnabled(Features, "sse4a", true);
2202 setFeatureEnabled(Features, "lzcnt", true);
2203 setFeatureEnabled(Features, "aes", true);
2204 setFeatureEnabled(Features, "pclmul", true);
2205 setFeatureEnabled(Features, "bmi", true);
2206 setFeatureEnabled(Features, "f16c", true);
2207 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002208 case CK_BDVER1:
Craig Topperb6af69e2012-06-09 22:24:14 +00002209 setFeatureEnabled(Features, "xop", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002210 setFeatureEnabled(Features, "lzcnt", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002211 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00002212 setFeatureEnabled(Features, "pclmul", true);
Eli Friedmanf5824992012-11-26 21:57:28 +00002213 break;
Eli Friedmanfaf35382012-11-17 01:43:10 +00002214 case CK_BDVER2:
2215 setFeatureEnabled(Features, "xop", true);
2216 setFeatureEnabled(Features, "lzcnt", true);
2217 setFeatureEnabled(Features, "aes", true);
2218 setFeatureEnabled(Features, "pclmul", true);
2219 setFeatureEnabled(Features, "bmi", true);
2220 setFeatureEnabled(Features, "fma", true);
2221 setFeatureEnabled(Features, "f16c", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002222 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002223 case CK_C3_2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002224 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002225 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002226 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002227}
2228
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002229bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00002230 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002231 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00002232 // FIXME: This *really* should not be here. We need some way of translating
2233 // options into llvm subtarget features.
2234 if (!Features.count(Name) &&
Benjamin Kramer84f30802012-07-07 09:39:18 +00002235 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1" &&
2236 Name != "rdrnd"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002237 return false;
2238
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002239 // FIXME: this should probably use a switch with fall through.
2240
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002241 if (Enabled) {
2242 if (Name == "mmx")
2243 Features["mmx"] = true;
2244 else if (Name == "sse")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002245 Features["mmx"] = Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002246 else if (Name == "sse2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002247 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002248 else if (Name == "sse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002249 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2250 true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002251 else if (Name == "ssse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002252 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002253 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00002254 else if (Name == "sse4" || Name == "sse4.2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002255 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002256 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2257 Features["popcnt"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00002258 else if (Name == "sse4.1")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002259 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00002260 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002261 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002262 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002263 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002264 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00002265 else if (Name == "aes")
Craig Toppera7463c32012-06-03 21:56:22 +00002266 Features["sse"] = Features["sse2"] = Features["aes"] = true;
Craig Topper3c0bc152012-05-31 05:18:48 +00002267 else if (Name == "pclmul")
Craig Toppera7463c32012-06-03 21:56:22 +00002268 Features["sse"] = Features["sse2"] = Features["pclmul"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002269 else if (Name == "avx")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002270 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2271 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002272 Features["popcnt"] = Features["avx"] = true;
Craig Topper2b03bb02011-12-17 19:55:21 +00002273 else if (Name == "avx2")
2274 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2275 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002276 Features["popcnt"] = Features["avx"] = Features["avx2"] = true;
Craig Topper2ae95072012-06-03 21:46:30 +00002277 else if (Name == "fma")
2278 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2279 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2280 Features["popcnt"] = Features["avx"] = Features["fma"] = true;
Craig Topper6a511e12011-12-30 07:33:42 +00002281 else if (Name == "fma4")
Eli Friedman612db2a2012-11-17 01:16:19 +00002282 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00002283 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper90ea0362012-05-30 05:54:54 +00002284 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
2285 Features["fma4"] = true;
Craig Topperb6af69e2012-06-09 22:24:14 +00002286 else if (Name == "xop")
Eli Friedman612db2a2012-11-17 01:16:19 +00002287 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002288 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2289 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
2290 Features["fma4"] = Features["xop"] = true;
Roman Divacky80b32b82011-10-30 13:47:56 +00002291 else if (Name == "sse4a")
Craig Topper6a511e12011-12-30 07:33:42 +00002292 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper90ea0362012-05-30 05:54:54 +00002293 Features["sse4a"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00002294 else if (Name == "lzcnt")
2295 Features["lzcnt"] = true;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002296 else if (Name == "rdrnd")
2297 Features["rdrand"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00002298 else if (Name == "bmi")
2299 Features["bmi"] = true;
2300 else if (Name == "bmi2")
2301 Features["bmi2"] = true;
Craig Toppere14e08b2011-12-29 16:10:46 +00002302 else if (Name == "popcnt")
2303 Features["popcnt"] = true;
Manman Ren146e5a42012-10-11 00:59:55 +00002304 else if (Name == "f16c")
2305 Features["f16c"] = true;
Michael Liao463eb892012-11-10 05:17:46 +00002306 else if (Name == "rtm")
2307 Features["rtm"] = true;
Michael Liao72339a02013-03-26 17:52:08 +00002308 else if (Name == "prfchw")
2309 Features["prfchw"] = true;
Michael Liao1bfc28c2013-03-29 05:17:55 +00002310 else if (Name == "rdseed")
2311 Features["rdseed"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002312 } else {
2313 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002314 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002315 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00002316 Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00002317 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002318 Features["sse4a"] = Features["avx"] = Features["avx2"] =
2319 Features["fma"] = Features["fma4"] = Features["aes"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002320 Features["pclmul"] = Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002321 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00002322 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Craig Toppera7463c32012-06-03 21:56:22 +00002323 Features["sse41"] = Features["sse42"] = Features["sse4a"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002324 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002325 Features["fma4"] = Features["aes"] = Features["pclmul"] =
2326 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002327 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00002328 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002329 Features["sse42"] = Features["sse4a"] = Features["avx"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002330 Features["avx2"] = Features["fma"] = Features["fma4"] =
2331 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002332 else if (Name == "ssse3")
Craig Topper31380fb2012-06-03 22:23:42 +00002333 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2334 Features["avx"] = Features["avx2"] = Features["fma"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00002335 else if (Name == "sse4" || Name == "sse4.1")
Craig Topper31380fb2012-06-03 22:23:42 +00002336 Features["sse41"] = Features["sse42"] = Features["avx"] =
2337 Features["avx2"] = Features["fma"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00002338 else if (Name == "sse4.2")
Craig Topper31380fb2012-06-03 22:23:42 +00002339 Features["sse42"] = Features["avx"] = Features["avx2"] =
2340 Features["fma"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002341 else if (Name == "3dnow")
2342 Features["3dnow"] = Features["3dnowa"] = false;
2343 else if (Name == "3dnowa")
2344 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00002345 else if (Name == "aes")
2346 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00002347 else if (Name == "pclmul")
2348 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002349 else if (Name == "avx")
Craig Topper2ae95072012-06-03 21:46:30 +00002350 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002351 Features["fma4"] = Features["xop"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00002352 else if (Name == "avx2")
2353 Features["avx2"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00002354 else if (Name == "fma")
2355 Features["fma"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00002356 else if (Name == "sse4a")
Craig Topperb6af69e2012-06-09 22:24:14 +00002357 Features["sse4a"] = Features["fma4"] = Features["xop"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002358 else if (Name == "lzcnt")
2359 Features["lzcnt"] = false;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002360 else if (Name == "rdrnd")
2361 Features["rdrand"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002362 else if (Name == "bmi")
2363 Features["bmi"] = false;
2364 else if (Name == "bmi2")
2365 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00002366 else if (Name == "popcnt")
2367 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00002368 else if (Name == "fma4")
Craig Topperb6af69e2012-06-09 22:24:14 +00002369 Features["fma4"] = Features["xop"] = false;
2370 else if (Name == "xop")
2371 Features["xop"] = false;
Manman Ren146e5a42012-10-11 00:59:55 +00002372 else if (Name == "f16c")
2373 Features["f16c"] = false;
Michael Liao463eb892012-11-10 05:17:46 +00002374 else if (Name == "rtm")
2375 Features["rtm"] = false;
Michael Liao72339a02013-03-26 17:52:08 +00002376 else if (Name == "prfchw")
2377 Features["prfchw"] = false;
Michael Liao1bfc28c2013-03-29 05:17:55 +00002378 else if (Name == "rdseed")
2379 Features["rdseed"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002380 }
2381
2382 return true;
2383}
2384
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002385/// HandleTargetOptions - Perform initialization based on the user
2386/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00002387void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002388 // Remember the maximum enabled sselevel.
2389 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
2390 // Ignore disabled features.
2391 if (Features[i][0] == '-')
2392 continue;
2393
Benjamin Kramer713575a2012-03-05 15:10:44 +00002394 StringRef Feature = StringRef(Features[i]).substr(1);
2395
2396 if (Feature == "aes") {
Eric Christophereea12d12010-04-02 23:50:19 +00002397 HasAES = true;
2398 continue;
2399 }
2400
Craig Topper3c0bc152012-05-31 05:18:48 +00002401 if (Feature == "pclmul") {
2402 HasPCLMUL = true;
2403 continue;
2404 }
2405
Benjamin Kramer713575a2012-03-05 15:10:44 +00002406 if (Feature == "lzcnt") {
Craig Topper31ceea02011-12-25 05:06:45 +00002407 HasLZCNT = true;
2408 continue;
2409 }
2410
Benjamin Kramer84f30802012-07-07 09:39:18 +00002411 if (Feature == "rdrand") {
2412 HasRDRND = true;
2413 continue;
2414 }
2415
Benjamin Kramer713575a2012-03-05 15:10:44 +00002416 if (Feature == "bmi") {
Craig Topper31ceea02011-12-25 05:06:45 +00002417 HasBMI = true;
2418 continue;
2419 }
2420
Benjamin Kramer713575a2012-03-05 15:10:44 +00002421 if (Feature == "bmi2") {
Craig Topper31ceea02011-12-25 05:06:45 +00002422 HasBMI2 = true;
2423 continue;
2424 }
2425
Benjamin Kramer713575a2012-03-05 15:10:44 +00002426 if (Feature == "popcnt") {
Craig Toppere14e08b2011-12-29 16:10:46 +00002427 HasPOPCNT = true;
2428 continue;
2429 }
2430
Michael Liao463eb892012-11-10 05:17:46 +00002431 if (Feature == "rtm") {
2432 HasRTM = true;
2433 continue;
2434 }
2435
Michael Liao72339a02013-03-26 17:52:08 +00002436 if (Feature == "prfchw") {
2437 HasPRFCHW = true;
2438 continue;
2439 }
2440
Michael Liao1bfc28c2013-03-29 05:17:55 +00002441 if (Feature == "rdseed") {
2442 HasRDSEED = true;
2443 continue;
2444 }
2445
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002446 if (Feature == "sse4a") {
2447 HasSSE4a = true;
2448 continue;
2449 }
2450
Benjamin Kramer713575a2012-03-05 15:10:44 +00002451 if (Feature == "fma4") {
Craig Topper6a511e12011-12-30 07:33:42 +00002452 HasFMA4 = true;
2453 continue;
2454 }
2455
Craig Topper2ae95072012-06-03 21:46:30 +00002456 if (Feature == "fma") {
2457 HasFMA = true;
2458 continue;
2459 }
2460
Craig Topperb6af69e2012-06-09 22:24:14 +00002461 if (Feature == "xop") {
2462 HasXOP = true;
2463 continue;
2464 }
2465
Manman Ren146e5a42012-10-11 00:59:55 +00002466 if (Feature == "f16c") {
2467 HasF16C = true;
2468 continue;
2469 }
2470
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002471 assert(Features[i][0] == '+' && "Invalid target feature!");
Benjamin Kramer713575a2012-03-05 15:10:44 +00002472 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Craig Topper05fe4b52012-01-09 09:19:09 +00002473 .Case("avx2", AVX2)
2474 .Case("avx", AVX)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002475 .Case("sse42", SSE42)
2476 .Case("sse41", SSE41)
2477 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00002478 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002479 .Case("sse2", SSE2)
2480 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002481 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002482 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002483
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002484 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer713575a2012-03-05 15:10:44 +00002485 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002486 .Case("3dnowa", AMD3DNowAthlon)
2487 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002488 .Case("mmx", MMX)
2489 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002490
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002491 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002492 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002493
2494 // Don't tell the backend if we're turning off mmx; it will end up disabling
2495 // SSE, which we don't want.
2496 std::vector<std::string>::iterator it;
2497 it = std::find(Features.begin(), Features.end(), "-mmx");
2498 if (it != Features.end())
2499 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00002500}
Chris Lattnerc0f59212009-03-02 22:27:17 +00002501
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002502/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
2503/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00002504void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002505 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002506 // Target identification.
Derek Schuffbabaf312012-10-11 15:52:22 +00002507 if (getTriple().getArch() == llvm::Triple::x86_64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002508 Builder.defineMacro("__amd64__");
2509 Builder.defineMacro("__amd64");
2510 Builder.defineMacro("__x86_64");
2511 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002512 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00002513 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00002514 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002515
Chris Lattnerc0f59212009-03-02 22:27:17 +00002516 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002517 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
2518 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002519 switch (CPU) {
2520 case CK_Generic:
2521 break;
2522 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002523 // The rest are coming from the i386 define above.
2524 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002525 break;
2526 case CK_i486:
2527 case CK_WinChipC6:
2528 case CK_WinChip2:
2529 case CK_C3:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002530 defineCPUMacros(Builder, "i486");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002531 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00002532 case CK_PentiumMMX:
2533 Builder.defineMacro("__pentium_mmx__");
2534 Builder.defineMacro("__tune_pentium_mmx__");
2535 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002536 case CK_i586:
2537 case CK_Pentium:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002538 defineCPUMacros(Builder, "i586");
2539 defineCPUMacros(Builder, "pentium");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002540 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002541 case CK_Pentium3:
2542 case CK_Pentium3M:
2543 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002544 Builder.defineMacro("__tune_pentium3__");
2545 // Fallthrough
2546 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002547 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002548 Builder.defineMacro("__tune_pentium2__");
2549 // Fallthrough
2550 case CK_PentiumPro:
2551 Builder.defineMacro("__tune_i686__");
2552 Builder.defineMacro("__tune_pentiumpro__");
2553 // Fallthrough
2554 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002555 Builder.defineMacro("__i686");
2556 Builder.defineMacro("__i686__");
2557 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
2558 Builder.defineMacro("__pentiumpro");
2559 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002560 break;
2561 case CK_Pentium4:
2562 case CK_Pentium4M:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002563 defineCPUMacros(Builder, "pentium4");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002564 break;
2565 case CK_Yonah:
2566 case CK_Prescott:
2567 case CK_Nocona:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002568 defineCPUMacros(Builder, "nocona");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002569 break;
2570 case CK_Core2:
2571 case CK_Penryn:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002572 defineCPUMacros(Builder, "core2");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002573 break;
2574 case CK_Atom:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002575 defineCPUMacros(Builder, "atom");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002576 break;
2577 case CK_Corei7:
2578 case CK_Corei7AVX:
2579 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00002580 case CK_CoreAVX2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002581 defineCPUMacros(Builder, "corei7");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002582 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002583 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002584 Builder.defineMacro("__k6_2__");
2585 Builder.defineMacro("__tune_k6_2__");
2586 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002587 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002588 if (CPU != CK_K6_2) { // In case of fallthrough
2589 // FIXME: GCC may be enabling these in cases where some other k6
2590 // architecture is specified but -m3dnow is explicitly provided. The
2591 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002592 Builder.defineMacro("__k6_3__");
2593 Builder.defineMacro("__tune_k6_3__");
2594 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00002595 // Fallthrough
2596 case CK_K6:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002597 defineCPUMacros(Builder, "k6");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002598 break;
2599 case CK_Athlon:
2600 case CK_AthlonThunderbird:
2601 case CK_Athlon4:
2602 case CK_AthlonXP:
2603 case CK_AthlonMP:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002604 defineCPUMacros(Builder, "athlon");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002605 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002606 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002607 Builder.defineMacro("__tune_athlon_sse__");
2608 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002609 break;
2610 case CK_K8:
2611 case CK_K8SSE3:
2612 case CK_x86_64:
2613 case CK_Opteron:
2614 case CK_OpteronSSE3:
2615 case CK_Athlon64:
2616 case CK_Athlon64SSE3:
2617 case CK_AthlonFX:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002618 defineCPUMacros(Builder, "k8");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002619 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002620 case CK_AMDFAM10:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002621 defineCPUMacros(Builder, "amdfam10");
Roman Divacky01c770d2011-10-30 07:48:46 +00002622 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002623 case CK_BTVER1:
2624 defineCPUMacros(Builder, "btver1");
2625 break;
Benjamin Kramer63063f52013-05-03 10:47:15 +00002626 case CK_BTVER2:
2627 defineCPUMacros(Builder, "btver2");
2628 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002629 case CK_BDVER1:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002630 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002631 break;
2632 case CK_BDVER2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002633 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002634 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002635 case CK_Geode:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002636 defineCPUMacros(Builder, "geode");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002637 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002638 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00002639
Chandler Carruth88c75b02011-09-28 09:54:07 +00002640 // Target properties.
2641 Builder.defineMacro("__LITTLE_ENDIAN__");
2642 Builder.defineMacro("__REGISTER_PREFIX__", "");
2643
Chris Lattner54175442009-04-19 17:32:33 +00002644 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2645 // functions in glibc header files that use FP Stack inline asm which the
2646 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00002647 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002648
Chandler Carruth88c75b02011-09-28 09:54:07 +00002649 if (HasAES)
2650 Builder.defineMacro("__AES__");
2651
Craig Topper3c0bc152012-05-31 05:18:48 +00002652 if (HasPCLMUL)
2653 Builder.defineMacro("__PCLMUL__");
2654
Craig Topper31ceea02011-12-25 05:06:45 +00002655 if (HasLZCNT)
2656 Builder.defineMacro("__LZCNT__");
2657
Benjamin Kramer84f30802012-07-07 09:39:18 +00002658 if (HasRDRND)
2659 Builder.defineMacro("__RDRND__");
2660
Craig Topper31ceea02011-12-25 05:06:45 +00002661 if (HasBMI)
2662 Builder.defineMacro("__BMI__");
2663
2664 if (HasBMI2)
2665 Builder.defineMacro("__BMI2__");
2666
Craig Toppere14e08b2011-12-29 16:10:46 +00002667 if (HasPOPCNT)
2668 Builder.defineMacro("__POPCNT__");
2669
Michael Liao463eb892012-11-10 05:17:46 +00002670 if (HasRTM)
2671 Builder.defineMacro("__RTM__");
2672
Michael Liao72339a02013-03-26 17:52:08 +00002673 if (HasPRFCHW)
2674 Builder.defineMacro("__PRFCHW__");
2675
Michael Liao1bfc28c2013-03-29 05:17:55 +00002676 if (HasRDSEED)
2677 Builder.defineMacro("__RDSEED__");
2678
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002679 if (HasSSE4a)
2680 Builder.defineMacro("__SSE4A__");
2681
Craig Topper6a511e12011-12-30 07:33:42 +00002682 if (HasFMA4)
2683 Builder.defineMacro("__FMA4__");
2684
Craig Topper2ae95072012-06-03 21:46:30 +00002685 if (HasFMA)
2686 Builder.defineMacro("__FMA__");
2687
Craig Topperb6af69e2012-06-09 22:24:14 +00002688 if (HasXOP)
2689 Builder.defineMacro("__XOP__");
2690
Manman Ren146e5a42012-10-11 00:59:55 +00002691 if (HasF16C)
2692 Builder.defineMacro("__F16C__");
2693
Chris Lattner84f0ea82009-03-02 22:40:39 +00002694 // Each case falls through to the previous one here.
2695 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002696 case AVX2:
2697 Builder.defineMacro("__AVX2__");
2698 case AVX:
2699 Builder.defineMacro("__AVX__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002700 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00002701 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002702 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00002703 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002704 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002705 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002706 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002707 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002708 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00002709 Builder.defineMacro("__SSE2__");
2710 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00002711 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00002712 Builder.defineMacro("__SSE__");
2713 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002714 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00002715 break;
2716 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002717
Derek Schuffbabaf312012-10-11 15:52:22 +00002718 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002719 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002720 case AVX2:
2721 case AVX:
Michael J. Spencera764e832010-10-21 08:22:51 +00002722 case SSE42:
2723 case SSE41:
2724 case SSSE3:
2725 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002726 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002727 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002728 break;
2729 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002730 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002731 break;
2732 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002733 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002734 }
2735 }
2736
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002737 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002738 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002739 case AMD3DNowAthlon:
2740 Builder.defineMacro("__3dNOW_A__");
2741 case AMD3DNow:
2742 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002743 case MMX:
2744 Builder.defineMacro("__MMX__");
2745 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002746 break;
2747 }
Michael J. Spencerd1b33942013-04-04 23:53:43 +00002748
2749 if (CPU >= CK_i486) {
2750 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
2751 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
2752 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
2753 }
2754 if (CPU >= CK_i586)
2755 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002756}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002757
Douglas Gregore727d212012-01-30 06:38:25 +00002758bool X86TargetInfo::hasFeature(StringRef Feature) const {
2759 return llvm::StringSwitch<bool>(Feature)
2760 .Case("aes", HasAES)
2761 .Case("avx", SSELevel >= AVX)
2762 .Case("avx2", SSELevel >= AVX2)
2763 .Case("bmi", HasBMI)
2764 .Case("bmi2", HasBMI2)
Craig Topper2ae95072012-06-03 21:46:30 +00002765 .Case("fma", HasFMA)
Douglas Gregore727d212012-01-30 06:38:25 +00002766 .Case("fma4", HasFMA4)
2767 .Case("lzcnt", HasLZCNT)
Benjamin Kramer84f30802012-07-07 09:39:18 +00002768 .Case("rdrnd", HasRDRND)
Douglas Gregore727d212012-01-30 06:38:25 +00002769 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
2770 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
2771 .Case("mmx", MMX3DNowLevel >= MMX)
Craig Topper3c0bc152012-05-31 05:18:48 +00002772 .Case("pclmul", HasPCLMUL)
Douglas Gregore727d212012-01-30 06:38:25 +00002773 .Case("popcnt", HasPOPCNT)
Michael Liao463eb892012-11-10 05:17:46 +00002774 .Case("rtm", HasRTM)
Michael Liao72339a02013-03-26 17:52:08 +00002775 .Case("prfchw", HasPRFCHW)
Michael Liao1bfc28c2013-03-29 05:17:55 +00002776 .Case("rdseed", HasRDSEED)
Douglas Gregore727d212012-01-30 06:38:25 +00002777 .Case("sse", SSELevel >= SSE1)
2778 .Case("sse2", SSELevel >= SSE2)
2779 .Case("sse3", SSELevel >= SSE3)
2780 .Case("ssse3", SSELevel >= SSSE3)
2781 .Case("sse41", SSELevel >= SSE41)
2782 .Case("sse42", SSELevel >= SSE42)
Craig Topper3c0bc152012-05-31 05:18:48 +00002783 .Case("sse4a", HasSSE4a)
Douglas Gregore727d212012-01-30 06:38:25 +00002784 .Case("x86", true)
Derek Schuffbabaf312012-10-11 15:52:22 +00002785 .Case("x86_32", getTriple().getArch() == llvm::Triple::x86)
2786 .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64)
Craig Topperb6af69e2012-06-09 22:24:14 +00002787 .Case("xop", HasXOP)
Manman Ren146e5a42012-10-11 00:59:55 +00002788 .Case("f16c", HasF16C)
Douglas Gregore727d212012-01-30 06:38:25 +00002789 .Default(false);
2790}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002791
Eli Friedman618234a2008-08-20 02:34:37 +00002792bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002793X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002794 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002795 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00002796 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00002797 case 'Y': // first letter of a pair:
2798 switch (*(Name+1)) {
2799 default: return false;
2800 case '0': // First SSE register.
2801 case 't': // Any SSE register, when SSE2 is enabled.
2802 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2803 case 'm': // any MMX register, when inter-unit moves enabled.
2804 break; // falls through to setAllowsRegister.
2805 }
Eli Friedman618234a2008-08-20 02:34:37 +00002806 case 'a': // eax.
2807 case 'b': // ebx.
2808 case 'c': // ecx.
2809 case 'd': // edx.
2810 case 'S': // esi.
2811 case 'D': // edi.
2812 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00002813 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00002814 case 't': // top of floating point stack.
2815 case 'u': // second from top of floating point stack.
2816 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00002817 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00002818 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00002819 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00002820 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2821 case 'l': // "Index" registers: any general register that can be used as an
2822 // index in a base+index memory access.
2823 Info.setAllowsRegister();
2824 return true;
2825 case 'C': // SSE floating point constant.
2826 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002827 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002828 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002829 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002830 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00002831 return true;
2832 }
2833}
2834
Dale Johannesenf6e2c202010-10-29 23:12:32 +00002835
Eli Friedman618234a2008-08-20 02:34:37 +00002836std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00002837X86TargetInfo::convertConstraint(const char *&Constraint) const {
2838 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00002839 case 'a': return std::string("{ax}");
2840 case 'b': return std::string("{bx}");
2841 case 'c': return std::string("{cx}");
2842 case 'd': return std::string("{dx}");
2843 case 'S': return std::string("{si}");
2844 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00002845 case 'p': // address
2846 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00002847 case 't': // top of floating point stack.
2848 return std::string("{st}");
2849 case 'u': // second from top of floating point stack.
2850 return std::string("{st(1)}"); // second from top of floating point stack.
2851 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00002852 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00002853 }
2854}
Eli Friedman618234a2008-08-20 02:34:37 +00002855} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00002856
2857namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002858// X86-32 generic target
2859class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00002860public:
Eli Friedman618234a2008-08-20 02:34:37 +00002861 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
2862 DoubleAlign = LongLongAlign = 32;
2863 LongDoubleWidth = 96;
2864 LongDoubleAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00002865 SuitableAlign = 128;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002866 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2867 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00002868 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00002869 SizeType = UnsignedInt;
2870 PtrDiffType = SignedInt;
2871 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002872 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002873
2874 // Use fpret for all types.
2875 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2876 (1 << TargetInfo::Double) |
2877 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002878
2879 // x86-32 has atomics up to 8 bytes
2880 // FIXME: Check that we actually have cmpxchg8b before setting
2881 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2882 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002883 }
Meador Ingec5613b22012-06-16 03:34:49 +00002884 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2885 return TargetInfo::CharPtrBuiltinVaList;
Eli Friedman618234a2008-08-20 02:34:37 +00002886 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002887
Chris Lattner21fb98e2009-09-23 06:06:36 +00002888 int getEHDataRegisterNumber(unsigned RegNo) const {
2889 if (RegNo == 0) return 0;
2890 if (RegNo == 1) return 2;
2891 return -1;
2892 }
Bill Wendling68fd6082012-11-12 06:42:51 +00002893 virtual bool validateInputSize(StringRef Constraint,
2894 unsigned Size) const {
2895 switch (Constraint[0]) {
2896 default: break;
2897 case 'a':
2898 case 'b':
2899 case 'c':
2900 case 'd':
Bill Wendlingf634bdf2012-11-12 18:52:32 +00002901 return Size <= 32;
Bill Wendling68fd6082012-11-12 06:42:51 +00002902 }
2903
2904 return true;
2905 }
Eli Friedman618234a2008-08-20 02:34:37 +00002906};
2907} // end anonymous namespace
2908
2909namespace {
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002910class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
2911public:
2912 NetBSDI386TargetInfo(const std::string &triple) :
2913 NetBSDTargetInfo<X86_32TargetInfo>(triple) {
2914 }
2915
2916 virtual unsigned getFloatEvalMethod() const {
2917 // NetBSD defaults to "double" rounding
2918 return 1;
2919 }
2920};
2921} // end anonymous namespace
2922
2923namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002924class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2925public:
2926 OpenBSDI386TargetInfo(const std::string& triple) :
2927 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2928 SizeType = UnsignedLong;
2929 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002930 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002931 }
2932};
2933} // end anonymous namespace
2934
2935namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00002936class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
2937public:
2938 BitrigI386TargetInfo(const std::string& triple) :
2939 BitrigTargetInfo<X86_32TargetInfo>(triple) {
2940 SizeType = UnsignedLong;
2941 IntPtrType = SignedLong;
2942 PtrDiffType = SignedLong;
2943 }
2944};
2945} // end anonymous namespace
2946
2947namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002948class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002949public:
Torok Edwin5f6c1942009-06-30 17:10:35 +00002950 DarwinI386TargetInfo(const std::string& triple) :
2951 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002952 LongDoubleWidth = 128;
2953 LongDoubleAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002954 SuitableAlign = 128;
Chad Rosierf9e9af72012-07-13 23:57:43 +00002955 MaxVectorAlign = 256;
Eli Friedman1afabd92009-03-29 20:31:09 +00002956 SizeType = UnsignedLong;
2957 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002958 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2959 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002960 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002961 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002962 }
2963
Eli Friedman618234a2008-08-20 02:34:37 +00002964};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002965} // end anonymous namespace
2966
2967namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002968// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002969class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002970public:
2971 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002972 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002973 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002974 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002975 DoubleAlign = LongLongAlign = 64;
2976 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 +00002977 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002978 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002979 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002980 virtual void getTargetDefines(const LangOptions &Opts,
2981 MacroBuilder &Builder) const {
2982 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2983 }
2984};
2985} // end anonymous namespace
2986
2987namespace {
2988
2989// x86-32 Windows Visual Studio target
2990class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2991public:
2992 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2993 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002994 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002995 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2996 }
2997 virtual void getTargetDefines(const LangOptions &Opts,
2998 MacroBuilder &Builder) const {
2999 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
3000 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
3001 // The value of the following reflects processor type.
3002 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
3003 // We lost the original triple, so we use the default.
3004 Builder.defineMacro("_M_IX86", "600");
3005 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003006};
3007} // end anonymous namespace
3008
3009namespace {
3010// x86-32 MinGW target
3011class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
3012public:
3013 MinGWX86_32TargetInfo(const std::string& triple)
3014 : WindowsX86_32TargetInfo(triple) {
3015 }
3016 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003017 MacroBuilder &Builder) const {
3018 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00003019 DefineStd(Builder, "WIN32", Opts);
3020 DefineStd(Builder, "WINNT", Opts);
3021 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00003022 Builder.defineMacro("__MSVCRT__");
3023 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003024
3025 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
3026 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00003027 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003028 // Provide "as-is" __declspec.
3029 Builder.defineMacro("__declspec", "__declspec");
3030 else
3031 // Provide alias of __attribute__ like mingw32-gcc.
3032 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003033 }
3034};
3035} // end anonymous namespace
3036
3037namespace {
3038// x86-32 Cygwin target
3039class CygwinX86_32TargetInfo : public X86_32TargetInfo {
3040public:
3041 CygwinX86_32TargetInfo(const std::string& triple)
3042 : X86_32TargetInfo(triple) {
3043 TLSSupported = false;
3044 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003045 DoubleAlign = LongLongAlign = 64;
3046 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3047 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003048 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003049 }
3050 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003051 MacroBuilder &Builder) const {
3052 X86_32TargetInfo::getTargetDefines(Opts, Builder);
NAKAMURA Takumie72f4d92012-12-14 10:17:26 +00003053 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00003054 Builder.defineMacro("__CYGWIN__");
3055 Builder.defineMacro("__CYGWIN32__");
3056 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00003057 if (Opts.CPlusPlus)
3058 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00003059 }
Eli Friedman29a30502008-08-21 01:40:19 +00003060};
3061} // end anonymous namespace
3062
3063namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00003064// x86-32 Haiku target
3065class HaikuX86_32TargetInfo : public X86_32TargetInfo {
3066public:
3067 HaikuX86_32TargetInfo(const std::string& triple)
3068 : X86_32TargetInfo(triple) {
3069 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00003070 IntPtrType = SignedLong;
3071 PtrDiffType = SignedLong;
Eli Friedman6902e412012-11-27 02:58:24 +00003072 ProcessIDType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00003073 this->UserLabelPrefix = "";
Benjamin Krameref7bcea2012-11-08 12:59:15 +00003074 this->TLSSupported = false;
Eli Friedmana7e68452010-08-22 01:00:03 +00003075 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00003076 virtual void getTargetDefines(const LangOptions &Opts,
3077 MacroBuilder &Builder) const {
3078 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3079 Builder.defineMacro("__INTEL__");
3080 Builder.defineMacro("__HAIKU__");
3081 }
3082};
3083} // end anonymous namespace
3084
Douglas Gregordca52262011-07-01 22:41:14 +00003085// RTEMS Target
3086template<typename Target>
3087class RTEMSTargetInfo : public OSTargetInfo<Target> {
3088protected:
3089 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
3090 MacroBuilder &Builder) const {
3091 // RTEMS defines; list based off of gcc output
3092
Douglas Gregordca52262011-07-01 22:41:14 +00003093 Builder.defineMacro("__rtems__");
3094 Builder.defineMacro("__ELF__");
3095 }
3096public:
3097 RTEMSTargetInfo(const std::string &triple)
3098 : OSTargetInfo<Target>(triple) {
3099 this->UserLabelPrefix = "";
3100
3101 llvm::Triple Triple(triple);
3102 switch (Triple.getArch()) {
3103 default:
3104 case llvm::Triple::x86:
3105 // this->MCountName = ".mcount";
3106 break;
3107 case llvm::Triple::mips:
3108 case llvm::Triple::mipsel:
3109 case llvm::Triple::ppc:
3110 case llvm::Triple::ppc64:
3111 // this->MCountName = "_mcount";
3112 break;
3113 case llvm::Triple::arm:
3114 // this->MCountName = "__mcount";
3115 break;
3116 }
3117
3118 }
3119};
3120
3121namespace {
3122// x86-32 RTEMS target
3123class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
3124public:
3125 RTEMSX86_32TargetInfo(const std::string& triple)
3126 : X86_32TargetInfo(triple) {
3127 SizeType = UnsignedLong;
3128 IntPtrType = SignedLong;
3129 PtrDiffType = SignedLong;
3130 this->UserLabelPrefix = "";
3131 }
3132 virtual void getTargetDefines(const LangOptions &Opts,
3133 MacroBuilder &Builder) const {
3134 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3135 Builder.defineMacro("__INTEL__");
3136 Builder.defineMacro("__rtems__");
3137 }
3138};
3139} // end anonymous namespace
3140
Chris Lattner86ed3a32010-04-11 19:29:39 +00003141namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00003142// x86-64 generic target
3143class X86_64TargetInfo : public X86TargetInfo {
3144public:
Chris Lattner33328642009-03-20 15:52:06 +00003145 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00003146 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00003147 LongDoubleWidth = 128;
3148 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00003149 LargeArrayMinWidth = 128;
3150 LargeArrayAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003151 SuitableAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00003152 IntMaxType = SignedLong;
3153 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003154 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00003155 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00003156
Eli Friedmaned855cb2008-08-21 00:13:15 +00003157 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3158 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003159 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00003160
3161 // Use fpret only for long double.
3162 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00003163
Anders Carlssoneea64802011-10-31 16:27:11 +00003164 // Use fp2ret for _Complex long double.
3165 ComplexLongDoubleUsesFP2Ret = true;
3166
Eli Friedman2be46072011-10-14 20:59:01 +00003167 // x86-64 has atomics up to 16 bytes.
3168 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
3169 // on CPUs with cmpxchg16b
3170 MaxAtomicPromoteWidth = 128;
3171 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00003172 }
Meador Ingec5613b22012-06-16 03:34:49 +00003173 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3174 return TargetInfo::X86_64ABIBuiltinVaList;
Anders Carlsson3346ae62007-11-24 23:38:12 +00003175 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00003176
Chris Lattner21fb98e2009-09-23 06:06:36 +00003177 int getEHDataRegisterNumber(unsigned RegNo) const {
3178 if (RegNo == 0) return 0;
3179 if (RegNo == 1) return 1;
3180 return -1;
3181 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00003182
3183 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
Peter Collingbourne7728cdd2013-02-23 00:06:18 +00003184 return (CC == CC_Default ||
3185 CC == CC_C ||
3186 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballman82bfa192012-10-02 14:26:08 +00003187 }
3188
Aaron Ballmanfff32482012-12-09 17:45:41 +00003189 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {
3190 return CC_C;
Aaron Ballman82bfa192012-10-02 14:26:08 +00003191 }
3192
Eli Friedman618234a2008-08-20 02:34:37 +00003193};
3194} // end anonymous namespace
3195
3196namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003197// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003198class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003199public:
3200 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003201 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003202 TLSSupported = false;
3203 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00003204 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00003205 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00003206 IntMaxType = SignedLongLong;
3207 UIntMaxType = UnsignedLongLong;
3208 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00003209 SizeType = UnsignedLongLong;
3210 PtrDiffType = SignedLongLong;
3211 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00003212 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003213 }
3214 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003215 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003216 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003217 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00003218 }
Meador Ingec5613b22012-06-16 03:34:49 +00003219 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3220 return TargetInfo::CharPtrBuiltinVaList;
NAKAMURA Takumi79521992011-01-17 22:56:23 +00003221 }
Michael J. Spencera764e832010-10-21 08:22:51 +00003222};
3223} // end anonymous namespace
3224
3225namespace {
3226// x86-64 Windows Visual Studio target
3227class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
3228public:
3229 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
3230 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00003231 LongDoubleWidth = LongDoubleAlign = 64;
3232 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00003233 }
3234 virtual void getTargetDefines(const LangOptions &Opts,
3235 MacroBuilder &Builder) const {
3236 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
3237 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00003238 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003239 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003240 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003241};
3242} // end anonymous namespace
3243
3244namespace {
3245// x86-64 MinGW target
3246class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
3247public:
3248 MinGWX86_64TargetInfo(const std::string& triple)
3249 : WindowsX86_64TargetInfo(triple) {
3250 }
3251 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003252 MacroBuilder &Builder) const {
3253 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00003254 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00003255 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00003256 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00003257 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003258
3259 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
3260 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00003261 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003262 // Provide "as-is" __declspec.
3263 Builder.defineMacro("__declspec", "__declspec");
3264 else
3265 // Provide alias of __attribute__ like mingw32-gcc.
3266 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003267 }
3268};
3269} // end anonymous namespace
3270
3271namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003272class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
3273public:
Mike Stump1eb44332009-09-09 15:08:12 +00003274 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003275 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
3276 Int64Type = SignedLongLong;
Chad Rosierf9e9af72012-07-13 23:57:43 +00003277 MaxVectorAlign = 256;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003278 }
3279};
3280} // end anonymous namespace
3281
3282namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00003283class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
3284public:
Mike Stump1eb44332009-09-09 15:08:12 +00003285 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman6036ebe2009-07-05 22:31:18 +00003286 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
3287 IntMaxType = SignedLongLong;
3288 UIntMaxType = UnsignedLongLong;
3289 Int64Type = SignedLongLong;
3290 }
3291};
3292} // end anonymous namespace
3293
3294namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00003295class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
3296public:
3297 BitrigX86_64TargetInfo(const std::string& triple)
3298 : BitrigTargetInfo<X86_64TargetInfo>(triple) {
3299 IntMaxType = SignedLongLong;
3300 UIntMaxType = UnsignedLongLong;
3301 Int64Type = SignedLongLong;
3302 }
3303};
Tim Northoverc264e162013-01-31 12:13:10 +00003304}
3305
3306namespace {
3307class AArch64TargetInfo : public TargetInfo {
3308 static const char * const GCCRegNames[];
3309 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Tim Northoverff920ee2013-05-04 07:15:13 +00003310
3311 static const Builtin::Info BuiltinInfo[];
Tim Northoverc264e162013-01-31 12:13:10 +00003312public:
3313 AArch64TargetInfo(const std::string& triple) : TargetInfo(triple) {
3314 BigEndian = false;
3315 LongWidth = LongAlign = 64;
3316 LongDoubleWidth = LongDoubleAlign = 128;
3317 PointerWidth = PointerAlign = 64;
3318 SuitableAlign = 128;
3319 DescriptionString = "e-p:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3320 "i64:64:64-i128:128:128-f32:32:32-f64:64:64-"
3321 "f128:128:128-n32:64-S128";
3322
3323 WCharType = UnsignedInt;
3324 LongDoubleFormat = &llvm::APFloat::IEEEquad;
3325
Tim Northover6a93c862013-02-18 12:11:32 +00003326 // AArch64 backend supports 64-bit operations at the moment. In principle
3327 // 128-bit is possible if register-pairs are used.
3328 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
3329
Tim Northoverc264e162013-01-31 12:13:10 +00003330 TheCXXABI.set(TargetCXXABI::GenericAArch64);
3331 }
3332 virtual void getTargetDefines(const LangOptions &Opts,
3333 MacroBuilder &Builder) const {
3334 // GCC defines theses currently
3335 Builder.defineMacro("__aarch64__");
3336 Builder.defineMacro("__AARCH64EL__");
3337
3338 // ACLE predefines. Many can only have one possible value on v8 AArch64.
3339
3340 // FIXME: these were written based on an unreleased version of a 32-bit ACLE
3341 // which was intended to be compatible with a 64-bit implementation. They
3342 // will need updating when a real 64-bit ACLE exists. Particularly pressing
Tim Northoverdabcbf92013-04-05 14:08:55 +00003343 // instances are: __ARM_ARCH_ISA_ARM, __ARM_ARCH_ISA_THUMB, __ARM_PCS.
3344 Builder.defineMacro("__ARM_ACLE", "101");
3345 Builder.defineMacro("__ARM_ARCH", "8");
3346 Builder.defineMacro("__ARM_ARCH_PROFILE", "'A'");
Tim Northoverc264e162013-01-31 12:13:10 +00003347
Tim Northoverdabcbf92013-04-05 14:08:55 +00003348 Builder.defineMacro("__ARM_FEATURE_UNALIGNED");
3349 Builder.defineMacro("__ARM_FEATURE_CLZ");
3350 Builder.defineMacro("__ARM_FEATURE_FMA");
Tim Northoverc264e162013-01-31 12:13:10 +00003351
3352 // FIXME: ACLE 1.1 reserves bit 4. Will almost certainly come to mean
3353 // 128-bit LDXP present, at which point this becomes 0x1f.
Tim Northoverdabcbf92013-04-05 14:08:55 +00003354 Builder.defineMacro("__ARM_FEATURE_LDREX", "0xf");
Tim Northoverc264e162013-01-31 12:13:10 +00003355
3356 // 0xe implies support for half, single and double precision operations.
Tim Northoverdabcbf92013-04-05 14:08:55 +00003357 Builder.defineMacro("__ARM_FP", "0xe");
Tim Northoverc264e162013-01-31 12:13:10 +00003358
3359 // PCS specifies this for SysV variants, which is all we support. Other ABIs
Tim Northoverdabcbf92013-04-05 14:08:55 +00003360 // may choose __ARM_FP16_FORMAT_ALTERNATIVE.
3361 Builder.defineMacro("__ARM_FP16_FORMAT_IEEE");
Tim Northoverc264e162013-01-31 12:13:10 +00003362
3363 if (Opts.FastMath || Opts.FiniteMathOnly)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003364 Builder.defineMacro("__ARM_FP_FAST");
Tim Northoverc264e162013-01-31 12:13:10 +00003365
3366 if ((Opts.C99 || Opts.C11) && !Opts.Freestanding)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003367 Builder.defineMacro("__ARM_FP_FENV_ROUNDING");
Tim Northoverc264e162013-01-31 12:13:10 +00003368
Tim Northoverdabcbf92013-04-05 14:08:55 +00003369 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
Tim Northoverc264e162013-01-31 12:13:10 +00003370 Opts.ShortWChar ? "2" : "4");
3371
Tim Northoverdabcbf92013-04-05 14:08:55 +00003372 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
Tim Northoverc264e162013-01-31 12:13:10 +00003373 Opts.ShortEnums ? "1" : "4");
3374
3375 if (BigEndian)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003376 Builder.defineMacro("__ARM_BIG_ENDIAN");
Tim Northoverc264e162013-01-31 12:13:10 +00003377 }
3378 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3379 unsigned &NumRecords) const {
Tim Northoverff920ee2013-05-04 07:15:13 +00003380 Records = BuiltinInfo;
3381 NumRecords = clang::AArch64::LastTSBuiltin-Builtin::FirstTSBuiltin;
Tim Northoverc264e162013-01-31 12:13:10 +00003382 }
3383 virtual bool hasFeature(StringRef Feature) const {
3384 return Feature == "aarch64";
3385 }
3386 virtual void getGCCRegNames(const char * const *&Names,
3387 unsigned &NumNames) const;
3388 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3389 unsigned &NumAliases) const;
3390
3391 virtual bool isCLZForZeroUndef() const { return false; }
3392
3393 virtual bool validateAsmConstraint(const char *&Name,
3394 TargetInfo::ConstraintInfo &Info) const {
3395 switch (*Name) {
3396 default: return false;
3397 case 'w': // An FP/SIMD vector register
3398 Info.setAllowsRegister();
3399 return true;
3400 case 'I': // Constant that can be used with an ADD instruction
3401 case 'J': // Constant that can be used with a SUB instruction
3402 case 'K': // Constant that can be used with a 32-bit logical instruction
3403 case 'L': // Constant that can be used with a 64-bit logical instruction
3404 case 'M': // Constant that can be used as a 32-bit MOV immediate
3405 case 'N': // Constant that can be used as a 64-bit MOV immediate
3406 case 'Y': // Floating point constant zero
3407 case 'Z': // Integer constant zero
3408 return true;
3409 case 'Q': // A memory reference with base register and no offset
3410 Info.setAllowsMemory();
3411 return true;
3412 case 'S': // A symbolic address
3413 Info.setAllowsRegister();
3414 return true;
3415 case 'U':
3416 // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes, whatever they may be
3417 // Utf: A memory address suitable for ldp/stp in TF mode, whatever it may be
3418 // Usa: An absolute symbolic address
3419 // Ush: The high part (bits 32:12) of a pc-relative symbolic address
3420 llvm_unreachable("FIXME: Unimplemented support for bizarre constraints");
3421 }
3422 }
3423
3424 virtual const char *getClobbers() const {
3425 // There are no AArch64 clobbers shared by all asm statements.
3426 return "";
3427 }
3428
3429 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3430 return TargetInfo::AArch64ABIBuiltinVaList;
3431 }
3432};
3433
3434const char * const AArch64TargetInfo::GCCRegNames[] = {
3435 "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7",
3436 "w8", "w9", "w10", "w11", "w12", "w13", "w14", "w15",
3437 "w16", "w17", "w18", "w19", "w20", "w21", "w22", "w23",
3438 "w24", "w25", "w26", "w27", "w28", "w29", "w30", "wsp", "wzr",
3439
3440 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
3441 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
3442 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
3443 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp", "xzr",
3444
3445 "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7",
3446 "b8", "b9", "b10", "b11", "b12", "b13", "b14", "b15",
3447 "b16", "b17", "b18", "b19", "b20", "b21", "b22", "b23",
3448 "b24", "b25", "b26", "b27", "b28", "b29", "b30", "b31",
3449
3450 "h0", "h1", "h2", "h3", "h4", "h5", "h6", "h7",
3451 "h8", "h9", "h10", "h11", "h12", "h13", "h14", "h15",
3452 "h16", "h17", "h18", "h19", "h20", "h21", "h22", "h23",
3453 "h24", "h25", "h26", "h27", "h28", "h29", "h30", "h31",
3454
3455 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3456 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3457 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
3458 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
3459
3460 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3461 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
3462 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3463 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
3464
3465 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3466 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15",
3467 "q16", "q17", "q18", "q19", "q20", "q21", "q22", "q23",
3468 "q24", "q25", "q26", "q27", "q28", "q29", "q30", "q31"
3469};
3470
3471void AArch64TargetInfo::getGCCRegNames(const char * const *&Names,
3472 unsigned &NumNames) const {
3473 Names = GCCRegNames;
3474 NumNames = llvm::array_lengthof(GCCRegNames);
3475}
3476
3477const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = {
3478 { { "x16" }, "ip0"},
3479 { { "x17" }, "ip1"},
3480 { { "x29" }, "fp" },
3481 { { "x30" }, "lr" }
3482};
3483
3484void AArch64TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3485 unsigned &NumAliases) const {
3486 Aliases = GCCRegAliases;
3487 NumAliases = llvm::array_lengthof(GCCRegAliases);
3488
3489}
Tim Northoverff920ee2013-05-04 07:15:13 +00003490
3491const Builtin::Info AArch64TargetInfo::BuiltinInfo[] = {
3492#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3493#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3494 ALL_LANGUAGES },
3495#include "clang/Basic/BuiltinsAArch64.def"
3496};
3497
Eli Friedman42f74f22012-08-08 23:57:20 +00003498} // end anonymous namespace
3499
3500namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00003501class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003502 // Possible FPU choices.
3503 enum FPUMode {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003504 VFP2FPU = (1 << 0),
3505 VFP3FPU = (1 << 1),
3506 VFP4FPU = (1 << 2),
3507 NeonFPU = (1 << 3)
Daniel Dunbara91320b2009-12-21 23:28:17 +00003508 };
3509
3510 static bool FPUModeIsVFP(FPUMode Mode) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003511 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU);
Daniel Dunbara91320b2009-12-21 23:28:17 +00003512 }
3513
3514 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3515 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003516
Daniel Dunbareac7c532009-12-18 18:42:37 +00003517 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003518
Bob Wilsoncfaab002012-09-29 23:52:52 +00003519 unsigned FPU : 4;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003520
Logan Chieneae5a8202012-10-10 06:56:20 +00003521 unsigned IsAAPCS : 1;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003522 unsigned IsThumb : 1;
3523
3524 // Initialized via features.
3525 unsigned SoftFloat : 1;
3526 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003527
Chris Lattner2752c012010-03-03 19:03:45 +00003528 static const Builtin::Info BuiltinInfo[];
3529
Chris Lattner393ff042008-04-21 18:56:49 +00003530public:
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003531 ARMTargetInfo(const std::string &TripleStr)
Logan Chieneae5a8202012-10-10 06:56:20 +00003532 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s"), IsAAPCS(true)
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003533 {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003534 BigEndian = false;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003535 SizeType = UnsignedInt;
3536 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00003537 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
3538 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003539
Chris Lattner9bffb072010-04-23 16:29:58 +00003540 // {} in inline assembly are neon specifiers, not assembly variant
3541 // specifiers.
3542 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00003543
Daniel Dunbareac7c532009-12-18 18:42:37 +00003544 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00003545 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003546 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003547 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3548 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003549 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
3550 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003551 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003552 } else {
3553 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3554 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003555 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003556 }
John McCallee79a4c2010-08-21 22:46:04 +00003557
3558 // ARM targets default to using the ARM C++ ABI.
John McCallb8b2c9d2013-01-25 22:30:49 +00003559 TheCXXABI.set(TargetCXXABI::GenericARM);
Eli Friedman2be46072011-10-14 20:59:01 +00003560
3561 // ARM has atomics up to 8 bytes
3562 // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e
3563 MaxAtomicPromoteWidth = 64;
James Molloye45b9b72012-03-12 09:14:10 +00003564
3565 // Do force alignment of members that follow zero length bitfields. If
3566 // the alignment of the zero-length bitfield is greater than the member
3567 // that follows it, `bar', `bar' will be aligned as the type of the
3568 // zero length bitfield.
3569 UseZeroLengthBitfieldAlignment = true;
Eli Friedman61538a72008-05-20 14:21:01 +00003570 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003571 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00003572 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003573 ABI = Name;
3574
Daniel Dunbara2a41612009-09-14 00:02:24 +00003575 // The defaults (above) are for AAPCS, check if we need to change them.
3576 //
3577 // FIXME: We need support for -meabi... we could just mangle it into the
3578 // name.
3579 if (Name == "apcs-gnu") {
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003580 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Rafael Espindola27fa2362012-12-13 04:17:14 +00003581 // size_t is unsigned int on FreeBSD.
3582 if (getTriple().getOS() != llvm::Triple::FreeBSD)
3583 SizeType = UnsignedLong;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003584
James Molloya6d81f92011-11-23 13:35:08 +00003585 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
3586 WCharType = SignedInt;
3587
Daniel Dunbar684de632010-04-22 16:14:54 +00003588 // Do not respect the alignment of bit-field types when laying out
3589 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
3590 UseBitFieldTypeAlignment = false;
3591
Chad Rosier61a62212011-08-04 01:21:14 +00003592 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00003593 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
3594 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00003595 ZeroLengthBitfieldBoundary = 32;
3596
Logan Chieneae5a8202012-10-10 06:56:20 +00003597 IsAAPCS = false;
3598
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003599 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003600 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3601 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003602 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 +00003603 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003604 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003605 } else {
3606 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 +00003607 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003608 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003609 }
3610
Chad Rosier9f1210c2011-07-26 07:03:04 +00003611 // FIXME: Override "preferred align" for double and long long.
David Tweedb16abb12012-10-25 13:33:01 +00003612 } else if (Name == "aapcs" || Name == "aapcs-vfp") {
Logan Chieneae5a8202012-10-10 06:56:20 +00003613 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003614 // FIXME: Enumerated types are variable width in straight AAPCS.
3615 } else if (Name == "aapcs-linux") {
Logan Chieneae5a8202012-10-10 06:56:20 +00003616 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003617 } else
3618 return false;
3619
3620 return true;
3621 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003622
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003623 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003624 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
3625 Features["vfp2"] = true;
Bob Wilsoncfaab002012-09-29 23:52:52 +00003626 else if (CPU == "cortex-a8" || CPU == "cortex-a15" ||
3627 CPU == "cortex-a9" || CPU == "cortex-a9-mp")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003628 Features["neon"] = true;
Bob Wilsonfc553452013-03-04 22:37:46 +00003629 else if (CPU == "swift" || CPU == "cortex-a7") {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003630 Features["vfp4"] = true;
3631 Features["neon"] = true;
3632 }
Daniel Dunbara91320b2009-12-21 23:28:17 +00003633 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003634
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003635 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00003636 StringRef Name,
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003637 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00003638 if (Name == "soft-float" || Name == "soft-float-abi" ||
Bob Wilsoncfaab002012-09-29 23:52:52 +00003639 Name == "vfp2" || Name == "vfp3" || Name == "vfp4" || Name == "neon" ||
3640 Name == "d16" || Name == "neonfp") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003641 Features[Name] = Enabled;
3642 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003643 return false;
3644
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003645 return true;
3646 }
3647
3648 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003649 FPU = 0;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003650 SoftFloat = SoftFloatABI = false;
3651 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
3652 if (Features[i] == "+soft-float")
3653 SoftFloat = true;
3654 else if (Features[i] == "+soft-float-abi")
3655 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003656 else if (Features[i] == "+vfp2")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003657 FPU |= VFP2FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003658 else if (Features[i] == "+vfp3")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003659 FPU |= VFP3FPU;
3660 else if (Features[i] == "+vfp4")
3661 FPU |= VFP4FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003662 else if (Features[i] == "+neon")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003663 FPU |= NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003664 }
3665
3666 // Remove front-end specific options which the backend handles differently.
3667 std::vector<std::string>::iterator it;
3668 it = std::find(Features.begin(), Features.end(), "+soft-float");
3669 if (it != Features.end())
3670 Features.erase(it);
3671 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
3672 if (it != Features.end())
3673 Features.erase(it);
3674 }
3675
Douglas Gregore727d212012-01-30 06:38:25 +00003676 virtual bool hasFeature(StringRef Feature) const {
3677 return llvm::StringSwitch<bool>(Feature)
3678 .Case("arm", true)
3679 .Case("softfloat", SoftFloat)
3680 .Case("thumb", IsThumb)
3681 .Case("neon", FPU == NeonFPU && !SoftFloat &&
3682 StringRef(getCPUDefineSuffix(CPU)).startswith("7"))
3683 .Default(false);
3684 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003685 // FIXME: Should we actually have some table instead of these switches?
Chris Lattner5f9e2722011-07-23 10:55:15 +00003686 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00003687 return llvm::StringSwitch<const char*>(Name)
3688 .Cases("arm8", "arm810", "4")
3689 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
3690 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
3691 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
3692 .Case("ep9312", "4T")
3693 .Cases("arm10tdmi", "arm1020t", "5T")
3694 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
3695 .Case("arm926ej-s", "5TEJ")
3696 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
3697 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003698 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003699 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003700 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003701 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
Bob Wilsonfc553452013-03-04 22:37:46 +00003702 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "7A")
3703 .Cases("cortex-a9", "cortex-a15", "7A")
Quentin Colombetab137512012-12-21 17:57:47 +00003704 .Case("cortex-r5", "7R")
Bob Wilson336bfa32012-09-29 23:52:50 +00003705 .Case("cortex-a9-mp", "7F")
3706 .Case("swift", "7S")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003707 .Cases("cortex-m3", "cortex-m4", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00003708 .Case("cortex-m0", "6M")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003709 .Default(0);
3710 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003711 static const char *getCPUProfile(StringRef Name) {
3712 return llvm::StringSwitch<const char*>(Name)
3713 .Cases("cortex-a8", "cortex-a9", "A")
3714 .Cases("cortex-m3", "cortex-m4", "cortex-m0", "M")
Quentin Colombetab137512012-12-21 17:57:47 +00003715 .Case("cortex-r5", "R")
Anton Korobeynikov8b0703d2012-09-08 08:22:13 +00003716 .Default("");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003717 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003718 virtual bool setCPU(const std::string &Name) {
3719 if (!getCPUDefineSuffix(Name))
3720 return false;
3721
3722 CPU = Name;
3723 return true;
3724 }
Chris Lattner33328642009-03-20 15:52:06 +00003725 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003726 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00003727 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00003728 Builder.defineMacro("__arm");
3729 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003730
Chris Lattnerc0f59212009-03-02 22:27:17 +00003731 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00003732 Builder.defineMacro("__ARMEL__");
3733 Builder.defineMacro("__LITTLE_ENDIAN__");
3734 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003735
Chris Lattner5f9e2722011-07-23 10:55:15 +00003736 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00003737 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003738 Builder.defineMacro("__ARM_ARCH", CPUArch.substr(0, 1));
3739 StringRef CPUProfile = getCPUProfile(CPU);
3740 if (!CPUProfile.empty())
3741 Builder.defineMacro("__ARM_ARCH_PROFILE", CPUProfile);
3742
Mike Stump437bb4b2009-04-08 02:07:04 +00003743 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003744
Daniel Dunbareac7c532009-12-18 18:42:37 +00003745 // FIXME: It's more complicated than this and we don't really support
3746 // interworking.
3747 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00003748 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003749
David Tweedb16abb12012-10-25 13:33:01 +00003750 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
Daniel Dunbar849289e2012-10-22 18:51:13 +00003751 // M-class CPUs on Darwin follow AAPCS, but not EABI.
Daniel Dunbar4d3ee9b2012-10-22 18:56:43 +00003752 if (!(getTriple().isOSDarwin() && CPUProfile == "M"))
Daniel Dunbar849289e2012-10-22 18:51:13 +00003753 Builder.defineMacro("__ARM_EABI__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003754 Builder.defineMacro("__ARM_PCS", "1");
3755
David Tweedb16abb12012-10-25 13:33:01 +00003756 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003757 Builder.defineMacro("__ARM_PCS_VFP", "1");
3758 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003759
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003760 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00003761 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003762
3763 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00003764 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003765
Bob Wilson84f95cf2011-05-13 18:56:03 +00003766 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003767 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003768 Builder.defineMacro("__THUMBEL__");
3769 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00003770 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003771 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003772 }
3773
3774 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00003775 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00003776
Bob Wilsoncfaab002012-09-29 23:52:52 +00003777 if (FPUModeIsVFP((FPUMode) FPU)) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003778 Builder.defineMacro("__VFP_FP__");
Bob Wilsoncfaab002012-09-29 23:52:52 +00003779 if (FPU & VFP2FPU)
3780 Builder.defineMacro("__ARM_VFPV2__");
3781 if (FPU & VFP3FPU)
3782 Builder.defineMacro("__ARM_VFPV3__");
3783 if (FPU & VFP4FPU)
3784 Builder.defineMacro("__ARM_VFPV4__");
3785 }
3786
Daniel Dunbara91320b2009-12-21 23:28:17 +00003787 // This only gets set when Neon instructions are actually available, unlike
3788 // the VFP define, hence the soft float and arch check. This is subtly
3789 // different from gcc, we follow the intent which was that it should be set
3790 // when Neon instructions are actually available.
Bob Wilsoncfaab002012-09-29 23:52:52 +00003791 if ((FPU & NeonFPU) && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003792 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00003793 }
3794 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3795 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00003796 Records = BuiltinInfo;
3797 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00003798 }
Bob Wilson8b30a932012-01-26 22:14:27 +00003799 virtual bool isCLZForZeroUndef() const { return false; }
Meador Ingec5613b22012-06-16 03:34:49 +00003800 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Logan Chieneae5a8202012-10-10 06:56:20 +00003801 return IsAAPCS ? AAPCSABIBuiltinVaList : TargetInfo::VoidPtrBuiltinVaList;
Chris Lattner393ff042008-04-21 18:56:49 +00003802 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003803 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003804 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003805 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003806 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003807 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00003808 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003809 switch (*Name) {
Eric Christophera0dfca12012-08-16 23:50:41 +00003810 default: break;
Nate Begemanad487f42008-04-22 05:03:19 +00003811 case 'l': // r0-r7
3812 case 'h': // r8-r15
3813 case 'w': // VFP Floating point register single precision
3814 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00003815 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00003816 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00003817 case 'Q': // A memory address that is a single base register.
3818 Info.setAllowsMemory();
3819 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00003820 case 'U': // a memory reference...
3821 switch (Name[1]) {
3822 case 'q': // ...ARMV4 ldrsb
3823 case 'v': // ...VFP load/store (reg+constant offset)
3824 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00003825 case 't': // address valid for load/store opaque types wider
Eric Christopher825d3862012-11-14 22:08:59 +00003826 // than 128-bits
Eric Christopherdda231a2011-06-17 01:40:49 +00003827 case 'n': // valid address for Neon doubleword vector load/store
3828 case 'm': // valid address for Neon element and structure load/store
3829 case 's': // valid address for non-offset loads/stores of quad-word
Eric Christopher825d3862012-11-14 22:08:59 +00003830 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00003831 Info.setAllowsMemory();
3832 Name++;
3833 return true;
3834 }
Nate Begemanad487f42008-04-22 05:03:19 +00003835 }
Chris Lattner393ff042008-04-21 18:56:49 +00003836 return false;
3837 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00003838 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00003839 std::string R;
3840 switch (*Constraint) {
3841 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00003842 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00003843 Constraint++;
3844 break;
Eric Christopher283f4472011-06-17 00:40:18 +00003845 case 'p': // 'p' should be translated to 'r' by default.
3846 R = std::string("r");
3847 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00003848 default:
3849 return std::string(1, *Constraint);
3850 }
3851 return R;
3852 }
Bill Wendling50d46ca2012-10-25 23:28:48 +00003853 virtual bool validateConstraintModifier(StringRef Constraint,
3854 const char Modifier,
3855 unsigned Size) const {
Bill Wendlinge2dbaa92012-11-30 23:18:12 +00003856 bool isOutput = (Constraint[0] == '=');
Bill Wendling6e6330c2012-11-30 23:46:56 +00003857 bool isInOut = (Constraint[0] == '+');
Bill Wendlinge2dbaa92012-11-30 23:18:12 +00003858
Bill Wendling50d46ca2012-10-25 23:28:48 +00003859 // Strip off constraint modifiers.
3860 while (Constraint[0] == '=' ||
3861 Constraint[0] == '+' ||
3862 Constraint[0] == '&')
3863 Constraint = Constraint.substr(1);
3864
3865 switch (Constraint[0]) {
3866 default: break;
3867 case 'r': {
3868 switch (Modifier) {
3869 default:
Bill Wendling6e6330c2012-11-30 23:46:56 +00003870 return isInOut || (isOutput && Size >= 32) ||
3871 (!isOutput && !isInOut && Size <= 32);
Bill Wendling50d46ca2012-10-25 23:28:48 +00003872 case 'q':
3873 // A register of size 32 cannot fit a vector type.
3874 return false;
3875 }
3876 }
3877 }
3878
3879 return true;
3880 }
Chris Lattner393ff042008-04-21 18:56:49 +00003881 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00003882 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00003883 return "";
3884 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00003885
3886 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
3887 return (CC == CC_AAPCS || CC == CC_AAPCS_VFP) ? CCCR_OK : CCCR_Warning;
3888 }
Logan Chiena8f7a972013-02-23 04:24:36 +00003889
3890 virtual int getEHDataRegisterNumber(unsigned RegNo) const {
3891 if (RegNo == 0) return 0;
3892 if (RegNo == 1) return 1;
3893 return -1;
3894 }
Chris Lattner393ff042008-04-21 18:56:49 +00003895};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003896
3897const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003898 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003899 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003900 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
3901
3902 // Float registers
3903 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3904 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3905 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003906 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003907
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003908 // Double registers
3909 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3910 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00003911 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3912 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003913
3914 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00003915 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3916 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003917};
3918
3919void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003920 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003921 Names = GCCRegNames;
3922 NumNames = llvm::array_lengthof(GCCRegNames);
3923}
3924
3925const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003926 { { "a1" }, "r0" },
3927 { { "a2" }, "r1" },
3928 { { "a3" }, "r2" },
3929 { { "a4" }, "r3" },
3930 { { "v1" }, "r4" },
3931 { { "v2" }, "r5" },
3932 { { "v3" }, "r6" },
3933 { { "v4" }, "r7" },
3934 { { "v5" }, "r8" },
3935 { { "v6", "rfp" }, "r9" },
3936 { { "sl" }, "r10" },
3937 { { "fp" }, "r11" },
3938 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003939 { { "r13" }, "sp" },
3940 { { "r14" }, "lr" },
3941 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003942 // The S, D and Q registers overlap, but aren't really aliases; we
3943 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003944};
3945
3946void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3947 unsigned &NumAliases) const {
3948 Aliases = GCCRegAliases;
3949 NumAliases = llvm::array_lengthof(GCCRegAliases);
3950}
Chris Lattner2752c012010-03-03 19:03:45 +00003951
3952const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00003953#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00003954#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00003955 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00003956#include "clang/Basic/BuiltinsARM.def"
3957};
Chris Lattner393ff042008-04-21 18:56:49 +00003958} // end anonymous namespace.
3959
Eli Friedmana9f54962008-08-20 07:44:10 +00003960namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00003961class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003962 public DarwinTargetInfo<ARMTargetInfo> {
3963protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00003964 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00003965 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00003966 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00003967 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003968
Torok Edwin5f6c1942009-06-30 17:10:35 +00003969public:
Mike Stump1eb44332009-09-09 15:08:12 +00003970 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003971 : DarwinTargetInfo<ARMTargetInfo>(triple) {
3972 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00003973 // iOS always has 64-bit atomic instructions.
3974 // FIXME: This should be based off of the target features in ARMTargetInfo.
3975 MaxAtomicInlineWidth = 64;
John McCallb8b2c9d2013-01-25 22:30:49 +00003976
3977 // Darwin on iOS uses a variant of the ARM C++ ABI.
3978 TheCXXABI.set(TargetCXXABI::iOS);
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003979 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003980};
3981} // end anonymous namespace.
3982
Tony Linthicum96319392011-12-12 21:14:55 +00003983
3984namespace {
3985// Hexagon abstract base class
3986class HexagonTargetInfo : public TargetInfo {
3987 static const Builtin::Info BuiltinInfo[];
3988 static const char * const GCCRegNames[];
3989 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3990 std::string CPU;
3991public:
3992 HexagonTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003993 BigEndian = false;
Tony Linthicum96319392011-12-12 21:14:55 +00003994 DescriptionString = ("e-p:32:32:32-"
Anshuman Dasgupta1a090f12013-01-02 21:25:57 +00003995 "i64:64:64-i32:32:32-i16:16:16-i1:32:32-"
Sirish Pande5f9688b2012-05-10 20:19:54 +00003996 "f64:64:64-f32:32:32-a0:0-n32");
Tony Linthicum96319392011-12-12 21:14:55 +00003997
3998 // {} in inline assembly are packet specifiers, not assembly variant
3999 // specifiers.
4000 NoAsmVariants = true;
4001 }
4002
4003 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4004 unsigned &NumRecords) const {
4005 Records = BuiltinInfo;
4006 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
4007 }
4008
4009 virtual bool validateAsmConstraint(const char *&Name,
4010 TargetInfo::ConstraintInfo &Info) const {
4011 return true;
4012 }
4013
4014 virtual void getTargetDefines(const LangOptions &Opts,
4015 MacroBuilder &Builder) const;
4016
Douglas Gregore727d212012-01-30 06:38:25 +00004017 virtual bool hasFeature(StringRef Feature) const {
4018 return Feature == "hexagon";
4019 }
4020
Meador Ingec5613b22012-06-16 03:34:49 +00004021 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4022 return TargetInfo::CharPtrBuiltinVaList;
Tony Linthicum96319392011-12-12 21:14:55 +00004023 }
4024 virtual void getGCCRegNames(const char * const *&Names,
4025 unsigned &NumNames) const;
4026 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4027 unsigned &NumAliases) const;
4028 virtual const char *getClobbers() const {
4029 return "";
4030 }
Sebastian Pop43115d42012-01-13 20:37:10 +00004031
4032 static const char *getHexagonCPUSuffix(StringRef Name) {
4033 return llvm::StringSwitch<const char*>(Name)
Sebastian Pop43115d42012-01-13 20:37:10 +00004034 .Case("hexagonv4", "4")
Sirish Pande5f9688b2012-05-10 20:19:54 +00004035 .Case("hexagonv5", "5")
Sebastian Pop43115d42012-01-13 20:37:10 +00004036 .Default(0);
4037 }
4038
Tony Linthicum96319392011-12-12 21:14:55 +00004039 virtual bool setCPU(const std::string &Name) {
Sebastian Pop43115d42012-01-13 20:37:10 +00004040 if (!getHexagonCPUSuffix(Name))
4041 return false;
4042
Tony Linthicum96319392011-12-12 21:14:55 +00004043 CPU = Name;
4044 return true;
4045 }
4046};
4047
4048void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
4049 MacroBuilder &Builder) const {
4050 Builder.defineMacro("qdsp6");
4051 Builder.defineMacro("__qdsp6", "1");
4052 Builder.defineMacro("__qdsp6__", "1");
4053
4054 Builder.defineMacro("hexagon");
4055 Builder.defineMacro("__hexagon", "1");
4056 Builder.defineMacro("__hexagon__", "1");
4057
4058 if(CPU == "hexagonv1") {
4059 Builder.defineMacro("__HEXAGON_V1__");
4060 Builder.defineMacro("__HEXAGON_ARCH__", "1");
4061 if(Opts.HexagonQdsp6Compat) {
4062 Builder.defineMacro("__QDSP6_V1__");
4063 Builder.defineMacro("__QDSP6_ARCH__", "1");
4064 }
4065 }
4066 else if(CPU == "hexagonv2") {
4067 Builder.defineMacro("__HEXAGON_V2__");
4068 Builder.defineMacro("__HEXAGON_ARCH__", "2");
4069 if(Opts.HexagonQdsp6Compat) {
4070 Builder.defineMacro("__QDSP6_V2__");
4071 Builder.defineMacro("__QDSP6_ARCH__", "2");
4072 }
4073 }
4074 else if(CPU == "hexagonv3") {
4075 Builder.defineMacro("__HEXAGON_V3__");
4076 Builder.defineMacro("__HEXAGON_ARCH__", "3");
4077 if(Opts.HexagonQdsp6Compat) {
4078 Builder.defineMacro("__QDSP6_V3__");
4079 Builder.defineMacro("__QDSP6_ARCH__", "3");
4080 }
4081 }
4082 else if(CPU == "hexagonv4") {
4083 Builder.defineMacro("__HEXAGON_V4__");
4084 Builder.defineMacro("__HEXAGON_ARCH__", "4");
4085 if(Opts.HexagonQdsp6Compat) {
4086 Builder.defineMacro("__QDSP6_V4__");
4087 Builder.defineMacro("__QDSP6_ARCH__", "4");
4088 }
4089 }
Sirish Pande5f9688b2012-05-10 20:19:54 +00004090 else if(CPU == "hexagonv5") {
4091 Builder.defineMacro("__HEXAGON_V5__");
4092 Builder.defineMacro("__HEXAGON_ARCH__", "5");
4093 if(Opts.HexagonQdsp6Compat) {
4094 Builder.defineMacro("__QDSP6_V5__");
4095 Builder.defineMacro("__QDSP6_ARCH__", "5");
4096 }
4097 }
Tony Linthicum96319392011-12-12 21:14:55 +00004098}
4099
4100const char * const HexagonTargetInfo::GCCRegNames[] = {
4101 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4102 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4103 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
4104 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
4105 "p0", "p1", "p2", "p3",
4106 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
4107};
4108
4109void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
4110 unsigned &NumNames) const {
4111 Names = GCCRegNames;
4112 NumNames = llvm::array_lengthof(GCCRegNames);
4113}
4114
4115
4116const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
4117 { { "sp" }, "r29" },
4118 { { "fp" }, "r30" },
4119 { { "lr" }, "r31" },
4120 };
4121
4122void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4123 unsigned &NumAliases) const {
4124 Aliases = GCCRegAliases;
4125 NumAliases = llvm::array_lengthof(GCCRegAliases);
4126}
4127
4128
4129const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
4130#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4131#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4132 ALL_LANGUAGES },
4133#include "clang/Basic/BuiltinsHexagon.def"
4134};
4135}
4136
4137
Reid Spencer5f016e22007-07-11 17:01:13 +00004138namespace {
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004139// Shared base class for SPARC v8 (32-bit) and SPARC v9 (64-bit).
4140class SparcTargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00004141 static const TargetInfo::GCCRegAlias GCCRegAliases[];
4142 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004143 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00004144public:
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004145 SparcTargetInfo(const std::string &triple) : TargetInfo(triple) {}
4146
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004147 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00004148 StringRef Name,
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004149 bool Enabled) const {
4150 if (Name == "soft-float")
4151 Features[Name] = Enabled;
4152 else
4153 return false;
4154
4155 return true;
4156 }
4157 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
4158 SoftFloat = false;
4159 for (unsigned i = 0, e = Features.size(); i != e; ++i)
4160 if (Features[i] == "+soft-float")
4161 SoftFloat = true;
4162 }
Chris Lattner33328642009-03-20 15:52:06 +00004163 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004164 MacroBuilder &Builder) const {
4165 DefineStd(Builder, "sparc", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00004166 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004167
4168 if (SoftFloat)
4169 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00004170 }
Douglas Gregore727d212012-01-30 06:38:25 +00004171
4172 virtual bool hasFeature(StringRef Feature) const {
4173 return llvm::StringSwitch<bool>(Feature)
4174 .Case("softfloat", SoftFloat)
4175 .Case("sparc", true)
4176 .Default(false);
4177 }
4178
Gabor Greif26658672008-02-21 16:29:08 +00004179 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4180 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00004181 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00004182 }
Meador Ingec5613b22012-06-16 03:34:49 +00004183 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4184 return TargetInfo::VoidPtrBuiltinVaList;
Gabor Greif26658672008-02-21 16:29:08 +00004185 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004186 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00004187 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004188 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00004189 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00004190 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00004191 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00004192 // FIXME: Implement!
4193 return false;
Gabor Greif26658672008-02-21 16:29:08 +00004194 }
4195 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00004196 // FIXME: Implement!
4197 return "";
Gabor Greif26658672008-02-21 16:29:08 +00004198 }
4199};
4200
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004201const char * const SparcTargetInfo::GCCRegNames[] = {
Chris Lattnere957f532009-01-27 01:58:38 +00004202 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4203 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4204 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
4205 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
4206};
4207
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004208void SparcTargetInfo::getGCCRegNames(const char * const *&Names,
4209 unsigned &NumNames) const {
Chris Lattnere957f532009-01-27 01:58:38 +00004210 Names = GCCRegNames;
4211 NumNames = llvm::array_lengthof(GCCRegNames);
4212}
4213
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004214const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004215 { { "g0" }, "r0" },
4216 { { "g1" }, "r1" },
4217 { { "g2" }, "r2" },
4218 { { "g3" }, "r3" },
4219 { { "g4" }, "r4" },
4220 { { "g5" }, "r5" },
4221 { { "g6" }, "r6" },
4222 { { "g7" }, "r7" },
4223 { { "o0" }, "r8" },
4224 { { "o1" }, "r9" },
4225 { { "o2" }, "r10" },
4226 { { "o3" }, "r11" },
4227 { { "o4" }, "r12" },
4228 { { "o5" }, "r13" },
4229 { { "o6", "sp" }, "r14" },
4230 { { "o7" }, "r15" },
4231 { { "l0" }, "r16" },
4232 { { "l1" }, "r17" },
4233 { { "l2" }, "r18" },
4234 { { "l3" }, "r19" },
4235 { { "l4" }, "r20" },
4236 { { "l5" }, "r21" },
4237 { { "l6" }, "r22" },
4238 { { "l7" }, "r23" },
4239 { { "i0" }, "r24" },
4240 { { "i1" }, "r25" },
4241 { { "i2" }, "r26" },
4242 { { "i3" }, "r27" },
4243 { { "i4" }, "r28" },
4244 { { "i5" }, "r29" },
4245 { { "i6", "fp" }, "r30" },
4246 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00004247};
4248
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004249void SparcTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4250 unsigned &NumAliases) const {
Chris Lattnere957f532009-01-27 01:58:38 +00004251 Aliases = GCCRegAliases;
4252 NumAliases = llvm::array_lengthof(GCCRegAliases);
4253}
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004254
4255// SPARC v8 is the 32-bit mode selected by Triple::sparc.
4256class SparcV8TargetInfo : public SparcTargetInfo {
4257public:
4258 SparcV8TargetInfo(const std::string& triple) : SparcTargetInfo(triple) {
4259 // FIXME: Support Sparc quad-precision long double?
4260 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
4261 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
4262 }
4263
4264 virtual void getTargetDefines(const LangOptions &Opts,
4265 MacroBuilder &Builder) const {
4266 SparcTargetInfo::getTargetDefines(Opts, Builder);
4267 Builder.defineMacro("__sparcv8");
4268 }
4269};
4270
4271// SPARC v9 is the 64-bit mode selected by Triple::sparcv9.
4272class SparcV9TargetInfo : public SparcTargetInfo {
4273public:
4274 SparcV9TargetInfo(const std::string& triple) : SparcTargetInfo(triple) {
4275 // FIXME: Support Sparc quad-precision long double?
4276 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
4277 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32:64-S128";
4278 }
4279
4280 virtual void getTargetDefines(const LangOptions &Opts,
4281 MacroBuilder &Builder) const {
4282 SparcTargetInfo::getTargetDefines(Opts, Builder);
4283 Builder.defineMacro("__sparcv9");
Jakob Stoklund Olesen44f72d32013-04-24 04:36:38 +00004284 Builder.defineMacro("__arch64__");
4285 // Solaris and its derivative AuroraUX don't need these variants, but the
4286 // BSDs do.
4287 if (getTriple().getOS() != llvm::Triple::Solaris &&
4288 getTriple().getOS() != llvm::Triple::AuroraUX) {
4289 Builder.defineMacro("__sparc64__");
4290 Builder.defineMacro("__sparc_v9__");
4291 Builder.defineMacro("__sparcv9__");
4292 }
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004293 }
4294};
4295
Gabor Greif26658672008-02-21 16:29:08 +00004296} // end anonymous namespace.
4297
Eli Friedman01b86682008-08-20 07:28:14 +00004298namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004299class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
4300public:
4301 AuroraUXSparcV8TargetInfo(const std::string& triple) :
4302 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
4303 SizeType = UnsignedInt;
4304 PtrDiffType = SignedInt;
4305 }
4306};
Torok Edwin5f6c1942009-06-30 17:10:35 +00004307class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00004308public:
4309 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwin5f6c1942009-06-30 17:10:35 +00004310 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00004311 SizeType = UnsignedInt;
4312 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00004313 }
4314};
4315} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00004316
Chris Lattner2621fd12008-05-08 05:58:21 +00004317namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004318 class MSP430TargetInfo : public TargetInfo {
4319 static const char * const GCCRegNames[];
4320 public:
4321 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004322 BigEndian = false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004323 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00004324 IntWidth = 16; IntAlign = 16;
4325 LongWidth = 32; LongLongWidth = 64;
4326 LongAlign = LongLongAlign = 16;
4327 PointerWidth = 16; PointerAlign = 16;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004328 SuitableAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004329 SizeType = UnsignedInt;
4330 IntMaxType = SignedLong;
4331 UIntMaxType = UnsignedLong;
4332 IntPtrType = SignedShort;
4333 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00004334 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00004335 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004336 }
4337 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004338 MacroBuilder &Builder) const {
4339 Builder.defineMacro("MSP430");
4340 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004341 // FIXME: defines for different 'flavours' of MCU
4342 }
4343 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4344 unsigned &NumRecords) const {
4345 // FIXME: Implement.
4346 Records = 0;
4347 NumRecords = 0;
4348 }
Douglas Gregore727d212012-01-30 06:38:25 +00004349 virtual bool hasFeature(StringRef Feature) const {
4350 return Feature == "msp430";
4351 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004352 virtual void getGCCRegNames(const char * const *&Names,
4353 unsigned &NumNames) const;
4354 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4355 unsigned &NumAliases) const {
4356 // No aliases.
4357 Aliases = 0;
4358 NumAliases = 0;
4359 }
4360 virtual bool validateAsmConstraint(const char *&Name,
4361 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00004362 // No target constraints for now.
4363 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004364 }
4365 virtual const char *getClobbers() const {
4366 // FIXME: Is this really right?
4367 return "";
4368 }
Meador Ingec5613b22012-06-16 03:34:49 +00004369 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004370 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00004371 return TargetInfo::CharPtrBuiltinVaList;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004372 }
4373 };
4374
4375 const char * const MSP430TargetInfo::GCCRegNames[] = {
4376 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4377 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
4378 };
4379
4380 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
4381 unsigned &NumNames) const {
4382 Names = GCCRegNames;
4383 NumNames = llvm::array_lengthof(GCCRegNames);
4384 }
4385}
4386
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00004387namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00004388
Mike Stump1eb44332009-09-09 15:08:12 +00004389 // LLVM and Clang cannot be used directly to output native binaries for
4390 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00004391 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00004392 //
4393 // TCE uses the llvm bitcode as input and uses it for generating customized
4394 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00004395 // publicly available in http://tce.cs.tut.fi
4396
Eli Friedman209f5bb2011-10-07 19:51:42 +00004397 static const unsigned TCEOpenCLAddrSpaceMap[] = {
4398 3, // opencl_global
4399 4, // opencl_local
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00004400 5, // opencl_constant
4401 0, // cuda_device
4402 0, // cuda_constant
4403 0 // cuda_shared
Eli Friedman209f5bb2011-10-07 19:51:42 +00004404 };
4405
Eli Friedmanb63decf2009-08-19 20:47:07 +00004406 class TCETargetInfo : public TargetInfo{
4407 public:
4408 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
4409 TLSSupported = false;
4410 IntWidth = 32;
4411 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004412 PointerWidth = 32;
4413 IntAlign = 32;
4414 LongAlign = LongLongAlign = 32;
4415 PointerAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004416 SuitableAlign = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004417 SizeType = UnsignedInt;
4418 IntMaxType = SignedLong;
4419 UIntMaxType = UnsignedLong;
4420 IntPtrType = SignedInt;
4421 PtrDiffType = SignedInt;
4422 FloatWidth = 32;
4423 FloatAlign = 32;
4424 DoubleWidth = 32;
4425 DoubleAlign = 32;
4426 LongDoubleWidth = 32;
4427 LongDoubleAlign = 32;
4428 FloatFormat = &llvm::APFloat::IEEEsingle;
4429 DoubleFormat = &llvm::APFloat::IEEEsingle;
4430 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00004431 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
4432 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00004433 "f32:32:32-f64:32:32-v64:32:32-"
4434 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00004435 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004436 }
4437
4438 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004439 MacroBuilder &Builder) const {
4440 DefineStd(Builder, "tce", Opts);
4441 Builder.defineMacro("__TCE__");
4442 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00004443 }
Douglas Gregore727d212012-01-30 06:38:25 +00004444 virtual bool hasFeature(StringRef Feature) const {
4445 return Feature == "tce";
4446 }
4447
Eli Friedmanb63decf2009-08-19 20:47:07 +00004448 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4449 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00004450 virtual const char *getClobbers() const {
4451 return "";
4452 }
Meador Ingec5613b22012-06-16 03:34:49 +00004453 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4454 return TargetInfo::VoidPtrBuiltinVaList;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004455 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00004456 virtual void getGCCRegNames(const char * const *&Names,
4457 unsigned &NumNames) const {}
4458 virtual bool validateAsmConstraint(const char *&Name,
4459 TargetInfo::ConstraintInfo &info) const {
4460 return true;
4461 }
4462 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4463 unsigned &NumAliases) const {}
4464 };
4465}
4466
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004467namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004468class MipsTargetInfoBase : public TargetInfo {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004469 static const Builtin::Info BuiltinInfo[];
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004470 std::string CPU;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004471 bool IsMips16;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004472 bool IsMicromips;
Simon Atanasyand96e3152013-04-14 14:07:30 +00004473 bool IsSingleFloat;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004474 enum MipsFloatABI {
Simon Atanasyand96e3152013-04-14 14:07:30 +00004475 HardFloat, SoftFloat
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004476 } FloatABI;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004477 enum DspRevEnum {
4478 NoDSP, DSP1, DSP2
4479 } DspRev;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004480
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004481protected:
4482 std::string ABI;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004483
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004484public:
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00004485 MipsTargetInfoBase(const std::string& triple,
4486 const std::string& ABIStr,
4487 const std::string& CPUStr)
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004488 : TargetInfo(triple),
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00004489 CPU(CPUStr),
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004490 IsMips16(false),
Simon Atanasyan321ae792013-04-14 14:07:51 +00004491 IsMicromips(false),
Simon Atanasyand96e3152013-04-14 14:07:30 +00004492 IsSingleFloat(false),
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004493 FloatABI(HardFloat),
Simon Atanasyana1b62272012-07-05 20:16:22 +00004494 DspRev(NoDSP),
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004495 ABI(ABIStr)
4496 {}
4497
Eric Christophered734732010-03-02 02:41:08 +00004498 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004499 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00004500 virtual bool setCPU(const std::string &Name) {
4501 CPU = Name;
4502 return true;
4503 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004504 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00004505 Features[ABI] = true;
4506 Features[CPU] = true;
4507 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004508
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004509 virtual void getTargetDefines(const LangOptions &Opts,
4510 MacroBuilder &Builder) const {
Simon Atanasyand4935a02012-08-29 19:14:58 +00004511 DefineStd(Builder, "mips", Opts);
4512 Builder.defineMacro("_mips");
4513 Builder.defineMacro("__REGISTER_PREFIX__", "");
4514
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004515 switch (FloatABI) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004516 case HardFloat:
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00004517 Builder.defineMacro("__mips_hard_float", Twine(1));
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004518 break;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004519 case SoftFloat:
4520 Builder.defineMacro("__mips_soft_float", Twine(1));
4521 break;
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00004522 }
Simon Atanasyan90913892012-04-05 19:28:31 +00004523
Simon Atanasyand96e3152013-04-14 14:07:30 +00004524 if (IsSingleFloat)
4525 Builder.defineMacro("__mips_single_float", Twine(1));
4526
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004527 if (IsMips16)
4528 Builder.defineMacro("__mips16", Twine(1));
4529
Simon Atanasyan321ae792013-04-14 14:07:51 +00004530 if (IsMicromips)
4531 Builder.defineMacro("__mips_micromips", Twine(1));
4532
Simon Atanasyana1b62272012-07-05 20:16:22 +00004533 switch (DspRev) {
4534 default:
4535 break;
4536 case DSP1:
4537 Builder.defineMacro("__mips_dsp_rev", Twine(1));
4538 Builder.defineMacro("__mips_dsp", Twine(1));
4539 break;
4540 case DSP2:
4541 Builder.defineMacro("__mips_dsp_rev", Twine(2));
4542 Builder.defineMacro("__mips_dspr2", Twine(1));
4543 Builder.defineMacro("__mips_dsp", Twine(1));
4544 break;
4545 }
4546
Simon Atanasyan90913892012-04-05 19:28:31 +00004547 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
4548 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
4549 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
Simon Atanasyan260e5062012-08-29 15:17:29 +00004550
4551 Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
4552 Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004553 }
4554
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004555 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4556 unsigned &NumRecords) const {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004557 Records = BuiltinInfo;
4558 NumRecords = clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004559 }
Douglas Gregore727d212012-01-30 06:38:25 +00004560 virtual bool hasFeature(StringRef Feature) const {
4561 return Feature == "mips";
4562 }
Meador Ingec5613b22012-06-16 03:34:49 +00004563 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4564 return TargetInfo::VoidPtrBuiltinVaList;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004565 }
4566 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004567 unsigned &NumNames) const {
4568 static const char * const GCCRegNames[] = {
Eric Christopherd1f853d2012-03-27 19:56:11 +00004569 // CPU register names
4570 // Must match second column of GCCRegAliases
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004571 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
4572 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
4573 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004574 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",
4575 // Floating point register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004576 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
4577 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
4578 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
4579 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004580 // Hi/lo and condition register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004581 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
4582 "$fcc5","$fcc6","$fcc7"
4583 };
4584 Names = GCCRegNames;
4585 NumNames = llvm::array_lengthof(GCCRegNames);
4586 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004587 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004588 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004589 virtual bool validateAsmConstraint(const char *&Name,
4590 TargetInfo::ConstraintInfo &Info) const {
4591 switch (*Name) {
4592 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00004593 return false;
4594
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004595 case 'r': // CPU registers.
4596 case 'd': // Equivalent to "r" unless generating MIPS16 code.
4597 case 'y': // Equivalent to "r", backwards compatibility only.
4598 case 'f': // floating-point registers.
Eric Christopher0ea61642012-04-03 01:16:32 +00004599 case 'c': // $25 for indirect jumps
4600 case 'l': // lo register
4601 case 'x': // hilo register pair
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004602 Info.setAllowsRegister();
4603 return true;
Jack Carter97102302013-03-05 19:10:54 +00004604 case 'R': // An address that can be used in a non-macro load or store
Jack Carterd2ab6d32013-03-04 21:36:11 +00004605 Info.setAllowsMemory();
4606 return true;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004607 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004608 }
4609
4610 virtual const char *getClobbers() const {
4611 // FIXME: Implement!
4612 return "";
4613 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004614
4615 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
4616 StringRef Name,
4617 bool Enabled) const {
Simon Atanasyan8b2a5d22012-04-18 12:00:11 +00004618 if (Name == "soft-float" || Name == "single-float" ||
4619 Name == "o32" || Name == "n32" || Name == "n64" || Name == "eabi" ||
4620 Name == "mips32" || Name == "mips32r2" ||
Simon Atanasyan0b273ef2012-07-05 14:19:39 +00004621 Name == "mips64" || Name == "mips64r2" ||
Simon Atanasyan321ae792013-04-14 14:07:51 +00004622 Name == "mips16" || Name == "micromips" ||
4623 Name == "dsp" || Name == "dspr2") {
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004624 Features[Name] = Enabled;
4625 return true;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004626 } else if (Name == "32") {
4627 Features["o32"] = Enabled;
4628 return true;
4629 } else if (Name == "64") {
4630 Features["n64"] = Enabled;
4631 return true;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004632 }
4633 return false;
4634 }
4635
4636 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004637 IsMips16 = false;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004638 IsMicromips = false;
Simon Atanasyand96e3152013-04-14 14:07:30 +00004639 IsSingleFloat = false;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004640 FloatABI = HardFloat;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004641 DspRev = NoDSP;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004642
4643 for (std::vector<std::string>::iterator it = Features.begin(),
4644 ie = Features.end(); it != ie; ++it) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004645 if (*it == "+single-float")
Simon Atanasyand96e3152013-04-14 14:07:30 +00004646 IsSingleFloat = true;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004647 else if (*it == "+soft-float")
4648 FloatABI = SoftFloat;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004649 else if (*it == "+mips16")
4650 IsMips16 = true;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004651 else if (*it == "+micromips")
4652 IsMicromips = true;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004653 else if (*it == "+dsp")
4654 DspRev = std::max(DspRev, DSP1);
4655 else if (*it == "+dspr2")
4656 DspRev = std::max(DspRev, DSP2);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004657 }
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004658
4659 // Remove front-end specific option.
4660 std::vector<std::string>::iterator it =
4661 std::find(Features.begin(), Features.end(), "+soft-float");
4662 if (it != Features.end())
4663 Features.erase(it);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004664 }
Logan Chiena8f7a972013-02-23 04:24:36 +00004665
4666 virtual int getEHDataRegisterNumber(unsigned RegNo) const {
4667 if (RegNo == 0) return 4;
4668 if (RegNo == 1) return 5;
4669 return -1;
4670 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004671};
4672
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004673const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = {
4674#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4675#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4676 ALL_LANGUAGES },
4677#include "clang/Basic/BuiltinsMips.def"
4678};
4679
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004680class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004681public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004682 Mips32TargetInfoBase(const std::string& triple) :
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00004683 MipsTargetInfoBase(triple, "o32", "mips32") {
Akira Hatanaka148735e2011-11-05 01:48:34 +00004684 SizeType = UnsignedInt;
4685 PtrDiffType = SignedInt;
Akira Hatanakadbee9492013-01-18 21:58:11 +00004686 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Akira Hatanaka148735e2011-11-05 01:48:34 +00004687 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004688 virtual bool setABI(const std::string &Name) {
4689 if ((Name == "o32") || (Name == "eabi")) {
4690 ABI = Name;
4691 return true;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004692 } else if (Name == "32") {
4693 ABI = "o32";
4694 return true;
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004695 } else
4696 return false;
4697 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004698 virtual void getTargetDefines(const LangOptions &Opts,
4699 MacroBuilder &Builder) const {
4700 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004701
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004702 if (ABI == "o32") {
4703 Builder.defineMacro("__mips_o32");
4704 Builder.defineMacro("_ABIO32", "1");
4705 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
4706 }
4707 else if (ABI == "eabi")
4708 Builder.defineMacro("__mips_eabi");
4709 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004710 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004711 }
4712 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4713 unsigned &NumAliases) const {
4714 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4715 { { "at" }, "$1" },
4716 { { "v0" }, "$2" },
4717 { { "v1" }, "$3" },
4718 { { "a0" }, "$4" },
4719 { { "a1" }, "$5" },
4720 { { "a2" }, "$6" },
4721 { { "a3" }, "$7" },
4722 { { "t0" }, "$8" },
4723 { { "t1" }, "$9" },
4724 { { "t2" }, "$10" },
4725 { { "t3" }, "$11" },
4726 { { "t4" }, "$12" },
4727 { { "t5" }, "$13" },
4728 { { "t6" }, "$14" },
4729 { { "t7" }, "$15" },
4730 { { "s0" }, "$16" },
4731 { { "s1" }, "$17" },
4732 { { "s2" }, "$18" },
4733 { { "s3" }, "$19" },
4734 { { "s4" }, "$20" },
4735 { { "s5" }, "$21" },
4736 { { "s6" }, "$22" },
4737 { { "s7" }, "$23" },
4738 { { "t8" }, "$24" },
4739 { { "t9" }, "$25" },
4740 { { "k0" }, "$26" },
4741 { { "k1" }, "$27" },
4742 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004743 { { "sp","$sp" }, "$29" },
4744 { { "fp","$fp" }, "$30" },
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004745 { { "ra" }, "$31" }
4746 };
4747 Aliases = GCCRegAliases;
4748 NumAliases = llvm::array_lengthof(GCCRegAliases);
4749 }
4750};
4751
4752class Mips32EBTargetInfo : public Mips32TargetInfoBase {
4753public:
4754 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
4755 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 +00004756 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004757 }
4758 virtual void getTargetDefines(const LangOptions &Opts,
4759 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004760 DefineStd(Builder, "MIPSEB", Opts);
4761 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004762 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004763 }
4764};
4765
4766class Mips32ELTargetInfo : public Mips32TargetInfoBase {
4767public:
4768 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004769 BigEndian = false;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004770 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 +00004771 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004772 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004773 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004774 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004775 DefineStd(Builder, "MIPSEL", Opts);
4776 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004777 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004778 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004779};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004780
4781class Mips64TargetInfoBase : public MipsTargetInfoBase {
4782 virtual void SetDescriptionString(const std::string &Name) = 0;
4783public:
4784 Mips64TargetInfoBase(const std::string& triple) :
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00004785 MipsTargetInfoBase(triple, "n64", "mips64") {
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004786 LongWidth = LongAlign = 64;
4787 PointerWidth = PointerAlign = 64;
4788 LongDoubleWidth = LongDoubleAlign = 128;
4789 LongDoubleFormat = &llvm::APFloat::IEEEquad;
David Chisnall6e399b42012-12-08 09:06:08 +00004790 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
4791 LongDoubleWidth = LongDoubleAlign = 64;
4792 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
4793 }
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004794 SuitableAlign = 128;
Akira Hatanakadbee9492013-01-18 21:58:11 +00004795 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004796 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004797 virtual bool setABI(const std::string &Name) {
4798 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004799 if (Name == "n32") {
4800 LongWidth = LongAlign = 32;
4801 PointerWidth = PointerAlign = 32;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004802 ABI = Name;
4803 return true;
4804 } else if (Name == "n64") {
4805 ABI = Name;
4806 return true;
4807 } else if (Name == "64") {
4808 ABI = "n64";
4809 return true;
4810 } else
4811 return false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004812 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004813 virtual void getTargetDefines(const LangOptions &Opts,
4814 MacroBuilder &Builder) const {
4815 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004816
Simon Atanasyan600a5132012-08-29 20:50:11 +00004817 Builder.defineMacro("__mips64");
4818 Builder.defineMacro("__mips64__");
4819
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004820 if (ABI == "n32") {
4821 Builder.defineMacro("__mips_n32");
4822 Builder.defineMacro("_ABIN32", "2");
4823 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
4824 }
4825 else if (ABI == "n64") {
4826 Builder.defineMacro("__mips_n64");
4827 Builder.defineMacro("_ABI64", "3");
4828 Builder.defineMacro("_MIPS_SIM", "_ABI64");
4829 }
4830 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004831 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004832 }
4833 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4834 unsigned &NumAliases) const {
4835 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4836 { { "at" }, "$1" },
4837 { { "v0" }, "$2" },
4838 { { "v1" }, "$3" },
4839 { { "a0" }, "$4" },
4840 { { "a1" }, "$5" },
4841 { { "a2" }, "$6" },
4842 { { "a3" }, "$7" },
4843 { { "a4" }, "$8" },
4844 { { "a5" }, "$9" },
4845 { { "a6" }, "$10" },
4846 { { "a7" }, "$11" },
4847 { { "t0" }, "$12" },
4848 { { "t1" }, "$13" },
4849 { { "t2" }, "$14" },
4850 { { "t3" }, "$15" },
4851 { { "s0" }, "$16" },
4852 { { "s1" }, "$17" },
4853 { { "s2" }, "$18" },
4854 { { "s3" }, "$19" },
4855 { { "s4" }, "$20" },
4856 { { "s5" }, "$21" },
4857 { { "s6" }, "$22" },
4858 { { "s7" }, "$23" },
4859 { { "t8" }, "$24" },
4860 { { "t9" }, "$25" },
4861 { { "k0" }, "$26" },
4862 { { "k1" }, "$27" },
4863 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004864 { { "sp","$sp" }, "$29" },
4865 { { "fp","$fp" }, "$30" },
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004866 { { "ra" }, "$31" }
4867 };
4868 Aliases = GCCRegAliases;
4869 NumAliases = llvm::array_lengthof(GCCRegAliases);
4870 }
4871};
4872
4873class Mips64EBTargetInfo : public Mips64TargetInfoBase {
4874 virtual void SetDescriptionString(const std::string &Name) {
4875 // Change DescriptionString only if ABI is n32.
4876 if (Name == "n32")
4877 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 +00004878 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004879 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004880 }
4881public:
4882 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
4883 // Default ABI is n64.
4884 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 +00004885 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004886 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004887 }
4888 virtual void getTargetDefines(const LangOptions &Opts,
4889 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004890 DefineStd(Builder, "MIPSEB", Opts);
4891 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004892 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004893 }
4894};
4895
4896class Mips64ELTargetInfo : public Mips64TargetInfoBase {
4897 virtual void SetDescriptionString(const std::string &Name) {
4898 // Change DescriptionString only if ABI is n32.
4899 if (Name == "n32")
4900 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 +00004901 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004902 "-v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004903 }
4904public:
4905 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004906 // Default ABI is n64.
4907 BigEndian = false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004908 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 +00004909 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004910 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004911 }
4912 virtual void getTargetDefines(const LangOptions &Opts,
4913 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004914 DefineStd(Builder, "MIPSEL", Opts);
4915 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004916 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004917 }
4918};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004919} // end anonymous namespace.
4920
Ivan Krasinef05abd2011-08-24 20:22:22 +00004921namespace {
4922class PNaClTargetInfo : public TargetInfo {
4923public:
4924 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004925 BigEndian = false;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004926 this->UserLabelPrefix = "";
4927 this->LongAlign = 32;
4928 this->LongWidth = 32;
4929 this->PointerAlign = 32;
4930 this->PointerWidth = 32;
4931 this->IntMaxType = TargetInfo::SignedLongLong;
4932 this->UIntMaxType = TargetInfo::UnsignedLongLong;
4933 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00004934 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00004935 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00004936 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00004937 this->SizeType = TargetInfo::UnsignedInt;
4938 this->PtrDiffType = TargetInfo::SignedInt;
4939 this->IntPtrType = TargetInfo::SignedInt;
Eli Benderskyc0783dc2013-04-08 21:31:01 +00004940 this->RegParmMax = 0; // Disallow regparm
Ivan Krasinef05abd2011-08-24 20:22:22 +00004941 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
4942 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
4943 }
4944
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004945 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00004946 }
4947 virtual void getArchDefines(const LangOptions &Opts,
4948 MacroBuilder &Builder) const {
4949 Builder.defineMacro("__le32__");
4950 Builder.defineMacro("__pnacl__");
4951 }
4952 virtual void getTargetDefines(const LangOptions &Opts,
4953 MacroBuilder &Builder) const {
Jan Wen Voungdde3bdb2012-03-29 00:05:59 +00004954 Builder.defineMacro("__LITTLE_ENDIAN__");
Ivan Krasinef05abd2011-08-24 20:22:22 +00004955 getArchDefines(Opts, Builder);
4956 }
Douglas Gregore727d212012-01-30 06:38:25 +00004957 virtual bool hasFeature(StringRef Feature) const {
4958 return Feature == "pnacl";
4959 }
Ivan Krasinef05abd2011-08-24 20:22:22 +00004960 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4961 unsigned &NumRecords) const {
4962 }
Meador Ingec5613b22012-06-16 03:34:49 +00004963 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4964 return TargetInfo::PNaClABIBuiltinVaList;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004965 }
4966 virtual void getGCCRegNames(const char * const *&Names,
4967 unsigned &NumNames) const;
4968 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4969 unsigned &NumAliases) const;
4970 virtual bool validateAsmConstraint(const char *&Name,
4971 TargetInfo::ConstraintInfo &Info) const {
4972 return false;
4973 }
4974
4975 virtual const char *getClobbers() const {
4976 return "";
4977 }
4978};
4979
4980void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
4981 unsigned &NumNames) const {
4982 Names = NULL;
4983 NumNames = 0;
4984}
4985
4986void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4987 unsigned &NumAliases) const {
4988 Aliases = NULL;
4989 NumAliases = 0;
4990}
4991} // end anonymous namespace.
4992
Guy Benyeibd5da3c2012-12-11 21:38:14 +00004993namespace {
4994 static const unsigned SPIRAddrSpaceMap[] = {
4995 1, // opencl_global
4996 3, // opencl_local
4997 2, // opencl_constant
4998 0, // cuda_device
4999 0, // cuda_constant
5000 0 // cuda_shared
5001 };
5002 class SPIRTargetInfo : public TargetInfo {
5003 static const char * const GCCRegNames[];
5004 static const Builtin::Info BuiltinInfo[];
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00005005 std::vector<StringRef> AvailableFeatures;
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005006 public:
5007 SPIRTargetInfo(const std::string& triple) : TargetInfo(triple) {
5008 assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
5009 "SPIR target must use unknown OS");
5010 assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
5011 "SPIR target must use unknown environment type");
5012 BigEndian = false;
5013 TLSSupported = false;
5014 LongWidth = LongAlign = 64;
5015 AddrSpaceMap = &SPIRAddrSpaceMap;
5016 // Define available target features
5017 // These must be defined in sorted order!
5018 NoAsmVariants = true;
5019 }
5020 virtual void getTargetDefines(const LangOptions &Opts,
5021 MacroBuilder &Builder) const {
5022 DefineStd(Builder, "SPIR", Opts);
5023 }
5024 virtual bool hasFeature(StringRef Feature) const {
5025 return Feature == "spir";
5026 }
5027
5028 virtual void getTargetBuiltins(const Builtin::Info *&Records,
5029 unsigned &NumRecords) const {}
5030 virtual const char *getClobbers() const {
5031 return "";
5032 }
5033 virtual void getGCCRegNames(const char * const *&Names,
5034 unsigned &NumNames) const {}
5035 virtual bool validateAsmConstraint(const char *&Name,
5036 TargetInfo::ConstraintInfo &info) const {
5037 return true;
5038 }
5039 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
5040 unsigned &NumAliases) const {}
5041 virtual BuiltinVaListKind getBuiltinVaListKind() const {
5042 return TargetInfo::VoidPtrBuiltinVaList;
5043 }
5044 };
5045
5046
5047 class SPIR32TargetInfo : public SPIRTargetInfo {
5048 public:
5049 SPIR32TargetInfo(const std::string& triple) : SPIRTargetInfo(triple) {
5050 PointerWidth = PointerAlign = 32;
5051 SizeType = TargetInfo::UnsignedInt;
5052 PtrDiffType = IntPtrType = TargetInfo::SignedInt;
5053 DescriptionString
Guy Benyeif3ddf632013-03-07 13:06:10 +00005054 = "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 +00005055 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-"
5056 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-"
5057 "v512:512:512-v1024:1024:1024";
Guy Benyeif3ddf632013-03-07 13:06:10 +00005058 }
5059 virtual void getTargetDefines(const LangOptions &Opts,
5060 MacroBuilder &Builder) const {
5061 DefineStd(Builder, "SPIR32", Opts);
5062 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005063 };
5064
5065 class SPIR64TargetInfo : public SPIRTargetInfo {
5066 public:
5067 SPIR64TargetInfo(const std::string& triple) : SPIRTargetInfo(triple) {
5068 PointerWidth = PointerAlign = 64;
5069 SizeType = TargetInfo::UnsignedLong;
5070 PtrDiffType = IntPtrType = TargetInfo::SignedLong;
5071 DescriptionString
Guy Benyeif3ddf632013-03-07 13:06:10 +00005072 = "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 +00005073 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-"
5074 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-"
5075 "v512:512:512-v1024:1024:1024";
Guy Benyeif3ddf632013-03-07 13:06:10 +00005076 }
5077 virtual void getTargetDefines(const LangOptions &Opts,
5078 MacroBuilder &Builder) const {
5079 DefineStd(Builder, "SPIR64", Opts);
5080 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005081 };
5082}
5083
Ivan Krasinef05abd2011-08-24 20:22:22 +00005084
Reid Spencer5f016e22007-07-11 17:01:13 +00005085//===----------------------------------------------------------------------===//
5086// Driver code
5087//===----------------------------------------------------------------------===//
5088
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005089static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005090 llvm::Triple Triple(T);
5091 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00005092
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005093 switch (Triple.getArch()) {
5094 default:
5095 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00005096
Tony Linthicum96319392011-12-12 21:14:55 +00005097 case llvm::Triple::hexagon:
5098 return new HexagonTargetInfo(T);
5099
Tim Northoverc264e162013-01-31 12:13:10 +00005100 case llvm::Triple::aarch64:
5101 switch (os) {
5102 case llvm::Triple::Linux:
5103 return new LinuxTargetInfo<AArch64TargetInfo>(T);
5104 default:
5105 return new AArch64TargetInfo(T);
5106 }
5107
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005108 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00005109 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005110 if (Triple.isOSDarwin())
5111 return new DarwinARMTargetInfo(T);
5112
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005113 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00005114 case llvm::Triple::Linux:
5115 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005116 case llvm::Triple::FreeBSD:
Torok Edwin5f6c1942009-06-30 17:10:35 +00005117 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005118 case llvm::Triple::NetBSD:
5119 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005120 case llvm::Triple::OpenBSD:
5121 return new OpenBSDTargetInfo<ARMTargetInfo>(T);
Eli Friedman42f74f22012-08-08 23:57:20 +00005122 case llvm::Triple::Bitrig:
5123 return new BitrigTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00005124 case llvm::Triple::RTEMS:
5125 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005126 case llvm::Triple::NaCl:
Derek Schuff7da46f92012-10-11 16:55:58 +00005127 return new NaClTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005128 default:
5129 return new ARMTargetInfo(T);
5130 }
Eli Friedman61538a72008-05-20 14:21:01 +00005131
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005132 case llvm::Triple::msp430:
5133 return new MSP430TargetInfo(T);
Eli Friedman61538a72008-05-20 14:21:01 +00005134
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005135 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005136 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005137 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005138 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005139 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005140 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005141 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005142 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005143 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005144 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005145 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005146 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005147 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005148
5149 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005150 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005151 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005152 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005153 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005154 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005155 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005156 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005157 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005158 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005159 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005160 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005161 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005162
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005163 case llvm::Triple::mips64:
5164 switch (os) {
5165 case llvm::Triple::Linux:
5166 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
5167 case llvm::Triple::RTEMS:
5168 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
5169 case llvm::Triple::FreeBSD:
5170 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
5171 case llvm::Triple::NetBSD:
5172 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005173 case llvm::Triple::OpenBSD:
5174 return new OpenBSDTargetInfo<Mips64EBTargetInfo>(T);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005175 default:
5176 return new Mips64EBTargetInfo(T);
5177 }
5178
5179 case llvm::Triple::mips64el:
5180 switch (os) {
5181 case llvm::Triple::Linux:
5182 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
5183 case llvm::Triple::RTEMS:
5184 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
5185 case llvm::Triple::FreeBSD:
5186 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
5187 case llvm::Triple::NetBSD:
5188 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005189 case llvm::Triple::OpenBSD:
5190 return new OpenBSDTargetInfo<Mips64ELTargetInfo>(T);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005191 default:
5192 return new Mips64ELTargetInfo(T);
5193 }
5194
Ivan Krasinef05abd2011-08-24 20:22:22 +00005195 case llvm::Triple::le32:
5196 switch (os) {
Eli Bendersky441d9f72012-12-04 18:38:10 +00005197 case llvm::Triple::NaCl:
Derek Schuff7da46f92012-10-11 16:55:58 +00005198 return new NaClTargetInfo<PNaClTargetInfo>(T);
Ivan Krasinef05abd2011-08-24 20:22:22 +00005199 default:
5200 return NULL;
5201 }
5202
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005203 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005204 if (Triple.isOSDarwin())
Roman Divackyc81f2a22011-01-06 08:27:10 +00005205 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005206 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005207 case llvm::Triple::Linux:
5208 return new LinuxTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005209 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00005210 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005211 case llvm::Triple::NetBSD:
5212 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005213 case llvm::Triple::OpenBSD:
5214 return new OpenBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005215 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00005216 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005217 default:
5218 return new PPC32TargetInfo(T);
5219 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005220
5221 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005222 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00005223 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005224 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005225 case llvm::Triple::Linux:
5226 return new LinuxTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005227 case llvm::Triple::Lv2:
John Thompson3f6918a2009-11-19 17:18:50 +00005228 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005229 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00005230 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005231 case llvm::Triple::NetBSD:
5232 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
5233 default:
5234 return new PPC64TargetInfo(T);
5235 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005236
Peter Collingbourneedb66f32012-05-20 23:28:41 +00005237 case llvm::Triple::nvptx:
5238 return new NVPTX32TargetInfo(T);
5239 case llvm::Triple::nvptx64:
5240 return new NVPTX64TargetInfo(T);
5241
Chris Lattner9cbeb632010-03-06 21:21:27 +00005242 case llvm::Triple::mblaze:
5243 return new MBlazeTargetInfo(T);
5244
Eli Friedman6505a292012-10-12 23:32:00 +00005245 case llvm::Triple::r600:
5246 return new R600TargetInfo(T);
5247
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005248 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005249 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005250 case llvm::Triple::Linux:
5251 return new LinuxTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005252 case llvm::Triple::AuroraUX:
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00005253 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005254 case llvm::Triple::Solaris:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005255 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005256 case llvm::Triple::NetBSD:
5257 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005258 case llvm::Triple::OpenBSD:
5259 return new OpenBSDTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005260 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00005261 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005262 default:
5263 return new SparcV8TargetInfo(T);
5264 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005265
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005266 case llvm::Triple::sparcv9:
5267 switch (os) {
5268 case llvm::Triple::Linux:
5269 return new LinuxTargetInfo<SparcV9TargetInfo>(T);
5270 case llvm::Triple::AuroraUX:
5271 return new AuroraUXTargetInfo<SparcV9TargetInfo>(T);
5272 case llvm::Triple::Solaris:
5273 return new SolarisTargetInfo<SparcV9TargetInfo>(T);
5274 case llvm::Triple::NetBSD:
5275 return new NetBSDTargetInfo<SparcV9TargetInfo>(T);
5276 case llvm::Triple::OpenBSD:
5277 return new OpenBSDTargetInfo<SparcV9TargetInfo>(T);
5278 case llvm::Triple::FreeBSD:
5279 return new FreeBSDTargetInfo<SparcV9TargetInfo>(T);
5280 default:
5281 return new SparcV9TargetInfo(T);
5282 }
5283
Eli Friedmanb63decf2009-08-19 20:47:07 +00005284 case llvm::Triple::tce:
5285 return new TCETargetInfo(T);
5286
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005287 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005288 if (Triple.isOSDarwin())
5289 return new DarwinI386TargetInfo(T);
5290
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005291 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00005292 case llvm::Triple::AuroraUX:
5293 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005294 case llvm::Triple::Linux:
5295 return new LinuxTargetInfo<X86_32TargetInfo>(T);
5296 case llvm::Triple::DragonFly:
5297 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
5298 case llvm::Triple::NetBSD:
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00005299 return new NetBSDI386TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005300 case llvm::Triple::OpenBSD:
5301 return new OpenBSDI386TargetInfo(T);
Eli Friedman42f74f22012-08-08 23:57:20 +00005302 case llvm::Triple::Bitrig:
5303 return new BitrigI386TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005304 case llvm::Triple::FreeBSD:
5305 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner38e317d2010-07-07 16:01:42 +00005306 case llvm::Triple::Minix:
5307 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005308 case llvm::Triple::Solaris:
5309 return new SolarisTargetInfo<X86_32TargetInfo>(T);
5310 case llvm::Triple::Cygwin:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00005311 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005312 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00005313 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005314 case llvm::Triple::Win32:
Michael J. Spencera764e832010-10-21 08:22:51 +00005315 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattner86ed3a32010-04-11 19:29:39 +00005316 case llvm::Triple::Haiku:
5317 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00005318 case llvm::Triple::RTEMS:
5319 return new RTEMSX86_32TargetInfo(T);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005320 case llvm::Triple::NaCl:
Derek Schuff7da46f92012-10-11 16:55:58 +00005321 return new NaClTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005322 default:
5323 return new X86_32TargetInfo(T);
5324 }
5325
5326 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005327 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
5328 return new DarwinX86_64TargetInfo(T);
5329
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005330 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00005331 case llvm::Triple::AuroraUX:
5332 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005333 case llvm::Triple::Linux:
5334 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner7a7ca282010-01-09 05:41:14 +00005335 case llvm::Triple::DragonFly:
5336 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005337 case llvm::Triple::NetBSD:
5338 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
5339 case llvm::Triple::OpenBSD:
5340 return new OpenBSDX86_64TargetInfo(T);
Eli Friedman42f74f22012-08-08 23:57:20 +00005341 case llvm::Triple::Bitrig:
5342 return new BitrigX86_64TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005343 case llvm::Triple::FreeBSD:
5344 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
5345 case llvm::Triple::Solaris:
5346 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00005347 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00005348 return new MinGWX86_64TargetInfo(T);
5349 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005350 return new VisualStudioWindowsX86_64TargetInfo(T);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005351 case llvm::Triple::NaCl:
Derek Schuff7da46f92012-10-11 16:55:58 +00005352 return new NaClTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005353 default:
5354 return new X86_64TargetInfo(T);
5355 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005356
5357 case llvm::Triple::spir: {
5358 llvm::Triple Triple(T);
5359 if (Triple.getOS() != llvm::Triple::UnknownOS ||
5360 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
5361 return NULL;
5362 return new SPIR32TargetInfo(T);
5363 }
5364 case llvm::Triple::spir64: {
5365 llvm::Triple Triple(T);
5366 if (Triple.getOS() != llvm::Triple::UnknownOS ||
5367 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
5368 return NULL;
5369 return new SPIR64TargetInfo(T);
5370 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005371 }
Reid Spencer5f016e22007-07-11 17:01:13 +00005372}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005373
5374/// CreateTargetInfo - Return the target info object for the specified target
5375/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00005376TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Douglas Gregor49a87542012-11-16 04:24:59 +00005377 TargetOptions *Opts) {
5378 llvm::Triple Triple(Opts->Triple);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005379
5380 // Construct the target
Dylan Noblesmith6f42b622012-02-05 02:12:40 +00005381 OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005382 if (!Target) {
5383 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
5384 return 0;
5385 }
Douglas Gregor9a022bb2012-10-15 16:45:32 +00005386 Target->setTargetOpts(Opts);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005387
Daniel Dunbareac7c532009-12-18 18:42:37 +00005388 // Set the target CPU if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00005389 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
5390 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
Daniel Dunbareac7c532009-12-18 18:42:37 +00005391 return 0;
5392 }
5393
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005394 // Set the target ABI if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00005395 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
5396 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005397 return 0;
5398 }
5399
Charles Davis98b7c5c2010-06-11 01:06:47 +00005400 // Set the target C++ ABI.
Douglas Gregor49a87542012-11-16 04:24:59 +00005401 if (!Opts->CXXABI.empty() && !Target->setCXXABI(Opts->CXXABI)) {
5402 Diags.Report(diag::err_target_unknown_cxxabi) << Opts->CXXABI;
Charles Davis98b7c5c2010-06-11 01:06:47 +00005403 return 0;
5404 }
5405
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005406 // Compute the default target features, we need the target to handle this
5407 // because features may have dependencies on one another.
5408 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00005409 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005410
5411 // Apply the user specified deltas.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005412 // First the enables.
Douglas Gregor57016dd2012-10-16 23:40:58 +00005413 for (std::vector<std::string>::const_iterator
Douglas Gregor49a87542012-11-16 04:24:59 +00005414 it = Opts->FeaturesAsWritten.begin(),
5415 ie = Opts->FeaturesAsWritten.end();
Douglas Gregor57016dd2012-10-16 23:40:58 +00005416 it != ie; ++it) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005417 const char *Name = it->c_str();
5418
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005419 if (Name[0] != '+')
5420 continue;
5421
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005422 // Apply the feature via the target.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005423 if (!Target->setFeatureEnabled(Features, Name + 1, true)) {
5424 Diags.Report(diag::err_target_invalid_feature) << Name;
5425 return 0;
5426 }
5427 }
5428
5429 // Then the disables.
Douglas Gregor57016dd2012-10-16 23:40:58 +00005430 for (std::vector<std::string>::const_iterator
Douglas Gregor49a87542012-11-16 04:24:59 +00005431 it = Opts->FeaturesAsWritten.begin(),
5432 ie = Opts->FeaturesAsWritten.end();
Douglas Gregor57016dd2012-10-16 23:40:58 +00005433 it != ie; ++it) {
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005434 const char *Name = it->c_str();
5435
5436 if (Name[0] == '+')
5437 continue;
5438
5439 // Apply the feature via the target.
5440 if (Name[0] != '-' ||
5441 !Target->setFeatureEnabled(Features, Name + 1, false)) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005442 Diags.Report(diag::err_target_invalid_feature) << Name;
5443 return 0;
5444 }
5445 }
5446
5447 // Add the features to the compile options.
5448 //
5449 // FIXME: If we are completely confident that we have the right set, we only
5450 // need to pass the minuses.
Douglas Gregor49a87542012-11-16 04:24:59 +00005451 Opts->Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005452 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
5453 ie = Features.end(); it != ie; ++it)
Douglas Gregor49a87542012-11-16 04:24:59 +00005454 Opts->Features.push_back((it->second ? "+" : "-") + it->first().str());
5455 Target->HandleTargetFeatures(Opts->Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005456
5457 return Target.take();
5458}