blob: 20e504c0be5d65486b2359f54373b307a70946a1 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- Targets.cpp - Implement -arch option and targets -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
Anton Korobeynikova7c47172009-05-03 13:42:53 +000010// This file implements construction of a TargetInfo object from a
Ted Kremenekbbced582007-12-12 18:05:32 +000011// target triple.
Reid Spencer5f016e22007-07-11 17:01:13 +000012//
13//===----------------------------------------------------------------------===//
14
Reid Spencer5f016e22007-07-11 17:01:13 +000015#include "clang/Basic/TargetInfo.h"
Daniel Dunbard58c03f2009-11-15 06:48:46 +000016#include "clang/Basic/Builtins.h"
17#include "clang/Basic/Diagnostic.h"
Chris Lattner8fc4dfb2008-12-04 22:54:33 +000018#include "clang/Basic/LangOptions.h"
Chandler Carruth103b71c2010-01-20 06:13:02 +000019#include "clang/Basic/MacroBuilder.h"
Daniel Dunbard58c03f2009-11-15 06:48:46 +000020#include "clang/Basic/TargetBuiltins.h"
21#include "clang/Basic/TargetOptions.h"
Eli Friedman25531262008-05-20 14:27:34 +000022#include "llvm/ADT/APFloat.h"
Daniel Dunbard58c03f2009-11-15 06:48:46 +000023#include "llvm/ADT/OwningPtr.h"
Daniel Dunbar29a790b2009-11-11 09:38:56 +000024#include "llvm/ADT/STLExtras.h"
Daniel Dunbar77659342009-08-19 20:04:03 +000025#include "llvm/ADT/StringRef.h"
Daniel Dunbar29a790b2009-11-11 09:38:56 +000026#include "llvm/ADT/StringSwitch.h"
Chris Lattner4c28b1c2009-08-12 06:24:27 +000027#include "llvm/ADT/Triple.h"
Chandler Carruth3b844ba2013-01-02 11:45:17 +000028#include "llvm/IR/Type.h"
Chris Lattner797c3c42009-08-10 19:03:04 +000029#include "llvm/MC/MCSectionMachO.h"
David Blaikie9fe8c742011-09-23 05:35:21 +000030#include "llvm/Support/ErrorHandling.h"
Benjamin Kramer48725082010-01-09 18:20:57 +000031#include <algorithm>
Reid Spencer5f016e22007-07-11 17:01:13 +000032using namespace clang;
33
Reid Spencer5f016e22007-07-11 17:01:13 +000034//===----------------------------------------------------------------------===//
35// Common code shared among targets.
36//===----------------------------------------------------------------------===//
37
Chris Lattnerca45cff2009-03-20 16:06:38 +000038/// DefineStd - Define a macro name and standard variants. For example if
39/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
40/// when in GNU mode.
Chris Lattner5f9e2722011-07-23 10:55:15 +000041static void DefineStd(MacroBuilder &Builder, StringRef MacroName,
Chris Lattnerca45cff2009-03-20 16:06:38 +000042 const LangOptions &Opts) {
43 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000044
Chris Lattnerca45cff2009-03-20 16:06:38 +000045 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
46 // in the user's namespace.
47 if (Opts.GNUMode)
Benjamin Kramera9992772010-01-09 17:55:51 +000048 Builder.defineMacro(MacroName);
Anton Korobeynikova7c47172009-05-03 13:42:53 +000049
Chris Lattnerca45cff2009-03-20 16:06:38 +000050 // Define __unix.
Benjamin Kramera9992772010-01-09 17:55:51 +000051 Builder.defineMacro("__" + MacroName);
Anton Korobeynikova7c47172009-05-03 13:42:53 +000052
Chris Lattnerca45cff2009-03-20 16:06:38 +000053 // Define __unix__.
Benjamin Kramera9992772010-01-09 17:55:51 +000054 Builder.defineMacro("__" + MacroName + "__");
Chris Lattnerca45cff2009-03-20 16:06:38 +000055}
56
Benjamin Kramer448f68d2012-01-10 11:50:09 +000057static void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName,
58 bool Tuning = true) {
59 Builder.defineMacro("__" + CPUName);
60 Builder.defineMacro("__" + CPUName + "__");
61 if (Tuning)
62 Builder.defineMacro("__tune_" + CPUName + "__");
63}
64
Chris Lattnerd29b6302008-10-05 21:50:58 +000065//===----------------------------------------------------------------------===//
66// Defines specific to certain operating systems.
67//===----------------------------------------------------------------------===//
Chris Lattner797c3c42009-08-10 19:03:04 +000068
Torok Edwin5f6c1942009-06-30 17:10:35 +000069namespace {
Douglas Gregora3844922009-07-01 15:12:53 +000070template<typename TgtInfo>
71class OSTargetInfo : public TgtInfo {
Torok Edwin5f6c1942009-06-30 17:10:35 +000072protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +000073 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +000074 MacroBuilder &Builder) const=0;
Torok Edwin5f6c1942009-06-30 17:10:35 +000075public:
Benjamin Kramer9df08232013-06-29 16:37:14 +000076 OSTargetInfo(const llvm::Triple &Triple) : TgtInfo(Triple) {}
Torok Edwin5f6c1942009-06-30 17:10:35 +000077 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +000078 MacroBuilder &Builder) const {
79 TgtInfo::getTargetDefines(Opts, Builder);
80 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Torok Edwinb0a5b242009-06-30 17:00:25 +000081 }
Torok Edwin5f6c1942009-06-30 17:10:35 +000082
83};
Chris Lattner4c28b1c2009-08-12 06:24:27 +000084} // end anonymous namespace
Torok Edwinb0a5b242009-06-30 17:00:25 +000085
Chris Lattner797c3c42009-08-10 19:03:04 +000086
Daniel Dunbar21ae3192010-01-26 01:44:04 +000087static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +000088 const llvm::Triple &Triple,
Chris Lattner5f9e2722011-07-23 10:55:15 +000089 StringRef &PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +000090 VersionTuple &PlatformMinVersion) {
Benjamin Kramera9992772010-01-09 17:55:51 +000091 Builder.defineMacro("__APPLE_CC__", "5621");
92 Builder.defineMacro("__APPLE__");
93 Builder.defineMacro("__MACH__");
94 Builder.defineMacro("OBJC_NEW_PROPERTIES");
Alexander Potapenko087c65f2012-09-20 10:10:01 +000095 // AddressSanitizer doesn't play well with source fortification, which is on
96 // by default on Darwin.
Will Dietz4f45bc02013-01-18 11:30:38 +000097 if (Opts.Sanitize.Address) Builder.defineMacro("_FORTIFY_SOURCE", "0");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000098
John McCall098df7f2011-06-16 00:03:19 +000099 if (!Opts.ObjCAutoRefCount) {
John McCallf85e1932011-06-15 23:02:42 +0000100 // __weak is always defined, for use in blocks and with objc pointers.
101 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000102
John McCallf85e1932011-06-15 23:02:42 +0000103 // Darwin defines __strong even in C mode (just to nothing).
Douglas Gregore289d812011-09-13 17:21:33 +0000104 if (Opts.getGC() != LangOptions::NonGC)
John McCallf85e1932011-06-15 23:02:42 +0000105 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
106 else
107 Builder.defineMacro("__strong", "");
Eric Christopher7c9adf92011-07-07 22:55:26 +0000108
John McCallf85e1932011-06-15 23:02:42 +0000109 // __unsafe_unretained is defined to nothing in non-ARC mode. We even
110 // allow this in C, since one might have block pointers in structs that
111 // are used in pure C code and in Objective-C ARC.
112 Builder.defineMacro("__unsafe_unretained", "");
John McCallf85e1932011-06-15 23:02:42 +0000113 }
Eric Christopher7c9adf92011-07-07 22:55:26 +0000114
Eli Friedman2de4fee2009-06-04 23:00:29 +0000115 if (Opts.Static)
Benjamin Kramera9992772010-01-09 17:55:51 +0000116 Builder.defineMacro("__STATIC__");
Eli Friedman2de4fee2009-06-04 23:00:29 +0000117 else
Benjamin Kramera9992772010-01-09 17:55:51 +0000118 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000119
120 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000121 Builder.defineMacro("_REENTRANT");
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000122
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000123 // Get the platform type and version number from the triple.
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000124 unsigned Maj, Min, Rev;
Bob Wilson48b68a02012-01-31 23:52:58 +0000125 if (Triple.isMacOSX()) {
126 Triple.getMacOSXVersion(Maj, Min, Rev);
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000127 PlatformName = "macosx";
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000128 } else {
Bob Wilson48b68a02012-01-31 23:52:58 +0000129 Triple.getOSVersion(Maj, Min, Rev);
130 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000131 }
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000132
Sebastian Pop9ec60df2012-01-20 22:01:23 +0000133 // If -target arch-pc-win32-macho option specified, we're
Eric Christopher895d4222011-07-29 21:20:35 +0000134 // generating code for Win32 ABI. No need to emit
Chad Rosierd9259f32011-07-19 20:00:06 +0000135 // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
136 if (PlatformName == "win32") {
137 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
138 return;
139 }
140
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000141 // Set the appropriate OS version define.
Bob Wilson48b68a02012-01-31 23:52:58 +0000142 if (Triple.getOS() == llvm::Triple::IOS) {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000143 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000144 char Str[6];
145 Str[0] = '0' + Maj;
146 Str[1] = '0' + (Min / 10);
147 Str[2] = '0' + (Min % 10);
148 Str[3] = '0' + (Rev / 10);
149 Str[4] = '0' + (Rev % 10);
150 Str[5] = '\0';
151 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
152 } else {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000153 // Note that the Driver allows versions which aren't representable in the
154 // define (because we only get a single digit for the minor and micro
155 // revision numbers). So, we limit them to the maximum representable
156 // version.
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000157 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000158 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000159 char Str[5];
160 Str[0] = '0' + (Maj / 10);
161 Str[1] = '0' + (Maj % 10);
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000162 Str[2] = '0' + std::min(Min, 9U);
163 Str[3] = '0' + std::min(Rev, 9U);
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000164 Str[4] = '\0';
165 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000166 }
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000167
168 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman618234a2008-08-20 02:34:37 +0000169}
Reid Spencer5f016e22007-07-11 17:01:13 +0000170
Chris Lattner797c3c42009-08-10 19:03:04 +0000171namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000172template<typename Target>
173class DarwinTargetInfo : public OSTargetInfo<Target> {
174protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000175 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000176 MacroBuilder &Builder) const {
Eric Christopher7c9adf92011-07-07 22:55:26 +0000177 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000178 this->PlatformMinVersion);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000179 }
Mike Stump1eb44332009-09-09 15:08:12 +0000180
Torok Edwin5f6c1942009-06-30 17:10:35 +0000181public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000182 DarwinTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
183 this->TLSSupported = Triple.isMacOSX() && !Triple.isMacOSXVersionLT(10, 7);
184 this->MCountName = "\01mcount";
185 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000186
Chris Lattner5f9e2722011-07-23 10:55:15 +0000187 virtual std::string isValidSectionSpecifier(StringRef SR) const {
Chris Lattner797c3c42009-08-10 19:03:04 +0000188 // Let MCSectionMachO validate this.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000189 StringRef Segment, Section;
Chris Lattner797c3c42009-08-10 19:03:04 +0000190 unsigned TAA, StubSize;
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000191 bool HasTAA;
Chris Lattner797c3c42009-08-10 19:03:04 +0000192 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000193 TAA, HasTAA, StubSize);
Chris Lattner797c3c42009-08-10 19:03:04 +0000194 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000195
Anders Carlsson18af3682010-06-08 22:47:50 +0000196 virtual const char *getStaticInitSectionSpecifier() const {
197 // FIXME: We should return 0 when building kexts.
198 return "__TEXT,__StaticInit,regular,pure_instructions";
199 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000200
John McCall41887602012-01-29 01:20:30 +0000201 /// Darwin does not support protected visibility. Darwin's "default"
202 /// is very similar to ELF's "protected"; Darwin requires a "weak"
203 /// attribute on declarations that can be dynamically replaced.
204 virtual bool hasProtectedVisibility() const {
205 return false;
206 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000207};
208
Chris Lattner797c3c42009-08-10 19:03:04 +0000209
Torok Edwin5f6c1942009-06-30 17:10:35 +0000210// DragonFlyBSD Target
211template<typename Target>
212class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
213protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000214 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000215 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000216 // DragonFly defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000217 Builder.defineMacro("__DragonFly__");
218 Builder.defineMacro("__DragonFly_cc_version", "100001");
219 Builder.defineMacro("__ELF__");
220 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
221 Builder.defineMacro("__tune_i386__");
222 DefineStd(Builder, "unix", Opts);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000223 }
224public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000225 DragonFlyBSDTargetInfo(const llvm::Triple &Triple)
226 : OSTargetInfo<Target>(Triple) {
227 this->UserLabelPrefix = "";
Eli Friedmanb089c4d2012-02-10 23:02:29 +0000228
Benjamin Kramer9df08232013-06-29 16:37:14 +0000229 switch (Triple.getArch()) {
230 default:
231 case llvm::Triple::x86:
232 case llvm::Triple::x86_64:
233 this->MCountName = ".mcount";
234 break;
235 }
Eli Friedmanb089c4d2012-02-10 23:02:29 +0000236 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000237};
238
239// FreeBSD Target
240template<typename Target>
241class FreeBSDTargetInfo : public OSTargetInfo<Target> {
242protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000243 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000244 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000245 // FreeBSD defines; list based off of gcc output
246
Benjamin Kramer474202f2011-10-18 10:10:08 +0000247 unsigned Release = Triple.getOSMajorVersion();
248 if (Release == 0U)
249 Release = 8;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000250
Benjamin Kramer474202f2011-10-18 10:10:08 +0000251 Builder.defineMacro("__FreeBSD__", Twine(Release));
252 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramera9992772010-01-09 17:55:51 +0000253 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
254 DefineStd(Builder, "unix", Opts);
255 Builder.defineMacro("__ELF__");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000256 }
257public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000258 FreeBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
259 this->UserLabelPrefix = "";
Roman Divackybe4c8702011-02-10 16:52:03 +0000260
Benjamin Kramer9df08232013-06-29 16:37:14 +0000261 switch (Triple.getArch()) {
262 default:
263 case llvm::Triple::x86:
264 case llvm::Triple::x86_64:
265 this->MCountName = ".mcount";
266 break;
267 case llvm::Triple::mips:
268 case llvm::Triple::mipsel:
269 case llvm::Triple::ppc:
270 case llvm::Triple::ppc64:
271 this->MCountName = "_mcount";
272 break;
273 case llvm::Triple::arm:
274 this->MCountName = "__mcount";
275 break;
Duncan Sands1e90faf2009-07-08 13:55:08 +0000276 }
Benjamin Kramer9df08232013-06-29 16:37:14 +0000277 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000278};
279
Chris Lattner38e317d2010-07-07 16:01:42 +0000280// Minix Target
281template<typename Target>
282class MinixTargetInfo : public OSTargetInfo<Target> {
283protected:
284 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
285 MacroBuilder &Builder) const {
286 // Minix defines
287
288 Builder.defineMacro("__minix", "3");
289 Builder.defineMacro("_EM_WSIZE", "4");
290 Builder.defineMacro("_EM_PSIZE", "4");
291 Builder.defineMacro("_EM_SSIZE", "2");
292 Builder.defineMacro("_EM_LSIZE", "4");
293 Builder.defineMacro("_EM_FSIZE", "4");
294 Builder.defineMacro("_EM_DSIZE", "8");
Eli Friedman6d402dc2011-12-08 23:54:21 +0000295 Builder.defineMacro("__ELF__");
Chris Lattner38e317d2010-07-07 16:01:42 +0000296 DefineStd(Builder, "unix", Opts);
297 }
298public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000299 MinixTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
300 this->UserLabelPrefix = "";
301 }
Chris Lattner38e317d2010-07-07 16:01:42 +0000302};
303
Torok Edwin5f6c1942009-06-30 17:10:35 +0000304// Linux target
305template<typename Target>
306class LinuxTargetInfo : public OSTargetInfo<Target> {
307protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000308 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000309 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000310 // Linux defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000311 DefineStd(Builder, "unix", Opts);
312 DefineStd(Builder, "linux", Opts);
313 Builder.defineMacro("__gnu_linux__");
314 Builder.defineMacro("__ELF__");
Logan Chien94a71422012-09-02 09:30:11 +0000315 if (Triple.getEnvironment() == llvm::Triple::Android)
Evgeniy Stepanov32064032012-04-26 12:08:09 +0000316 Builder.defineMacro("__ANDROID__", "1");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000317 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000318 Builder.defineMacro("_REENTRANT");
Douglas Gregor2b003fd2010-04-21 05:52:38 +0000319 if (Opts.CPlusPlus)
320 Builder.defineMacro("_GNU_SOURCE");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000321 }
322public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000323 LinuxTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000324 this->UserLabelPrefix = "";
Douglas Gregor12e84642011-01-12 21:19:25 +0000325 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000326 }
Benjamin Kramer86d18c52011-10-15 17:53:33 +0000327
328 virtual const char *getStaticInitSectionSpecifier() const {
329 return ".text.startup";
330 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000331};
332
Chris Lattnerb62bb282009-07-13 20:29:08 +0000333// NetBSD Target
334template<typename Target>
335class NetBSDTargetInfo : public OSTargetInfo<Target> {
336protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000337 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000338 MacroBuilder &Builder) const {
Chris Lattnerb62bb282009-07-13 20:29:08 +0000339 // NetBSD defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000340 Builder.defineMacro("__NetBSD__");
341 Builder.defineMacro("__unix__");
342 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000343 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000344 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerb62bb282009-07-13 20:29:08 +0000345 }
346public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000347 NetBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
348 this->UserLabelPrefix = "";
349 }
Chris Lattnerb62bb282009-07-13 20:29:08 +0000350};
351
Torok Edwin5f6c1942009-06-30 17:10:35 +0000352// OpenBSD Target
353template<typename Target>
354class OpenBSDTargetInfo : public OSTargetInfo<Target> {
355protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000356 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000357 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000358 // OpenBSD defines; list based off of gcc output
359
Benjamin Kramera9992772010-01-09 17:55:51 +0000360 Builder.defineMacro("__OpenBSD__");
361 DefineStd(Builder, "unix", Opts);
362 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000363 if (Opts.POSIXThreads)
Chris Lattner4ddcf3b2012-04-25 06:12:24 +0000364 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000365 }
366public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000367 OpenBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
368 this->UserLabelPrefix = "";
369 this->TLSSupported = false;
Eli Friedman62d829a2011-12-15 02:15:56 +0000370
Eli Friedman62d829a2011-12-15 02:15:56 +0000371 switch (Triple.getArch()) {
372 default:
373 case llvm::Triple::x86:
374 case llvm::Triple::x86_64:
375 case llvm::Triple::arm:
Eric Christopher825d3862012-11-14 22:08:59 +0000376 case llvm::Triple::sparc:
Eli Friedman62d829a2011-12-15 02:15:56 +0000377 this->MCountName = "__mcount";
378 break;
379 case llvm::Triple::mips64:
380 case llvm::Triple::mips64el:
381 case llvm::Triple::ppc:
Eric Christopher825d3862012-11-14 22:08:59 +0000382 case llvm::Triple::sparcv9:
Eli Friedman62d829a2011-12-15 02:15:56 +0000383 this->MCountName = "_mcount";
384 break;
385 }
386 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000387};
388
Eli Friedman42f74f22012-08-08 23:57:20 +0000389// Bitrig Target
390template<typename Target>
391class BitrigTargetInfo : public OSTargetInfo<Target> {
392protected:
393 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
394 MacroBuilder &Builder) const {
395 // Bitrig defines; list based off of gcc output
396
397 Builder.defineMacro("__Bitrig__");
398 DefineStd(Builder, "unix", Opts);
399 Builder.defineMacro("__ELF__");
400 if (Opts.POSIXThreads)
401 Builder.defineMacro("_REENTRANT");
402 }
403public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000404 BitrigTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
405 this->UserLabelPrefix = "";
406 this->TLSSupported = false;
407 this->MCountName = "__mcount";
Eli Friedman42f74f22012-08-08 23:57:20 +0000408 }
409};
410
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000411// PSP Target
412template<typename Target>
413class PSPTargetInfo : public OSTargetInfo<Target> {
414protected:
415 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000416 MacroBuilder &Builder) const {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000417 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramera9992772010-01-09 17:55:51 +0000418 Builder.defineMacro("PSP");
419 Builder.defineMacro("_PSP");
420 Builder.defineMacro("__psp__");
421 Builder.defineMacro("__ELF__");
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000422 }
423public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000424 PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000425 this->UserLabelPrefix = "";
426 }
427};
428
John Thompson3f6918a2009-11-19 17:18:50 +0000429// PS3 PPU Target
430template<typename Target>
431class PS3PPUTargetInfo : public OSTargetInfo<Target> {
432protected:
433 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000434 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000435 // PS3 PPU defines.
John Thompsonfb457972010-03-25 16:18:32 +0000436 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000437 Builder.defineMacro("__PPU__");
438 Builder.defineMacro("__CELLOS_LV2__");
439 Builder.defineMacro("__ELF__");
440 Builder.defineMacro("__LP32__");
John Thompson8e6065a2010-06-24 22:44:13 +0000441 Builder.defineMacro("_ARCH_PPC64");
442 Builder.defineMacro("__powerpc64__");
John Thompson3f6918a2009-11-19 17:18:50 +0000443 }
444public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000445 PS3PPUTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
John Thompson3f6918a2009-11-19 17:18:50 +0000446 this->UserLabelPrefix = "";
Nick Lewycky99520702011-12-16 22:32:39 +0000447 this->LongWidth = this->LongAlign = 32;
448 this->PointerWidth = this->PointerAlign = 32;
John Thompson8e6065a2010-06-24 22:44:13 +0000449 this->IntMaxType = TargetInfo::SignedLongLong;
450 this->UIntMaxType = TargetInfo::UnsignedLongLong;
451 this->Int64Type = TargetInfo::SignedLongLong;
John Thompsonec387af2009-12-18 14:21:08 +0000452 this->SizeType = TargetInfo::UnsignedInt;
John Thompson8e6065a2010-06-24 22:44:13 +0000453 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 +0000454 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompson3f6918a2009-11-19 17:18:50 +0000455 }
456};
457
458// FIXME: Need a real SPU target.
459// PS3 SPU Target
460template<typename Target>
461class PS3SPUTargetInfo : public OSTargetInfo<Target> {
462protected:
463 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000464 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000465 // PS3 PPU defines.
Benjamin Kramera9992772010-01-09 17:55:51 +0000466 Builder.defineMacro("__SPU__");
467 Builder.defineMacro("__ELF__");
John Thompson3f6918a2009-11-19 17:18:50 +0000468 }
469public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000470 PS3SPUTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
John Thompson3f6918a2009-11-19 17:18:50 +0000471 this->UserLabelPrefix = "";
472 }
473};
474
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000475// AuroraUX target
476template<typename Target>
477class AuroraUXTargetInfo : public OSTargetInfo<Target> {
478protected:
479 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000480 MacroBuilder &Builder) const {
481 DefineStd(Builder, "sun", Opts);
482 DefineStd(Builder, "unix", Opts);
483 Builder.defineMacro("__ELF__");
484 Builder.defineMacro("__svr4__");
485 Builder.defineMacro("__SVR4");
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000486 }
487public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000488 AuroraUXTargetInfo(const llvm::Triple &Triple)
489 : OSTargetInfo<Target>(Triple) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000490 this->UserLabelPrefix = "";
491 this->WCharType = this->SignedLong;
492 // FIXME: WIntType should be SignedLong
493 }
494};
495
Torok Edwin5f6c1942009-06-30 17:10:35 +0000496// Solaris target
497template<typename Target>
498class SolarisTargetInfo : public OSTargetInfo<Target> {
499protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000500 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000501 MacroBuilder &Builder) const {
502 DefineStd(Builder, "sun", Opts);
503 DefineStd(Builder, "unix", Opts);
504 Builder.defineMacro("__ELF__");
505 Builder.defineMacro("__svr4__");
506 Builder.defineMacro("__SVR4");
David Chisnall165329c2012-02-28 17:10:04 +0000507 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
508 // newer, but to 500 for everything else. feature_test.h has a check to
509 // ensure that you are not using C99 with an old version of X/Open or C89
510 // with a new version.
511 if (Opts.C99 || Opts.C11)
512 Builder.defineMacro("_XOPEN_SOURCE", "600");
513 else
514 Builder.defineMacro("_XOPEN_SOURCE", "500");
David Chisnallb4f0bd62012-03-02 10:49:52 +0000515 if (Opts.CPlusPlus)
David Chisnall165329c2012-02-28 17:10:04 +0000516 Builder.defineMacro("__C99FEATURES__");
David Chisnall48fad492012-02-17 18:35:11 +0000517 Builder.defineMacro("_LARGEFILE_SOURCE");
518 Builder.defineMacro("_LARGEFILE64_SOURCE");
519 Builder.defineMacro("__EXTENSIONS__");
David Chisnall165329c2012-02-28 17:10:04 +0000520 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000521 }
522public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000523 SolarisTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000524 this->UserLabelPrefix = "";
David Chisnallfb027842012-03-28 18:04:14 +0000525 this->WCharType = this->SignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000526 // FIXME: WIntType should be SignedLong
527 }
528};
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000529
530// Windows target
531template<typename Target>
532class WindowsTargetInfo : public OSTargetInfo<Target> {
533protected:
534 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
535 MacroBuilder &Builder) const {
Michael J. Spencera764e832010-10-21 08:22:51 +0000536 Builder.defineMacro("_WIN32");
537 }
538 void getVisualStudioDefines(const LangOptions &Opts,
539 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000540 if (Opts.CPlusPlus) {
541 if (Opts.RTTI)
542 Builder.defineMacro("_CPPRTTI");
543
544 if (Opts.Exceptions)
545 Builder.defineMacro("_CPPUNWIND");
546 }
547
548 if (!Opts.CharIsSigned)
549 Builder.defineMacro("_CHAR_UNSIGNED");
550
551 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
552 // but it works for now.
553 if (Opts.POSIXThreads)
554 Builder.defineMacro("_MT");
Michael J. Spencera764e832010-10-21 08:22:51 +0000555
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000556 if (Opts.MSCVersion != 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000557 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000558
Francois Pichet62ec1f22011-09-17 17:15:52 +0000559 if (Opts.MicrosoftExt) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000560 Builder.defineMacro("_MSC_EXTENSIONS");
561
Richard Smith80ad52f2013-01-02 11:42:31 +0000562 if (Opts.CPlusPlus11) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000563 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
564 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
565 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
566 }
567 }
568
569 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000570 }
571
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000572public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000573 WindowsTargetInfo(const llvm::Triple &Triple)
574 : OSTargetInfo<Target>(Triple) {}
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000575};
576
Derek Schuff7da46f92012-10-11 16:55:58 +0000577template <typename Target>
578class NaClTargetInfo : public OSTargetInfo<Target> {
Benjamin Kramer9df08232013-06-29 16:37:14 +0000579protected:
Derek Schuff7da46f92012-10-11 16:55:58 +0000580 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
581 MacroBuilder &Builder) const {
582 if (Opts.POSIXThreads)
583 Builder.defineMacro("_REENTRANT");
584 if (Opts.CPlusPlus)
585 Builder.defineMacro("_GNU_SOURCE");
586
587 DefineStd(Builder, "unix", Opts);
588 Builder.defineMacro("__ELF__");
589 Builder.defineMacro("__native_client__");
590 }
Benjamin Kramer9df08232013-06-29 16:37:14 +0000591
592public:
593 NaClTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Derek Schuff7da46f92012-10-11 16:55:58 +0000594 this->UserLabelPrefix = "";
595 this->LongAlign = 32;
596 this->LongWidth = 32;
597 this->PointerAlign = 32;
598 this->PointerWidth = 32;
599 this->IntMaxType = TargetInfo::SignedLongLong;
600 this->UIntMaxType = TargetInfo::UnsignedLongLong;
601 this->Int64Type = TargetInfo::SignedLongLong;
602 this->DoubleAlign = 64;
603 this->LongDoubleWidth = 64;
604 this->LongDoubleAlign = 64;
605 this->SizeType = TargetInfo::UnsignedInt;
606 this->PtrDiffType = TargetInfo::SignedInt;
607 this->IntPtrType = TargetInfo::SignedInt;
Eli Benderskyc0783dc2013-04-08 21:31:01 +0000608 // RegParmMax is inherited from the underlying architecture
Derek Schuff7da46f92012-10-11 16:55:58 +0000609 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble;
610 this->DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
611 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
612 }
Derek Schuff263366f2012-10-16 22:30:41 +0000613 virtual typename Target::CallingConvCheckResult checkCallingConvention(
614 CallingConv CC) const {
615 return CC == CC_PnaclCall ? Target::CCCR_OK :
616 Target::checkCallingConvention(CC);
617 }
Derek Schuff7da46f92012-10-11 16:55:58 +0000618};
Mike Stump1eb44332009-09-09 15:08:12 +0000619} // end anonymous namespace.
Torok Edwin5f6c1942009-06-30 17:10:35 +0000620
Chris Lattnerd29b6302008-10-05 21:50:58 +0000621//===----------------------------------------------------------------------===//
Eli Friedmane4277982008-08-20 23:11:40 +0000622// Specific target implementations.
623//===----------------------------------------------------------------------===//
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +0000624
Eli Friedmane4277982008-08-20 23:11:40 +0000625namespace {
626// PPC abstract base class
627class PPCTargetInfo : public TargetInfo {
628 static const Builtin::Info BuiltinInfo[];
629 static const char * const GCCRegNames[];
630 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Hal Finkel02a84272012-06-11 22:35:19 +0000631 std::string CPU;
Eli Friedmane4277982008-08-20 23:11:40 +0000632public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000633 PPCTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Nico Weber6e1d2ea2012-01-31 02:07:33 +0000634 LongDoubleWidth = LongDoubleAlign = 128;
635 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
636 }
Eli Friedman15b91762009-06-05 07:05:05 +0000637
Hal Finkel39d5fa12012-07-03 16:51:04 +0000638 /// \brief Flags for architecture specific defines.
639 typedef enum {
640 ArchDefineNone = 0,
641 ArchDefineName = 1 << 0, // <name> is substituted for arch name.
642 ArchDefinePpcgr = 1 << 1,
643 ArchDefinePpcsq = 1 << 2,
644 ArchDefine440 = 1 << 3,
645 ArchDefine603 = 1 << 4,
646 ArchDefine604 = 1 << 5,
647 ArchDefinePwr4 = 1 << 6,
Bill Schmidt2821e182013-02-01 20:23:10 +0000648 ArchDefinePwr5 = 1 << 7,
649 ArchDefinePwr5x = 1 << 8,
650 ArchDefinePwr6 = 1 << 9,
651 ArchDefinePwr6x = 1 << 10,
652 ArchDefinePwr7 = 1 << 11,
653 ArchDefineA2 = 1 << 12,
654 ArchDefineA2q = 1 << 13
Hal Finkel39d5fa12012-07-03 16:51:04 +0000655 } ArchDefineTypes;
656
Bill Schmidt2821e182013-02-01 20:23:10 +0000657 // Note: GCC recognizes the following additional cpus:
658 // 401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801,
659 // 821, 823, 8540, 8548, e300c2, e300c3, e500mc64, e6500, 860, cell,
660 // titan, rs64.
Hal Finkel02a84272012-06-11 22:35:19 +0000661 virtual bool setCPU(const std::string &Name) {
662 bool CPUKnown = llvm::StringSwitch<bool>(Name)
663 .Case("generic", true)
664 .Case("440", true)
665 .Case("450", true)
666 .Case("601", true)
667 .Case("602", true)
668 .Case("603", true)
669 .Case("603e", true)
670 .Case("603ev", true)
671 .Case("604", true)
672 .Case("604e", true)
673 .Case("620", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000674 .Case("630", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000675 .Case("g3", true)
676 .Case("7400", true)
677 .Case("g4", true)
678 .Case("7450", true)
679 .Case("g4+", true)
680 .Case("750", true)
681 .Case("970", true)
682 .Case("g5", true)
683 .Case("a2", true)
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000684 .Case("a2q", true)
Hal Finkel7de32962012-09-18 22:25:03 +0000685 .Case("e500mc", true)
686 .Case("e5500", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000687 .Case("power3", true)
688 .Case("pwr3", true)
689 .Case("power4", true)
690 .Case("pwr4", true)
691 .Case("power5", true)
692 .Case("pwr5", true)
693 .Case("power5x", true)
694 .Case("pwr5x", true)
695 .Case("power6", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000696 .Case("pwr6", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000697 .Case("power6x", true)
698 .Case("pwr6x", true)
699 .Case("power7", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000700 .Case("pwr7", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000701 .Case("powerpc", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000702 .Case("ppc", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000703 .Case("powerpc64", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000704 .Case("ppc64", true)
705 .Default(false);
706
707 if (CPUKnown)
708 CPU = Name;
709
710 return CPUKnown;
711 }
712
Eli Friedmane4277982008-08-20 23:11:40 +0000713 virtual void getTargetBuiltins(const Builtin::Info *&Records,
714 unsigned &NumRecords) const {
Reid Spencer5f016e22007-07-11 17:01:13 +0000715 Records = BuiltinInfo;
Eli Friedmane4277982008-08-20 23:11:40 +0000716 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +0000717 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000718
Bob Wilson9f1c49c2012-01-28 18:02:29 +0000719 virtual bool isCLZForZeroUndef() const { return false; }
720
Chris Lattner33328642009-03-20 15:52:06 +0000721 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000722 MacroBuilder &Builder) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000723
Bill Schmidt199402b2013-02-01 02:14:03 +0000724 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
725
726 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
727 StringRef Name,
728 bool Enabled) const;
729
Douglas Gregore727d212012-01-30 06:38:25 +0000730 virtual bool hasFeature(StringRef Feature) const;
731
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000732 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000733 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000734 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000735 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000736 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +0000737 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000738 switch (*Name) {
Anders Carlssond04c6e22007-11-27 04:11:28 +0000739 default: return false;
740 case 'O': // Zero
John Thompson8e6065a2010-06-24 22:44:13 +0000741 break;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000742 case 'b': // Base register
743 case 'f': // Floating point register
Chris Lattner44def072009-04-26 07:16:29 +0000744 Info.setAllowsRegister();
John Thompson8e6065a2010-06-24 22:44:13 +0000745 break;
746 // FIXME: The following are added to allow parsing.
747 // I just took a guess at what the actions should be.
748 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer20249a12010-10-21 03:16:25 +0000749 case 'd': // Floating point register (containing 64-bit value)
John Thompson8e6065a2010-06-24 22:44:13 +0000750 case 'v': // Altivec vector register
751 Info.setAllowsRegister();
752 break;
753 case 'w':
754 switch (Name[1]) {
Michael J. Spencer20249a12010-10-21 03:16:25 +0000755 case 'd':// VSX vector register to hold vector double data
756 case 'f':// VSX vector register to hold vector float data
757 case 's':// VSX vector register to hold scalar float data
758 case 'a':// Any VSX register
John Thompson8e6065a2010-06-24 22:44:13 +0000759 break;
760 default:
761 return false;
762 }
763 Info.setAllowsRegister();
764 Name++; // Skip over 'w'.
765 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000766 case 'h': // `MQ', `CTR', or `LINK' register
767 case 'q': // `MQ' register
768 case 'c': // `CTR' register
769 case 'l': // `LINK' register
770 case 'x': // `CR' register (condition register) number 0
771 case 'y': // `CR' register (condition register)
772 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson8e6065a2010-06-24 22:44:13 +0000773 Info.setAllowsRegister();
774 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000775 case 'I': // Signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000776 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer20249a12010-10-21 03:16:25 +0000777 // (use `L' instead for SImode constants)
778 case 'K': // Unsigned 16-bit constant
779 case 'L': // Signed 16-bit constant shifted left 16 bits
780 case 'M': // Constant larger than 31
781 case 'N': // Exact power of 2
782 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000783 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000784 // register with one instruction per word
John Thompson8e6065a2010-06-24 22:44:13 +0000785 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer20249a12010-10-21 03:16:25 +0000786 // into a register using three instructions
John Thompson8e6065a2010-06-24 22:44:13 +0000787 break;
788 case 'm': // Memory operand. Note that on PowerPC targets, m can
789 // include addresses that update the base register. It
790 // is therefore only safe to use `m' in an asm statement
791 // if that asm statement accesses the operand exactly once.
792 // The asm statement must also use `%U<opno>' as a
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000793 // placeholder for the "update" flag in the corresponding
Michael J. Spencer20249a12010-10-21 03:16:25 +0000794 // load or store instruction. For example:
John Thompson8e6065a2010-06-24 22:44:13 +0000795 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000796 // is correct but:
John Thompson8e6065a2010-06-24 22:44:13 +0000797 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
798 // is not. Use es rather than m if you don't want the base
Michael J. Spencer20249a12010-10-21 03:16:25 +0000799 // register to be updated.
800 case 'e':
John Thompson56b6eca2010-06-25 00:02:05 +0000801 if (Name[1] != 's')
802 return false;
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000803 // es: A "stable" memory operand; that is, one which does not
John Thompson8e6065a2010-06-24 22:44:13 +0000804 // include any automodification of the base register. Unlike
805 // `m', this constraint can be used in asm statements that
806 // might access the operand several times, or that might not
John Thompson56b6eca2010-06-25 00:02:05 +0000807 // access it at all.
John Thompson8e6065a2010-06-24 22:44:13 +0000808 Info.setAllowsMemory();
John Thompson56b6eca2010-06-25 00:02:05 +0000809 Name++; // Skip over 'e'.
John Thompson8e6065a2010-06-24 22:44:13 +0000810 break;
811 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer20249a12010-10-21 03:16:25 +0000812 // usually better to use `m' or `es' in asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000813 case 'Z': // Memory operand that is an indexed or indirect from a
814 // register (it is usually better to use `m' or `es' in
Michael J. Spencer20249a12010-10-21 03:16:25 +0000815 // asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000816 Info.setAllowsMemory();
817 Info.setAllowsRegister();
818 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000819 case 'R': // AIX TOC entry
John Thompson8e6065a2010-06-24 22:44:13 +0000820 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000821 // register (`p' is preferable for asm statements)
822 case 'S': // Constant suitable as a 64-bit mask operand
823 case 'T': // Constant suitable as a 32-bit mask operand
824 case 'U': // System V Release 4 small data area reference
John Thompson8e6065a2010-06-24 22:44:13 +0000825 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000826 // instructions
827 case 'W': // Vector constant that does not require memory
828 case 'j': // Vector constant that is all zeros.
John Thompson8e6065a2010-06-24 22:44:13 +0000829 break;
830 // End FIXME.
Anders Carlssond04c6e22007-11-27 04:11:28 +0000831 }
John Thompson8e6065a2010-06-24 22:44:13 +0000832 return true;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000833 }
Eli Friedmane4277982008-08-20 23:11:40 +0000834 virtual const char *getClobbers() const {
835 return "";
Anders Carlssond04c6e22007-11-27 04:11:28 +0000836 }
Adhemerval Zanellab0fc94c2013-01-22 20:02:45 +0000837 int getEHDataRegisterNumber(unsigned RegNo) const {
838 if (RegNo == 0) return 3;
839 if (RegNo == 1) return 4;
840 return -1;
841 }
Eli Friedmane4277982008-08-20 23:11:40 +0000842};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000843
Eli Friedmane4277982008-08-20 23:11:40 +0000844const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000845#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000846#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000847 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000848#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000849};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000850
851
Chris Lattnerc0f59212009-03-02 22:27:17 +0000852/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
853/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000854void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000855 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000856 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000857 Builder.defineMacro("__ppc__");
Chandler Carruthc6fa1152013-06-25 11:13:47 +0000858 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000859 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000860 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000861 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000862 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000863 Builder.defineMacro("_ARCH_PPC64");
Chris Lattnere03ae302010-02-16 18:14:57 +0000864 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000865 Builder.defineMacro("__ppc64__");
Chandler Carruthc6fa1152013-06-25 11:13:47 +0000866 Builder.defineMacro("__PPC64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000867 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000868
Chris Lattnerc0f59212009-03-02 22:27:17 +0000869 // Target properties.
Hans Wennborg5e601dc2012-08-02 13:45:48 +0000870 if (getTriple().getOS() != llvm::Triple::NetBSD &&
871 getTriple().getOS() != llvm::Triple::OpenBSD)
Joerg Sonnenberger7cd1de52011-07-05 14:56:12 +0000872 Builder.defineMacro("_BIG_ENDIAN");
Benjamin Kramera9992772010-01-09 17:55:51 +0000873 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000874
Chris Lattnerc0f59212009-03-02 22:27:17 +0000875 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000876 Builder.defineMacro("__NATURAL_ALIGNMENT__");
877 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000878
Chris Lattnerc0f59212009-03-02 22:27:17 +0000879 // FIXME: Should be controlled by command line option.
Roman Divackyb2f6f472013-07-03 19:45:54 +0000880 if (LongDoubleWidth == 128)
881 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000882
John Thompson3f6918a2009-11-19 17:18:50 +0000883 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000884 Builder.defineMacro("__VEC__", "10206");
885 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000886 }
Hal Finkel02a84272012-06-11 22:35:19 +0000887
888 // CPU identification.
Hal Finkel39d5fa12012-07-03 16:51:04 +0000889 ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
890 .Case("440", ArchDefineName)
891 .Case("450", ArchDefineName | ArchDefine440)
892 .Case("601", ArchDefineName)
893 .Case("602", ArchDefineName | ArchDefinePpcgr)
894 .Case("603", ArchDefineName | ArchDefinePpcgr)
895 .Case("603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
896 .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
897 .Case("604", ArchDefineName | ArchDefinePpcgr)
898 .Case("604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
899 .Case("620", ArchDefineName | ArchDefinePpcgr)
Bill Schmidt2821e182013-02-01 20:23:10 +0000900 .Case("630", ArchDefineName | ArchDefinePpcgr)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000901 .Case("7400", ArchDefineName | ArchDefinePpcgr)
902 .Case("7450", ArchDefineName | ArchDefinePpcgr)
903 .Case("750", ArchDefineName | ArchDefinePpcgr)
904 .Case("970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
905 | ArchDefinePpcsq)
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000906 .Case("a2", ArchDefineA2)
907 .Case("a2q", ArchDefineName | ArchDefineA2 | ArchDefineA2q)
Bill Schmidt2821e182013-02-01 20:23:10 +0000908 .Case("pwr3", ArchDefinePpcgr)
909 .Case("pwr4", ArchDefineName | ArchDefinePpcgr | ArchDefinePpcsq)
910 .Case("pwr5", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
911 | ArchDefinePpcsq)
912 .Case("pwr5x", ArchDefineName | ArchDefinePwr5 | ArchDefinePwr4
913 | ArchDefinePpcgr | ArchDefinePpcsq)
914 .Case("pwr6", ArchDefineName | ArchDefinePwr5x | ArchDefinePwr5
915 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
916 .Case("pwr6x", ArchDefineName | ArchDefinePwr6 | ArchDefinePwr5x
917 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
918 | ArchDefinePpcsq)
919 .Case("pwr7", ArchDefineName | ArchDefinePwr6x | ArchDefinePwr6
920 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
921 | ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq)
922 .Case("power3", ArchDefinePpcgr)
923 .Case("power4", ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
924 .Case("power5", ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
925 | ArchDefinePpcsq)
926 .Case("power5x", ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
927 | ArchDefinePpcgr | ArchDefinePpcsq)
928 .Case("power6", ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
929 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
930 .Case("power6x", ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x
931 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
932 | ArchDefinePpcsq)
933 .Case("power7", ArchDefinePwr7 | ArchDefinePwr6x | ArchDefinePwr6
934 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
935 | ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000936 .Default(ArchDefineNone);
937
938 if (defs & ArchDefineName)
939 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
940 if (defs & ArchDefinePpcgr)
941 Builder.defineMacro("_ARCH_PPCGR");
942 if (defs & ArchDefinePpcsq)
943 Builder.defineMacro("_ARCH_PPCSQ");
944 if (defs & ArchDefine440)
Hal Finkel02a84272012-06-11 22:35:19 +0000945 Builder.defineMacro("_ARCH_440");
Hal Finkel39d5fa12012-07-03 16:51:04 +0000946 if (defs & ArchDefine603)
947 Builder.defineMacro("_ARCH_603");
948 if (defs & ArchDefine604)
949 Builder.defineMacro("_ARCH_604");
Bill Schmidt2821e182013-02-01 20:23:10 +0000950 if (defs & ArchDefinePwr4)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000951 Builder.defineMacro("_ARCH_PWR4");
Bill Schmidt2821e182013-02-01 20:23:10 +0000952 if (defs & ArchDefinePwr5)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000953 Builder.defineMacro("_ARCH_PWR5");
Bill Schmidt2821e182013-02-01 20:23:10 +0000954 if (defs & ArchDefinePwr5x)
955 Builder.defineMacro("_ARCH_PWR5X");
956 if (defs & ArchDefinePwr6)
Hal Finkel02a84272012-06-11 22:35:19 +0000957 Builder.defineMacro("_ARCH_PWR6");
Bill Schmidt2821e182013-02-01 20:23:10 +0000958 if (defs & ArchDefinePwr6x)
959 Builder.defineMacro("_ARCH_PWR6X");
960 if (defs & ArchDefinePwr7)
961 Builder.defineMacro("_ARCH_PWR7");
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000962 if (defs & ArchDefineA2)
963 Builder.defineMacro("_ARCH_A2");
964 if (defs & ArchDefineA2q) {
965 Builder.defineMacro("_ARCH_A2Q");
966 Builder.defineMacro("_ARCH_QP");
967 }
968
969 if (getTriple().getVendor() == llvm::Triple::BGQ) {
970 Builder.defineMacro("__bg__");
971 Builder.defineMacro("__THW_BLUEGENE__");
972 Builder.defineMacro("__bgq__");
973 Builder.defineMacro("__TOS_BGQ__");
974 }
Bill Schmidt2821e182013-02-01 20:23:10 +0000975
976 // FIXME: The following are not yet generated here by Clang, but are
977 // generated by GCC:
978 //
979 // _SOFT_FLOAT_
980 // __RECIP_PRECISION__
981 // __APPLE_ALTIVEC__
982 // __VSX__
983 // __RECIP__
984 // __RECIPF__
985 // __RSQRTE__
986 // __RSQRTEF__
987 // _SOFT_DOUBLE_
988 // __NO_LWSYNC__
989 // __HAVE_BSWAP__
990 // __LONGDOUBLE128
991 // __CMODEL_MEDIUM__
992 // __CMODEL_LARGE__
993 // _CALL_SYSV
994 // _CALL_DARWIN
995 // __NO_FPRS__
Bill Schmidt199402b2013-02-01 02:14:03 +0000996}
997
998void PPCTargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
999 Features["altivec"] = llvm::StringSwitch<bool>(CPU)
1000 .Case("7400", true)
1001 .Case("g4", true)
1002 .Case("7450", true)
1003 .Case("g4+", true)
1004 .Case("970", true)
1005 .Case("g5", true)
1006 .Case("pwr6", true)
1007 .Case("pwr7", true)
1008 .Case("ppc64", true)
1009 .Default(false);
Hal Finkel3c6aaeb2013-02-01 18:44:19 +00001010
1011 Features["qpx"] = (CPU == "a2q");
Bill Schmidt199402b2013-02-01 02:14:03 +00001012}
1013
1014bool PPCTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1015 StringRef Name,
1016 bool Enabled) const {
Hal Finkelfe6b2712013-03-30 13:47:44 +00001017 if (Name == "altivec" || Name == "fprnd" || Name == "mfocrf" ||
1018 Name == "popcntd" || Name == "qpx") {
Bill Schmidt199402b2013-02-01 02:14:03 +00001019 Features[Name] = Enabled;
1020 return true;
Hal Finkel02a84272012-06-11 22:35:19 +00001021 }
Bill Schmidt199402b2013-02-01 02:14:03 +00001022
1023 return false;
Chris Lattnerc0f59212009-03-02 22:27:17 +00001024}
1025
Douglas Gregore727d212012-01-30 06:38:25 +00001026bool PPCTargetInfo::hasFeature(StringRef Feature) const {
1027 return Feature == "powerpc";
1028}
Chris Lattner393ff042008-04-21 18:56:49 +00001029
Douglas Gregore727d212012-01-30 06:38:25 +00001030
Eli Friedmane4277982008-08-20 23:11:40 +00001031const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +00001032 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1033 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1034 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1035 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1036 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
1037 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
1038 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
1039 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +00001040 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +00001041 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +00001042 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +00001043 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1044 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
1045 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
1046 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +00001047 "vrsave", "vscr",
1048 "spe_acc", "spefscr",
1049 "sfp"
1050};
Reid Spencer5f016e22007-07-11 17:01:13 +00001051
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001052void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +00001053 unsigned &NumNames) const {
1054 Names = GCCRegNames;
1055 NumNames = llvm::array_lengthof(GCCRegNames);
1056}
Reid Spencer5f016e22007-07-11 17:01:13 +00001057
Eli Friedmane4277982008-08-20 23:11:40 +00001058const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
1059 // While some of these aliases do map to different registers
1060 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00001061 { { "0" }, "r0" },
1062 { { "1"}, "r1" },
1063 { { "2" }, "r2" },
1064 { { "3" }, "r3" },
1065 { { "4" }, "r4" },
1066 { { "5" }, "r5" },
1067 { { "6" }, "r6" },
1068 { { "7" }, "r7" },
1069 { { "8" }, "r8" },
1070 { { "9" }, "r9" },
1071 { { "10" }, "r10" },
1072 { { "11" }, "r11" },
1073 { { "12" }, "r12" },
1074 { { "13" }, "r13" },
1075 { { "14" }, "r14" },
1076 { { "15" }, "r15" },
1077 { { "16" }, "r16" },
1078 { { "17" }, "r17" },
1079 { { "18" }, "r18" },
1080 { { "19" }, "r19" },
1081 { { "20" }, "r20" },
1082 { { "21" }, "r21" },
1083 { { "22" }, "r22" },
1084 { { "23" }, "r23" },
1085 { { "24" }, "r24" },
1086 { { "25" }, "r25" },
1087 { { "26" }, "r26" },
1088 { { "27" }, "r27" },
1089 { { "28" }, "r28" },
1090 { { "29" }, "r29" },
1091 { { "30" }, "r30" },
1092 { { "31" }, "r31" },
1093 { { "fr0" }, "f0" },
1094 { { "fr1" }, "f1" },
1095 { { "fr2" }, "f2" },
1096 { { "fr3" }, "f3" },
1097 { { "fr4" }, "f4" },
1098 { { "fr5" }, "f5" },
1099 { { "fr6" }, "f6" },
1100 { { "fr7" }, "f7" },
1101 { { "fr8" }, "f8" },
1102 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +00001103 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00001104 { { "fr11" }, "f11" },
1105 { { "fr12" }, "f12" },
1106 { { "fr13" }, "f13" },
1107 { { "fr14" }, "f14" },
1108 { { "fr15" }, "f15" },
1109 { { "fr16" }, "f16" },
1110 { { "fr17" }, "f17" },
1111 { { "fr18" }, "f18" },
1112 { { "fr19" }, "f19" },
1113 { { "fr20" }, "f20" },
1114 { { "fr21" }, "f21" },
1115 { { "fr22" }, "f22" },
1116 { { "fr23" }, "f23" },
1117 { { "fr24" }, "f24" },
1118 { { "fr25" }, "f25" },
1119 { { "fr26" }, "f26" },
1120 { { "fr27" }, "f27" },
1121 { { "fr28" }, "f28" },
1122 { { "fr29" }, "f29" },
1123 { { "fr30" }, "f30" },
1124 { { "fr31" }, "f31" },
1125 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +00001126};
1127
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001128void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +00001129 unsigned &NumAliases) const {
1130 Aliases = GCCRegAliases;
1131 NumAliases = llvm::array_lengthof(GCCRegAliases);
1132}
1133} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00001134
1135namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001136class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001137public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001138 PPC32TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +00001139 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 +00001140 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +00001141
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001142 switch (getTriple().getOS()) {
Nico Weber6e1d2ea2012-01-31 02:07:33 +00001143 case llvm::Triple::Linux:
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001144 case llvm::Triple::FreeBSD:
1145 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001146 SizeType = UnsignedInt;
Hal Finkel178a9b82012-03-02 20:54:36 +00001147 PtrDiffType = SignedInt;
1148 IntPtrType = SignedInt;
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001149 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +00001150 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001151 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001152 }
Roman Divackye3d175d2012-03-13 16:53:54 +00001153
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001154 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1155 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001156 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001157 }
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001158
1159 // PPC32 supports atomics up to 4 bytes.
1160 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001161 }
1162
Meador Ingec5613b22012-06-16 03:34:49 +00001163 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001164 // This is the ELF definition, and is overridden by the Darwin sub-target
Meador Ingec5613b22012-06-16 03:34:49 +00001165 return TargetInfo::PowerABIBuiltinVaList;
Eli Friedmaned855cb2008-08-21 00:13:15 +00001166 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001167};
1168} // end anonymous namespace.
1169
1170namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001171class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001172public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001173 PPC64TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00001174 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00001175 IntMaxType = SignedLong;
1176 UIntMaxType = UnsignedLong;
1177 Int64Type = SignedLong;
Roman Divackye3d175d2012-03-13 16:53:54 +00001178
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001179 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1180 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001181 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001182 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Bill Schmidtb1baad62013-07-03 21:03:06 +00001183 "i64:64:64-f32:32:32-f64:64:64-"
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001184 "v128:128:128-n32:64";
1185 } else
1186 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1187 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
1188 "v128:128:128-n32:64";
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001189
1190 // PPC64 supports atomics up to 8 bytes.
1191 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Chris Lattnerf291b102008-05-09 06:17:04 +00001192 }
Meador Ingec5613b22012-06-16 03:34:49 +00001193 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1194 return TargetInfo::CharPtrBuiltinVaList;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001195 }
Eli Friedmane4277982008-08-20 23:11:40 +00001196};
1197} // end anonymous namespace.
1198
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001199
1200namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001201class DarwinPPC32TargetInfo :
1202 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001203public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001204 DarwinPPC32TargetInfo(const llvm::Triple &Triple)
1205 : DarwinTargetInfo<PPC32TargetInfo>(Triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001206 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001207 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
David Fangb5afadd2013-05-16 17:51:48 +00001208 PtrDiffType = SignedInt; // for http://llvm.org/bugs/show_bug.cgi?id=15726
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001209 LongLongAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001210 SuitableAlign = 128;
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001211 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1212 "i64:32:64-f32:32:32-f64:64:64-v128:128:128-n32";
Roman Divackyc81f2a22011-01-06 08:27:10 +00001213 }
Meador Ingec5613b22012-06-16 03:34:49 +00001214 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1215 return TargetInfo::CharPtrBuiltinVaList;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001216 }
1217};
1218
1219class DarwinPPC64TargetInfo :
1220 public DarwinTargetInfo<PPC64TargetInfo> {
1221public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001222 DarwinPPC64TargetInfo(const llvm::Triple &Triple)
1223 : DarwinTargetInfo<PPC64TargetInfo>(Triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001224 HasAlignMac68kSupport = true;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001225 SuitableAlign = 128;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001226 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1227 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001228 }
1229};
1230} // end anonymous namespace.
1231
Reid Spencer5f016e22007-07-11 17:01:13 +00001232namespace {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001233 static const unsigned NVPTXAddrSpaceMap[] = {
1234 1, // opencl_global
1235 3, // opencl_local
1236 4, // opencl_constant
1237 1, // cuda_device
1238 4, // cuda_constant
1239 3, // cuda_shared
1240 };
1241 class NVPTXTargetInfo : public TargetInfo {
1242 static const char * const GCCRegNames[];
Justin Holewinski2c585b92012-05-24 17:43:12 +00001243 static const Builtin::Info BuiltinInfo[];
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00001244 std::vector<StringRef> AvailableFeatures;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001245 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001246 NVPTXTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001247 BigEndian = false;
1248 TLSSupported = false;
1249 LongWidth = LongAlign = 64;
1250 AddrSpaceMap = &NVPTXAddrSpaceMap;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001251 // Define available target features
1252 // These must be defined in sorted order!
Justin Holewinski9903e942012-07-11 15:34:55 +00001253 NoAsmVariants = true;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001254 }
1255 virtual void getTargetDefines(const LangOptions &Opts,
1256 MacroBuilder &Builder) const {
1257 Builder.defineMacro("__PTX__");
Justin Holewinski2c585b92012-05-24 17:43:12 +00001258 Builder.defineMacro("__NVPTX__");
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001259 }
1260 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1261 unsigned &NumRecords) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001262 Records = BuiltinInfo;
1263 NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001264 }
1265 virtual bool hasFeature(StringRef Feature) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001266 return Feature == "ptx" || Feature == "nvptx";
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001267 }
1268
1269 virtual void getGCCRegNames(const char * const *&Names,
1270 unsigned &NumNames) const;
1271 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1272 unsigned &NumAliases) const {
1273 // No aliases.
1274 Aliases = 0;
1275 NumAliases = 0;
1276 }
1277 virtual bool validateAsmConstraint(const char *&Name,
Justin Holewinski0ac428e2013-06-21 18:51:24 +00001278 TargetInfo::ConstraintInfo &Info) const {
1279 switch (*Name) {
1280 default: return false;
1281 case 'c':
1282 case 'h':
1283 case 'r':
1284 case 'l':
1285 case 'f':
1286 case 'd':
1287 Info.setAllowsRegister();
1288 return true;
1289 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001290 }
1291 virtual const char *getClobbers() const {
1292 // FIXME: Is this really right?
1293 return "";
1294 }
Meador Ingec5613b22012-06-16 03:34:49 +00001295 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001296 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00001297 return TargetInfo::CharPtrBuiltinVaList;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001298 }
1299 virtual bool setCPU(const std::string &Name) {
Justin Holewinskiaffa3af2013-03-30 14:38:26 +00001300 bool Valid = llvm::StringSwitch<bool>(Name)
1301 .Case("sm_20", true)
1302 .Case("sm_21", true)
1303 .Case("sm_30", true)
1304 .Case("sm_35", true)
1305 .Default(false);
1306
1307 return Valid;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001308 }
Justin Holewinski2c585b92012-05-24 17:43:12 +00001309 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1310 StringRef Name,
1311 bool Enabled) const;
1312 };
1313
1314 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1315#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1316#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1317 ALL_LANGUAGES },
1318#include "clang/Basic/BuiltinsNVPTX.def"
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001319 };
1320
1321 const char * const NVPTXTargetInfo::GCCRegNames[] = {
1322 "r0"
1323 };
1324
1325 void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names,
1326 unsigned &NumNames) const {
1327 Names = GCCRegNames;
1328 NumNames = llvm::array_lengthof(GCCRegNames);
1329 }
1330
Justin Holewinski2c585b92012-05-24 17:43:12 +00001331 bool NVPTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1332 StringRef Name,
1333 bool Enabled) const {
1334 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
1335 Name)) {
1336 Features[Name] = Enabled;
1337 return true;
1338 } else {
1339 return false;
1340 }
1341 }
1342
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001343 class NVPTX32TargetInfo : public NVPTXTargetInfo {
1344 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001345 NVPTX32TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001346 PointerWidth = PointerAlign = 32;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001347 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001348 DescriptionString
1349 = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1350 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1351 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001352 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001353 };
1354
1355 class NVPTX64TargetInfo : public NVPTXTargetInfo {
1356 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001357 NVPTX64TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001358 PointerWidth = PointerAlign = 64;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001359 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001360 DescriptionString
1361 = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1362 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1363 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001364 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001365 };
1366}
1367
1368namespace {
Eli Friedman6505a292012-10-12 23:32:00 +00001369
1370static const unsigned R600AddrSpaceMap[] = {
1371 1, // opencl_global
1372 3, // opencl_local
1373 2, // opencl_constant
1374 1, // cuda_device
1375 2, // cuda_constant
1376 3 // cuda_shared
1377};
1378
Tom Stellardfd075912013-03-04 17:40:53 +00001379static const char *DescriptionStringR600 =
1380 "e"
1381 "-p:32:32:32"
1382 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32"
1383 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1384 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1385 "-n32:64";
1386
1387static const char *DescriptionStringR600DoubleOps =
1388 "e"
1389 "-p:32:32:32"
1390 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64"
1391 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1392 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1393 "-n32:64";
1394
1395static const char *DescriptionStringSI =
1396 "e"
1397 "-p:64:64:64"
1398 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64"
1399 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1400 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1401 "-n32:64";
1402
Eli Friedman6505a292012-10-12 23:32:00 +00001403class R600TargetInfo : public TargetInfo {
Tom Stellardfd075912013-03-04 17:40:53 +00001404 /// \brief The GPU profiles supported by the R600 target.
1405 enum GPUKind {
1406 GK_NONE,
1407 GK_R600,
1408 GK_R600_DOUBLE_OPS,
1409 GK_R700,
1410 GK_R700_DOUBLE_OPS,
1411 GK_EVERGREEN,
1412 GK_EVERGREEN_DOUBLE_OPS,
1413 GK_NORTHERN_ISLANDS,
1414 GK_CAYMAN,
1415 GK_SOUTHERN_ISLANDS
1416 } GPU;
1417
Eli Friedman6505a292012-10-12 23:32:00 +00001418public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001419 R600TargetInfo(const llvm::Triple &Triple)
1420 : TargetInfo(Triple), GPU(GK_R600) {
Tom Stellardfd075912013-03-04 17:40:53 +00001421 DescriptionString = DescriptionStringR600;
Eli Friedman6505a292012-10-12 23:32:00 +00001422 AddrSpaceMap = &R600AddrSpaceMap;
1423 }
1424
1425 virtual const char * getClobbers() const {
1426 return "";
1427 }
1428
1429 virtual void getGCCRegNames(const char * const *&Names,
1430 unsigned &numNames) const {
1431 Names = NULL;
1432 numNames = 0;
1433 }
1434
1435 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1436 unsigned &NumAliases) const {
1437 Aliases = NULL;
1438 NumAliases = 0;
1439 }
1440
1441 virtual bool validateAsmConstraint(const char *&Name,
1442 TargetInfo::ConstraintInfo &info) const {
1443 return true;
1444 }
1445
1446 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1447 unsigned &NumRecords) const {
1448 Records = NULL;
1449 NumRecords = 0;
1450 }
1451
1452
1453 virtual void getTargetDefines(const LangOptions &Opts,
1454 MacroBuilder &Builder) const {
1455 Builder.defineMacro("__R600__");
1456 }
1457
1458 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1459 return TargetInfo::CharPtrBuiltinVaList;
1460 }
1461
Tom Stellardfd075912013-03-04 17:40:53 +00001462 virtual bool setCPU(const std::string &Name) {
1463 GPU = llvm::StringSwitch<GPUKind>(Name)
1464 .Case("r600" , GK_R600)
1465 .Case("rv610", GK_R600)
1466 .Case("rv620", GK_R600)
1467 .Case("rv630", GK_R600)
1468 .Case("rv635", GK_R600)
1469 .Case("rs780", GK_R600)
1470 .Case("rs880", GK_R600)
1471 .Case("rv670", GK_R600_DOUBLE_OPS)
1472 .Case("rv710", GK_R700)
1473 .Case("rv730", GK_R700)
1474 .Case("rv740", GK_R700_DOUBLE_OPS)
1475 .Case("rv770", GK_R700_DOUBLE_OPS)
1476 .Case("palm", GK_EVERGREEN)
1477 .Case("cedar", GK_EVERGREEN)
1478 .Case("sumo", GK_EVERGREEN)
1479 .Case("sumo2", GK_EVERGREEN)
1480 .Case("redwood", GK_EVERGREEN)
1481 .Case("juniper", GK_EVERGREEN)
1482 .Case("hemlock", GK_EVERGREEN_DOUBLE_OPS)
1483 .Case("cypress", GK_EVERGREEN_DOUBLE_OPS)
1484 .Case("barts", GK_NORTHERN_ISLANDS)
1485 .Case("turks", GK_NORTHERN_ISLANDS)
1486 .Case("caicos", GK_NORTHERN_ISLANDS)
1487 .Case("cayman", GK_CAYMAN)
1488 .Case("aruba", GK_CAYMAN)
Tom Stellard3b848ec2013-04-01 20:56:49 +00001489 .Case("tahiti", GK_SOUTHERN_ISLANDS)
Tom Stellardfd075912013-03-04 17:40:53 +00001490 .Case("pitcairn", GK_SOUTHERN_ISLANDS)
1491 .Case("verde", GK_SOUTHERN_ISLANDS)
1492 .Case("oland", GK_SOUTHERN_ISLANDS)
1493 .Default(GK_NONE);
1494
1495 if (GPU == GK_NONE) {
1496 return false;
1497 }
1498
1499 // Set the correct data layout
1500 switch (GPU) {
1501 case GK_NONE:
1502 case GK_R600:
1503 case GK_R700:
1504 case GK_EVERGREEN:
1505 case GK_NORTHERN_ISLANDS:
1506 DescriptionString = DescriptionStringR600;
1507 break;
1508 case GK_R600_DOUBLE_OPS:
1509 case GK_R700_DOUBLE_OPS:
1510 case GK_EVERGREEN_DOUBLE_OPS:
1511 case GK_CAYMAN:
1512 DescriptionString = DescriptionStringR600DoubleOps;
1513 break;
1514 case GK_SOUTHERN_ISLANDS:
1515 DescriptionString = DescriptionStringSI;
1516 break;
1517 }
1518
1519 return true;
1520 }
Eli Friedman6505a292012-10-12 23:32:00 +00001521};
1522
1523} // end anonymous namespace
1524
1525namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001526// Namespace for x86 abstract base class
1527const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001528#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001529#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001530 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001531#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001532};
Eli Friedman61538a72008-05-20 14:21:01 +00001533
Nuno Lopes2550d702009-12-23 17:49:57 +00001534static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001535 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1536 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001537 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001538 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1539 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1540 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001541 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopherc5f9a012011-12-02 02:12:16 +00001542 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1543 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001544};
1545
Eric Christophercfd323d2011-06-21 00:05:20 +00001546const TargetInfo::AddlRegName AddlRegNames[] = {
1547 { { "al", "ah", "eax", "rax" }, 0 },
1548 { { "bl", "bh", "ebx", "rbx" }, 3 },
1549 { { "cl", "ch", "ecx", "rcx" }, 2 },
1550 { { "dl", "dh", "edx", "rdx" }, 1 },
1551 { { "esi", "rsi" }, 4 },
1552 { { "edi", "rdi" }, 5 },
1553 { { "esp", "rsp" }, 7 },
1554 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001555};
1556
1557// X86 target abstract base class; x86-32 and x86-64 are very close, so
1558// most of the implementation can be shared.
1559class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001560 enum X86SSEEnum {
Craig Topper05fe4b52012-01-09 09:19:09 +00001561 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2
Chris Lattner84f0ea82009-03-02 22:40:39 +00001562 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001563 enum MMX3DNowEnum {
1564 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1565 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001566
Eric Christophereea12d12010-04-02 23:50:19 +00001567 bool HasAES;
Craig Topper3c0bc152012-05-31 05:18:48 +00001568 bool HasPCLMUL;
Craig Topper31ceea02011-12-25 05:06:45 +00001569 bool HasLZCNT;
Benjamin Kramer84f30802012-07-07 09:39:18 +00001570 bool HasRDRND;
Craig Topper31ceea02011-12-25 05:06:45 +00001571 bool HasBMI;
1572 bool HasBMI2;
Craig Toppere14e08b2011-12-29 16:10:46 +00001573 bool HasPOPCNT;
Michael Liao463eb892012-11-10 05:17:46 +00001574 bool HasRTM;
Michael Liao72339a02013-03-26 17:52:08 +00001575 bool HasPRFCHW;
Michael Liao1bfc28c2013-03-29 05:17:55 +00001576 bool HasRDSEED;
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00001577 bool HasSSE4a;
Craig Topper6a511e12011-12-30 07:33:42 +00001578 bool HasFMA4;
Craig Topper2ae95072012-06-03 21:46:30 +00001579 bool HasFMA;
Craig Topperb6af69e2012-06-09 22:24:14 +00001580 bool HasXOP;
Manman Ren146e5a42012-10-11 00:59:55 +00001581 bool HasF16C;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001582
Chandler Carruth499d9722011-09-28 08:55:34 +00001583 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1584 ///
1585 /// Each enumeration represents a particular CPU supported by Clang. These
1586 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1587 enum CPUKind {
1588 CK_Generic,
1589
1590 /// \name i386
1591 /// i386-generation processors.
1592 //@{
1593 CK_i386,
1594 //@}
1595
1596 /// \name i486
1597 /// i486-generation processors.
1598 //@{
1599 CK_i486,
1600 CK_WinChipC6,
1601 CK_WinChip2,
1602 CK_C3,
1603 //@}
1604
1605 /// \name i586
1606 /// i586-generation processors, P5 microarchitecture based.
1607 //@{
1608 CK_i586,
1609 CK_Pentium,
1610 CK_PentiumMMX,
1611 //@}
1612
1613 /// \name i686
1614 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1615 //@{
1616 CK_i686,
1617 CK_PentiumPro,
1618 CK_Pentium2,
1619 CK_Pentium3,
1620 CK_Pentium3M,
1621 CK_PentiumM,
1622 CK_C3_2,
1623
1624 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1625 /// Clang however has some logic to suport this.
1626 // FIXME: Warn, deprecate, and potentially remove this.
1627 CK_Yonah,
1628 //@}
1629
1630 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001631 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001632 //@{
1633 CK_Pentium4,
1634 CK_Pentium4M,
1635 CK_Prescott,
1636 CK_Nocona,
1637 //@}
1638
1639 /// \name Core
1640 /// Core microarchitecture based processors.
1641 //@{
1642 CK_Core2,
1643
1644 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1645 /// codename which GCC no longer accepts as an option to -march, but Clang
1646 /// has some logic for recognizing it.
1647 // FIXME: Warn, deprecate, and potentially remove this.
1648 CK_Penryn,
1649 //@}
1650
1651 /// \name Atom
1652 /// Atom processors
1653 //@{
1654 CK_Atom,
1655 //@}
1656
1657 /// \name Nehalem
1658 /// Nehalem microarchitecture based processors.
1659 //@{
1660 CK_Corei7,
1661 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001662 CK_CoreAVXi,
Craig Topper2b03bb02011-12-17 19:55:21 +00001663 CK_CoreAVX2,
Chandler Carruth499d9722011-09-28 08:55:34 +00001664 //@}
1665
1666 /// \name K6
1667 /// K6 architecture processors.
1668 //@{
1669 CK_K6,
1670 CK_K6_2,
1671 CK_K6_3,
1672 //@}
1673
1674 /// \name K7
1675 /// K7 architecture processors.
1676 //@{
1677 CK_Athlon,
1678 CK_AthlonThunderbird,
1679 CK_Athlon4,
1680 CK_AthlonXP,
1681 CK_AthlonMP,
1682 //@}
1683
1684 /// \name K8
1685 /// K8 architecture processors.
1686 //@{
1687 CK_Athlon64,
1688 CK_Athlon64SSE3,
1689 CK_AthlonFX,
1690 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001691 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001692 CK_Opteron,
1693 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001694 CK_AMDFAM10,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001695 //@}
Chandler Carruth499d9722011-09-28 08:55:34 +00001696
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001697 /// \name Bobcat
1698 /// Bobcat architecture processors.
1699 //@{
1700 CK_BTVER1,
Benjamin Kramer63063f52013-05-03 10:47:15 +00001701 CK_BTVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001702 //@}
1703
1704 /// \name Bulldozer
1705 /// Bulldozer architecture processors.
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001706 //@{
1707 CK_BDVER1,
1708 CK_BDVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001709 //@}
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001710
Chandler Carruth499d9722011-09-28 08:55:34 +00001711 /// This specification is deprecated and will be removed in the future.
1712 /// Users should prefer \see CK_K8.
1713 // FIXME: Warn on this when the CPU is set to it.
1714 CK_x86_64,
1715 //@}
1716
1717 /// \name Geode
1718 /// Geode processors.
1719 //@{
1720 CK_Geode
1721 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001722 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001723
Eli Friedman618234a2008-08-20 02:34:37 +00001724public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001725 X86TargetInfo(const llvm::Triple &Triple)
1726 : TargetInfo(Triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
1727 HasAES(false), HasPCLMUL(false), HasLZCNT(false), HasRDRND(false),
1728 HasBMI(false), HasBMI2(false), HasPOPCNT(false), HasRTM(false),
1729 HasPRFCHW(false), HasRDSEED(false), HasSSE4a(false), HasFMA4(false),
1730 HasFMA(false), HasXOP(false), HasF16C(false), CPU(CK_Generic) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00001731 BigEndian = false;
Eli Friedman618234a2008-08-20 02:34:37 +00001732 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001733 }
Benjamin Kramerb4066692011-12-28 15:47:06 +00001734 virtual unsigned getFloatEvalMethod() const {
1735 // X87 evaluates with 80 bits "long double" precision.
1736 return SSELevel == NoSSE ? 2 : 0;
1737 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001738 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1739 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001740 Records = BuiltinInfo;
1741 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001742 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001743 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001744 unsigned &NumNames) const {
1745 Names = GCCRegNames;
1746 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001747 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001748 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001749 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001750 Aliases = 0;
1751 NumAliases = 0;
1752 }
1753 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
Eric Christopher825d3862012-11-14 22:08:59 +00001754 unsigned &NumNames) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001755 Names = AddlRegNames;
1756 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001757 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001758 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001759 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001760 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001761 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001762 return "~{dirflag},~{fpsr},~{flags}";
1763 }
Chris Lattner33328642009-03-20 15:52:06 +00001764 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001765 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001766 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001767 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001768 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001769 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Douglas Gregore727d212012-01-30 06:38:25 +00001770 virtual bool hasFeature(StringRef Feature) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001771 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001772 virtual const char* getABI() const {
Derek Schuffbabaf312012-10-11 15:52:22 +00001773 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001774 return "avx";
Derek Schuffbabaf312012-10-11 15:52:22 +00001775 else if (getTriple().getArch() == llvm::Triple::x86 &&
1776 MMX3DNowLevel == NoMMX3DNow)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001777 return "no-mmx";
1778 return "";
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001779 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001780 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001781 CPU = llvm::StringSwitch<CPUKind>(Name)
1782 .Case("i386", CK_i386)
1783 .Case("i486", CK_i486)
1784 .Case("winchip-c6", CK_WinChipC6)
1785 .Case("winchip2", CK_WinChip2)
1786 .Case("c3", CK_C3)
1787 .Case("i586", CK_i586)
1788 .Case("pentium", CK_Pentium)
1789 .Case("pentium-mmx", CK_PentiumMMX)
1790 .Case("i686", CK_i686)
1791 .Case("pentiumpro", CK_PentiumPro)
1792 .Case("pentium2", CK_Pentium2)
1793 .Case("pentium3", CK_Pentium3)
1794 .Case("pentium3m", CK_Pentium3M)
1795 .Case("pentium-m", CK_PentiumM)
1796 .Case("c3-2", CK_C3_2)
1797 .Case("yonah", CK_Yonah)
1798 .Case("pentium4", CK_Pentium4)
1799 .Case("pentium4m", CK_Pentium4M)
1800 .Case("prescott", CK_Prescott)
1801 .Case("nocona", CK_Nocona)
1802 .Case("core2", CK_Core2)
1803 .Case("penryn", CK_Penryn)
1804 .Case("atom", CK_Atom)
1805 .Case("corei7", CK_Corei7)
1806 .Case("corei7-avx", CK_Corei7AVX)
1807 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper2b03bb02011-12-17 19:55:21 +00001808 .Case("core-avx2", CK_CoreAVX2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001809 .Case("k6", CK_K6)
1810 .Case("k6-2", CK_K6_2)
1811 .Case("k6-3", CK_K6_3)
1812 .Case("athlon", CK_Athlon)
1813 .Case("athlon-tbird", CK_AthlonThunderbird)
1814 .Case("athlon-4", CK_Athlon4)
1815 .Case("athlon-xp", CK_AthlonXP)
1816 .Case("athlon-mp", CK_AthlonMP)
1817 .Case("athlon64", CK_Athlon64)
1818 .Case("athlon64-sse3", CK_Athlon64SSE3)
1819 .Case("athlon-fx", CK_AthlonFX)
1820 .Case("k8", CK_K8)
1821 .Case("k8-sse3", CK_K8SSE3)
1822 .Case("opteron", CK_Opteron)
1823 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001824 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001825 .Case("btver1", CK_BTVER1)
Benjamin Kramer63063f52013-05-03 10:47:15 +00001826 .Case("btver2", CK_BTVER2)
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001827 .Case("bdver1", CK_BDVER1)
1828 .Case("bdver2", CK_BDVER2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001829 .Case("x86-64", CK_x86_64)
1830 .Case("geode", CK_Geode)
1831 .Default(CK_Generic);
1832
Chandler Carruth26a39142011-09-28 09:45:08 +00001833 // Perform any per-CPU checks necessary to determine if this CPU is
1834 // acceptable.
1835 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1836 // invalid without explaining *why*.
1837 switch (CPU) {
1838 case CK_Generic:
1839 // No processor selected!
1840 return false;
1841
1842 case CK_i386:
1843 case CK_i486:
1844 case CK_WinChipC6:
1845 case CK_WinChip2:
1846 case CK_C3:
1847 case CK_i586:
1848 case CK_Pentium:
1849 case CK_PentiumMMX:
1850 case CK_i686:
1851 case CK_PentiumPro:
1852 case CK_Pentium2:
1853 case CK_Pentium3:
1854 case CK_Pentium3M:
1855 case CK_PentiumM:
1856 case CK_Yonah:
1857 case CK_C3_2:
1858 case CK_Pentium4:
1859 case CK_Pentium4M:
1860 case CK_Prescott:
1861 case CK_K6:
1862 case CK_K6_2:
1863 case CK_K6_3:
1864 case CK_Athlon:
1865 case CK_AthlonThunderbird:
1866 case CK_Athlon4:
1867 case CK_AthlonXP:
1868 case CK_AthlonMP:
1869 case CK_Geode:
1870 // Only accept certain architectures when compiling in 32-bit mode.
Derek Schuffbabaf312012-10-11 15:52:22 +00001871 if (getTriple().getArch() != llvm::Triple::x86)
Chandler Carruth26a39142011-09-28 09:45:08 +00001872 return false;
1873
1874 // Fallthrough
1875 case CK_Nocona:
1876 case CK_Core2:
1877 case CK_Penryn:
1878 case CK_Atom:
1879 case CK_Corei7:
1880 case CK_Corei7AVX:
1881 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001882 case CK_CoreAVX2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001883 case CK_Athlon64:
1884 case CK_Athlon64SSE3:
1885 case CK_AthlonFX:
1886 case CK_K8:
1887 case CK_K8SSE3:
1888 case CK_Opteron:
1889 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00001890 case CK_AMDFAM10:
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001891 case CK_BTVER1:
Benjamin Kramer63063f52013-05-03 10:47:15 +00001892 case CK_BTVER2:
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001893 case CK_BDVER1:
1894 case CK_BDVER2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001895 case CK_x86_64:
1896 return true;
1897 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001898 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001899 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00001900
1901 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
1902 // We accept all non-ARM calling conventions
1903 return (CC == CC_X86ThisCall ||
1904 CC == CC_X86FastCall ||
Peter Collingbourne7728cdd2013-02-23 00:06:18 +00001905 CC == CC_X86StdCall ||
1906 CC == CC_C ||
Guy Benyei38980082012-12-25 08:53:55 +00001907 CC == CC_X86Pascal ||
1908 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballman82bfa192012-10-02 14:26:08 +00001909 }
1910
Aaron Ballmanfff32482012-12-09 17:45:41 +00001911 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {
1912 return MT == CCMT_Member ? CC_X86ThisCall : CC_C;
Aaron Ballman82bfa192012-10-02 14:26:08 +00001913 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001914};
Chris Lattner3daed522009-03-02 22:20:04 +00001915
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001916void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001917 // FIXME: This should not be here.
1918 Features["3dnow"] = false;
1919 Features["3dnowa"] = false;
1920 Features["mmx"] = false;
1921 Features["sse"] = false;
1922 Features["sse2"] = false;
1923 Features["sse3"] = false;
1924 Features["ssse3"] = false;
1925 Features["sse41"] = false;
1926 Features["sse42"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001927 Features["sse4a"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001928 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00001929 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001930 Features["avx"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001931 Features["avx2"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001932 Features["lzcnt"] = false;
Benjamin Kramer84f30802012-07-07 09:39:18 +00001933 Features["rdrand"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001934 Features["bmi"] = false;
1935 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001936 Features["popcnt"] = false;
Michael Liao463eb892012-11-10 05:17:46 +00001937 Features["rtm"] = false;
Michael Liao72339a02013-03-26 17:52:08 +00001938 Features["prfchw"] = false;
Michael Liao1bfc28c2013-03-29 05:17:55 +00001939 Features["rdseed"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001940 Features["fma4"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00001941 Features["fma"] = false;
Craig Topperb6af69e2012-06-09 22:24:14 +00001942 Features["xop"] = false;
Manman Ren146e5a42012-10-11 00:59:55 +00001943 Features["f16c"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001944
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001945 // FIXME: This *really* should not be here.
1946
1947 // X86_64 always has SSE2.
Derek Schuffbabaf312012-10-11 15:52:22 +00001948 if (getTriple().getArch() == llvm::Triple::x86_64)
Eli Friedman612db2a2012-11-17 01:16:19 +00001949 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001950
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001951 switch (CPU) {
1952 case CK_Generic:
1953 case CK_i386:
1954 case CK_i486:
1955 case CK_i586:
1956 case CK_Pentium:
1957 case CK_i686:
1958 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001959 break;
1960 case CK_PentiumMMX:
1961 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001962 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001963 break;
1964 case CK_Pentium3:
1965 case CK_Pentium3M:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001966 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001967 break;
1968 case CK_PentiumM:
1969 case CK_Pentium4:
1970 case CK_Pentium4M:
1971 case CK_x86_64:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001972 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001973 break;
1974 case CK_Yonah:
1975 case CK_Prescott:
1976 case CK_Nocona:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001977 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001978 break;
1979 case CK_Core2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001980 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001981 break;
1982 case CK_Penryn:
Benjamin Kramerb3453a82012-01-04 14:36:57 +00001983 setFeatureEnabled(Features, "sse4.1", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001984 break;
1985 case CK_Atom:
Chandler Carruth49defe62011-09-28 10:36:46 +00001986 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001987 break;
1988 case CK_Corei7:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001989 setFeatureEnabled(Features, "sse4", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001990 break;
1991 case CK_Corei7AVX:
Benjamin Kramer84f30802012-07-07 09:39:18 +00001992 setFeatureEnabled(Features, "avx", true);
1993 setFeatureEnabled(Features, "aes", true);
1994 setFeatureEnabled(Features, "pclmul", true);
1995 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001996 case CK_CoreAVXi:
Craig Topperfd936302012-04-26 07:31:30 +00001997 setFeatureEnabled(Features, "avx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00001998 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00001999 setFeatureEnabled(Features, "pclmul", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00002000 setFeatureEnabled(Features, "rdrnd", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002001 setFeatureEnabled(Features, "f16c", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002002 break;
Craig Topper2b03bb02011-12-17 19:55:21 +00002003 case CK_CoreAVX2:
Craig Topperfd936302012-04-26 07:31:30 +00002004 setFeatureEnabled(Features, "avx2", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00002005 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00002006 setFeatureEnabled(Features, "pclmul", true);
Craig Topper31ceea02011-12-25 05:06:45 +00002007 setFeatureEnabled(Features, "lzcnt", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00002008 setFeatureEnabled(Features, "rdrnd", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002009 setFeatureEnabled(Features, "f16c", true);
Craig Topper31ceea02011-12-25 05:06:45 +00002010 setFeatureEnabled(Features, "bmi", true);
2011 setFeatureEnabled(Features, "bmi2", true);
Michael Liao463eb892012-11-10 05:17:46 +00002012 setFeatureEnabled(Features, "rtm", true);
Craig Topper2ae95072012-06-03 21:46:30 +00002013 setFeatureEnabled(Features, "fma", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00002014 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002015 case CK_K6:
2016 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002017 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002018 break;
2019 case CK_K6_2:
2020 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002021 case CK_WinChip2:
2022 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002023 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002024 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00002025 case CK_Athlon:
2026 case CK_AthlonThunderbird:
2027 case CK_Geode:
2028 setFeatureEnabled(Features, "3dnowa", true);
2029 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002030 case CK_Athlon4:
2031 case CK_AthlonXP:
2032 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002033 setFeatureEnabled(Features, "sse", true);
2034 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002035 break;
2036 case CK_K8:
2037 case CK_Opteron:
2038 case CK_Athlon64:
2039 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00002040 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002041 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002042 break;
2043 case CK_K8SSE3:
2044 case CK_OpteronSSE3:
2045 case CK_Athlon64SSE3:
Roman Divacky80b32b82011-10-30 13:47:56 +00002046 setFeatureEnabled(Features, "sse3", true);
2047 setFeatureEnabled(Features, "3dnowa", true);
2048 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002049 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00002050 setFeatureEnabled(Features, "sse3", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00002051 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00002052 setFeatureEnabled(Features, "3dnowa", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002053 setFeatureEnabled(Features, "lzcnt", true);
2054 setFeatureEnabled(Features, "popcnt", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002055 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002056 case CK_BTVER1:
2057 setFeatureEnabled(Features, "ssse3", true);
2058 setFeatureEnabled(Features, "sse4a", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002059 setFeatureEnabled(Features, "lzcnt", true);
2060 setFeatureEnabled(Features, "popcnt", true);
Craig Topper90ea0362012-05-30 05:54:54 +00002061 break;
Benjamin Kramer63063f52013-05-03 10:47:15 +00002062 case CK_BTVER2:
2063 setFeatureEnabled(Features, "avx", true);
2064 setFeatureEnabled(Features, "sse4a", true);
2065 setFeatureEnabled(Features, "lzcnt", true);
2066 setFeatureEnabled(Features, "aes", true);
2067 setFeatureEnabled(Features, "pclmul", true);
2068 setFeatureEnabled(Features, "bmi", true);
2069 setFeatureEnabled(Features, "f16c", true);
2070 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002071 case CK_BDVER1:
Craig Topperb6af69e2012-06-09 22:24:14 +00002072 setFeatureEnabled(Features, "xop", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002073 setFeatureEnabled(Features, "lzcnt", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002074 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00002075 setFeatureEnabled(Features, "pclmul", true);
Eli Friedmanf5824992012-11-26 21:57:28 +00002076 break;
Eli Friedmanfaf35382012-11-17 01:43:10 +00002077 case CK_BDVER2:
2078 setFeatureEnabled(Features, "xop", true);
2079 setFeatureEnabled(Features, "lzcnt", true);
2080 setFeatureEnabled(Features, "aes", true);
2081 setFeatureEnabled(Features, "pclmul", true);
2082 setFeatureEnabled(Features, "bmi", true);
2083 setFeatureEnabled(Features, "fma", true);
2084 setFeatureEnabled(Features, "f16c", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002085 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002086 case CK_C3_2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002087 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002088 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002089 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002090}
2091
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002092bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00002093 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002094 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00002095 // FIXME: This *really* should not be here. We need some way of translating
2096 // options into llvm subtarget features.
2097 if (!Features.count(Name) &&
Benjamin Kramer84f30802012-07-07 09:39:18 +00002098 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1" &&
2099 Name != "rdrnd"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002100 return false;
2101
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002102 // FIXME: this should probably use a switch with fall through.
2103
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002104 if (Enabled) {
2105 if (Name == "mmx")
2106 Features["mmx"] = true;
2107 else if (Name == "sse")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002108 Features["mmx"] = Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002109 else if (Name == "sse2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002110 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002111 else if (Name == "sse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002112 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2113 true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002114 else if (Name == "ssse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002115 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002116 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00002117 else if (Name == "sse4" || Name == "sse4.2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002118 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002119 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2120 Features["popcnt"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00002121 else if (Name == "sse4.1")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002122 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00002123 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002124 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002125 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002126 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002127 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00002128 else if (Name == "aes")
Craig Toppera7463c32012-06-03 21:56:22 +00002129 Features["sse"] = Features["sse2"] = Features["aes"] = true;
Craig Topper3c0bc152012-05-31 05:18:48 +00002130 else if (Name == "pclmul")
Craig Toppera7463c32012-06-03 21:56:22 +00002131 Features["sse"] = Features["sse2"] = Features["pclmul"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002132 else if (Name == "avx")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002133 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2134 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002135 Features["popcnt"] = Features["avx"] = true;
Craig Topper2b03bb02011-12-17 19:55:21 +00002136 else if (Name == "avx2")
2137 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2138 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002139 Features["popcnt"] = Features["avx"] = Features["avx2"] = true;
Craig Topper2ae95072012-06-03 21:46:30 +00002140 else if (Name == "fma")
2141 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2142 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2143 Features["popcnt"] = Features["avx"] = Features["fma"] = true;
Craig Topper6a511e12011-12-30 07:33:42 +00002144 else if (Name == "fma4")
Eli Friedman612db2a2012-11-17 01:16:19 +00002145 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00002146 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper90ea0362012-05-30 05:54:54 +00002147 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
2148 Features["fma4"] = true;
Craig Topperb6af69e2012-06-09 22:24:14 +00002149 else if (Name == "xop")
Eli Friedman612db2a2012-11-17 01:16:19 +00002150 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002151 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2152 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
2153 Features["fma4"] = Features["xop"] = true;
Roman Divacky80b32b82011-10-30 13:47:56 +00002154 else if (Name == "sse4a")
Craig Topper6a511e12011-12-30 07:33:42 +00002155 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper90ea0362012-05-30 05:54:54 +00002156 Features["sse4a"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00002157 else if (Name == "lzcnt")
2158 Features["lzcnt"] = true;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002159 else if (Name == "rdrnd")
2160 Features["rdrand"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00002161 else if (Name == "bmi")
2162 Features["bmi"] = true;
2163 else if (Name == "bmi2")
2164 Features["bmi2"] = true;
Craig Toppere14e08b2011-12-29 16:10:46 +00002165 else if (Name == "popcnt")
2166 Features["popcnt"] = true;
Manman Ren146e5a42012-10-11 00:59:55 +00002167 else if (Name == "f16c")
2168 Features["f16c"] = true;
Michael Liao463eb892012-11-10 05:17:46 +00002169 else if (Name == "rtm")
2170 Features["rtm"] = true;
Michael Liao72339a02013-03-26 17:52:08 +00002171 else if (Name == "prfchw")
2172 Features["prfchw"] = true;
Michael Liao1bfc28c2013-03-29 05:17:55 +00002173 else if (Name == "rdseed")
2174 Features["rdseed"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002175 } else {
2176 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002177 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002178 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00002179 Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00002180 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002181 Features["sse4a"] = Features["avx"] = Features["avx2"] =
2182 Features["fma"] = Features["fma4"] = Features["aes"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002183 Features["pclmul"] = Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002184 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00002185 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Craig Toppera7463c32012-06-03 21:56:22 +00002186 Features["sse41"] = Features["sse42"] = Features["sse4a"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002187 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002188 Features["fma4"] = Features["aes"] = Features["pclmul"] =
2189 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002190 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00002191 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002192 Features["sse42"] = Features["sse4a"] = Features["avx"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002193 Features["avx2"] = Features["fma"] = Features["fma4"] =
2194 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002195 else if (Name == "ssse3")
Craig Topper31380fb2012-06-03 22:23:42 +00002196 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2197 Features["avx"] = Features["avx2"] = Features["fma"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00002198 else if (Name == "sse4" || Name == "sse4.1")
Craig Topper31380fb2012-06-03 22:23:42 +00002199 Features["sse41"] = Features["sse42"] = Features["avx"] =
2200 Features["avx2"] = Features["fma"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00002201 else if (Name == "sse4.2")
Craig Topper31380fb2012-06-03 22:23:42 +00002202 Features["sse42"] = Features["avx"] = Features["avx2"] =
2203 Features["fma"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002204 else if (Name == "3dnow")
2205 Features["3dnow"] = Features["3dnowa"] = false;
2206 else if (Name == "3dnowa")
2207 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00002208 else if (Name == "aes")
2209 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00002210 else if (Name == "pclmul")
2211 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002212 else if (Name == "avx")
Craig Topper2ae95072012-06-03 21:46:30 +00002213 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002214 Features["fma4"] = Features["xop"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00002215 else if (Name == "avx2")
2216 Features["avx2"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00002217 else if (Name == "fma")
2218 Features["fma"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00002219 else if (Name == "sse4a")
Craig Topperb6af69e2012-06-09 22:24:14 +00002220 Features["sse4a"] = Features["fma4"] = Features["xop"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002221 else if (Name == "lzcnt")
2222 Features["lzcnt"] = false;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002223 else if (Name == "rdrnd")
2224 Features["rdrand"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002225 else if (Name == "bmi")
2226 Features["bmi"] = false;
2227 else if (Name == "bmi2")
2228 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00002229 else if (Name == "popcnt")
2230 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00002231 else if (Name == "fma4")
Craig Topperb6af69e2012-06-09 22:24:14 +00002232 Features["fma4"] = Features["xop"] = false;
2233 else if (Name == "xop")
2234 Features["xop"] = false;
Manman Ren146e5a42012-10-11 00:59:55 +00002235 else if (Name == "f16c")
2236 Features["f16c"] = false;
Michael Liao463eb892012-11-10 05:17:46 +00002237 else if (Name == "rtm")
2238 Features["rtm"] = false;
Michael Liao72339a02013-03-26 17:52:08 +00002239 else if (Name == "prfchw")
2240 Features["prfchw"] = false;
Michael Liao1bfc28c2013-03-29 05:17:55 +00002241 else if (Name == "rdseed")
2242 Features["rdseed"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002243 }
2244
2245 return true;
2246}
2247
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002248/// HandleTargetOptions - Perform initialization based on the user
2249/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00002250void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002251 // Remember the maximum enabled sselevel.
2252 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
2253 // Ignore disabled features.
2254 if (Features[i][0] == '-')
2255 continue;
2256
Benjamin Kramer713575a2012-03-05 15:10:44 +00002257 StringRef Feature = StringRef(Features[i]).substr(1);
2258
2259 if (Feature == "aes") {
Eric Christophereea12d12010-04-02 23:50:19 +00002260 HasAES = true;
2261 continue;
2262 }
2263
Craig Topper3c0bc152012-05-31 05:18:48 +00002264 if (Feature == "pclmul") {
2265 HasPCLMUL = true;
2266 continue;
2267 }
2268
Benjamin Kramer713575a2012-03-05 15:10:44 +00002269 if (Feature == "lzcnt") {
Craig Topper31ceea02011-12-25 05:06:45 +00002270 HasLZCNT = true;
2271 continue;
2272 }
2273
Benjamin Kramer84f30802012-07-07 09:39:18 +00002274 if (Feature == "rdrand") {
2275 HasRDRND = true;
2276 continue;
2277 }
2278
Benjamin Kramer713575a2012-03-05 15:10:44 +00002279 if (Feature == "bmi") {
Craig Topper31ceea02011-12-25 05:06:45 +00002280 HasBMI = true;
2281 continue;
2282 }
2283
Benjamin Kramer713575a2012-03-05 15:10:44 +00002284 if (Feature == "bmi2") {
Craig Topper31ceea02011-12-25 05:06:45 +00002285 HasBMI2 = true;
2286 continue;
2287 }
2288
Benjamin Kramer713575a2012-03-05 15:10:44 +00002289 if (Feature == "popcnt") {
Craig Toppere14e08b2011-12-29 16:10:46 +00002290 HasPOPCNT = true;
2291 continue;
2292 }
2293
Michael Liao463eb892012-11-10 05:17:46 +00002294 if (Feature == "rtm") {
2295 HasRTM = true;
2296 continue;
2297 }
2298
Michael Liao72339a02013-03-26 17:52:08 +00002299 if (Feature == "prfchw") {
2300 HasPRFCHW = true;
2301 continue;
2302 }
2303
Michael Liao1bfc28c2013-03-29 05:17:55 +00002304 if (Feature == "rdseed") {
2305 HasRDSEED = true;
2306 continue;
2307 }
2308
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002309 if (Feature == "sse4a") {
2310 HasSSE4a = true;
2311 continue;
2312 }
2313
Benjamin Kramer713575a2012-03-05 15:10:44 +00002314 if (Feature == "fma4") {
Craig Topper6a511e12011-12-30 07:33:42 +00002315 HasFMA4 = true;
2316 continue;
2317 }
2318
Craig Topper2ae95072012-06-03 21:46:30 +00002319 if (Feature == "fma") {
2320 HasFMA = true;
2321 continue;
2322 }
2323
Craig Topperb6af69e2012-06-09 22:24:14 +00002324 if (Feature == "xop") {
2325 HasXOP = true;
2326 continue;
2327 }
2328
Manman Ren146e5a42012-10-11 00:59:55 +00002329 if (Feature == "f16c") {
2330 HasF16C = true;
2331 continue;
2332 }
2333
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002334 assert(Features[i][0] == '+' && "Invalid target feature!");
Benjamin Kramer713575a2012-03-05 15:10:44 +00002335 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Craig Topper05fe4b52012-01-09 09:19:09 +00002336 .Case("avx2", AVX2)
2337 .Case("avx", AVX)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002338 .Case("sse42", SSE42)
2339 .Case("sse41", SSE41)
2340 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00002341 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002342 .Case("sse2", SSE2)
2343 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002344 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002345 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002346
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002347 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer713575a2012-03-05 15:10:44 +00002348 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002349 .Case("3dnowa", AMD3DNowAthlon)
2350 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002351 .Case("mmx", MMX)
2352 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002353
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002354 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002355 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002356
2357 // Don't tell the backend if we're turning off mmx; it will end up disabling
2358 // SSE, which we don't want.
2359 std::vector<std::string>::iterator it;
2360 it = std::find(Features.begin(), Features.end(), "-mmx");
2361 if (it != Features.end())
2362 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00002363}
Chris Lattnerc0f59212009-03-02 22:27:17 +00002364
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002365/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
2366/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00002367void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002368 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002369 // Target identification.
Derek Schuffbabaf312012-10-11 15:52:22 +00002370 if (getTriple().getArch() == llvm::Triple::x86_64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002371 Builder.defineMacro("__amd64__");
2372 Builder.defineMacro("__amd64");
2373 Builder.defineMacro("__x86_64");
2374 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002375 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00002376 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00002377 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002378
Chris Lattnerc0f59212009-03-02 22:27:17 +00002379 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002380 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
2381 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002382 switch (CPU) {
2383 case CK_Generic:
2384 break;
2385 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002386 // The rest are coming from the i386 define above.
2387 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002388 break;
2389 case CK_i486:
2390 case CK_WinChipC6:
2391 case CK_WinChip2:
2392 case CK_C3:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002393 defineCPUMacros(Builder, "i486");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002394 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00002395 case CK_PentiumMMX:
2396 Builder.defineMacro("__pentium_mmx__");
2397 Builder.defineMacro("__tune_pentium_mmx__");
2398 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002399 case CK_i586:
2400 case CK_Pentium:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002401 defineCPUMacros(Builder, "i586");
2402 defineCPUMacros(Builder, "pentium");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002403 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002404 case CK_Pentium3:
2405 case CK_Pentium3M:
2406 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002407 Builder.defineMacro("__tune_pentium3__");
2408 // Fallthrough
2409 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002410 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002411 Builder.defineMacro("__tune_pentium2__");
2412 // Fallthrough
2413 case CK_PentiumPro:
2414 Builder.defineMacro("__tune_i686__");
2415 Builder.defineMacro("__tune_pentiumpro__");
2416 // Fallthrough
2417 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002418 Builder.defineMacro("__i686");
2419 Builder.defineMacro("__i686__");
2420 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
2421 Builder.defineMacro("__pentiumpro");
2422 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002423 break;
2424 case CK_Pentium4:
2425 case CK_Pentium4M:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002426 defineCPUMacros(Builder, "pentium4");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002427 break;
2428 case CK_Yonah:
2429 case CK_Prescott:
2430 case CK_Nocona:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002431 defineCPUMacros(Builder, "nocona");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002432 break;
2433 case CK_Core2:
2434 case CK_Penryn:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002435 defineCPUMacros(Builder, "core2");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002436 break;
2437 case CK_Atom:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002438 defineCPUMacros(Builder, "atom");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002439 break;
2440 case CK_Corei7:
2441 case CK_Corei7AVX:
2442 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00002443 case CK_CoreAVX2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002444 defineCPUMacros(Builder, "corei7");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002445 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002446 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002447 Builder.defineMacro("__k6_2__");
2448 Builder.defineMacro("__tune_k6_2__");
2449 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002450 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002451 if (CPU != CK_K6_2) { // In case of fallthrough
2452 // FIXME: GCC may be enabling these in cases where some other k6
2453 // architecture is specified but -m3dnow is explicitly provided. The
2454 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002455 Builder.defineMacro("__k6_3__");
2456 Builder.defineMacro("__tune_k6_3__");
2457 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00002458 // Fallthrough
2459 case CK_K6:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002460 defineCPUMacros(Builder, "k6");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002461 break;
2462 case CK_Athlon:
2463 case CK_AthlonThunderbird:
2464 case CK_Athlon4:
2465 case CK_AthlonXP:
2466 case CK_AthlonMP:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002467 defineCPUMacros(Builder, "athlon");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002468 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002469 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002470 Builder.defineMacro("__tune_athlon_sse__");
2471 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002472 break;
2473 case CK_K8:
2474 case CK_K8SSE3:
2475 case CK_x86_64:
2476 case CK_Opteron:
2477 case CK_OpteronSSE3:
2478 case CK_Athlon64:
2479 case CK_Athlon64SSE3:
2480 case CK_AthlonFX:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002481 defineCPUMacros(Builder, "k8");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002482 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002483 case CK_AMDFAM10:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002484 defineCPUMacros(Builder, "amdfam10");
Roman Divacky01c770d2011-10-30 07:48:46 +00002485 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002486 case CK_BTVER1:
2487 defineCPUMacros(Builder, "btver1");
2488 break;
Benjamin Kramer63063f52013-05-03 10:47:15 +00002489 case CK_BTVER2:
2490 defineCPUMacros(Builder, "btver2");
2491 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002492 case CK_BDVER1:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002493 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002494 break;
2495 case CK_BDVER2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002496 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002497 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002498 case CK_Geode:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002499 defineCPUMacros(Builder, "geode");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002500 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002501 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00002502
Chandler Carruth88c75b02011-09-28 09:54:07 +00002503 // Target properties.
2504 Builder.defineMacro("__LITTLE_ENDIAN__");
2505 Builder.defineMacro("__REGISTER_PREFIX__", "");
2506
Chris Lattner54175442009-04-19 17:32:33 +00002507 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2508 // functions in glibc header files that use FP Stack inline asm which the
2509 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00002510 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002511
Chandler Carruth88c75b02011-09-28 09:54:07 +00002512 if (HasAES)
2513 Builder.defineMacro("__AES__");
2514
Craig Topper3c0bc152012-05-31 05:18:48 +00002515 if (HasPCLMUL)
2516 Builder.defineMacro("__PCLMUL__");
2517
Craig Topper31ceea02011-12-25 05:06:45 +00002518 if (HasLZCNT)
2519 Builder.defineMacro("__LZCNT__");
2520
Benjamin Kramer84f30802012-07-07 09:39:18 +00002521 if (HasRDRND)
2522 Builder.defineMacro("__RDRND__");
2523
Craig Topper31ceea02011-12-25 05:06:45 +00002524 if (HasBMI)
2525 Builder.defineMacro("__BMI__");
2526
2527 if (HasBMI2)
2528 Builder.defineMacro("__BMI2__");
2529
Craig Toppere14e08b2011-12-29 16:10:46 +00002530 if (HasPOPCNT)
2531 Builder.defineMacro("__POPCNT__");
2532
Michael Liao463eb892012-11-10 05:17:46 +00002533 if (HasRTM)
2534 Builder.defineMacro("__RTM__");
2535
Michael Liao72339a02013-03-26 17:52:08 +00002536 if (HasPRFCHW)
2537 Builder.defineMacro("__PRFCHW__");
2538
Michael Liao1bfc28c2013-03-29 05:17:55 +00002539 if (HasRDSEED)
2540 Builder.defineMacro("__RDSEED__");
2541
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002542 if (HasSSE4a)
2543 Builder.defineMacro("__SSE4A__");
2544
Craig Topper6a511e12011-12-30 07:33:42 +00002545 if (HasFMA4)
2546 Builder.defineMacro("__FMA4__");
2547
Craig Topper2ae95072012-06-03 21:46:30 +00002548 if (HasFMA)
2549 Builder.defineMacro("__FMA__");
2550
Craig Topperb6af69e2012-06-09 22:24:14 +00002551 if (HasXOP)
2552 Builder.defineMacro("__XOP__");
2553
Manman Ren146e5a42012-10-11 00:59:55 +00002554 if (HasF16C)
2555 Builder.defineMacro("__F16C__");
2556
Chris Lattner84f0ea82009-03-02 22:40:39 +00002557 // Each case falls through to the previous one here.
2558 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002559 case AVX2:
2560 Builder.defineMacro("__AVX2__");
2561 case AVX:
2562 Builder.defineMacro("__AVX__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002563 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00002564 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002565 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00002566 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002567 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002568 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002569 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002570 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002571 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00002572 Builder.defineMacro("__SSE2__");
2573 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00002574 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00002575 Builder.defineMacro("__SSE__");
2576 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002577 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00002578 break;
2579 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002580
Derek Schuffbabaf312012-10-11 15:52:22 +00002581 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002582 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002583 case AVX2:
2584 case AVX:
Michael J. Spencera764e832010-10-21 08:22:51 +00002585 case SSE42:
2586 case SSE41:
2587 case SSSE3:
2588 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002589 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002590 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002591 break;
2592 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002593 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002594 break;
2595 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002596 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002597 }
2598 }
2599
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002600 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002601 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002602 case AMD3DNowAthlon:
2603 Builder.defineMacro("__3dNOW_A__");
2604 case AMD3DNow:
2605 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002606 case MMX:
2607 Builder.defineMacro("__MMX__");
2608 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002609 break;
2610 }
Michael J. Spencerd1b33942013-04-04 23:53:43 +00002611
2612 if (CPU >= CK_i486) {
2613 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
2614 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
2615 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
2616 }
2617 if (CPU >= CK_i586)
2618 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002619}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002620
Douglas Gregore727d212012-01-30 06:38:25 +00002621bool X86TargetInfo::hasFeature(StringRef Feature) const {
2622 return llvm::StringSwitch<bool>(Feature)
2623 .Case("aes", HasAES)
2624 .Case("avx", SSELevel >= AVX)
2625 .Case("avx2", SSELevel >= AVX2)
2626 .Case("bmi", HasBMI)
2627 .Case("bmi2", HasBMI2)
Craig Topper2ae95072012-06-03 21:46:30 +00002628 .Case("fma", HasFMA)
Douglas Gregore727d212012-01-30 06:38:25 +00002629 .Case("fma4", HasFMA4)
2630 .Case("lzcnt", HasLZCNT)
Benjamin Kramer84f30802012-07-07 09:39:18 +00002631 .Case("rdrnd", HasRDRND)
Douglas Gregore727d212012-01-30 06:38:25 +00002632 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
2633 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
2634 .Case("mmx", MMX3DNowLevel >= MMX)
Craig Topper3c0bc152012-05-31 05:18:48 +00002635 .Case("pclmul", HasPCLMUL)
Douglas Gregore727d212012-01-30 06:38:25 +00002636 .Case("popcnt", HasPOPCNT)
Michael Liao463eb892012-11-10 05:17:46 +00002637 .Case("rtm", HasRTM)
Michael Liao72339a02013-03-26 17:52:08 +00002638 .Case("prfchw", HasPRFCHW)
Michael Liao1bfc28c2013-03-29 05:17:55 +00002639 .Case("rdseed", HasRDSEED)
Douglas Gregore727d212012-01-30 06:38:25 +00002640 .Case("sse", SSELevel >= SSE1)
2641 .Case("sse2", SSELevel >= SSE2)
2642 .Case("sse3", SSELevel >= SSE3)
2643 .Case("ssse3", SSELevel >= SSSE3)
2644 .Case("sse41", SSELevel >= SSE41)
2645 .Case("sse42", SSELevel >= SSE42)
Craig Topper3c0bc152012-05-31 05:18:48 +00002646 .Case("sse4a", HasSSE4a)
Douglas Gregore727d212012-01-30 06:38:25 +00002647 .Case("x86", true)
Derek Schuffbabaf312012-10-11 15:52:22 +00002648 .Case("x86_32", getTriple().getArch() == llvm::Triple::x86)
2649 .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64)
Craig Topperb6af69e2012-06-09 22:24:14 +00002650 .Case("xop", HasXOP)
Manman Ren146e5a42012-10-11 00:59:55 +00002651 .Case("f16c", HasF16C)
Douglas Gregore727d212012-01-30 06:38:25 +00002652 .Default(false);
2653}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002654
Eli Friedman618234a2008-08-20 02:34:37 +00002655bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002656X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002657 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002658 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00002659 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00002660 case 'Y': // first letter of a pair:
2661 switch (*(Name+1)) {
2662 default: return false;
2663 case '0': // First SSE register.
2664 case 't': // Any SSE register, when SSE2 is enabled.
2665 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2666 case 'm': // any MMX register, when inter-unit moves enabled.
2667 break; // falls through to setAllowsRegister.
2668 }
Eli Friedman618234a2008-08-20 02:34:37 +00002669 case 'a': // eax.
2670 case 'b': // ebx.
2671 case 'c': // ecx.
2672 case 'd': // edx.
2673 case 'S': // esi.
2674 case 'D': // edi.
2675 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00002676 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00002677 case 't': // top of floating point stack.
2678 case 'u': // second from top of floating point stack.
2679 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00002680 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00002681 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00002682 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00002683 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2684 case 'l': // "Index" registers: any general register that can be used as an
2685 // index in a base+index memory access.
2686 Info.setAllowsRegister();
2687 return true;
2688 case 'C': // SSE floating point constant.
2689 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002690 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002691 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002692 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002693 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00002694 return true;
2695 }
2696}
2697
Dale Johannesenf6e2c202010-10-29 23:12:32 +00002698
Eli Friedman618234a2008-08-20 02:34:37 +00002699std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00002700X86TargetInfo::convertConstraint(const char *&Constraint) const {
2701 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00002702 case 'a': return std::string("{ax}");
2703 case 'b': return std::string("{bx}");
2704 case 'c': return std::string("{cx}");
2705 case 'd': return std::string("{dx}");
2706 case 'S': return std::string("{si}");
2707 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00002708 case 'p': // address
2709 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00002710 case 't': // top of floating point stack.
2711 return std::string("{st}");
2712 case 'u': // second from top of floating point stack.
2713 return std::string("{st(1)}"); // second from top of floating point stack.
2714 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00002715 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00002716 }
2717}
Eli Friedman618234a2008-08-20 02:34:37 +00002718} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00002719
2720namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002721// X86-32 generic target
2722class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00002723public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002724 X86_32TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002725 DoubleAlign = LongLongAlign = 32;
2726 LongDoubleWidth = 96;
2727 LongDoubleAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00002728 SuitableAlign = 128;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002729 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2730 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00002731 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00002732 SizeType = UnsignedInt;
2733 PtrDiffType = SignedInt;
2734 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002735 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002736
2737 // Use fpret for all types.
2738 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2739 (1 << TargetInfo::Double) |
2740 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002741
2742 // x86-32 has atomics up to 8 bytes
2743 // FIXME: Check that we actually have cmpxchg8b before setting
2744 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2745 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002746 }
Meador Ingec5613b22012-06-16 03:34:49 +00002747 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2748 return TargetInfo::CharPtrBuiltinVaList;
Eli Friedman618234a2008-08-20 02:34:37 +00002749 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002750
Chris Lattner21fb98e2009-09-23 06:06:36 +00002751 int getEHDataRegisterNumber(unsigned RegNo) const {
2752 if (RegNo == 0) return 0;
2753 if (RegNo == 1) return 2;
2754 return -1;
2755 }
Bill Wendling68fd6082012-11-12 06:42:51 +00002756 virtual bool validateInputSize(StringRef Constraint,
2757 unsigned Size) const {
2758 switch (Constraint[0]) {
2759 default: break;
2760 case 'a':
2761 case 'b':
2762 case 'c':
2763 case 'd':
Bill Wendlingf634bdf2012-11-12 18:52:32 +00002764 return Size <= 32;
Bill Wendling68fd6082012-11-12 06:42:51 +00002765 }
2766
2767 return true;
2768 }
Eli Friedman618234a2008-08-20 02:34:37 +00002769};
2770} // end anonymous namespace
2771
2772namespace {
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002773class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
2774public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002775 NetBSDI386TargetInfo(const llvm::Triple &Triple)
2776 : NetBSDTargetInfo<X86_32TargetInfo>(Triple) {}
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002777
2778 virtual unsigned getFloatEvalMethod() const {
2779 // NetBSD defaults to "double" rounding
2780 return 1;
2781 }
2782};
2783} // end anonymous namespace
2784
2785namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002786class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2787public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002788 OpenBSDI386TargetInfo(const llvm::Triple &Triple)
2789 : OpenBSDTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman624c1462009-07-05 18:47:56 +00002790 SizeType = UnsignedLong;
2791 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002792 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002793 }
2794};
2795} // end anonymous namespace
2796
2797namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00002798class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
2799public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002800 BitrigI386TargetInfo(const llvm::Triple &Triple)
2801 : BitrigTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman42f74f22012-08-08 23:57:20 +00002802 SizeType = UnsignedLong;
2803 IntPtrType = SignedLong;
2804 PtrDiffType = SignedLong;
2805 }
2806};
2807} // end anonymous namespace
2808
2809namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002810class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002811public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002812 DarwinI386TargetInfo(const llvm::Triple &Triple)
2813 : DarwinTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002814 LongDoubleWidth = 128;
2815 LongDoubleAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002816 SuitableAlign = 128;
Chad Rosierf9e9af72012-07-13 23:57:43 +00002817 MaxVectorAlign = 256;
Eli Friedman1afabd92009-03-29 20:31:09 +00002818 SizeType = UnsignedLong;
2819 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002820 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2821 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002822 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002823 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002824 }
2825
Eli Friedman618234a2008-08-20 02:34:37 +00002826};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002827} // end anonymous namespace
2828
2829namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002830// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002831class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002832public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002833 WindowsX86_32TargetInfo(const llvm::Triple &Triple)
2834 : WindowsTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002835 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002836 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002837 DoubleAlign = LongLongAlign = 64;
2838 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 +00002839 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002840 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002841 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002842 virtual void getTargetDefines(const LangOptions &Opts,
2843 MacroBuilder &Builder) const {
2844 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2845 }
2846};
2847} // end anonymous namespace
2848
2849namespace {
2850
2851// x86-32 Windows Visual Studio target
2852class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2853public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002854 VisualStudioWindowsX86_32TargetInfo(const llvm::Triple &Triple)
2855 : WindowsX86_32TargetInfo(Triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002856 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002857 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2858 }
2859 virtual void getTargetDefines(const LangOptions &Opts,
2860 MacroBuilder &Builder) const {
2861 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2862 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2863 // The value of the following reflects processor type.
2864 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2865 // We lost the original triple, so we use the default.
2866 Builder.defineMacro("_M_IX86", "600");
2867 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002868};
2869} // end anonymous namespace
2870
2871namespace {
2872// x86-32 MinGW target
2873class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2874public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002875 MinGWX86_32TargetInfo(const llvm::Triple &Triple)
2876 : WindowsX86_32TargetInfo(Triple) {}
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002877 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002878 MacroBuilder &Builder) const {
2879 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002880 DefineStd(Builder, "WIN32", Opts);
2881 DefineStd(Builder, "WINNT", Opts);
2882 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002883 Builder.defineMacro("__MSVCRT__");
2884 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002885
2886 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2887 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002888 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002889 // Provide "as-is" __declspec.
2890 Builder.defineMacro("__declspec", "__declspec");
2891 else
2892 // Provide alias of __attribute__ like mingw32-gcc.
2893 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002894 }
2895};
2896} // end anonymous namespace
2897
2898namespace {
2899// x86-32 Cygwin target
2900class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2901public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002902 CygwinX86_32TargetInfo(const llvm::Triple &Triple)
2903 : X86_32TargetInfo(Triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002904 TLSSupported = false;
2905 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002906 DoubleAlign = LongLongAlign = 64;
2907 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2908 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002909 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002910 }
2911 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002912 MacroBuilder &Builder) const {
2913 X86_32TargetInfo::getTargetDefines(Opts, Builder);
NAKAMURA Takumie72f4d92012-12-14 10:17:26 +00002914 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002915 Builder.defineMacro("__CYGWIN__");
2916 Builder.defineMacro("__CYGWIN32__");
2917 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00002918 if (Opts.CPlusPlus)
2919 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00002920 }
Eli Friedman29a30502008-08-21 01:40:19 +00002921};
2922} // end anonymous namespace
2923
2924namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002925// x86-32 Haiku target
2926class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2927public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002928 HaikuX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002929 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00002930 IntPtrType = SignedLong;
2931 PtrDiffType = SignedLong;
Eli Friedman6902e412012-11-27 02:58:24 +00002932 ProcessIDType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00002933 this->UserLabelPrefix = "";
Benjamin Krameref7bcea2012-11-08 12:59:15 +00002934 this->TLSSupported = false;
Eli Friedmana7e68452010-08-22 01:00:03 +00002935 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00002936 virtual void getTargetDefines(const LangOptions &Opts,
2937 MacroBuilder &Builder) const {
2938 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2939 Builder.defineMacro("__INTEL__");
2940 Builder.defineMacro("__HAIKU__");
2941 }
2942};
2943} // end anonymous namespace
2944
Douglas Gregordca52262011-07-01 22:41:14 +00002945// RTEMS Target
2946template<typename Target>
2947class RTEMSTargetInfo : public OSTargetInfo<Target> {
2948protected:
2949 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2950 MacroBuilder &Builder) const {
2951 // RTEMS defines; list based off of gcc output
2952
Douglas Gregordca52262011-07-01 22:41:14 +00002953 Builder.defineMacro("__rtems__");
2954 Builder.defineMacro("__ELF__");
2955 }
Benjamin Kramer9df08232013-06-29 16:37:14 +00002956
Douglas Gregordca52262011-07-01 22:41:14 +00002957public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002958 RTEMSTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
2959 this->UserLabelPrefix = "";
Douglas Gregordca52262011-07-01 22:41:14 +00002960
Benjamin Kramer9df08232013-06-29 16:37:14 +00002961 switch (Triple.getArch()) {
2962 default:
2963 case llvm::Triple::x86:
2964 // this->MCountName = ".mcount";
2965 break;
2966 case llvm::Triple::mips:
2967 case llvm::Triple::mipsel:
2968 case llvm::Triple::ppc:
2969 case llvm::Triple::ppc64:
2970 // this->MCountName = "_mcount";
2971 break;
2972 case llvm::Triple::arm:
2973 // this->MCountName = "__mcount";
2974 break;
Douglas Gregordca52262011-07-01 22:41:14 +00002975 }
Benjamin Kramer9df08232013-06-29 16:37:14 +00002976 }
Douglas Gregordca52262011-07-01 22:41:14 +00002977};
2978
2979namespace {
2980// x86-32 RTEMS target
2981class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2982public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002983 RTEMSX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Douglas Gregordca52262011-07-01 22:41:14 +00002984 SizeType = UnsignedLong;
2985 IntPtrType = SignedLong;
2986 PtrDiffType = SignedLong;
2987 this->UserLabelPrefix = "";
2988 }
2989 virtual void getTargetDefines(const LangOptions &Opts,
2990 MacroBuilder &Builder) const {
2991 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2992 Builder.defineMacro("__INTEL__");
2993 Builder.defineMacro("__rtems__");
2994 }
2995};
2996} // end anonymous namespace
2997
Chris Lattner86ed3a32010-04-11 19:29:39 +00002998namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002999// x86-64 generic target
3000class X86_64TargetInfo : public X86TargetInfo {
3001public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003002 X86_64TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00003003 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00003004 LongDoubleWidth = 128;
3005 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00003006 LargeArrayMinWidth = 128;
3007 LargeArrayAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003008 SuitableAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00003009 IntMaxType = SignedLong;
3010 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003011 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00003012 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00003013
Eli Friedmaned855cb2008-08-21 00:13:15 +00003014 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3015 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003016 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00003017
3018 // Use fpret only for long double.
3019 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00003020
Anders Carlssoneea64802011-10-31 16:27:11 +00003021 // Use fp2ret for _Complex long double.
3022 ComplexLongDoubleUsesFP2Ret = true;
3023
Eli Friedman2be46072011-10-14 20:59:01 +00003024 // x86-64 has atomics up to 16 bytes.
3025 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
3026 // on CPUs with cmpxchg16b
3027 MaxAtomicPromoteWidth = 128;
3028 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00003029 }
Meador Ingec5613b22012-06-16 03:34:49 +00003030 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3031 return TargetInfo::X86_64ABIBuiltinVaList;
Anders Carlsson3346ae62007-11-24 23:38:12 +00003032 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00003033
Chris Lattner21fb98e2009-09-23 06:06:36 +00003034 int getEHDataRegisterNumber(unsigned RegNo) const {
3035 if (RegNo == 0) return 0;
3036 if (RegNo == 1) return 1;
3037 return -1;
3038 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00003039
3040 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
Peter Collingbourne7728cdd2013-02-23 00:06:18 +00003041 return (CC == CC_Default ||
3042 CC == CC_C ||
3043 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballman82bfa192012-10-02 14:26:08 +00003044 }
3045
Aaron Ballmanfff32482012-12-09 17:45:41 +00003046 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {
3047 return CC_C;
Aaron Ballman82bfa192012-10-02 14:26:08 +00003048 }
3049
Eli Friedman618234a2008-08-20 02:34:37 +00003050};
3051} // end anonymous namespace
3052
3053namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003054// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003055class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003056public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003057 WindowsX86_64TargetInfo(const llvm::Triple &Triple)
3058 : WindowsTargetInfo<X86_64TargetInfo>(Triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003059 TLSSupported = false;
3060 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00003061 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00003062 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00003063 IntMaxType = SignedLongLong;
3064 UIntMaxType = UnsignedLongLong;
3065 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00003066 SizeType = UnsignedLongLong;
3067 PtrDiffType = SignedLongLong;
3068 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00003069 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003070 }
3071 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003072 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003073 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003074 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00003075 }
Meador Ingec5613b22012-06-16 03:34:49 +00003076 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3077 return TargetInfo::CharPtrBuiltinVaList;
NAKAMURA Takumi79521992011-01-17 22:56:23 +00003078 }
Michael J. Spencera764e832010-10-21 08:22:51 +00003079};
3080} // end anonymous namespace
3081
3082namespace {
3083// x86-64 Windows Visual Studio target
3084class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
3085public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003086 VisualStudioWindowsX86_64TargetInfo(const llvm::Triple &Triple)
3087 : WindowsX86_64TargetInfo(Triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00003088 LongDoubleWidth = LongDoubleAlign = 64;
3089 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00003090 }
3091 virtual void getTargetDefines(const LangOptions &Opts,
3092 MacroBuilder &Builder) const {
3093 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
3094 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00003095 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003096 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003097 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003098};
3099} // end anonymous namespace
3100
3101namespace {
3102// x86-64 MinGW target
3103class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
3104public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003105 MinGWX86_64TargetInfo(const llvm::Triple &Triple)
3106 : WindowsX86_64TargetInfo(Triple) {}
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003107 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003108 MacroBuilder &Builder) const {
3109 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00003110 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00003111 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00003112 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00003113 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003114
3115 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
3116 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00003117 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003118 // Provide "as-is" __declspec.
3119 Builder.defineMacro("__declspec", "__declspec");
3120 else
3121 // Provide alias of __attribute__ like mingw32-gcc.
3122 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003123 }
3124};
3125} // end anonymous namespace
3126
3127namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003128class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
3129public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003130 DarwinX86_64TargetInfo(const llvm::Triple &Triple)
3131 : DarwinTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003132 Int64Type = SignedLongLong;
Chad Rosierf9e9af72012-07-13 23:57:43 +00003133 MaxVectorAlign = 256;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003134 }
3135};
3136} // end anonymous namespace
3137
3138namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00003139class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
3140public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003141 OpenBSDX86_64TargetInfo(const llvm::Triple &Triple)
3142 : OpenBSDTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman6036ebe2009-07-05 22:31:18 +00003143 IntMaxType = SignedLongLong;
3144 UIntMaxType = UnsignedLongLong;
3145 Int64Type = SignedLongLong;
3146 }
3147};
3148} // end anonymous namespace
3149
3150namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00003151class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
3152public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003153 BitrigX86_64TargetInfo(const llvm::Triple &Triple)
3154 : BitrigTargetInfo<X86_64TargetInfo>(Triple) {
3155 IntMaxType = SignedLongLong;
3156 UIntMaxType = UnsignedLongLong;
3157 Int64Type = SignedLongLong;
Eli Friedman42f74f22012-08-08 23:57:20 +00003158 }
3159};
Tim Northoverc264e162013-01-31 12:13:10 +00003160}
3161
3162namespace {
3163class AArch64TargetInfo : public TargetInfo {
3164 static const char * const GCCRegNames[];
3165 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Tim Northoverff920ee2013-05-04 07:15:13 +00003166
3167 static const Builtin::Info BuiltinInfo[];
Tim Northoverc264e162013-01-31 12:13:10 +00003168public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003169 AArch64TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Tim Northoverc264e162013-01-31 12:13:10 +00003170 BigEndian = false;
3171 LongWidth = LongAlign = 64;
3172 LongDoubleWidth = LongDoubleAlign = 128;
3173 PointerWidth = PointerAlign = 64;
3174 SuitableAlign = 128;
3175 DescriptionString = "e-p:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3176 "i64:64:64-i128:128:128-f32:32:32-f64:64:64-"
3177 "f128:128:128-n32:64-S128";
3178
3179 WCharType = UnsignedInt;
3180 LongDoubleFormat = &llvm::APFloat::IEEEquad;
3181
Tim Northover6a93c862013-02-18 12:11:32 +00003182 // AArch64 backend supports 64-bit operations at the moment. In principle
3183 // 128-bit is possible if register-pairs are used.
3184 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
3185
Tim Northoverc264e162013-01-31 12:13:10 +00003186 TheCXXABI.set(TargetCXXABI::GenericAArch64);
3187 }
3188 virtual void getTargetDefines(const LangOptions &Opts,
3189 MacroBuilder &Builder) const {
3190 // GCC defines theses currently
3191 Builder.defineMacro("__aarch64__");
3192 Builder.defineMacro("__AARCH64EL__");
3193
3194 // ACLE predefines. Many can only have one possible value on v8 AArch64.
3195
3196 // FIXME: these were written based on an unreleased version of a 32-bit ACLE
3197 // which was intended to be compatible with a 64-bit implementation. They
3198 // will need updating when a real 64-bit ACLE exists. Particularly pressing
Tim Northoverdabcbf92013-04-05 14:08:55 +00003199 // instances are: __ARM_ARCH_ISA_ARM, __ARM_ARCH_ISA_THUMB, __ARM_PCS.
3200 Builder.defineMacro("__ARM_ACLE", "101");
3201 Builder.defineMacro("__ARM_ARCH", "8");
3202 Builder.defineMacro("__ARM_ARCH_PROFILE", "'A'");
Tim Northoverc264e162013-01-31 12:13:10 +00003203
Tim Northoverdabcbf92013-04-05 14:08:55 +00003204 Builder.defineMacro("__ARM_FEATURE_UNALIGNED");
3205 Builder.defineMacro("__ARM_FEATURE_CLZ");
3206 Builder.defineMacro("__ARM_FEATURE_FMA");
Tim Northoverc264e162013-01-31 12:13:10 +00003207
3208 // FIXME: ACLE 1.1 reserves bit 4. Will almost certainly come to mean
3209 // 128-bit LDXP present, at which point this becomes 0x1f.
Tim Northoverdabcbf92013-04-05 14:08:55 +00003210 Builder.defineMacro("__ARM_FEATURE_LDREX", "0xf");
Tim Northoverc264e162013-01-31 12:13:10 +00003211
3212 // 0xe implies support for half, single and double precision operations.
Tim Northoverdabcbf92013-04-05 14:08:55 +00003213 Builder.defineMacro("__ARM_FP", "0xe");
Tim Northoverc264e162013-01-31 12:13:10 +00003214
3215 // PCS specifies this for SysV variants, which is all we support. Other ABIs
Tim Northoverdabcbf92013-04-05 14:08:55 +00003216 // may choose __ARM_FP16_FORMAT_ALTERNATIVE.
3217 Builder.defineMacro("__ARM_FP16_FORMAT_IEEE");
Tim Northoverc264e162013-01-31 12:13:10 +00003218
3219 if (Opts.FastMath || Opts.FiniteMathOnly)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003220 Builder.defineMacro("__ARM_FP_FAST");
Tim Northoverc264e162013-01-31 12:13:10 +00003221
3222 if ((Opts.C99 || Opts.C11) && !Opts.Freestanding)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003223 Builder.defineMacro("__ARM_FP_FENV_ROUNDING");
Tim Northoverc264e162013-01-31 12:13:10 +00003224
Tim Northoverdabcbf92013-04-05 14:08:55 +00003225 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
Tim Northoverc264e162013-01-31 12:13:10 +00003226 Opts.ShortWChar ? "2" : "4");
3227
Tim Northoverdabcbf92013-04-05 14:08:55 +00003228 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
Tim Northoverc264e162013-01-31 12:13:10 +00003229 Opts.ShortEnums ? "1" : "4");
3230
3231 if (BigEndian)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003232 Builder.defineMacro("__ARM_BIG_ENDIAN");
Tim Northoverc264e162013-01-31 12:13:10 +00003233 }
3234 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3235 unsigned &NumRecords) const {
Tim Northoverff920ee2013-05-04 07:15:13 +00003236 Records = BuiltinInfo;
3237 NumRecords = clang::AArch64::LastTSBuiltin-Builtin::FirstTSBuiltin;
Tim Northoverc264e162013-01-31 12:13:10 +00003238 }
3239 virtual bool hasFeature(StringRef Feature) const {
3240 return Feature == "aarch64";
3241 }
3242 virtual void getGCCRegNames(const char * const *&Names,
3243 unsigned &NumNames) const;
3244 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3245 unsigned &NumAliases) const;
3246
3247 virtual bool isCLZForZeroUndef() const { return false; }
3248
3249 virtual bool validateAsmConstraint(const char *&Name,
3250 TargetInfo::ConstraintInfo &Info) const {
3251 switch (*Name) {
3252 default: return false;
3253 case 'w': // An FP/SIMD vector register
3254 Info.setAllowsRegister();
3255 return true;
3256 case 'I': // Constant that can be used with an ADD instruction
3257 case 'J': // Constant that can be used with a SUB instruction
3258 case 'K': // Constant that can be used with a 32-bit logical instruction
3259 case 'L': // Constant that can be used with a 64-bit logical instruction
3260 case 'M': // Constant that can be used as a 32-bit MOV immediate
3261 case 'N': // Constant that can be used as a 64-bit MOV immediate
3262 case 'Y': // Floating point constant zero
3263 case 'Z': // Integer constant zero
3264 return true;
3265 case 'Q': // A memory reference with base register and no offset
3266 Info.setAllowsMemory();
3267 return true;
3268 case 'S': // A symbolic address
3269 Info.setAllowsRegister();
3270 return true;
3271 case 'U':
3272 // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes, whatever they may be
3273 // Utf: A memory address suitable for ldp/stp in TF mode, whatever it may be
3274 // Usa: An absolute symbolic address
3275 // Ush: The high part (bits 32:12) of a pc-relative symbolic address
3276 llvm_unreachable("FIXME: Unimplemented support for bizarre constraints");
3277 }
3278 }
3279
3280 virtual const char *getClobbers() const {
3281 // There are no AArch64 clobbers shared by all asm statements.
3282 return "";
3283 }
3284
3285 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3286 return TargetInfo::AArch64ABIBuiltinVaList;
3287 }
3288};
3289
3290const char * const AArch64TargetInfo::GCCRegNames[] = {
3291 "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7",
3292 "w8", "w9", "w10", "w11", "w12", "w13", "w14", "w15",
3293 "w16", "w17", "w18", "w19", "w20", "w21", "w22", "w23",
3294 "w24", "w25", "w26", "w27", "w28", "w29", "w30", "wsp", "wzr",
3295
3296 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
3297 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
3298 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
3299 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp", "xzr",
3300
3301 "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7",
3302 "b8", "b9", "b10", "b11", "b12", "b13", "b14", "b15",
3303 "b16", "b17", "b18", "b19", "b20", "b21", "b22", "b23",
3304 "b24", "b25", "b26", "b27", "b28", "b29", "b30", "b31",
3305
3306 "h0", "h1", "h2", "h3", "h4", "h5", "h6", "h7",
3307 "h8", "h9", "h10", "h11", "h12", "h13", "h14", "h15",
3308 "h16", "h17", "h18", "h19", "h20", "h21", "h22", "h23",
3309 "h24", "h25", "h26", "h27", "h28", "h29", "h30", "h31",
3310
3311 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3312 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3313 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
3314 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
3315
3316 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3317 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
3318 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3319 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
3320
3321 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3322 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15",
3323 "q16", "q17", "q18", "q19", "q20", "q21", "q22", "q23",
3324 "q24", "q25", "q26", "q27", "q28", "q29", "q30", "q31"
3325};
3326
3327void AArch64TargetInfo::getGCCRegNames(const char * const *&Names,
3328 unsigned &NumNames) const {
3329 Names = GCCRegNames;
3330 NumNames = llvm::array_lengthof(GCCRegNames);
3331}
3332
3333const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = {
3334 { { "x16" }, "ip0"},
3335 { { "x17" }, "ip1"},
3336 { { "x29" }, "fp" },
3337 { { "x30" }, "lr" }
3338};
3339
3340void AArch64TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3341 unsigned &NumAliases) const {
3342 Aliases = GCCRegAliases;
3343 NumAliases = llvm::array_lengthof(GCCRegAliases);
3344
3345}
Tim Northoverff920ee2013-05-04 07:15:13 +00003346
3347const Builtin::Info AArch64TargetInfo::BuiltinInfo[] = {
3348#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3349#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3350 ALL_LANGUAGES },
3351#include "clang/Basic/BuiltinsAArch64.def"
3352};
3353
Eli Friedman42f74f22012-08-08 23:57:20 +00003354} // end anonymous namespace
3355
3356namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00003357class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003358 // Possible FPU choices.
3359 enum FPUMode {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003360 VFP2FPU = (1 << 0),
3361 VFP3FPU = (1 << 1),
3362 VFP4FPU = (1 << 2),
3363 NeonFPU = (1 << 3)
Daniel Dunbara91320b2009-12-21 23:28:17 +00003364 };
3365
3366 static bool FPUModeIsVFP(FPUMode Mode) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003367 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU);
Daniel Dunbara91320b2009-12-21 23:28:17 +00003368 }
3369
3370 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3371 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003372
Daniel Dunbareac7c532009-12-18 18:42:37 +00003373 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003374
Bob Wilsoncfaab002012-09-29 23:52:52 +00003375 unsigned FPU : 4;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003376
Logan Chieneae5a8202012-10-10 06:56:20 +00003377 unsigned IsAAPCS : 1;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003378 unsigned IsThumb : 1;
3379
3380 // Initialized via features.
3381 unsigned SoftFloat : 1;
3382 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003383
Chris Lattner2752c012010-03-03 19:03:45 +00003384 static const Builtin::Info BuiltinInfo[];
3385
Rafael Espindola620c0af2013-05-13 20:09:47 +00003386 static bool shouldUseInlineAtomic(const llvm::Triple &T) {
3387 // On linux, binaries targeting old cpus call functions in libgcc to
3388 // perform atomic operations. The implementation in libgcc then calls into
3389 // the kernel which on armv6 and newer uses ldrex and strex. The net result
3390 // is that if we assume the kernel is at least as recent as the hardware,
3391 // it is safe to use atomic instructions on armv6 and newer.
Rafael Espindolae1e03422013-06-17 20:00:15 +00003392 if (T.getOS() != llvm::Triple::Linux &&
3393 T.getOS() != llvm::Triple::FreeBSD &&
3394 T.getOS() != llvm::Triple::Bitrig)
Ed Schouten04491632013-06-15 09:40:14 +00003395 return false;
Rafael Espindola620c0af2013-05-13 20:09:47 +00003396 StringRef ArchName = T.getArchName();
Rafael Espindola69db5552013-05-14 00:44:24 +00003397 if (T.getArch() == llvm::Triple::arm) {
3398 if (!ArchName.startswith("armv"))
3399 return false;
3400 StringRef VersionStr = ArchName.substr(4);
3401 unsigned Version;
3402 if (VersionStr.getAsInteger(10, Version))
3403 return false;
3404 return Version >= 6;
3405 }
3406 assert(T.getArch() == llvm::Triple::thumb);
3407 if (!ArchName.startswith("thumbv"))
3408 return false;
3409 StringRef VersionStr = ArchName.substr(6);
3410 unsigned Version;
3411 if (VersionStr.getAsInteger(10, Version))
3412 return false;
3413 return Version >= 7;
Rafael Espindola620c0af2013-05-13 20:09:47 +00003414 }
3415
Chris Lattner393ff042008-04-21 18:56:49 +00003416public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003417 ARMTargetInfo(const llvm::Triple &Triple)
3418 : TargetInfo(Triple), ABI("aapcs-linux"), CPU("arm1136j-s"),
3419 IsAAPCS(true) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003420 BigEndian = false;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003421 SizeType = UnsignedInt;
3422 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00003423 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
3424 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003425
Chris Lattner9bffb072010-04-23 16:29:58 +00003426 // {} in inline assembly are neon specifiers, not assembly variant
3427 // specifiers.
3428 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00003429
Daniel Dunbareac7c532009-12-18 18:42:37 +00003430 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00003431 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003432 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003433 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3434 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003435 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
3436 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003437 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003438 } else {
3439 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3440 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003441 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003442 }
John McCallee79a4c2010-08-21 22:46:04 +00003443
3444 // ARM targets default to using the ARM C++ ABI.
John McCallb8b2c9d2013-01-25 22:30:49 +00003445 TheCXXABI.set(TargetCXXABI::GenericARM);
Eli Friedman2be46072011-10-14 20:59:01 +00003446
3447 // ARM has atomics up to 8 bytes
Eli Friedman2be46072011-10-14 20:59:01 +00003448 MaxAtomicPromoteWidth = 64;
Rafael Espindola620c0af2013-05-13 20:09:47 +00003449 if (shouldUseInlineAtomic(getTriple()))
3450 MaxAtomicInlineWidth = 64;
James Molloye45b9b72012-03-12 09:14:10 +00003451
3452 // Do force alignment of members that follow zero length bitfields. If
3453 // the alignment of the zero-length bitfield is greater than the member
3454 // that follows it, `bar', `bar' will be aligned as the type of the
3455 // zero length bitfield.
3456 UseZeroLengthBitfieldAlignment = true;
Eli Friedman61538a72008-05-20 14:21:01 +00003457 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003458 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00003459 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003460 ABI = Name;
3461
Daniel Dunbara2a41612009-09-14 00:02:24 +00003462 // The defaults (above) are for AAPCS, check if we need to change them.
3463 //
3464 // FIXME: We need support for -meabi... we could just mangle it into the
3465 // name.
3466 if (Name == "apcs-gnu") {
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003467 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Rafael Espindola27fa2362012-12-13 04:17:14 +00003468 // size_t is unsigned int on FreeBSD.
3469 if (getTriple().getOS() != llvm::Triple::FreeBSD)
3470 SizeType = UnsignedLong;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003471
James Molloya6d81f92011-11-23 13:35:08 +00003472 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
3473 WCharType = SignedInt;
3474
Daniel Dunbar684de632010-04-22 16:14:54 +00003475 // Do not respect the alignment of bit-field types when laying out
3476 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
3477 UseBitFieldTypeAlignment = false;
3478
Chad Rosier61a62212011-08-04 01:21:14 +00003479 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00003480 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
3481 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00003482 ZeroLengthBitfieldBoundary = 32;
3483
Logan Chieneae5a8202012-10-10 06:56:20 +00003484 IsAAPCS = false;
3485
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003486 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003487 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3488 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003489 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 +00003490 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003491 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003492 } else {
3493 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 +00003494 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003495 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003496 }
3497
Chad Rosier9f1210c2011-07-26 07:03:04 +00003498 // FIXME: Override "preferred align" for double and long long.
David Tweedb16abb12012-10-25 13:33:01 +00003499 } else if (Name == "aapcs" || Name == "aapcs-vfp") {
Bob Wilsone4bce7a2013-06-18 05:36:04 +00003500 // size_t is unsigned long on Darwin.
3501 if (getTriple().isOSDarwin())
3502 SizeType = UnsignedLong;
Logan Chieneae5a8202012-10-10 06:56:20 +00003503 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003504 // FIXME: Enumerated types are variable width in straight AAPCS.
3505 } else if (Name == "aapcs-linux") {
Logan Chieneae5a8202012-10-10 06:56:20 +00003506 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003507 } else
3508 return false;
3509
3510 return true;
3511 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003512
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003513 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003514 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
3515 Features["vfp2"] = true;
Bob Wilsoncfaab002012-09-29 23:52:52 +00003516 else if (CPU == "cortex-a8" || CPU == "cortex-a15" ||
3517 CPU == "cortex-a9" || CPU == "cortex-a9-mp")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003518 Features["neon"] = true;
Bob Wilsonfc553452013-03-04 22:37:46 +00003519 else if (CPU == "swift" || CPU == "cortex-a7") {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003520 Features["vfp4"] = true;
3521 Features["neon"] = true;
3522 }
Daniel Dunbara91320b2009-12-21 23:28:17 +00003523 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003524
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003525 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00003526 StringRef Name,
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003527 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00003528 if (Name == "soft-float" || Name == "soft-float-abi" ||
Bob Wilsoncfaab002012-09-29 23:52:52 +00003529 Name == "vfp2" || Name == "vfp3" || Name == "vfp4" || Name == "neon" ||
Joey Goulycbed3bf2013-06-27 13:19:54 +00003530 Name == "d16" || Name == "neonfp" || Name == "v8fp") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003531 Features[Name] = Enabled;
3532 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003533 return false;
3534
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003535 return true;
3536 }
3537
3538 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003539 FPU = 0;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003540 SoftFloat = SoftFloatABI = false;
3541 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
3542 if (Features[i] == "+soft-float")
3543 SoftFloat = true;
3544 else if (Features[i] == "+soft-float-abi")
3545 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003546 else if (Features[i] == "+vfp2")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003547 FPU |= VFP2FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003548 else if (Features[i] == "+vfp3")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003549 FPU |= VFP3FPU;
3550 else if (Features[i] == "+vfp4")
3551 FPU |= VFP4FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003552 else if (Features[i] == "+neon")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003553 FPU |= NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003554 }
3555
3556 // Remove front-end specific options which the backend handles differently.
3557 std::vector<std::string>::iterator it;
3558 it = std::find(Features.begin(), Features.end(), "+soft-float");
3559 if (it != Features.end())
3560 Features.erase(it);
3561 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
3562 if (it != Features.end())
3563 Features.erase(it);
3564 }
3565
Douglas Gregore727d212012-01-30 06:38:25 +00003566 virtual bool hasFeature(StringRef Feature) const {
3567 return llvm::StringSwitch<bool>(Feature)
3568 .Case("arm", true)
3569 .Case("softfloat", SoftFloat)
3570 .Case("thumb", IsThumb)
3571 .Case("neon", FPU == NeonFPU && !SoftFloat &&
3572 StringRef(getCPUDefineSuffix(CPU)).startswith("7"))
3573 .Default(false);
3574 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003575 // FIXME: Should we actually have some table instead of these switches?
Chris Lattner5f9e2722011-07-23 10:55:15 +00003576 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00003577 return llvm::StringSwitch<const char*>(Name)
3578 .Cases("arm8", "arm810", "4")
3579 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
3580 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
3581 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
3582 .Case("ep9312", "4T")
3583 .Cases("arm10tdmi", "arm1020t", "5T")
3584 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
3585 .Case("arm926ej-s", "5TEJ")
3586 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
3587 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003588 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003589 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003590 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003591 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
Bob Wilsonfc553452013-03-04 22:37:46 +00003592 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "7A")
3593 .Cases("cortex-a9", "cortex-a15", "7A")
Quentin Colombetab137512012-12-21 17:57:47 +00003594 .Case("cortex-r5", "7R")
Bob Wilson336bfa32012-09-29 23:52:50 +00003595 .Case("cortex-a9-mp", "7F")
3596 .Case("swift", "7S")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003597 .Cases("cortex-m3", "cortex-m4", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00003598 .Case("cortex-m0", "6M")
Joey Gouly4ec8d5b2013-06-26 17:19:48 +00003599 .Case("cortex-a53", "8A")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003600 .Default(0);
3601 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003602 static const char *getCPUProfile(StringRef Name) {
3603 return llvm::StringSwitch<const char*>(Name)
3604 .Cases("cortex-a8", "cortex-a9", "A")
3605 .Cases("cortex-m3", "cortex-m4", "cortex-m0", "M")
Quentin Colombetab137512012-12-21 17:57:47 +00003606 .Case("cortex-r5", "R")
Anton Korobeynikov8b0703d2012-09-08 08:22:13 +00003607 .Default("");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003608 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003609 virtual bool setCPU(const std::string &Name) {
3610 if (!getCPUDefineSuffix(Name))
3611 return false;
3612
3613 CPU = Name;
3614 return true;
3615 }
Chris Lattner33328642009-03-20 15:52:06 +00003616 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003617 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00003618 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00003619 Builder.defineMacro("__arm");
3620 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003621
Chris Lattnerc0f59212009-03-02 22:27:17 +00003622 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00003623 Builder.defineMacro("__ARMEL__");
3624 Builder.defineMacro("__LITTLE_ENDIAN__");
3625 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003626
Chris Lattner5f9e2722011-07-23 10:55:15 +00003627 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00003628 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003629 Builder.defineMacro("__ARM_ARCH", CPUArch.substr(0, 1));
3630 StringRef CPUProfile = getCPUProfile(CPU);
3631 if (!CPUProfile.empty())
3632 Builder.defineMacro("__ARM_ARCH_PROFILE", CPUProfile);
3633
Mike Stump437bb4b2009-04-08 02:07:04 +00003634 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003635
Daniel Dunbareac7c532009-12-18 18:42:37 +00003636 // FIXME: It's more complicated than this and we don't really support
3637 // interworking.
3638 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00003639 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003640
David Tweedb16abb12012-10-25 13:33:01 +00003641 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
Daniel Dunbar849289e2012-10-22 18:51:13 +00003642 // M-class CPUs on Darwin follow AAPCS, but not EABI.
Daniel Dunbar4d3ee9b2012-10-22 18:56:43 +00003643 if (!(getTriple().isOSDarwin() && CPUProfile == "M"))
Daniel Dunbar849289e2012-10-22 18:51:13 +00003644 Builder.defineMacro("__ARM_EABI__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003645 Builder.defineMacro("__ARM_PCS", "1");
3646
David Tweedb16abb12012-10-25 13:33:01 +00003647 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003648 Builder.defineMacro("__ARM_PCS_VFP", "1");
3649 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003650
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003651 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00003652 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003653
3654 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00003655 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003656
Bob Wilson84f95cf2011-05-13 18:56:03 +00003657 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003658 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003659 Builder.defineMacro("__THUMBEL__");
3660 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00003661 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003662 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003663 }
3664
3665 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00003666 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00003667
Bob Wilsoncfaab002012-09-29 23:52:52 +00003668 if (FPUModeIsVFP((FPUMode) FPU)) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003669 Builder.defineMacro("__VFP_FP__");
Bob Wilsoncfaab002012-09-29 23:52:52 +00003670 if (FPU & VFP2FPU)
3671 Builder.defineMacro("__ARM_VFPV2__");
3672 if (FPU & VFP3FPU)
3673 Builder.defineMacro("__ARM_VFPV3__");
3674 if (FPU & VFP4FPU)
3675 Builder.defineMacro("__ARM_VFPV4__");
3676 }
3677
Daniel Dunbara91320b2009-12-21 23:28:17 +00003678 // This only gets set when Neon instructions are actually available, unlike
3679 // the VFP define, hence the soft float and arch check. This is subtly
3680 // different from gcc, we follow the intent which was that it should be set
3681 // when Neon instructions are actually available.
Bob Wilsoncfaab002012-09-29 23:52:52 +00003682 if ((FPU & NeonFPU) && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003683 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00003684 }
3685 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3686 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00003687 Records = BuiltinInfo;
3688 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00003689 }
Bob Wilson8b30a932012-01-26 22:14:27 +00003690 virtual bool isCLZForZeroUndef() const { return false; }
Meador Ingec5613b22012-06-16 03:34:49 +00003691 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Logan Chieneae5a8202012-10-10 06:56:20 +00003692 return IsAAPCS ? AAPCSABIBuiltinVaList : TargetInfo::VoidPtrBuiltinVaList;
Chris Lattner393ff042008-04-21 18:56:49 +00003693 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003694 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003695 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003696 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003697 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003698 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00003699 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003700 switch (*Name) {
Eric Christophera0dfca12012-08-16 23:50:41 +00003701 default: break;
Nate Begemanad487f42008-04-22 05:03:19 +00003702 case 'l': // r0-r7
3703 case 'h': // r8-r15
3704 case 'w': // VFP Floating point register single precision
3705 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00003706 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00003707 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00003708 case 'Q': // A memory address that is a single base register.
3709 Info.setAllowsMemory();
3710 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00003711 case 'U': // a memory reference...
3712 switch (Name[1]) {
3713 case 'q': // ...ARMV4 ldrsb
3714 case 'v': // ...VFP load/store (reg+constant offset)
3715 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00003716 case 't': // address valid for load/store opaque types wider
Eric Christopher825d3862012-11-14 22:08:59 +00003717 // than 128-bits
Eric Christopherdda231a2011-06-17 01:40:49 +00003718 case 'n': // valid address for Neon doubleword vector load/store
3719 case 'm': // valid address for Neon element and structure load/store
3720 case 's': // valid address for non-offset loads/stores of quad-word
Eric Christopher825d3862012-11-14 22:08:59 +00003721 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00003722 Info.setAllowsMemory();
3723 Name++;
3724 return true;
3725 }
Nate Begemanad487f42008-04-22 05:03:19 +00003726 }
Chris Lattner393ff042008-04-21 18:56:49 +00003727 return false;
3728 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00003729 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00003730 std::string R;
3731 switch (*Constraint) {
3732 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00003733 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00003734 Constraint++;
3735 break;
Eric Christopher283f4472011-06-17 00:40:18 +00003736 case 'p': // 'p' should be translated to 'r' by default.
3737 R = std::string("r");
3738 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00003739 default:
3740 return std::string(1, *Constraint);
3741 }
3742 return R;
3743 }
Bill Wendling50d46ca2012-10-25 23:28:48 +00003744 virtual bool validateConstraintModifier(StringRef Constraint,
3745 const char Modifier,
3746 unsigned Size) const {
Bill Wendlinge2dbaa92012-11-30 23:18:12 +00003747 bool isOutput = (Constraint[0] == '=');
Bill Wendling6e6330c2012-11-30 23:46:56 +00003748 bool isInOut = (Constraint[0] == '+');
Bill Wendlinge2dbaa92012-11-30 23:18:12 +00003749
Bill Wendling50d46ca2012-10-25 23:28:48 +00003750 // Strip off constraint modifiers.
3751 while (Constraint[0] == '=' ||
3752 Constraint[0] == '+' ||
3753 Constraint[0] == '&')
3754 Constraint = Constraint.substr(1);
3755
3756 switch (Constraint[0]) {
3757 default: break;
3758 case 'r': {
3759 switch (Modifier) {
3760 default:
Bob Wilson221a8902013-06-03 23:57:13 +00003761 return (isInOut || isOutput || Size <= 32);
Bill Wendling50d46ca2012-10-25 23:28:48 +00003762 case 'q':
3763 // A register of size 32 cannot fit a vector type.
3764 return false;
3765 }
3766 }
3767 }
3768
3769 return true;
3770 }
Chris Lattner393ff042008-04-21 18:56:49 +00003771 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00003772 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00003773 return "";
3774 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00003775
3776 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
3777 return (CC == CC_AAPCS || CC == CC_AAPCS_VFP) ? CCCR_OK : CCCR_Warning;
3778 }
Logan Chiena8f7a972013-02-23 04:24:36 +00003779
3780 virtual int getEHDataRegisterNumber(unsigned RegNo) const {
3781 if (RegNo == 0) return 0;
3782 if (RegNo == 1) return 1;
3783 return -1;
3784 }
Chris Lattner393ff042008-04-21 18:56:49 +00003785};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003786
3787const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003788 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003789 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003790 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
3791
3792 // Float registers
3793 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3794 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3795 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003796 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003797
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003798 // Double registers
3799 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3800 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00003801 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3802 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003803
3804 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00003805 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3806 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003807};
3808
3809void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003810 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003811 Names = GCCRegNames;
3812 NumNames = llvm::array_lengthof(GCCRegNames);
3813}
3814
3815const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003816 { { "a1" }, "r0" },
3817 { { "a2" }, "r1" },
3818 { { "a3" }, "r2" },
3819 { { "a4" }, "r3" },
3820 { { "v1" }, "r4" },
3821 { { "v2" }, "r5" },
3822 { { "v3" }, "r6" },
3823 { { "v4" }, "r7" },
3824 { { "v5" }, "r8" },
3825 { { "v6", "rfp" }, "r9" },
3826 { { "sl" }, "r10" },
3827 { { "fp" }, "r11" },
3828 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003829 { { "r13" }, "sp" },
3830 { { "r14" }, "lr" },
3831 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003832 // The S, D and Q registers overlap, but aren't really aliases; we
3833 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003834};
3835
3836void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3837 unsigned &NumAliases) const {
3838 Aliases = GCCRegAliases;
3839 NumAliases = llvm::array_lengthof(GCCRegAliases);
3840}
Chris Lattner2752c012010-03-03 19:03:45 +00003841
3842const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00003843#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00003844#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00003845 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00003846#include "clang/Basic/BuiltinsARM.def"
3847};
Chris Lattner393ff042008-04-21 18:56:49 +00003848} // end anonymous namespace.
3849
Eli Friedmana9f54962008-08-20 07:44:10 +00003850namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00003851class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003852 public DarwinTargetInfo<ARMTargetInfo> {
3853protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00003854 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00003855 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00003856 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00003857 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003858
Torok Edwin5f6c1942009-06-30 17:10:35 +00003859public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003860 DarwinARMTargetInfo(const llvm::Triple &Triple)
3861 : DarwinTargetInfo<ARMTargetInfo>(Triple) {
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003862 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00003863 // iOS always has 64-bit atomic instructions.
3864 // FIXME: This should be based off of the target features in ARMTargetInfo.
3865 MaxAtomicInlineWidth = 64;
John McCallb8b2c9d2013-01-25 22:30:49 +00003866
3867 // Darwin on iOS uses a variant of the ARM C++ ABI.
3868 TheCXXABI.set(TargetCXXABI::iOS);
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003869 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003870};
3871} // end anonymous namespace.
3872
Tony Linthicum96319392011-12-12 21:14:55 +00003873
3874namespace {
3875// Hexagon abstract base class
3876class HexagonTargetInfo : public TargetInfo {
3877 static const Builtin::Info BuiltinInfo[];
3878 static const char * const GCCRegNames[];
3879 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3880 std::string CPU;
3881public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003882 HexagonTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003883 BigEndian = false;
Tony Linthicum96319392011-12-12 21:14:55 +00003884 DescriptionString = ("e-p:32:32:32-"
Anshuman Dasgupta1a090f12013-01-02 21:25:57 +00003885 "i64:64:64-i32:32:32-i16:16:16-i1:32:32-"
Sirish Pande5f9688b2012-05-10 20:19:54 +00003886 "f64:64:64-f32:32:32-a0:0-n32");
Tony Linthicum96319392011-12-12 21:14:55 +00003887
3888 // {} in inline assembly are packet specifiers, not assembly variant
3889 // specifiers.
3890 NoAsmVariants = true;
3891 }
3892
3893 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3894 unsigned &NumRecords) const {
3895 Records = BuiltinInfo;
3896 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
3897 }
3898
3899 virtual bool validateAsmConstraint(const char *&Name,
3900 TargetInfo::ConstraintInfo &Info) const {
3901 return true;
3902 }
3903
3904 virtual void getTargetDefines(const LangOptions &Opts,
3905 MacroBuilder &Builder) const;
3906
Douglas Gregore727d212012-01-30 06:38:25 +00003907 virtual bool hasFeature(StringRef Feature) const {
3908 return Feature == "hexagon";
3909 }
3910
Meador Ingec5613b22012-06-16 03:34:49 +00003911 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3912 return TargetInfo::CharPtrBuiltinVaList;
Tony Linthicum96319392011-12-12 21:14:55 +00003913 }
3914 virtual void getGCCRegNames(const char * const *&Names,
3915 unsigned &NumNames) const;
3916 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3917 unsigned &NumAliases) const;
3918 virtual const char *getClobbers() const {
3919 return "";
3920 }
Sebastian Pop43115d42012-01-13 20:37:10 +00003921
3922 static const char *getHexagonCPUSuffix(StringRef Name) {
3923 return llvm::StringSwitch<const char*>(Name)
Sebastian Pop43115d42012-01-13 20:37:10 +00003924 .Case("hexagonv4", "4")
Sirish Pande5f9688b2012-05-10 20:19:54 +00003925 .Case("hexagonv5", "5")
Sebastian Pop43115d42012-01-13 20:37:10 +00003926 .Default(0);
3927 }
3928
Tony Linthicum96319392011-12-12 21:14:55 +00003929 virtual bool setCPU(const std::string &Name) {
Sebastian Pop43115d42012-01-13 20:37:10 +00003930 if (!getHexagonCPUSuffix(Name))
3931 return false;
3932
Tony Linthicum96319392011-12-12 21:14:55 +00003933 CPU = Name;
3934 return true;
3935 }
3936};
3937
3938void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
3939 MacroBuilder &Builder) const {
3940 Builder.defineMacro("qdsp6");
3941 Builder.defineMacro("__qdsp6", "1");
3942 Builder.defineMacro("__qdsp6__", "1");
3943
3944 Builder.defineMacro("hexagon");
3945 Builder.defineMacro("__hexagon", "1");
3946 Builder.defineMacro("__hexagon__", "1");
3947
3948 if(CPU == "hexagonv1") {
3949 Builder.defineMacro("__HEXAGON_V1__");
3950 Builder.defineMacro("__HEXAGON_ARCH__", "1");
3951 if(Opts.HexagonQdsp6Compat) {
3952 Builder.defineMacro("__QDSP6_V1__");
3953 Builder.defineMacro("__QDSP6_ARCH__", "1");
3954 }
3955 }
3956 else if(CPU == "hexagonv2") {
3957 Builder.defineMacro("__HEXAGON_V2__");
3958 Builder.defineMacro("__HEXAGON_ARCH__", "2");
3959 if(Opts.HexagonQdsp6Compat) {
3960 Builder.defineMacro("__QDSP6_V2__");
3961 Builder.defineMacro("__QDSP6_ARCH__", "2");
3962 }
3963 }
3964 else if(CPU == "hexagonv3") {
3965 Builder.defineMacro("__HEXAGON_V3__");
3966 Builder.defineMacro("__HEXAGON_ARCH__", "3");
3967 if(Opts.HexagonQdsp6Compat) {
3968 Builder.defineMacro("__QDSP6_V3__");
3969 Builder.defineMacro("__QDSP6_ARCH__", "3");
3970 }
3971 }
3972 else if(CPU == "hexagonv4") {
3973 Builder.defineMacro("__HEXAGON_V4__");
3974 Builder.defineMacro("__HEXAGON_ARCH__", "4");
3975 if(Opts.HexagonQdsp6Compat) {
3976 Builder.defineMacro("__QDSP6_V4__");
3977 Builder.defineMacro("__QDSP6_ARCH__", "4");
3978 }
3979 }
Sirish Pande5f9688b2012-05-10 20:19:54 +00003980 else if(CPU == "hexagonv5") {
3981 Builder.defineMacro("__HEXAGON_V5__");
3982 Builder.defineMacro("__HEXAGON_ARCH__", "5");
3983 if(Opts.HexagonQdsp6Compat) {
3984 Builder.defineMacro("__QDSP6_V5__");
3985 Builder.defineMacro("__QDSP6_ARCH__", "5");
3986 }
3987 }
Tony Linthicum96319392011-12-12 21:14:55 +00003988}
3989
3990const char * const HexagonTargetInfo::GCCRegNames[] = {
3991 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3992 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3993 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3994 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
3995 "p0", "p1", "p2", "p3",
3996 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
3997};
3998
3999void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
4000 unsigned &NumNames) const {
4001 Names = GCCRegNames;
4002 NumNames = llvm::array_lengthof(GCCRegNames);
4003}
4004
4005
4006const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
4007 { { "sp" }, "r29" },
4008 { { "fp" }, "r30" },
4009 { { "lr" }, "r31" },
4010 };
4011
4012void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4013 unsigned &NumAliases) const {
4014 Aliases = GCCRegAliases;
4015 NumAliases = llvm::array_lengthof(GCCRegAliases);
4016}
4017
4018
4019const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
4020#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4021#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4022 ALL_LANGUAGES },
4023#include "clang/Basic/BuiltinsHexagon.def"
4024};
4025}
4026
4027
Reid Spencer5f016e22007-07-11 17:01:13 +00004028namespace {
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004029// Shared base class for SPARC v8 (32-bit) and SPARC v9 (64-bit).
4030class SparcTargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00004031 static const TargetInfo::GCCRegAlias GCCRegAliases[];
4032 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004033 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00004034public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004035 SparcTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {}
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004036
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004037 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00004038 StringRef Name,
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004039 bool Enabled) const {
4040 if (Name == "soft-float")
4041 Features[Name] = Enabled;
4042 else
4043 return false;
4044
4045 return true;
4046 }
4047 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
4048 SoftFloat = false;
4049 for (unsigned i = 0, e = Features.size(); i != e; ++i)
4050 if (Features[i] == "+soft-float")
4051 SoftFloat = true;
4052 }
Chris Lattner33328642009-03-20 15:52:06 +00004053 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004054 MacroBuilder &Builder) const {
4055 DefineStd(Builder, "sparc", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00004056 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004057
4058 if (SoftFloat)
4059 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00004060 }
Douglas Gregore727d212012-01-30 06:38:25 +00004061
4062 virtual bool hasFeature(StringRef Feature) const {
4063 return llvm::StringSwitch<bool>(Feature)
4064 .Case("softfloat", SoftFloat)
4065 .Case("sparc", true)
4066 .Default(false);
4067 }
4068
Gabor Greif26658672008-02-21 16:29:08 +00004069 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4070 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00004071 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00004072 }
Meador Ingec5613b22012-06-16 03:34:49 +00004073 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4074 return TargetInfo::VoidPtrBuiltinVaList;
Gabor Greif26658672008-02-21 16:29:08 +00004075 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004076 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00004077 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004078 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00004079 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00004080 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00004081 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00004082 // FIXME: Implement!
4083 return false;
Gabor Greif26658672008-02-21 16:29:08 +00004084 }
4085 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00004086 // FIXME: Implement!
4087 return "";
Gabor Greif26658672008-02-21 16:29:08 +00004088 }
4089};
4090
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004091const char * const SparcTargetInfo::GCCRegNames[] = {
Chris Lattnere957f532009-01-27 01:58:38 +00004092 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4093 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4094 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
4095 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
4096};
4097
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004098void SparcTargetInfo::getGCCRegNames(const char * const *&Names,
4099 unsigned &NumNames) const {
Chris Lattnere957f532009-01-27 01:58:38 +00004100 Names = GCCRegNames;
4101 NumNames = llvm::array_lengthof(GCCRegNames);
4102}
4103
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004104const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004105 { { "g0" }, "r0" },
4106 { { "g1" }, "r1" },
4107 { { "g2" }, "r2" },
4108 { { "g3" }, "r3" },
4109 { { "g4" }, "r4" },
4110 { { "g5" }, "r5" },
4111 { { "g6" }, "r6" },
4112 { { "g7" }, "r7" },
4113 { { "o0" }, "r8" },
4114 { { "o1" }, "r9" },
4115 { { "o2" }, "r10" },
4116 { { "o3" }, "r11" },
4117 { { "o4" }, "r12" },
4118 { { "o5" }, "r13" },
4119 { { "o6", "sp" }, "r14" },
4120 { { "o7" }, "r15" },
4121 { { "l0" }, "r16" },
4122 { { "l1" }, "r17" },
4123 { { "l2" }, "r18" },
4124 { { "l3" }, "r19" },
4125 { { "l4" }, "r20" },
4126 { { "l5" }, "r21" },
4127 { { "l6" }, "r22" },
4128 { { "l7" }, "r23" },
4129 { { "i0" }, "r24" },
4130 { { "i1" }, "r25" },
4131 { { "i2" }, "r26" },
4132 { { "i3" }, "r27" },
4133 { { "i4" }, "r28" },
4134 { { "i5" }, "r29" },
4135 { { "i6", "fp" }, "r30" },
4136 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00004137};
4138
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004139void SparcTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4140 unsigned &NumAliases) const {
Chris Lattnere957f532009-01-27 01:58:38 +00004141 Aliases = GCCRegAliases;
4142 NumAliases = llvm::array_lengthof(GCCRegAliases);
4143}
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004144
4145// SPARC v8 is the 32-bit mode selected by Triple::sparc.
4146class SparcV8TargetInfo : public SparcTargetInfo {
4147public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004148 SparcV8TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004149 // FIXME: Support Sparc quad-precision long double?
4150 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
4151 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
4152 }
4153
4154 virtual void getTargetDefines(const LangOptions &Opts,
4155 MacroBuilder &Builder) const {
4156 SparcTargetInfo::getTargetDefines(Opts, Builder);
4157 Builder.defineMacro("__sparcv8");
4158 }
4159};
4160
4161// SPARC v9 is the 64-bit mode selected by Triple::sparcv9.
4162class SparcV9TargetInfo : public SparcTargetInfo {
4163public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004164 SparcV9TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004165 // FIXME: Support Sparc quad-precision long double?
4166 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
4167 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32:64-S128";
Jakob Stoklund Olesenfcec0c92013-05-15 03:22:33 +00004168 // This is an LP64 platform.
4169 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Jakob Stoklund Olesen5ac8c4f2013-05-19 17:53:37 +00004170
4171 // OpenBSD uses long long for int64_t and intmax_t.
4172 if (getTriple().getOS() == llvm::Triple::OpenBSD) {
4173 IntMaxType = SignedLongLong;
4174 UIntMaxType = UnsignedLongLong;
4175 } else {
4176 IntMaxType = SignedLong;
4177 UIntMaxType = UnsignedLong;
4178 }
4179 Int64Type = IntMaxType;
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004180 }
4181
4182 virtual void getTargetDefines(const LangOptions &Opts,
4183 MacroBuilder &Builder) const {
4184 SparcTargetInfo::getTargetDefines(Opts, Builder);
4185 Builder.defineMacro("__sparcv9");
Jakob Stoklund Olesen44f72d32013-04-24 04:36:38 +00004186 Builder.defineMacro("__arch64__");
4187 // Solaris and its derivative AuroraUX don't need these variants, but the
4188 // BSDs do.
4189 if (getTriple().getOS() != llvm::Triple::Solaris &&
4190 getTriple().getOS() != llvm::Triple::AuroraUX) {
4191 Builder.defineMacro("__sparc64__");
4192 Builder.defineMacro("__sparc_v9__");
4193 Builder.defineMacro("__sparcv9__");
4194 }
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004195 }
4196};
4197
Gabor Greif26658672008-02-21 16:29:08 +00004198} // end anonymous namespace.
4199
Eli Friedman01b86682008-08-20 07:28:14 +00004200namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004201class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
4202public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004203 AuroraUXSparcV8TargetInfo(const llvm::Triple &Triple)
4204 : AuroraUXTargetInfo<SparcV8TargetInfo>(Triple) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004205 SizeType = UnsignedInt;
4206 PtrDiffType = SignedInt;
4207 }
4208};
Torok Edwin5f6c1942009-06-30 17:10:35 +00004209class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00004210public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004211 SolarisSparcV8TargetInfo(const llvm::Triple &Triple)
4212 : SolarisTargetInfo<SparcV8TargetInfo>(Triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00004213 SizeType = UnsignedInt;
4214 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00004215 }
4216};
4217} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00004218
Chris Lattner2621fd12008-05-08 05:58:21 +00004219namespace {
Ulrich Weigandb8409212013-05-06 16:26:41 +00004220 class SystemZTargetInfo : public TargetInfo {
4221 static const char *const GCCRegNames[];
4222
4223 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004224 SystemZTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Ulrich Weigandb8409212013-05-06 16:26:41 +00004225 TLSSupported = true;
4226 IntWidth = IntAlign = 32;
4227 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
4228 PointerWidth = PointerAlign = 64;
4229 LongDoubleWidth = 128;
4230 LongDoubleAlign = 64;
4231 LongDoubleFormat = &llvm::APFloat::IEEEquad;
4232 MinGlobalAlign = 16;
4233 DescriptionString = "E-p:64:64:64-i1:8:16-i8:8:16-i16:16-i32:32-i64:64"
4234 "-f32:32-f64:64-f128:64-a0:8:16-n32:64";
4235 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
4236 }
4237 virtual void getTargetDefines(const LangOptions &Opts,
4238 MacroBuilder &Builder) const {
4239 Builder.defineMacro("__s390__");
4240 Builder.defineMacro("__s390x__");
4241 Builder.defineMacro("__zarch__");
4242 Builder.defineMacro("__LONG_DOUBLE_128__");
4243 }
4244 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4245 unsigned &NumRecords) const {
4246 // FIXME: Implement.
4247 Records = 0;
4248 NumRecords = 0;
4249 }
4250
4251 virtual void getGCCRegNames(const char *const *&Names,
4252 unsigned &NumNames) const;
4253 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4254 unsigned &NumAliases) const {
4255 // No aliases.
4256 Aliases = 0;
4257 NumAliases = 0;
4258 }
4259 virtual bool validateAsmConstraint(const char *&Name,
4260 TargetInfo::ConstraintInfo &info) const;
4261 virtual const char *getClobbers() const {
4262 // FIXME: Is this really right?
4263 return "";
4264 }
4265 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4266 return TargetInfo::SystemZBuiltinVaList;
4267 }
Richard Sandiford5c92b9a2013-07-19 16:51:51 +00004268 virtual bool setCPU(const std::string &Name) {
4269 bool CPUKnown = llvm::StringSwitch<bool>(Name)
4270 .Case("z10", true)
4271 .Case("z196", true)
4272 .Case("zEC12", true)
4273 .Default(false);
4274
4275 // No need to store the CPU yet. There aren't any CPU-specific
4276 // macros to define.
4277 return CPUKnown;
4278 }
Ulrich Weigandb8409212013-05-06 16:26:41 +00004279 };
4280
4281 const char *const SystemZTargetInfo::GCCRegNames[] = {
4282 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4283 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4284 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
4285 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15"
4286 };
4287
4288 void SystemZTargetInfo::getGCCRegNames(const char *const *&Names,
4289 unsigned &NumNames) const {
4290 Names = GCCRegNames;
4291 NumNames = llvm::array_lengthof(GCCRegNames);
4292 }
4293
4294 bool SystemZTargetInfo::
4295 validateAsmConstraint(const char *&Name,
4296 TargetInfo::ConstraintInfo &Info) const {
4297 switch (*Name) {
4298 default:
4299 return false;
4300
4301 case 'a': // Address register
4302 case 'd': // Data register (equivalent to 'r')
4303 case 'f': // Floating-point register
4304 Info.setAllowsRegister();
4305 return true;
4306
4307 case 'I': // Unsigned 8-bit constant
4308 case 'J': // Unsigned 12-bit constant
4309 case 'K': // Signed 16-bit constant
4310 case 'L': // Signed 20-bit displacement (on all targets we support)
4311 case 'M': // 0x7fffffff
4312 return true;
4313
4314 case 'Q': // Memory with base and unsigned 12-bit displacement
4315 case 'R': // Likewise, plus an index
4316 case 'S': // Memory with base and signed 20-bit displacement
4317 case 'T': // Likewise, plus an index
4318 Info.setAllowsMemory();
4319 return true;
4320 }
4321 }
4322}
4323
4324namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004325 class MSP430TargetInfo : public TargetInfo {
4326 static const char * const GCCRegNames[];
4327 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004328 MSP430TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004329 BigEndian = false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004330 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00004331 IntWidth = 16; IntAlign = 16;
4332 LongWidth = 32; LongLongWidth = 64;
4333 LongAlign = LongLongAlign = 16;
4334 PointerWidth = 16; PointerAlign = 16;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004335 SuitableAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004336 SizeType = UnsignedInt;
Anton Korobeynikov18a295d2013-07-01 19:42:40 +00004337 IntMaxType = SignedLongLong;
4338 UIntMaxType = UnsignedLongLong;
4339 IntPtrType = SignedInt;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004340 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00004341 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00004342 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004343 }
4344 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004345 MacroBuilder &Builder) const {
4346 Builder.defineMacro("MSP430");
4347 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004348 // FIXME: defines for different 'flavours' of MCU
4349 }
4350 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4351 unsigned &NumRecords) const {
4352 // FIXME: Implement.
4353 Records = 0;
4354 NumRecords = 0;
4355 }
Douglas Gregore727d212012-01-30 06:38:25 +00004356 virtual bool hasFeature(StringRef Feature) const {
4357 return Feature == "msp430";
4358 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004359 virtual void getGCCRegNames(const char * const *&Names,
4360 unsigned &NumNames) const;
4361 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4362 unsigned &NumAliases) const {
4363 // No aliases.
4364 Aliases = 0;
4365 NumAliases = 0;
4366 }
4367 virtual bool validateAsmConstraint(const char *&Name,
4368 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00004369 // No target constraints for now.
4370 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004371 }
4372 virtual const char *getClobbers() const {
4373 // FIXME: Is this really right?
4374 return "";
4375 }
Meador Ingec5613b22012-06-16 03:34:49 +00004376 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004377 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00004378 return TargetInfo::CharPtrBuiltinVaList;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004379 }
4380 };
4381
4382 const char * const MSP430TargetInfo::GCCRegNames[] = {
4383 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4384 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
4385 };
4386
4387 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
4388 unsigned &NumNames) const {
4389 Names = GCCRegNames;
4390 NumNames = llvm::array_lengthof(GCCRegNames);
4391 }
4392}
4393
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00004394namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00004395
Mike Stump1eb44332009-09-09 15:08:12 +00004396 // LLVM and Clang cannot be used directly to output native binaries for
4397 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00004398 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00004399 //
4400 // TCE uses the llvm bitcode as input and uses it for generating customized
4401 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00004402 // publicly available in http://tce.cs.tut.fi
4403
Eli Friedman209f5bb2011-10-07 19:51:42 +00004404 static const unsigned TCEOpenCLAddrSpaceMap[] = {
4405 3, // opencl_global
4406 4, // opencl_local
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00004407 5, // opencl_constant
4408 0, // cuda_device
4409 0, // cuda_constant
4410 0 // cuda_shared
Eli Friedman209f5bb2011-10-07 19:51:42 +00004411 };
4412
Eli Friedmanb63decf2009-08-19 20:47:07 +00004413 class TCETargetInfo : public TargetInfo{
4414 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004415 TCETargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmanb63decf2009-08-19 20:47:07 +00004416 TLSSupported = false;
4417 IntWidth = 32;
4418 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004419 PointerWidth = 32;
4420 IntAlign = 32;
4421 LongAlign = LongLongAlign = 32;
4422 PointerAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004423 SuitableAlign = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004424 SizeType = UnsignedInt;
4425 IntMaxType = SignedLong;
4426 UIntMaxType = UnsignedLong;
4427 IntPtrType = SignedInt;
4428 PtrDiffType = SignedInt;
4429 FloatWidth = 32;
4430 FloatAlign = 32;
4431 DoubleWidth = 32;
4432 DoubleAlign = 32;
4433 LongDoubleWidth = 32;
4434 LongDoubleAlign = 32;
4435 FloatFormat = &llvm::APFloat::IEEEsingle;
4436 DoubleFormat = &llvm::APFloat::IEEEsingle;
4437 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00004438 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
4439 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00004440 "f32:32:32-f64:32:32-v64:32:32-"
4441 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00004442 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004443 }
4444
4445 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004446 MacroBuilder &Builder) const {
4447 DefineStd(Builder, "tce", Opts);
4448 Builder.defineMacro("__TCE__");
4449 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00004450 }
Douglas Gregore727d212012-01-30 06:38:25 +00004451 virtual bool hasFeature(StringRef Feature) const {
4452 return Feature == "tce";
4453 }
4454
Eli Friedmanb63decf2009-08-19 20:47:07 +00004455 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4456 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00004457 virtual const char *getClobbers() const {
4458 return "";
4459 }
Meador Ingec5613b22012-06-16 03:34:49 +00004460 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4461 return TargetInfo::VoidPtrBuiltinVaList;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004462 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00004463 virtual void getGCCRegNames(const char * const *&Names,
4464 unsigned &NumNames) const {}
4465 virtual bool validateAsmConstraint(const char *&Name,
4466 TargetInfo::ConstraintInfo &info) const {
4467 return true;
4468 }
4469 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4470 unsigned &NumAliases) const {}
4471 };
4472}
4473
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004474namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004475class MipsTargetInfoBase : public TargetInfo {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004476 static const Builtin::Info BuiltinInfo[];
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004477 std::string CPU;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004478 bool IsMips16;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004479 bool IsMicromips;
Simon Atanasyand96e3152013-04-14 14:07:30 +00004480 bool IsSingleFloat;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004481 enum MipsFloatABI {
Simon Atanasyand96e3152013-04-14 14:07:30 +00004482 HardFloat, SoftFloat
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004483 } FloatABI;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004484 enum DspRevEnum {
4485 NoDSP, DSP1, DSP2
4486 } DspRev;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004487
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004488protected:
4489 std::string ABI;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004490
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004491public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004492 MipsTargetInfoBase(const llvm::Triple &Triple, const std::string &ABIStr,
4493 const std::string &CPUStr)
4494 : TargetInfo(Triple), CPU(CPUStr), IsMips16(false), IsMicromips(false),
4495 IsSingleFloat(false), FloatABI(HardFloat), DspRev(NoDSP), ABI(ABIStr) {}
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004496
Eric Christophered734732010-03-02 02:41:08 +00004497 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004498 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00004499 virtual bool setCPU(const std::string &Name) {
4500 CPU = Name;
4501 return true;
4502 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004503 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00004504 Features[ABI] = true;
4505 Features[CPU] = true;
4506 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004507
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004508 virtual void getTargetDefines(const LangOptions &Opts,
4509 MacroBuilder &Builder) const {
Simon Atanasyand4935a02012-08-29 19:14:58 +00004510 DefineStd(Builder, "mips", Opts);
4511 Builder.defineMacro("_mips");
4512 Builder.defineMacro("__REGISTER_PREFIX__", "");
4513
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004514 switch (FloatABI) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004515 case HardFloat:
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00004516 Builder.defineMacro("__mips_hard_float", Twine(1));
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004517 break;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004518 case SoftFloat:
4519 Builder.defineMacro("__mips_soft_float", Twine(1));
4520 break;
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00004521 }
Simon Atanasyan90913892012-04-05 19:28:31 +00004522
Simon Atanasyand96e3152013-04-14 14:07:30 +00004523 if (IsSingleFloat)
4524 Builder.defineMacro("__mips_single_float", Twine(1));
4525
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004526 if (IsMips16)
4527 Builder.defineMacro("__mips16", Twine(1));
4528
Simon Atanasyan321ae792013-04-14 14:07:51 +00004529 if (IsMicromips)
4530 Builder.defineMacro("__mips_micromips", Twine(1));
4531
Simon Atanasyana1b62272012-07-05 20:16:22 +00004532 switch (DspRev) {
4533 default:
4534 break;
4535 case DSP1:
4536 Builder.defineMacro("__mips_dsp_rev", Twine(1));
4537 Builder.defineMacro("__mips_dsp", Twine(1));
4538 break;
4539 case DSP2:
4540 Builder.defineMacro("__mips_dsp_rev", Twine(2));
4541 Builder.defineMacro("__mips_dspr2", Twine(1));
4542 Builder.defineMacro("__mips_dsp", Twine(1));
4543 break;
4544 }
4545
Simon Atanasyan90913892012-04-05 19:28:31 +00004546 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
4547 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
4548 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
Simon Atanasyan260e5062012-08-29 15:17:29 +00004549
4550 Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
4551 Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004552 }
4553
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004554 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4555 unsigned &NumRecords) const {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004556 Records = BuiltinInfo;
4557 NumRecords = clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004558 }
Douglas Gregore727d212012-01-30 06:38:25 +00004559 virtual bool hasFeature(StringRef Feature) const {
4560 return Feature == "mips";
4561 }
Meador Ingec5613b22012-06-16 03:34:49 +00004562 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4563 return TargetInfo::VoidPtrBuiltinVaList;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004564 }
4565 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004566 unsigned &NumNames) const {
4567 static const char * const GCCRegNames[] = {
Eric Christopherd1f853d2012-03-27 19:56:11 +00004568 // CPU register names
4569 // Must match second column of GCCRegAliases
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004570 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
4571 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
4572 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004573 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",
4574 // Floating point register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004575 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
4576 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
4577 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
4578 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004579 // Hi/lo and condition register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004580 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
4581 "$fcc5","$fcc6","$fcc7"
4582 };
4583 Names = GCCRegNames;
4584 NumNames = llvm::array_lengthof(GCCRegNames);
4585 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004586 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004587 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004588 virtual bool validateAsmConstraint(const char *&Name,
4589 TargetInfo::ConstraintInfo &Info) const {
4590 switch (*Name) {
4591 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00004592 return false;
4593
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004594 case 'r': // CPU registers.
4595 case 'd': // Equivalent to "r" unless generating MIPS16 code.
4596 case 'y': // Equivalent to "r", backwards compatibility only.
4597 case 'f': // floating-point registers.
Eric Christopher0ea61642012-04-03 01:16:32 +00004598 case 'c': // $25 for indirect jumps
4599 case 'l': // lo register
4600 case 'x': // hilo register pair
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004601 Info.setAllowsRegister();
4602 return true;
Jack Carter97102302013-03-05 19:10:54 +00004603 case 'R': // An address that can be used in a non-macro load or store
Jack Carterd2ab6d32013-03-04 21:36:11 +00004604 Info.setAllowsMemory();
4605 return true;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004606 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004607 }
4608
4609 virtual const char *getClobbers() const {
4610 // FIXME: Implement!
4611 return "";
4612 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004613
4614 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
4615 StringRef Name,
4616 bool Enabled) const {
Simon Atanasyan8b2a5d22012-04-18 12:00:11 +00004617 if (Name == "soft-float" || Name == "single-float" ||
4618 Name == "o32" || Name == "n32" || Name == "n64" || Name == "eabi" ||
4619 Name == "mips32" || Name == "mips32r2" ||
Simon Atanasyan0b273ef2012-07-05 14:19:39 +00004620 Name == "mips64" || Name == "mips64r2" ||
Simon Atanasyan321ae792013-04-14 14:07:51 +00004621 Name == "mips16" || Name == "micromips" ||
4622 Name == "dsp" || Name == "dspr2") {
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004623 Features[Name] = Enabled;
4624 return true;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004625 } else if (Name == "32") {
4626 Features["o32"] = Enabled;
4627 return true;
4628 } else if (Name == "64") {
4629 Features["n64"] = Enabled;
4630 return true;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004631 }
4632 return false;
4633 }
4634
4635 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004636 IsMips16 = false;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004637 IsMicromips = false;
Simon Atanasyand96e3152013-04-14 14:07:30 +00004638 IsSingleFloat = false;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004639 FloatABI = HardFloat;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004640 DspRev = NoDSP;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004641
4642 for (std::vector<std::string>::iterator it = Features.begin(),
4643 ie = Features.end(); it != ie; ++it) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004644 if (*it == "+single-float")
Simon Atanasyand96e3152013-04-14 14:07:30 +00004645 IsSingleFloat = true;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004646 else if (*it == "+soft-float")
4647 FloatABI = SoftFloat;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004648 else if (*it == "+mips16")
4649 IsMips16 = true;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004650 else if (*it == "+micromips")
4651 IsMicromips = true;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004652 else if (*it == "+dsp")
4653 DspRev = std::max(DspRev, DSP1);
4654 else if (*it == "+dspr2")
4655 DspRev = std::max(DspRev, DSP2);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004656 }
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004657
4658 // Remove front-end specific option.
4659 std::vector<std::string>::iterator it =
4660 std::find(Features.begin(), Features.end(), "+soft-float");
4661 if (it != Features.end())
4662 Features.erase(it);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004663 }
Logan Chiena8f7a972013-02-23 04:24:36 +00004664
4665 virtual int getEHDataRegisterNumber(unsigned RegNo) const {
4666 if (RegNo == 0) return 4;
4667 if (RegNo == 1) return 5;
4668 return -1;
4669 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004670};
4671
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004672const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = {
4673#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4674#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4675 ALL_LANGUAGES },
4676#include "clang/Basic/BuiltinsMips.def"
4677};
4678
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004679class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004680public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004681 Mips32TargetInfoBase(const llvm::Triple &Triple)
4682 : MipsTargetInfoBase(Triple, "o32", "mips32") {
Akira Hatanaka148735e2011-11-05 01:48:34 +00004683 SizeType = UnsignedInt;
4684 PtrDiffType = SignedInt;
Akira Hatanakadbee9492013-01-18 21:58:11 +00004685 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Akira Hatanaka148735e2011-11-05 01:48:34 +00004686 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004687 virtual bool setABI(const std::string &Name) {
4688 if ((Name == "o32") || (Name == "eabi")) {
4689 ABI = Name;
4690 return true;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004691 } else if (Name == "32") {
4692 ABI = "o32";
4693 return true;
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004694 } else
4695 return false;
4696 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004697 virtual void getTargetDefines(const LangOptions &Opts,
4698 MacroBuilder &Builder) const {
4699 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004700
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004701 if (ABI == "o32") {
4702 Builder.defineMacro("__mips_o32");
4703 Builder.defineMacro("_ABIO32", "1");
4704 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
4705 }
4706 else if (ABI == "eabi")
4707 Builder.defineMacro("__mips_eabi");
4708 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004709 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004710 }
4711 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4712 unsigned &NumAliases) const {
4713 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4714 { { "at" }, "$1" },
4715 { { "v0" }, "$2" },
4716 { { "v1" }, "$3" },
4717 { { "a0" }, "$4" },
4718 { { "a1" }, "$5" },
4719 { { "a2" }, "$6" },
4720 { { "a3" }, "$7" },
4721 { { "t0" }, "$8" },
4722 { { "t1" }, "$9" },
4723 { { "t2" }, "$10" },
4724 { { "t3" }, "$11" },
4725 { { "t4" }, "$12" },
4726 { { "t5" }, "$13" },
4727 { { "t6" }, "$14" },
4728 { { "t7" }, "$15" },
4729 { { "s0" }, "$16" },
4730 { { "s1" }, "$17" },
4731 { { "s2" }, "$18" },
4732 { { "s3" }, "$19" },
4733 { { "s4" }, "$20" },
4734 { { "s5" }, "$21" },
4735 { { "s6" }, "$22" },
4736 { { "s7" }, "$23" },
4737 { { "t8" }, "$24" },
4738 { { "t9" }, "$25" },
4739 { { "k0" }, "$26" },
4740 { { "k1" }, "$27" },
4741 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004742 { { "sp","$sp" }, "$29" },
4743 { { "fp","$fp" }, "$30" },
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004744 { { "ra" }, "$31" }
4745 };
4746 Aliases = GCCRegAliases;
4747 NumAliases = llvm::array_lengthof(GCCRegAliases);
4748 }
4749};
4750
4751class Mips32EBTargetInfo : public Mips32TargetInfoBase {
4752public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004753 Mips32EBTargetInfo(const llvm::Triple &Triple)
4754 : Mips32TargetInfoBase(Triple) {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004755 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:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004768 Mips32ELTargetInfo(const llvm::Triple &Triple)
4769 : Mips32TargetInfoBase(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004770 BigEndian = false;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004771 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 +00004772 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004773 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004774 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004775 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004776 DefineStd(Builder, "MIPSEL", Opts);
4777 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004778 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004779 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004780};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004781
4782class Mips64TargetInfoBase : public MipsTargetInfoBase {
4783 virtual void SetDescriptionString(const std::string &Name) = 0;
4784public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004785 Mips64TargetInfoBase(const llvm::Triple &Triple)
4786 : MipsTargetInfoBase(Triple, "n64", "mips64") {
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004787 LongWidth = LongAlign = 64;
4788 PointerWidth = PointerAlign = 64;
4789 LongDoubleWidth = LongDoubleAlign = 128;
4790 LongDoubleFormat = &llvm::APFloat::IEEEquad;
David Chisnall6e399b42012-12-08 09:06:08 +00004791 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
4792 LongDoubleWidth = LongDoubleAlign = 64;
4793 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
4794 }
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004795 SuitableAlign = 128;
Akira Hatanakadbee9492013-01-18 21:58:11 +00004796 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004797 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004798 virtual bool setABI(const std::string &Name) {
4799 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004800 if (Name == "n32") {
4801 LongWidth = LongAlign = 32;
4802 PointerWidth = PointerAlign = 32;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004803 ABI = Name;
4804 return true;
4805 } else if (Name == "n64") {
4806 ABI = Name;
4807 return true;
4808 } else if (Name == "64") {
4809 ABI = "n64";
4810 return true;
4811 } else
4812 return false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004813 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004814 virtual void getTargetDefines(const LangOptions &Opts,
4815 MacroBuilder &Builder) const {
4816 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004817
Simon Atanasyan600a5132012-08-29 20:50:11 +00004818 Builder.defineMacro("__mips64");
4819 Builder.defineMacro("__mips64__");
4820
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004821 if (ABI == "n32") {
4822 Builder.defineMacro("__mips_n32");
4823 Builder.defineMacro("_ABIN32", "2");
4824 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
4825 }
4826 else if (ABI == "n64") {
4827 Builder.defineMacro("__mips_n64");
4828 Builder.defineMacro("_ABI64", "3");
4829 Builder.defineMacro("_MIPS_SIM", "_ABI64");
4830 }
4831 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004832 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004833 }
4834 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4835 unsigned &NumAliases) const {
4836 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4837 { { "at" }, "$1" },
4838 { { "v0" }, "$2" },
4839 { { "v1" }, "$3" },
4840 { { "a0" }, "$4" },
4841 { { "a1" }, "$5" },
4842 { { "a2" }, "$6" },
4843 { { "a3" }, "$7" },
4844 { { "a4" }, "$8" },
4845 { { "a5" }, "$9" },
4846 { { "a6" }, "$10" },
4847 { { "a7" }, "$11" },
4848 { { "t0" }, "$12" },
4849 { { "t1" }, "$13" },
4850 { { "t2" }, "$14" },
4851 { { "t3" }, "$15" },
4852 { { "s0" }, "$16" },
4853 { { "s1" }, "$17" },
4854 { { "s2" }, "$18" },
4855 { { "s3" }, "$19" },
4856 { { "s4" }, "$20" },
4857 { { "s5" }, "$21" },
4858 { { "s6" }, "$22" },
4859 { { "s7" }, "$23" },
4860 { { "t8" }, "$24" },
4861 { { "t9" }, "$25" },
4862 { { "k0" }, "$26" },
4863 { { "k1" }, "$27" },
4864 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004865 { { "sp","$sp" }, "$29" },
4866 { { "fp","$fp" }, "$30" },
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004867 { { "ra" }, "$31" }
4868 };
4869 Aliases = GCCRegAliases;
4870 NumAliases = llvm::array_lengthof(GCCRegAliases);
4871 }
4872};
4873
4874class Mips64EBTargetInfo : public Mips64TargetInfoBase {
4875 virtual void SetDescriptionString(const std::string &Name) {
4876 // Change DescriptionString only if ABI is n32.
4877 if (Name == "n32")
4878 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 +00004879 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004880 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004881 }
4882public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004883 Mips64EBTargetInfo(const llvm::Triple &Triple)
4884 : Mips64TargetInfoBase(Triple) {
4885 // Default ABI is n64.
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004886 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 +00004887 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004888 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004889 }
4890 virtual void getTargetDefines(const LangOptions &Opts,
4891 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004892 DefineStd(Builder, "MIPSEB", Opts);
4893 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004894 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004895 }
4896};
4897
4898class Mips64ELTargetInfo : public Mips64TargetInfoBase {
4899 virtual void SetDescriptionString(const std::string &Name) {
4900 // Change DescriptionString only if ABI is n32.
4901 if (Name == "n32")
4902 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 +00004903 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004904 "-v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004905 }
4906public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004907 Mips64ELTargetInfo(const llvm::Triple &Triple)
4908 : Mips64TargetInfoBase(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004909 // Default ABI is n64.
4910 BigEndian = false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004911 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 +00004912 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004913 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004914 }
4915 virtual void getTargetDefines(const LangOptions &Opts,
4916 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004917 DefineStd(Builder, "MIPSEL", Opts);
4918 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004919 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004920 }
4921};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004922} // end anonymous namespace.
4923
Ivan Krasinef05abd2011-08-24 20:22:22 +00004924namespace {
4925class PNaClTargetInfo : public TargetInfo {
4926public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004927 PNaClTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004928 BigEndian = false;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004929 this->UserLabelPrefix = "";
4930 this->LongAlign = 32;
4931 this->LongWidth = 32;
4932 this->PointerAlign = 32;
4933 this->PointerWidth = 32;
4934 this->IntMaxType = TargetInfo::SignedLongLong;
4935 this->UIntMaxType = TargetInfo::UnsignedLongLong;
4936 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00004937 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00004938 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00004939 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00004940 this->SizeType = TargetInfo::UnsignedInt;
4941 this->PtrDiffType = TargetInfo::SignedInt;
4942 this->IntPtrType = TargetInfo::SignedInt;
Eli Benderskyc0783dc2013-04-08 21:31:01 +00004943 this->RegParmMax = 0; // Disallow regparm
Ivan Krasinef05abd2011-08-24 20:22:22 +00004944 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
4945 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
4946 }
4947
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004948 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00004949 }
4950 virtual void getArchDefines(const LangOptions &Opts,
4951 MacroBuilder &Builder) const {
4952 Builder.defineMacro("__le32__");
4953 Builder.defineMacro("__pnacl__");
4954 }
4955 virtual void getTargetDefines(const LangOptions &Opts,
4956 MacroBuilder &Builder) const {
Jan Wen Voungdde3bdb2012-03-29 00:05:59 +00004957 Builder.defineMacro("__LITTLE_ENDIAN__");
Ivan Krasinef05abd2011-08-24 20:22:22 +00004958 getArchDefines(Opts, Builder);
4959 }
Douglas Gregore727d212012-01-30 06:38:25 +00004960 virtual bool hasFeature(StringRef Feature) const {
4961 return Feature == "pnacl";
4962 }
Ivan Krasinef05abd2011-08-24 20:22:22 +00004963 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4964 unsigned &NumRecords) const {
4965 }
Meador Ingec5613b22012-06-16 03:34:49 +00004966 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4967 return TargetInfo::PNaClABIBuiltinVaList;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004968 }
4969 virtual void getGCCRegNames(const char * const *&Names,
4970 unsigned &NumNames) const;
4971 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4972 unsigned &NumAliases) const;
4973 virtual bool validateAsmConstraint(const char *&Name,
4974 TargetInfo::ConstraintInfo &Info) const {
4975 return false;
4976 }
4977
4978 virtual const char *getClobbers() const {
4979 return "";
4980 }
4981};
4982
4983void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
4984 unsigned &NumNames) const {
4985 Names = NULL;
4986 NumNames = 0;
4987}
4988
4989void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4990 unsigned &NumAliases) const {
4991 Aliases = NULL;
4992 NumAliases = 0;
4993}
4994} // end anonymous namespace.
4995
Guy Benyeibd5da3c2012-12-11 21:38:14 +00004996namespace {
4997 static const unsigned SPIRAddrSpaceMap[] = {
4998 1, // opencl_global
4999 3, // opencl_local
5000 2, // opencl_constant
5001 0, // cuda_device
5002 0, // cuda_constant
5003 0 // cuda_shared
5004 };
5005 class SPIRTargetInfo : public TargetInfo {
5006 static const char * const GCCRegNames[];
5007 static const Builtin::Info BuiltinInfo[];
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00005008 std::vector<StringRef> AvailableFeatures;
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005009 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005010 SPIRTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005011 assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
5012 "SPIR target must use unknown OS");
5013 assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
5014 "SPIR target must use unknown environment type");
5015 BigEndian = false;
5016 TLSSupported = false;
5017 LongWidth = LongAlign = 64;
5018 AddrSpaceMap = &SPIRAddrSpaceMap;
5019 // Define available target features
5020 // These must be defined in sorted order!
5021 NoAsmVariants = true;
5022 }
5023 virtual void getTargetDefines(const LangOptions &Opts,
5024 MacroBuilder &Builder) const {
5025 DefineStd(Builder, "SPIR", Opts);
5026 }
5027 virtual bool hasFeature(StringRef Feature) const {
5028 return Feature == "spir";
5029 }
5030
5031 virtual void getTargetBuiltins(const Builtin::Info *&Records,
5032 unsigned &NumRecords) const {}
5033 virtual const char *getClobbers() const {
5034 return "";
5035 }
5036 virtual void getGCCRegNames(const char * const *&Names,
5037 unsigned &NumNames) const {}
5038 virtual bool validateAsmConstraint(const char *&Name,
5039 TargetInfo::ConstraintInfo &info) const {
5040 return true;
5041 }
5042 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
5043 unsigned &NumAliases) const {}
5044 virtual BuiltinVaListKind getBuiltinVaListKind() const {
5045 return TargetInfo::VoidPtrBuiltinVaList;
5046 }
5047 };
5048
5049
5050 class SPIR32TargetInfo : public SPIRTargetInfo {
5051 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005052 SPIR32TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005053 PointerWidth = PointerAlign = 32;
5054 SizeType = TargetInfo::UnsignedInt;
5055 PtrDiffType = IntPtrType = TargetInfo::SignedInt;
5056 DescriptionString
Guy Benyeif3ddf632013-03-07 13:06:10 +00005057 = "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 +00005058 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-"
5059 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-"
5060 "v512:512:512-v1024:1024:1024";
Guy Benyeif3ddf632013-03-07 13:06:10 +00005061 }
5062 virtual void getTargetDefines(const LangOptions &Opts,
5063 MacroBuilder &Builder) const {
5064 DefineStd(Builder, "SPIR32", Opts);
5065 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005066 };
5067
5068 class SPIR64TargetInfo : public SPIRTargetInfo {
5069 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005070 SPIR64TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005071 PointerWidth = PointerAlign = 64;
5072 SizeType = TargetInfo::UnsignedLong;
5073 PtrDiffType = IntPtrType = TargetInfo::SignedLong;
5074 DescriptionString
Guy Benyeif3ddf632013-03-07 13:06:10 +00005075 = "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 +00005076 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-"
5077 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-"
5078 "v512:512:512-v1024:1024:1024";
Guy Benyeif3ddf632013-03-07 13:06:10 +00005079 }
5080 virtual void getTargetDefines(const LangOptions &Opts,
5081 MacroBuilder &Builder) const {
5082 DefineStd(Builder, "SPIR64", Opts);
5083 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005084 };
5085}
5086
Ivan Krasinef05abd2011-08-24 20:22:22 +00005087
Reid Spencer5f016e22007-07-11 17:01:13 +00005088//===----------------------------------------------------------------------===//
5089// Driver code
5090//===----------------------------------------------------------------------===//
5091
Benjamin Kramer9df08232013-06-29 16:37:14 +00005092static TargetInfo *AllocateTarget(const llvm::Triple &Triple) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005093 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00005094
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005095 switch (Triple.getArch()) {
5096 default:
5097 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00005098
Tony Linthicum96319392011-12-12 21:14:55 +00005099 case llvm::Triple::hexagon:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005100 return new HexagonTargetInfo(Triple);
Tony Linthicum96319392011-12-12 21:14:55 +00005101
Tim Northoverc264e162013-01-31 12:13:10 +00005102 case llvm::Triple::aarch64:
5103 switch (os) {
5104 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005105 return new LinuxTargetInfo<AArch64TargetInfo>(Triple);
Tim Northoverc264e162013-01-31 12:13:10 +00005106 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005107 return new AArch64TargetInfo(Triple);
Tim Northoverc264e162013-01-31 12:13:10 +00005108 }
5109
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005110 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00005111 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005112 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005113 return new DarwinARMTargetInfo(Triple);
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005114
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005115 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00005116 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005117 return new LinuxTargetInfo<ARMTargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005118 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005119 return new FreeBSDTargetInfo<ARMTargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005120 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005121 return new NetBSDTargetInfo<ARMTargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005122 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005123 return new OpenBSDTargetInfo<ARMTargetInfo>(Triple);
Eli Friedman42f74f22012-08-08 23:57:20 +00005124 case llvm::Triple::Bitrig:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005125 return new BitrigTargetInfo<ARMTargetInfo>(Triple);
Douglas Gregordca52262011-07-01 22:41:14 +00005126 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005127 return new RTEMSTargetInfo<ARMTargetInfo>(Triple);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005128 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005129 return new NaClTargetInfo<ARMTargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005130 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005131 return new ARMTargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005132 }
Eli Friedman61538a72008-05-20 14:21:01 +00005133
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005134 case llvm::Triple::msp430:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005135 return new MSP430TargetInfo(Triple);
Eli Friedman61538a72008-05-20 14:21:01 +00005136
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005137 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005138 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005139 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005140 return new LinuxTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005141 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005142 return new RTEMSTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005143 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005144 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005145 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005146 return new NetBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005147 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005148 return new Mips32EBTargetInfo(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005149 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005150
5151 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005152 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005153 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005154 return new LinuxTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005155 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005156 return new RTEMSTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005157 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005158 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005159 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005160 return new NetBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005161 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005162 return new Mips32ELTargetInfo(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005163 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005164
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005165 case llvm::Triple::mips64:
5166 switch (os) {
5167 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005168 return new LinuxTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005169 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005170 return new RTEMSTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005171 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005172 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005173 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005174 return new NetBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005175 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005176 return new OpenBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005177 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005178 return new Mips64EBTargetInfo(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005179 }
5180
5181 case llvm::Triple::mips64el:
5182 switch (os) {
5183 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005184 return new LinuxTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005185 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005186 return new RTEMSTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005187 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005188 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005189 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005190 return new NetBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005191 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005192 return new OpenBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005193 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005194 return new Mips64ELTargetInfo(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005195 }
5196
Ivan Krasinef05abd2011-08-24 20:22:22 +00005197 case llvm::Triple::le32:
5198 switch (os) {
Eli Bendersky441d9f72012-12-04 18:38:10 +00005199 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005200 return new NaClTargetInfo<PNaClTargetInfo>(Triple);
Ivan Krasinef05abd2011-08-24 20:22:22 +00005201 default:
5202 return NULL;
5203 }
5204
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005205 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005206 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005207 return new DarwinPPC32TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005208 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005209 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005210 return new LinuxTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005211 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005212 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005213 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005214 return new NetBSDTargetInfo<PPC32TargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005215 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005216 return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005217 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005218 return new RTEMSTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005219 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005220 return new PPC32TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005221 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005222
5223 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005224 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005225 return new DarwinPPC64TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005226 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005227 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005228 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005229 case llvm::Triple::Lv2:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005230 return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005231 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005232 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005233 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005234 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005235 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005236 return new PPC64TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005237 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005238
Peter Collingbourneedb66f32012-05-20 23:28:41 +00005239 case llvm::Triple::nvptx:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005240 return new NVPTX32TargetInfo(Triple);
Peter Collingbourneedb66f32012-05-20 23:28:41 +00005241 case llvm::Triple::nvptx64:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005242 return new NVPTX64TargetInfo(Triple);
Peter Collingbourneedb66f32012-05-20 23:28:41 +00005243
Eli Friedman6505a292012-10-12 23:32:00 +00005244 case llvm::Triple::r600:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005245 return new R600TargetInfo(Triple);
Eli Friedman6505a292012-10-12 23:32:00 +00005246
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005247 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005248 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005249 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005250 return new LinuxTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005251 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005252 return new AuroraUXSparcV8TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005253 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005254 return new SolarisSparcV8TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005255 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005256 return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005257 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005258 return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005259 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005260 return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005261 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005262 return new SparcV8TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005263 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005264
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005265 case llvm::Triple::sparcv9:
5266 switch (os) {
5267 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005268 return new LinuxTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005269 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005270 return new AuroraUXTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005271 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005272 return new SolarisTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005273 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005274 return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005275 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005276 return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005277 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005278 return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005279 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005280 return new SparcV9TargetInfo(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005281 }
5282
Ulrich Weigandb8409212013-05-06 16:26:41 +00005283 case llvm::Triple::systemz:
5284 switch (os) {
5285 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005286 return new LinuxTargetInfo<SystemZTargetInfo>(Triple);
Ulrich Weigandb8409212013-05-06 16:26:41 +00005287 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005288 return new SystemZTargetInfo(Triple);
Ulrich Weigandb8409212013-05-06 16:26:41 +00005289 }
5290
Eli Friedmanb63decf2009-08-19 20:47:07 +00005291 case llvm::Triple::tce:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005292 return new TCETargetInfo(Triple);
Eli Friedmanb63decf2009-08-19 20:47:07 +00005293
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005294 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005295 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005296 return new DarwinI386TargetInfo(Triple);
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005297
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005298 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00005299 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005300 return new AuroraUXTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005301 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005302 return new LinuxTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005303 case llvm::Triple::DragonFly:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005304 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005305 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005306 return new NetBSDI386TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005307 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005308 return new OpenBSDI386TargetInfo(Triple);
Eli Friedman42f74f22012-08-08 23:57:20 +00005309 case llvm::Triple::Bitrig:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005310 return new BitrigI386TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005311 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005312 return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple);
Chris Lattner38e317d2010-07-07 16:01:42 +00005313 case llvm::Triple::Minix:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005314 return new MinixTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005315 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005316 return new SolarisTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005317 case llvm::Triple::Cygwin:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005318 return new CygwinX86_32TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005319 case llvm::Triple::MinGW32:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005320 return new MinGWX86_32TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005321 case llvm::Triple::Win32:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005322 return new VisualStudioWindowsX86_32TargetInfo(Triple);
Chris Lattner86ed3a32010-04-11 19:29:39 +00005323 case llvm::Triple::Haiku:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005324 return new HaikuX86_32TargetInfo(Triple);
Douglas Gregordca52262011-07-01 22:41:14 +00005325 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005326 return new RTEMSX86_32TargetInfo(Triple);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005327 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005328 return new NaClTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005329 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005330 return new X86_32TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005331 }
5332
5333 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005334 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
Benjamin Kramer9df08232013-06-29 16:37:14 +00005335 return new DarwinX86_64TargetInfo(Triple);
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005336
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005337 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00005338 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005339 return new AuroraUXTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005340 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005341 return new LinuxTargetInfo<X86_64TargetInfo>(Triple);
Chris Lattner7a7ca282010-01-09 05:41:14 +00005342 case llvm::Triple::DragonFly:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005343 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005344 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005345 return new NetBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005346 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005347 return new OpenBSDX86_64TargetInfo(Triple);
Eli Friedman42f74f22012-08-08 23:57:20 +00005348 case llvm::Triple::Bitrig:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005349 return new BitrigX86_64TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005350 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005351 return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005352 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005353 return new SolarisTargetInfo<X86_64TargetInfo>(Triple);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00005354 case llvm::Triple::MinGW32:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005355 return new MinGWX86_64TargetInfo(Triple);
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00005356 case llvm::Triple::Win32: // This is what Triple.h supports now.
Benjamin Kramer9df08232013-06-29 16:37:14 +00005357 return new VisualStudioWindowsX86_64TargetInfo(Triple);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005358 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005359 return new NaClTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005360 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005361 return new X86_64TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005362 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005363
5364 case llvm::Triple::spir: {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005365 if (Triple.getOS() != llvm::Triple::UnknownOS ||
Benjamin Kramer9df08232013-06-29 16:37:14 +00005366 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005367 return NULL;
Benjamin Kramer9df08232013-06-29 16:37:14 +00005368 return new SPIR32TargetInfo(Triple);
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005369 }
5370 case llvm::Triple::spir64: {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005371 if (Triple.getOS() != llvm::Triple::UnknownOS ||
Benjamin Kramer9df08232013-06-29 16:37:14 +00005372 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005373 return NULL;
Benjamin Kramer9df08232013-06-29 16:37:14 +00005374 return new SPIR64TargetInfo(Triple);
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005375 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005376 }
Reid Spencer5f016e22007-07-11 17:01:13 +00005377}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005378
5379/// CreateTargetInfo - Return the target info object for the specified target
5380/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00005381TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Douglas Gregor49a87542012-11-16 04:24:59 +00005382 TargetOptions *Opts) {
5383 llvm::Triple Triple(Opts->Triple);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005384
5385 // Construct the target
Benjamin Kramer9df08232013-06-29 16:37:14 +00005386 OwningPtr<TargetInfo> Target(AllocateTarget(Triple));
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005387 if (!Target) {
5388 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
5389 return 0;
5390 }
Douglas Gregor9a022bb2012-10-15 16:45:32 +00005391 Target->setTargetOpts(Opts);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005392
Daniel Dunbareac7c532009-12-18 18:42:37 +00005393 // Set the target CPU if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00005394 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
5395 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
Daniel Dunbareac7c532009-12-18 18:42:37 +00005396 return 0;
5397 }
5398
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005399 // Set the target ABI if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00005400 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
5401 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005402 return 0;
5403 }
5404
Charles Davis98b7c5c2010-06-11 01:06:47 +00005405 // Set the target C++ ABI.
Douglas Gregor49a87542012-11-16 04:24:59 +00005406 if (!Opts->CXXABI.empty() && !Target->setCXXABI(Opts->CXXABI)) {
5407 Diags.Report(diag::err_target_unknown_cxxabi) << Opts->CXXABI;
Charles Davis98b7c5c2010-06-11 01:06:47 +00005408 return 0;
5409 }
5410
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005411 // Compute the default target features, we need the target to handle this
5412 // because features may have dependencies on one another.
5413 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00005414 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005415
5416 // Apply the user specified deltas.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005417 // First the enables.
Douglas Gregor57016dd2012-10-16 23:40:58 +00005418 for (std::vector<std::string>::const_iterator
Douglas Gregor49a87542012-11-16 04:24:59 +00005419 it = Opts->FeaturesAsWritten.begin(),
5420 ie = Opts->FeaturesAsWritten.end();
Douglas Gregor57016dd2012-10-16 23:40:58 +00005421 it != ie; ++it) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005422 const char *Name = it->c_str();
5423
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005424 if (Name[0] != '+')
5425 continue;
5426
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005427 // Apply the feature via the target.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005428 if (!Target->setFeatureEnabled(Features, Name + 1, true)) {
5429 Diags.Report(diag::err_target_invalid_feature) << Name;
5430 return 0;
5431 }
5432 }
5433
5434 // Then the disables.
Douglas Gregor57016dd2012-10-16 23:40:58 +00005435 for (std::vector<std::string>::const_iterator
Douglas Gregor49a87542012-11-16 04:24:59 +00005436 it = Opts->FeaturesAsWritten.begin(),
5437 ie = Opts->FeaturesAsWritten.end();
Douglas Gregor57016dd2012-10-16 23:40:58 +00005438 it != ie; ++it) {
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005439 const char *Name = it->c_str();
5440
5441 if (Name[0] == '+')
5442 continue;
5443
5444 // Apply the feature via the target.
5445 if (Name[0] != '-' ||
5446 !Target->setFeatureEnabled(Features, Name + 1, false)) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005447 Diags.Report(diag::err_target_invalid_feature) << Name;
5448 return 0;
5449 }
5450 }
5451
5452 // Add the features to the compile options.
5453 //
5454 // FIXME: If we are completely confident that we have the right set, we only
5455 // need to pass the minuses.
Douglas Gregor49a87542012-11-16 04:24:59 +00005456 Opts->Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005457 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
5458 ie = Features.end(); it != ie; ++it)
Douglas Gregor49a87542012-11-16 04:24:59 +00005459 Opts->Features.push_back((it->second ? "+" : "-") + it->first().str());
5460 Target->HandleTargetFeatures(Opts->Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005461
5462 return Target.take();
5463}