blob: 084b6b364ebffa623c810eb84d41ae93e6347858 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- Targets.cpp - Implement -arch option and targets -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
Anton Korobeynikova7c47172009-05-03 13:42:53 +000010// This file implements construction of a TargetInfo object from a
Ted Kremenekbbced582007-12-12 18:05:32 +000011// target triple.
Reid Spencer5f016e22007-07-11 17:01:13 +000012//
13//===----------------------------------------------------------------------===//
14
Reid Spencer5f016e22007-07-11 17:01:13 +000015#include "clang/Basic/TargetInfo.h"
Daniel Dunbard58c03f2009-11-15 06:48:46 +000016#include "clang/Basic/Builtins.h"
17#include "clang/Basic/Diagnostic.h"
Chris Lattner8fc4dfb2008-12-04 22:54:33 +000018#include "clang/Basic/LangOptions.h"
Chandler Carruth103b71c2010-01-20 06:13:02 +000019#include "clang/Basic/MacroBuilder.h"
Daniel Dunbard58c03f2009-11-15 06:48:46 +000020#include "clang/Basic/TargetBuiltins.h"
21#include "clang/Basic/TargetOptions.h"
Eli Friedman25531262008-05-20 14:27:34 +000022#include "llvm/ADT/APFloat.h"
Daniel Dunbard58c03f2009-11-15 06:48:46 +000023#include "llvm/ADT/OwningPtr.h"
Daniel Dunbar29a790b2009-11-11 09:38:56 +000024#include "llvm/ADT/STLExtras.h"
Daniel Dunbar77659342009-08-19 20:04:03 +000025#include "llvm/ADT/StringRef.h"
Daniel Dunbar29a790b2009-11-11 09:38:56 +000026#include "llvm/ADT/StringSwitch.h"
Chris Lattner4c28b1c2009-08-12 06:24:27 +000027#include "llvm/ADT/Triple.h"
Chandler Carruth3b844ba2013-01-02 11:45:17 +000028#include "llvm/IR/Type.h"
Chris Lattner797c3c42009-08-10 19:03:04 +000029#include "llvm/MC/MCSectionMachO.h"
David Blaikie9fe8c742011-09-23 05:35:21 +000030#include "llvm/Support/ErrorHandling.h"
Benjamin Kramer48725082010-01-09 18:20:57 +000031#include <algorithm>
Reid Spencer5f016e22007-07-11 17:01:13 +000032using namespace clang;
33
Reid Spencer5f016e22007-07-11 17:01:13 +000034//===----------------------------------------------------------------------===//
35// Common code shared among targets.
36//===----------------------------------------------------------------------===//
37
Chris Lattnerca45cff2009-03-20 16:06:38 +000038/// DefineStd - Define a macro name and standard variants. For example if
39/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
40/// when in GNU mode.
Chris Lattner5f9e2722011-07-23 10:55:15 +000041static void DefineStd(MacroBuilder &Builder, StringRef MacroName,
Chris Lattnerca45cff2009-03-20 16:06:38 +000042 const LangOptions &Opts) {
43 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000044
Chris Lattnerca45cff2009-03-20 16:06:38 +000045 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
46 // in the user's namespace.
47 if (Opts.GNUMode)
Benjamin Kramera9992772010-01-09 17:55:51 +000048 Builder.defineMacro(MacroName);
Anton Korobeynikova7c47172009-05-03 13:42:53 +000049
Chris Lattnerca45cff2009-03-20 16:06:38 +000050 // Define __unix.
Benjamin Kramera9992772010-01-09 17:55:51 +000051 Builder.defineMacro("__" + MacroName);
Anton Korobeynikova7c47172009-05-03 13:42:53 +000052
Chris Lattnerca45cff2009-03-20 16:06:38 +000053 // Define __unix__.
Benjamin Kramera9992772010-01-09 17:55:51 +000054 Builder.defineMacro("__" + MacroName + "__");
Chris Lattnerca45cff2009-03-20 16:06:38 +000055}
56
Benjamin Kramer448f68d2012-01-10 11:50:09 +000057static void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName,
58 bool Tuning = true) {
59 Builder.defineMacro("__" + CPUName);
60 Builder.defineMacro("__" + CPUName + "__");
61 if (Tuning)
62 Builder.defineMacro("__tune_" + CPUName + "__");
63}
64
Chris Lattnerd29b6302008-10-05 21:50:58 +000065//===----------------------------------------------------------------------===//
66// Defines specific to certain operating systems.
67//===----------------------------------------------------------------------===//
Chris Lattner797c3c42009-08-10 19:03:04 +000068
Torok Edwin5f6c1942009-06-30 17:10:35 +000069namespace {
Douglas Gregora3844922009-07-01 15:12:53 +000070template<typename TgtInfo>
71class OSTargetInfo : public TgtInfo {
Torok Edwin5f6c1942009-06-30 17:10:35 +000072protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +000073 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +000074 MacroBuilder &Builder) const=0;
Torok Edwin5f6c1942009-06-30 17:10:35 +000075public:
Douglas Gregora3844922009-07-01 15:12:53 +000076 OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
Torok Edwin5f6c1942009-06-30 17:10:35 +000077 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +000078 MacroBuilder &Builder) const {
79 TgtInfo::getTargetDefines(Opts, Builder);
80 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Torok Edwinb0a5b242009-06-30 17:00:25 +000081 }
Torok Edwin5f6c1942009-06-30 17:10:35 +000082
83};
Chris Lattner4c28b1c2009-08-12 06:24:27 +000084} // end anonymous namespace
Torok Edwinb0a5b242009-06-30 17:00:25 +000085
Chris Lattner797c3c42009-08-10 19:03:04 +000086
Daniel Dunbar21ae3192010-01-26 01:44:04 +000087static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +000088 const llvm::Triple &Triple,
Chris Lattner5f9e2722011-07-23 10:55:15 +000089 StringRef &PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +000090 VersionTuple &PlatformMinVersion) {
Benjamin Kramera9992772010-01-09 17:55:51 +000091 Builder.defineMacro("__APPLE_CC__", "5621");
92 Builder.defineMacro("__APPLE__");
93 Builder.defineMacro("__MACH__");
94 Builder.defineMacro("OBJC_NEW_PROPERTIES");
Alexander Potapenko087c65f2012-09-20 10:10:01 +000095 // AddressSanitizer doesn't play well with source fortification, which is on
96 // by default on Darwin.
Will Dietz4f45bc02013-01-18 11:30:38 +000097 if (Opts.Sanitize.Address) Builder.defineMacro("_FORTIFY_SOURCE", "0");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000098
John McCall098df7f2011-06-16 00:03:19 +000099 if (!Opts.ObjCAutoRefCount) {
John McCallf85e1932011-06-15 23:02:42 +0000100 // __weak is always defined, for use in blocks and with objc pointers.
101 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000102
John McCallf85e1932011-06-15 23:02:42 +0000103 // Darwin defines __strong even in C mode (just to nothing).
Douglas Gregore289d812011-09-13 17:21:33 +0000104 if (Opts.getGC() != LangOptions::NonGC)
John McCallf85e1932011-06-15 23:02:42 +0000105 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
106 else
107 Builder.defineMacro("__strong", "");
Eric Christopher7c9adf92011-07-07 22:55:26 +0000108
John McCallf85e1932011-06-15 23:02:42 +0000109 // __unsafe_unretained is defined to nothing in non-ARC mode. We even
110 // allow this in C, since one might have block pointers in structs that
111 // are used in pure C code and in Objective-C ARC.
112 Builder.defineMacro("__unsafe_unretained", "");
John McCallf85e1932011-06-15 23:02:42 +0000113 }
Eric Christopher7c9adf92011-07-07 22:55:26 +0000114
Eli Friedman2de4fee2009-06-04 23:00:29 +0000115 if (Opts.Static)
Benjamin Kramera9992772010-01-09 17:55:51 +0000116 Builder.defineMacro("__STATIC__");
Eli Friedman2de4fee2009-06-04 23:00:29 +0000117 else
Benjamin Kramera9992772010-01-09 17:55:51 +0000118 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000119
120 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000121 Builder.defineMacro("_REENTRANT");
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000122
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000123 // Get the platform type and version number from the triple.
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000124 unsigned Maj, Min, Rev;
Bob Wilson48b68a02012-01-31 23:52:58 +0000125 if (Triple.isMacOSX()) {
126 Triple.getMacOSXVersion(Maj, Min, Rev);
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000127 PlatformName = "macosx";
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000128 } else {
Bob Wilson48b68a02012-01-31 23:52:58 +0000129 Triple.getOSVersion(Maj, Min, Rev);
130 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000131 }
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000132
Sebastian Pop9ec60df2012-01-20 22:01:23 +0000133 // If -target arch-pc-win32-macho option specified, we're
Eric Christopher895d4222011-07-29 21:20:35 +0000134 // generating code for Win32 ABI. No need to emit
Chad Rosierd9259f32011-07-19 20:00:06 +0000135 // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
136 if (PlatformName == "win32") {
137 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
138 return;
139 }
140
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000141 // Set the appropriate OS version define.
Bob Wilson48b68a02012-01-31 23:52:58 +0000142 if (Triple.getOS() == llvm::Triple::IOS) {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000143 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000144 char Str[6];
145 Str[0] = '0' + Maj;
146 Str[1] = '0' + (Min / 10);
147 Str[2] = '0' + (Min % 10);
148 Str[3] = '0' + (Rev / 10);
149 Str[4] = '0' + (Rev % 10);
150 Str[5] = '\0';
151 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
152 } else {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000153 // Note that the Driver allows versions which aren't representable in the
154 // define (because we only get a single digit for the minor and micro
155 // revision numbers). So, we limit them to the maximum representable
156 // version.
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000157 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000158 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000159 char Str[5];
160 Str[0] = '0' + (Maj / 10);
161 Str[1] = '0' + (Maj % 10);
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000162 Str[2] = '0' + std::min(Min, 9U);
163 Str[3] = '0' + std::min(Rev, 9U);
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000164 Str[4] = '\0';
165 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000166 }
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000167
168 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman618234a2008-08-20 02:34:37 +0000169}
Reid Spencer5f016e22007-07-11 17:01:13 +0000170
Chris Lattner797c3c42009-08-10 19:03:04 +0000171namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000172template<typename Target>
173class DarwinTargetInfo : public OSTargetInfo<Target> {
174protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000175 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000176 MacroBuilder &Builder) const {
Eric Christopher7c9adf92011-07-07 22:55:26 +0000177 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000178 this->PlatformMinVersion);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000179 }
Mike Stump1eb44332009-09-09 15:08:12 +0000180
Torok Edwin5f6c1942009-06-30 17:10:35 +0000181public:
182 DarwinTargetInfo(const std::string& triple) :
183 OSTargetInfo<Target>(triple) {
Eric Christopheraa7333c2011-07-02 00:20:22 +0000184 llvm::Triple T = llvm::Triple(triple);
185 this->TLSSupported = T.isMacOSX() && !T.isMacOSXVersionLT(10,7);
Daniel Dunbare177d3b2011-02-21 23:12:51 +0000186 this->MCountName = "\01mcount";
Torok Edwin5f6c1942009-06-30 17:10:35 +0000187 }
188
Chris Lattner5f9e2722011-07-23 10:55:15 +0000189 virtual std::string isValidSectionSpecifier(StringRef SR) const {
Chris Lattner797c3c42009-08-10 19:03:04 +0000190 // Let MCSectionMachO validate this.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000191 StringRef Segment, Section;
Chris Lattner797c3c42009-08-10 19:03:04 +0000192 unsigned TAA, StubSize;
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000193 bool HasTAA;
Chris Lattner797c3c42009-08-10 19:03:04 +0000194 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000195 TAA, HasTAA, StubSize);
Chris Lattner797c3c42009-08-10 19:03:04 +0000196 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000197
Anders Carlsson18af3682010-06-08 22:47:50 +0000198 virtual const char *getStaticInitSectionSpecifier() const {
199 // FIXME: We should return 0 when building kexts.
200 return "__TEXT,__StaticInit,regular,pure_instructions";
201 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000202
John McCall41887602012-01-29 01:20:30 +0000203 /// Darwin does not support protected visibility. Darwin's "default"
204 /// is very similar to ELF's "protected"; Darwin requires a "weak"
205 /// attribute on declarations that can be dynamically replaced.
206 virtual bool hasProtectedVisibility() const {
207 return false;
208 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000209};
210
Chris Lattner797c3c42009-08-10 19:03:04 +0000211
Torok Edwin5f6c1942009-06-30 17:10:35 +0000212// DragonFlyBSD Target
213template<typename Target>
214class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
215protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000216 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000217 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000218 // DragonFly defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000219 Builder.defineMacro("__DragonFly__");
220 Builder.defineMacro("__DragonFly_cc_version", "100001");
221 Builder.defineMacro("__ELF__");
222 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
223 Builder.defineMacro("__tune_i386__");
224 DefineStd(Builder, "unix", Opts);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000225 }
226public:
Mike Stump1eb44332009-09-09 15:08:12 +0000227 DragonFlyBSDTargetInfo(const std::string &triple)
Eli Friedmanb089c4d2012-02-10 23:02:29 +0000228 : OSTargetInfo<Target>(triple) {
229 this->UserLabelPrefix = "";
230
231 llvm::Triple Triple(triple);
232 switch (Triple.getArch()) {
233 default:
234 case llvm::Triple::x86:
235 case llvm::Triple::x86_64:
236 this->MCountName = ".mcount";
237 break;
238 }
239 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000240};
241
242// FreeBSD Target
243template<typename Target>
244class FreeBSDTargetInfo : public OSTargetInfo<Target> {
245protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000246 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000247 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000248 // FreeBSD defines; list based off of gcc output
249
Benjamin Kramer474202f2011-10-18 10:10:08 +0000250 unsigned Release = Triple.getOSMajorVersion();
251 if (Release == 0U)
252 Release = 8;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000253
Benjamin Kramer474202f2011-10-18 10:10:08 +0000254 Builder.defineMacro("__FreeBSD__", Twine(Release));
255 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramera9992772010-01-09 17:55:51 +0000256 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
257 DefineStd(Builder, "unix", Opts);
258 Builder.defineMacro("__ELF__");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000259 }
260public:
Mike Stump1eb44332009-09-09 15:08:12 +0000261 FreeBSDTargetInfo(const std::string &triple)
Duncan Sands1e90faf2009-07-08 13:55:08 +0000262 : OSTargetInfo<Target>(triple) {
263 this->UserLabelPrefix = "";
Roman Divackybe4c8702011-02-10 16:52:03 +0000264
265 llvm::Triple Triple(triple);
266 switch (Triple.getArch()) {
267 default:
268 case llvm::Triple::x86:
269 case llvm::Triple::x86_64:
270 this->MCountName = ".mcount";
271 break;
272 case llvm::Triple::mips:
273 case llvm::Triple::mipsel:
274 case llvm::Triple::ppc:
275 case llvm::Triple::ppc64:
276 this->MCountName = "_mcount";
277 break;
278 case llvm::Triple::arm:
279 this->MCountName = "__mcount";
280 break;
281 }
282
Duncan Sands1e90faf2009-07-08 13:55:08 +0000283 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000284};
285
Chris Lattner38e317d2010-07-07 16:01:42 +0000286// Minix Target
287template<typename Target>
288class MinixTargetInfo : public OSTargetInfo<Target> {
289protected:
290 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
291 MacroBuilder &Builder) const {
292 // Minix defines
293
294 Builder.defineMacro("__minix", "3");
295 Builder.defineMacro("_EM_WSIZE", "4");
296 Builder.defineMacro("_EM_PSIZE", "4");
297 Builder.defineMacro("_EM_SSIZE", "2");
298 Builder.defineMacro("_EM_LSIZE", "4");
299 Builder.defineMacro("_EM_FSIZE", "4");
300 Builder.defineMacro("_EM_DSIZE", "8");
Eli Friedman6d402dc2011-12-08 23:54:21 +0000301 Builder.defineMacro("__ELF__");
Chris Lattner38e317d2010-07-07 16:01:42 +0000302 DefineStd(Builder, "unix", Opts);
303 }
304public:
305 MinixTargetInfo(const std::string &triple)
306 : OSTargetInfo<Target>(triple) {
307 this->UserLabelPrefix = "";
308 }
309};
310
Torok Edwin5f6c1942009-06-30 17:10:35 +0000311// Linux target
312template<typename Target>
313class LinuxTargetInfo : public OSTargetInfo<Target> {
314protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000315 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000316 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000317 // Linux defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000318 DefineStd(Builder, "unix", Opts);
319 DefineStd(Builder, "linux", Opts);
320 Builder.defineMacro("__gnu_linux__");
321 Builder.defineMacro("__ELF__");
Logan Chien94a71422012-09-02 09:30:11 +0000322 if (Triple.getEnvironment() == llvm::Triple::Android)
Evgeniy Stepanov32064032012-04-26 12:08:09 +0000323 Builder.defineMacro("__ANDROID__", "1");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000324 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000325 Builder.defineMacro("_REENTRANT");
Douglas Gregor2b003fd2010-04-21 05:52:38 +0000326 if (Opts.CPlusPlus)
327 Builder.defineMacro("_GNU_SOURCE");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000328 }
329public:
Mike Stump1eb44332009-09-09 15:08:12 +0000330 LinuxTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000331 : OSTargetInfo<Target>(triple) {
332 this->UserLabelPrefix = "";
Douglas Gregor12e84642011-01-12 21:19:25 +0000333 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000334 }
Benjamin Kramer86d18c52011-10-15 17:53:33 +0000335
336 virtual const char *getStaticInitSectionSpecifier() const {
337 return ".text.startup";
338 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000339};
340
Chris Lattnerb62bb282009-07-13 20:29:08 +0000341// NetBSD Target
342template<typename Target>
343class NetBSDTargetInfo : public OSTargetInfo<Target> {
344protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000345 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000346 MacroBuilder &Builder) const {
Chris Lattnerb62bb282009-07-13 20:29:08 +0000347 // NetBSD defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000348 Builder.defineMacro("__NetBSD__");
349 Builder.defineMacro("__unix__");
350 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000351 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000352 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerb62bb282009-07-13 20:29:08 +0000353 }
354public:
Mike Stump1eb44332009-09-09 15:08:12 +0000355 NetBSDTargetInfo(const std::string &triple)
Chris Lattnerb62bb282009-07-13 20:29:08 +0000356 : OSTargetInfo<Target>(triple) {
357 this->UserLabelPrefix = "";
358 }
359};
360
Torok Edwin5f6c1942009-06-30 17:10:35 +0000361// OpenBSD Target
362template<typename Target>
363class OpenBSDTargetInfo : public OSTargetInfo<Target> {
364protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000365 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000366 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000367 // OpenBSD defines; list based off of gcc output
368
Benjamin Kramera9992772010-01-09 17:55:51 +0000369 Builder.defineMacro("__OpenBSD__");
370 DefineStd(Builder, "unix", Opts);
371 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000372 if (Opts.POSIXThreads)
Chris Lattner4ddcf3b2012-04-25 06:12:24 +0000373 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000374 }
375public:
Mike Stump1eb44332009-09-09 15:08:12 +0000376 OpenBSDTargetInfo(const std::string &triple)
Eli Friedman62d829a2011-12-15 02:15:56 +0000377 : OSTargetInfo<Target>(triple) {
378 this->UserLabelPrefix = "";
Hans Wennborge48667f2012-08-01 18:53:19 +0000379 this->TLSSupported = false;
Eli Friedman62d829a2011-12-15 02:15:56 +0000380
381 llvm::Triple Triple(triple);
382 switch (Triple.getArch()) {
383 default:
384 case llvm::Triple::x86:
385 case llvm::Triple::x86_64:
386 case llvm::Triple::arm:
Eric Christopher825d3862012-11-14 22:08:59 +0000387 case llvm::Triple::sparc:
Eli Friedman62d829a2011-12-15 02:15:56 +0000388 this->MCountName = "__mcount";
389 break;
390 case llvm::Triple::mips64:
391 case llvm::Triple::mips64el:
392 case llvm::Triple::ppc:
Eric Christopher825d3862012-11-14 22:08:59 +0000393 case llvm::Triple::sparcv9:
Eli Friedman62d829a2011-12-15 02:15:56 +0000394 this->MCountName = "_mcount";
395 break;
396 }
397 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000398};
399
Eli Friedman42f74f22012-08-08 23:57:20 +0000400// Bitrig Target
401template<typename Target>
402class BitrigTargetInfo : public OSTargetInfo<Target> {
403protected:
404 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
405 MacroBuilder &Builder) const {
406 // Bitrig defines; list based off of gcc output
407
408 Builder.defineMacro("__Bitrig__");
409 DefineStd(Builder, "unix", Opts);
410 Builder.defineMacro("__ELF__");
411 if (Opts.POSIXThreads)
412 Builder.defineMacro("_REENTRANT");
413 }
414public:
415 BitrigTargetInfo(const std::string &triple)
416 : OSTargetInfo<Target>(triple) {
417 this->UserLabelPrefix = "";
418 this->TLSSupported = false;
419 this->MCountName = "__mcount";
420 }
421};
422
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000423// PSP Target
424template<typename Target>
425class PSPTargetInfo : public OSTargetInfo<Target> {
426protected:
427 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000428 MacroBuilder &Builder) const {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000429 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramera9992772010-01-09 17:55:51 +0000430 Builder.defineMacro("PSP");
431 Builder.defineMacro("_PSP");
432 Builder.defineMacro("__psp__");
433 Builder.defineMacro("__ELF__");
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000434 }
435public:
436 PSPTargetInfo(const std::string& triple)
437 : OSTargetInfo<Target>(triple) {
438 this->UserLabelPrefix = "";
439 }
440};
441
John Thompson3f6918a2009-11-19 17:18:50 +0000442// PS3 PPU Target
443template<typename Target>
444class PS3PPUTargetInfo : public OSTargetInfo<Target> {
445protected:
446 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000447 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000448 // PS3 PPU defines.
John Thompsonfb457972010-03-25 16:18:32 +0000449 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000450 Builder.defineMacro("__PPU__");
451 Builder.defineMacro("__CELLOS_LV2__");
452 Builder.defineMacro("__ELF__");
453 Builder.defineMacro("__LP32__");
John Thompson8e6065a2010-06-24 22:44:13 +0000454 Builder.defineMacro("_ARCH_PPC64");
455 Builder.defineMacro("__powerpc64__");
John Thompson3f6918a2009-11-19 17:18:50 +0000456 }
457public:
458 PS3PPUTargetInfo(const std::string& triple)
459 : OSTargetInfo<Target>(triple) {
460 this->UserLabelPrefix = "";
Nick Lewycky99520702011-12-16 22:32:39 +0000461 this->LongWidth = this->LongAlign = 32;
462 this->PointerWidth = this->PointerAlign = 32;
John Thompson8e6065a2010-06-24 22:44:13 +0000463 this->IntMaxType = TargetInfo::SignedLongLong;
464 this->UIntMaxType = TargetInfo::UnsignedLongLong;
465 this->Int64Type = TargetInfo::SignedLongLong;
John Thompsonec387af2009-12-18 14:21:08 +0000466 this->SizeType = TargetInfo::UnsignedInt;
John Thompson8e6065a2010-06-24 22:44:13 +0000467 this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Nick Lewycky99520702011-12-16 22:32:39 +0000468 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompson3f6918a2009-11-19 17:18:50 +0000469 }
470};
471
472// FIXME: Need a real SPU target.
473// PS3 SPU Target
474template<typename Target>
475class PS3SPUTargetInfo : public OSTargetInfo<Target> {
476protected:
477 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000478 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000479 // PS3 PPU defines.
Benjamin Kramera9992772010-01-09 17:55:51 +0000480 Builder.defineMacro("__SPU__");
481 Builder.defineMacro("__ELF__");
John Thompson3f6918a2009-11-19 17:18:50 +0000482 }
483public:
484 PS3SPUTargetInfo(const std::string& triple)
485 : OSTargetInfo<Target>(triple) {
486 this->UserLabelPrefix = "";
487 }
488};
489
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000490// AuroraUX target
491template<typename Target>
492class AuroraUXTargetInfo : public OSTargetInfo<Target> {
493protected:
494 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000495 MacroBuilder &Builder) const {
496 DefineStd(Builder, "sun", Opts);
497 DefineStd(Builder, "unix", Opts);
498 Builder.defineMacro("__ELF__");
499 Builder.defineMacro("__svr4__");
500 Builder.defineMacro("__SVR4");
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000501 }
502public:
503 AuroraUXTargetInfo(const std::string& triple)
504 : OSTargetInfo<Target>(triple) {
505 this->UserLabelPrefix = "";
506 this->WCharType = this->SignedLong;
507 // FIXME: WIntType should be SignedLong
508 }
509};
510
Torok Edwin5f6c1942009-06-30 17:10:35 +0000511// Solaris target
512template<typename Target>
513class SolarisTargetInfo : public OSTargetInfo<Target> {
514protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000515 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000516 MacroBuilder &Builder) const {
517 DefineStd(Builder, "sun", Opts);
518 DefineStd(Builder, "unix", Opts);
519 Builder.defineMacro("__ELF__");
520 Builder.defineMacro("__svr4__");
521 Builder.defineMacro("__SVR4");
David Chisnall165329c2012-02-28 17:10:04 +0000522 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
523 // newer, but to 500 for everything else. feature_test.h has a check to
524 // ensure that you are not using C99 with an old version of X/Open or C89
525 // with a new version.
526 if (Opts.C99 || Opts.C11)
527 Builder.defineMacro("_XOPEN_SOURCE", "600");
528 else
529 Builder.defineMacro("_XOPEN_SOURCE", "500");
David Chisnallb4f0bd62012-03-02 10:49:52 +0000530 if (Opts.CPlusPlus)
David Chisnall165329c2012-02-28 17:10:04 +0000531 Builder.defineMacro("__C99FEATURES__");
David Chisnall48fad492012-02-17 18:35:11 +0000532 Builder.defineMacro("_LARGEFILE_SOURCE");
533 Builder.defineMacro("_LARGEFILE64_SOURCE");
534 Builder.defineMacro("__EXTENSIONS__");
David Chisnall165329c2012-02-28 17:10:04 +0000535 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000536 }
537public:
Mike Stump1eb44332009-09-09 15:08:12 +0000538 SolarisTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000539 : OSTargetInfo<Target>(triple) {
540 this->UserLabelPrefix = "";
David Chisnallfb027842012-03-28 18:04:14 +0000541 this->WCharType = this->SignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000542 // FIXME: WIntType should be SignedLong
543 }
544};
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000545
546// Windows target
547template<typename Target>
548class WindowsTargetInfo : public OSTargetInfo<Target> {
549protected:
550 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
551 MacroBuilder &Builder) const {
Michael J. Spencera764e832010-10-21 08:22:51 +0000552 Builder.defineMacro("_WIN32");
553 }
554 void getVisualStudioDefines(const LangOptions &Opts,
555 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000556 if (Opts.CPlusPlus) {
557 if (Opts.RTTI)
558 Builder.defineMacro("_CPPRTTI");
559
560 if (Opts.Exceptions)
561 Builder.defineMacro("_CPPUNWIND");
562 }
563
564 if (!Opts.CharIsSigned)
565 Builder.defineMacro("_CHAR_UNSIGNED");
566
567 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
568 // but it works for now.
569 if (Opts.POSIXThreads)
570 Builder.defineMacro("_MT");
Michael J. Spencera764e832010-10-21 08:22:51 +0000571
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000572 if (Opts.MSCVersion != 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000573 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000574
Francois Pichet62ec1f22011-09-17 17:15:52 +0000575 if (Opts.MicrosoftExt) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000576 Builder.defineMacro("_MSC_EXTENSIONS");
577
Richard Smith80ad52f2013-01-02 11:42:31 +0000578 if (Opts.CPlusPlus11) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000579 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
580 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
581 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
582 }
583 }
584
585 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000586 }
587
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000588public:
589 WindowsTargetInfo(const std::string &triple)
590 : OSTargetInfo<Target>(triple) {}
591};
592
Derek Schuff7da46f92012-10-11 16:55:58 +0000593template <typename Target>
594class NaClTargetInfo : public OSTargetInfo<Target> {
595 protected:
596 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
597 MacroBuilder &Builder) const {
598 if (Opts.POSIXThreads)
599 Builder.defineMacro("_REENTRANT");
600 if (Opts.CPlusPlus)
601 Builder.defineMacro("_GNU_SOURCE");
602
603 DefineStd(Builder, "unix", Opts);
604 Builder.defineMacro("__ELF__");
605 Builder.defineMacro("__native_client__");
606 }
607 public:
608 NaClTargetInfo(const std::string &triple)
609 : OSTargetInfo<Target>(triple) {
610 this->UserLabelPrefix = "";
611 this->LongAlign = 32;
612 this->LongWidth = 32;
613 this->PointerAlign = 32;
614 this->PointerWidth = 32;
615 this->IntMaxType = TargetInfo::SignedLongLong;
616 this->UIntMaxType = TargetInfo::UnsignedLongLong;
617 this->Int64Type = TargetInfo::SignedLongLong;
618 this->DoubleAlign = 64;
619 this->LongDoubleWidth = 64;
620 this->LongDoubleAlign = 64;
621 this->SizeType = TargetInfo::UnsignedInt;
622 this->PtrDiffType = TargetInfo::SignedInt;
623 this->IntPtrType = TargetInfo::SignedInt;
624 this->RegParmMax = 2;
625 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble;
626 this->DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
627 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
628 }
Derek Schuff263366f2012-10-16 22:30:41 +0000629 virtual typename Target::CallingConvCheckResult checkCallingConvention(
630 CallingConv CC) const {
631 return CC == CC_PnaclCall ? Target::CCCR_OK :
632 Target::checkCallingConvention(CC);
633 }
Derek Schuff7da46f92012-10-11 16:55:58 +0000634};
Mike Stump1eb44332009-09-09 15:08:12 +0000635} // end anonymous namespace.
Torok Edwin5f6c1942009-06-30 17:10:35 +0000636
Chris Lattnerd29b6302008-10-05 21:50:58 +0000637//===----------------------------------------------------------------------===//
Eli Friedmane4277982008-08-20 23:11:40 +0000638// Specific target implementations.
639//===----------------------------------------------------------------------===//
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +0000640
Eli Friedmane4277982008-08-20 23:11:40 +0000641namespace {
642// PPC abstract base class
643class PPCTargetInfo : public TargetInfo {
644 static const Builtin::Info BuiltinInfo[];
645 static const char * const GCCRegNames[];
646 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Hal Finkel02a84272012-06-11 22:35:19 +0000647 std::string CPU;
Eli Friedmane4277982008-08-20 23:11:40 +0000648public:
Nico Weber6e1d2ea2012-01-31 02:07:33 +0000649 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {
650 LongDoubleWidth = LongDoubleAlign = 128;
651 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
652 }
Eli Friedman15b91762009-06-05 07:05:05 +0000653
Hal Finkel39d5fa12012-07-03 16:51:04 +0000654 /// \brief Flags for architecture specific defines.
655 typedef enum {
656 ArchDefineNone = 0,
657 ArchDefineName = 1 << 0, // <name> is substituted for arch name.
658 ArchDefinePpcgr = 1 << 1,
659 ArchDefinePpcsq = 1 << 2,
660 ArchDefine440 = 1 << 3,
661 ArchDefine603 = 1 << 4,
662 ArchDefine604 = 1 << 5,
663 ArchDefinePwr4 = 1 << 6,
664 ArchDefinePwr6 = 1 << 7
665 } ArchDefineTypes;
666
Hal Finkel02a84272012-06-11 22:35:19 +0000667 virtual bool setCPU(const std::string &Name) {
668 bool CPUKnown = llvm::StringSwitch<bool>(Name)
669 .Case("generic", true)
670 .Case("440", true)
671 .Case("450", true)
672 .Case("601", true)
673 .Case("602", true)
674 .Case("603", true)
675 .Case("603e", true)
676 .Case("603ev", true)
677 .Case("604", true)
678 .Case("604e", true)
679 .Case("620", true)
680 .Case("g3", true)
681 .Case("7400", true)
682 .Case("g4", true)
683 .Case("7450", true)
684 .Case("g4+", true)
685 .Case("750", true)
686 .Case("970", true)
687 .Case("g5", true)
688 .Case("a2", true)
Hal Finkel7de32962012-09-18 22:25:03 +0000689 .Case("e500mc", true)
690 .Case("e5500", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000691 .Case("pwr6", true)
692 .Case("pwr7", true)
693 .Case("ppc", true)
694 .Case("ppc64", true)
695 .Default(false);
696
697 if (CPUKnown)
698 CPU = Name;
699
700 return CPUKnown;
701 }
702
Eli Friedmane4277982008-08-20 23:11:40 +0000703 virtual void getTargetBuiltins(const Builtin::Info *&Records,
704 unsigned &NumRecords) const {
Reid Spencer5f016e22007-07-11 17:01:13 +0000705 Records = BuiltinInfo;
Eli Friedmane4277982008-08-20 23:11:40 +0000706 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +0000707 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000708
Bob Wilson9f1c49c2012-01-28 18:02:29 +0000709 virtual bool isCLZForZeroUndef() const { return false; }
710
Chris Lattner33328642009-03-20 15:52:06 +0000711 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000712 MacroBuilder &Builder) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000713
Douglas Gregore727d212012-01-30 06:38:25 +0000714 virtual bool hasFeature(StringRef Feature) const;
715
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000716 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000717 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000718 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000719 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000720 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +0000721 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000722 switch (*Name) {
Anders Carlssond04c6e22007-11-27 04:11:28 +0000723 default: return false;
724 case 'O': // Zero
John Thompson8e6065a2010-06-24 22:44:13 +0000725 break;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000726 case 'b': // Base register
727 case 'f': // Floating point register
Chris Lattner44def072009-04-26 07:16:29 +0000728 Info.setAllowsRegister();
John Thompson8e6065a2010-06-24 22:44:13 +0000729 break;
730 // FIXME: The following are added to allow parsing.
731 // I just took a guess at what the actions should be.
732 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer20249a12010-10-21 03:16:25 +0000733 case 'd': // Floating point register (containing 64-bit value)
John Thompson8e6065a2010-06-24 22:44:13 +0000734 case 'v': // Altivec vector register
735 Info.setAllowsRegister();
736 break;
737 case 'w':
738 switch (Name[1]) {
Michael J. Spencer20249a12010-10-21 03:16:25 +0000739 case 'd':// VSX vector register to hold vector double data
740 case 'f':// VSX vector register to hold vector float data
741 case 's':// VSX vector register to hold scalar float data
742 case 'a':// Any VSX register
John Thompson8e6065a2010-06-24 22:44:13 +0000743 break;
744 default:
745 return false;
746 }
747 Info.setAllowsRegister();
748 Name++; // Skip over 'w'.
749 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000750 case 'h': // `MQ', `CTR', or `LINK' register
751 case 'q': // `MQ' register
752 case 'c': // `CTR' register
753 case 'l': // `LINK' register
754 case 'x': // `CR' register (condition register) number 0
755 case 'y': // `CR' register (condition register)
756 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson8e6065a2010-06-24 22:44:13 +0000757 Info.setAllowsRegister();
758 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000759 case 'I': // Signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000760 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer20249a12010-10-21 03:16:25 +0000761 // (use `L' instead for SImode constants)
762 case 'K': // Unsigned 16-bit constant
763 case 'L': // Signed 16-bit constant shifted left 16 bits
764 case 'M': // Constant larger than 31
765 case 'N': // Exact power of 2
766 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000767 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000768 // register with one instruction per word
John Thompson8e6065a2010-06-24 22:44:13 +0000769 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer20249a12010-10-21 03:16:25 +0000770 // into a register using three instructions
John Thompson8e6065a2010-06-24 22:44:13 +0000771 break;
772 case 'm': // Memory operand. Note that on PowerPC targets, m can
773 // include addresses that update the base register. It
774 // is therefore only safe to use `m' in an asm statement
775 // if that asm statement accesses the operand exactly once.
776 // The asm statement must also use `%U<opno>' as a
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000777 // placeholder for the "update" flag in the corresponding
Michael J. Spencer20249a12010-10-21 03:16:25 +0000778 // load or store instruction. For example:
John Thompson8e6065a2010-06-24 22:44:13 +0000779 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000780 // is correct but:
John Thompson8e6065a2010-06-24 22:44:13 +0000781 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
782 // is not. Use es rather than m if you don't want the base
Michael J. Spencer20249a12010-10-21 03:16:25 +0000783 // register to be updated.
784 case 'e':
John Thompson56b6eca2010-06-25 00:02:05 +0000785 if (Name[1] != 's')
786 return false;
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000787 // es: A "stable" memory operand; that is, one which does not
John Thompson8e6065a2010-06-24 22:44:13 +0000788 // include any automodification of the base register. Unlike
789 // `m', this constraint can be used in asm statements that
790 // might access the operand several times, or that might not
John Thompson56b6eca2010-06-25 00:02:05 +0000791 // access it at all.
John Thompson8e6065a2010-06-24 22:44:13 +0000792 Info.setAllowsMemory();
John Thompson56b6eca2010-06-25 00:02:05 +0000793 Name++; // Skip over 'e'.
John Thompson8e6065a2010-06-24 22:44:13 +0000794 break;
795 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer20249a12010-10-21 03:16:25 +0000796 // usually better to use `m' or `es' in asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000797 case 'Z': // Memory operand that is an indexed or indirect from a
798 // register (it is usually better to use `m' or `es' in
Michael J. Spencer20249a12010-10-21 03:16:25 +0000799 // asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000800 Info.setAllowsMemory();
801 Info.setAllowsRegister();
802 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000803 case 'R': // AIX TOC entry
John Thompson8e6065a2010-06-24 22:44:13 +0000804 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000805 // register (`p' is preferable for asm statements)
806 case 'S': // Constant suitable as a 64-bit mask operand
807 case 'T': // Constant suitable as a 32-bit mask operand
808 case 'U': // System V Release 4 small data area reference
John Thompson8e6065a2010-06-24 22:44:13 +0000809 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000810 // instructions
811 case 'W': // Vector constant that does not require memory
812 case 'j': // Vector constant that is all zeros.
John Thompson8e6065a2010-06-24 22:44:13 +0000813 break;
814 // End FIXME.
Anders Carlssond04c6e22007-11-27 04:11:28 +0000815 }
John Thompson8e6065a2010-06-24 22:44:13 +0000816 return true;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000817 }
Eli Friedmane4277982008-08-20 23:11:40 +0000818 virtual const char *getClobbers() const {
819 return "";
Anders Carlssond04c6e22007-11-27 04:11:28 +0000820 }
Adhemerval Zanellab0fc94c2013-01-22 20:02:45 +0000821 int getEHDataRegisterNumber(unsigned RegNo) const {
822 if (RegNo == 0) return 3;
823 if (RegNo == 1) return 4;
824 return -1;
825 }
Eli Friedmane4277982008-08-20 23:11:40 +0000826};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000827
Eli Friedmane4277982008-08-20 23:11:40 +0000828const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000829#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000830#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000831 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000832#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000833};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000834
835
Chris Lattnerc0f59212009-03-02 22:27:17 +0000836/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
837/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000838void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000839 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000840 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000841 Builder.defineMacro("__ppc__");
842 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000843 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000844 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000845 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000846 Builder.defineMacro("_ARCH_PPC64");
Chris Lattnere03ae302010-02-16 18:14:57 +0000847 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000848 Builder.defineMacro("__ppc64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000849 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +0000850 Builder.defineMacro("__ppc__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000851 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000852
Chris Lattnerc0f59212009-03-02 22:27:17 +0000853 // Target properties.
Hans Wennborg5e601dc2012-08-02 13:45:48 +0000854 if (getTriple().getOS() != llvm::Triple::NetBSD &&
855 getTriple().getOS() != llvm::Triple::OpenBSD)
Joerg Sonnenberger7cd1de52011-07-05 14:56:12 +0000856 Builder.defineMacro("_BIG_ENDIAN");
Benjamin Kramera9992772010-01-09 17:55:51 +0000857 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000858
Chris Lattnerc0f59212009-03-02 22:27:17 +0000859 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000860 Builder.defineMacro("__NATURAL_ALIGNMENT__");
861 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000862
Chris Lattnerc0f59212009-03-02 22:27:17 +0000863 // FIXME: Should be controlled by command line option.
Benjamin Kramera9992772010-01-09 17:55:51 +0000864 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000865
John Thompson3f6918a2009-11-19 17:18:50 +0000866 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000867 Builder.defineMacro("__VEC__", "10206");
868 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000869 }
Hal Finkel02a84272012-06-11 22:35:19 +0000870
871 // CPU identification.
Hal Finkel39d5fa12012-07-03 16:51:04 +0000872 ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
873 .Case("440", ArchDefineName)
874 .Case("450", ArchDefineName | ArchDefine440)
875 .Case("601", ArchDefineName)
876 .Case("602", ArchDefineName | ArchDefinePpcgr)
877 .Case("603", ArchDefineName | ArchDefinePpcgr)
878 .Case("603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
879 .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
880 .Case("604", ArchDefineName | ArchDefinePpcgr)
881 .Case("604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
882 .Case("620", ArchDefineName | ArchDefinePpcgr)
883 .Case("7400", ArchDefineName | ArchDefinePpcgr)
884 .Case("7450", ArchDefineName | ArchDefinePpcgr)
885 .Case("750", ArchDefineName | ArchDefinePpcgr)
886 .Case("970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
887 | ArchDefinePpcsq)
888 .Case("pwr6", ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq)
889 .Case("pwr7", ArchDefineName | ArchDefinePwr6 | ArchDefinePpcgr
890 | ArchDefinePpcsq)
891 .Default(ArchDefineNone);
892
893 if (defs & ArchDefineName)
894 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
895 if (defs & ArchDefinePpcgr)
896 Builder.defineMacro("_ARCH_PPCGR");
897 if (defs & ArchDefinePpcsq)
898 Builder.defineMacro("_ARCH_PPCSQ");
899 if (defs & ArchDefine440)
Hal Finkel02a84272012-06-11 22:35:19 +0000900 Builder.defineMacro("_ARCH_440");
Hal Finkel39d5fa12012-07-03 16:51:04 +0000901 if (defs & ArchDefine603)
902 Builder.defineMacro("_ARCH_603");
903 if (defs & ArchDefine604)
904 Builder.defineMacro("_ARCH_604");
905 if (defs & (ArchDefinePwr4 | ArchDefinePwr6))
906 Builder.defineMacro("_ARCH_PWR4");
907 if (defs & ArchDefinePwr6) {
908 Builder.defineMacro("_ARCH_PWR5");
Hal Finkel02a84272012-06-11 22:35:19 +0000909 Builder.defineMacro("_ARCH_PWR6");
Hal Finkel02a84272012-06-11 22:35:19 +0000910 }
Chris Lattnerc0f59212009-03-02 22:27:17 +0000911}
912
Douglas Gregore727d212012-01-30 06:38:25 +0000913bool PPCTargetInfo::hasFeature(StringRef Feature) const {
914 return Feature == "powerpc";
915}
Chris Lattner393ff042008-04-21 18:56:49 +0000916
Douglas Gregore727d212012-01-30 06:38:25 +0000917
Eli Friedmane4277982008-08-20 23:11:40 +0000918const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +0000919 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
920 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
921 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
922 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
923 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
924 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
925 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
926 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +0000927 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000928 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +0000929 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000930 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
931 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
932 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
933 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +0000934 "vrsave", "vscr",
935 "spe_acc", "spefscr",
936 "sfp"
937};
Reid Spencer5f016e22007-07-11 17:01:13 +0000938
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000939void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000940 unsigned &NumNames) const {
941 Names = GCCRegNames;
942 NumNames = llvm::array_lengthof(GCCRegNames);
943}
Reid Spencer5f016e22007-07-11 17:01:13 +0000944
Eli Friedmane4277982008-08-20 23:11:40 +0000945const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
946 // While some of these aliases do map to different registers
947 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000948 { { "0" }, "r0" },
949 { { "1"}, "r1" },
950 { { "2" }, "r2" },
951 { { "3" }, "r3" },
952 { { "4" }, "r4" },
953 { { "5" }, "r5" },
954 { { "6" }, "r6" },
955 { { "7" }, "r7" },
956 { { "8" }, "r8" },
957 { { "9" }, "r9" },
958 { { "10" }, "r10" },
959 { { "11" }, "r11" },
960 { { "12" }, "r12" },
961 { { "13" }, "r13" },
962 { { "14" }, "r14" },
963 { { "15" }, "r15" },
964 { { "16" }, "r16" },
965 { { "17" }, "r17" },
966 { { "18" }, "r18" },
967 { { "19" }, "r19" },
968 { { "20" }, "r20" },
969 { { "21" }, "r21" },
970 { { "22" }, "r22" },
971 { { "23" }, "r23" },
972 { { "24" }, "r24" },
973 { { "25" }, "r25" },
974 { { "26" }, "r26" },
975 { { "27" }, "r27" },
976 { { "28" }, "r28" },
977 { { "29" }, "r29" },
978 { { "30" }, "r30" },
979 { { "31" }, "r31" },
980 { { "fr0" }, "f0" },
981 { { "fr1" }, "f1" },
982 { { "fr2" }, "f2" },
983 { { "fr3" }, "f3" },
984 { { "fr4" }, "f4" },
985 { { "fr5" }, "f5" },
986 { { "fr6" }, "f6" },
987 { { "fr7" }, "f7" },
988 { { "fr8" }, "f8" },
989 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +0000990 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000991 { { "fr11" }, "f11" },
992 { { "fr12" }, "f12" },
993 { { "fr13" }, "f13" },
994 { { "fr14" }, "f14" },
995 { { "fr15" }, "f15" },
996 { { "fr16" }, "f16" },
997 { { "fr17" }, "f17" },
998 { { "fr18" }, "f18" },
999 { { "fr19" }, "f19" },
1000 { { "fr20" }, "f20" },
1001 { { "fr21" }, "f21" },
1002 { { "fr22" }, "f22" },
1003 { { "fr23" }, "f23" },
1004 { { "fr24" }, "f24" },
1005 { { "fr25" }, "f25" },
1006 { { "fr26" }, "f26" },
1007 { { "fr27" }, "f27" },
1008 { { "fr28" }, "f28" },
1009 { { "fr29" }, "f29" },
1010 { { "fr30" }, "f30" },
1011 { { "fr31" }, "f31" },
1012 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +00001013};
1014
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001015void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +00001016 unsigned &NumAliases) const {
1017 Aliases = GCCRegAliases;
1018 NumAliases = llvm::array_lengthof(GCCRegAliases);
1019}
1020} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00001021
1022namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001023class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001024public:
Chris Lattnere03ae302010-02-16 18:14:57 +00001025 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +00001026 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 +00001027 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +00001028
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001029 switch (getTriple().getOS()) {
Nico Weber6e1d2ea2012-01-31 02:07:33 +00001030 case llvm::Triple::Linux:
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001031 case llvm::Triple::FreeBSD:
1032 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001033 SizeType = UnsignedInt;
Hal Finkel178a9b82012-03-02 20:54:36 +00001034 PtrDiffType = SignedInt;
1035 IntPtrType = SignedInt;
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001036 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +00001037 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001038 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001039 }
Roman Divackye3d175d2012-03-13 16:53:54 +00001040
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001041 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1042 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001043 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001044 }
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001045
1046 // PPC32 supports atomics up to 4 bytes.
1047 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001048 }
1049
Meador Ingec5613b22012-06-16 03:34:49 +00001050 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001051 // This is the ELF definition, and is overridden by the Darwin sub-target
Meador Ingec5613b22012-06-16 03:34:49 +00001052 return TargetInfo::PowerABIBuiltinVaList;
Eli Friedmaned855cb2008-08-21 00:13:15 +00001053 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001054};
1055} // end anonymous namespace.
1056
1057namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001058class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001059public:
Eli Friedmane4277982008-08-20 23:11:40 +00001060 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00001061 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00001062 IntMaxType = SignedLong;
1063 UIntMaxType = UnsignedLong;
1064 Int64Type = SignedLong;
Roman Divackye3d175d2012-03-13 16:53:54 +00001065
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001066 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1067 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001068 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001069 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1070 "i64:64:64-f32:32:32-f64:64:64-f128:64:64-"
1071 "v128:128:128-n32:64";
1072 } else
1073 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1074 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
1075 "v128:128:128-n32:64";
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001076
1077 // PPC64 supports atomics up to 8 bytes.
1078 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Chris Lattnerf291b102008-05-09 06:17:04 +00001079 }
Meador Ingec5613b22012-06-16 03:34:49 +00001080 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1081 return TargetInfo::CharPtrBuiltinVaList;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001082 }
Eli Friedmane4277982008-08-20 23:11:40 +00001083};
1084} // end anonymous namespace.
1085
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001086
1087namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001088class DarwinPPC32TargetInfo :
1089 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001090public:
Roman Divackyc81f2a22011-01-06 08:27:10 +00001091 DarwinPPC32TargetInfo(const std::string& triple)
1092 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001093 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001094 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001095 LongLongAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001096 SuitableAlign = 128;
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001097 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1098 "i64:32:64-f32:32:32-f64:64:64-v128:128:128-n32";
Roman Divackyc81f2a22011-01-06 08:27:10 +00001099 }
Meador Ingec5613b22012-06-16 03:34:49 +00001100 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1101 return TargetInfo::CharPtrBuiltinVaList;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001102 }
1103};
1104
1105class DarwinPPC64TargetInfo :
1106 public DarwinTargetInfo<PPC64TargetInfo> {
1107public:
1108 DarwinPPC64TargetInfo(const std::string& triple)
1109 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
1110 HasAlignMac68kSupport = true;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001111 SuitableAlign = 128;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001112 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1113 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001114 }
1115};
1116} // end anonymous namespace.
1117
Reid Spencer5f016e22007-07-11 17:01:13 +00001118namespace {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001119 static const unsigned NVPTXAddrSpaceMap[] = {
1120 1, // opencl_global
1121 3, // opencl_local
1122 4, // opencl_constant
1123 1, // cuda_device
1124 4, // cuda_constant
1125 3, // cuda_shared
1126 };
1127 class NVPTXTargetInfo : public TargetInfo {
1128 static const char * const GCCRegNames[];
Justin Holewinski2c585b92012-05-24 17:43:12 +00001129 static const Builtin::Info BuiltinInfo[];
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00001130 std::vector<StringRef> AvailableFeatures;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001131 public:
1132 NVPTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
1133 BigEndian = false;
1134 TLSSupported = false;
1135 LongWidth = LongAlign = 64;
1136 AddrSpaceMap = &NVPTXAddrSpaceMap;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001137 // Define available target features
1138 // These must be defined in sorted order!
Justin Holewinski9903e942012-07-11 15:34:55 +00001139 NoAsmVariants = true;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001140 }
1141 virtual void getTargetDefines(const LangOptions &Opts,
1142 MacroBuilder &Builder) const {
1143 Builder.defineMacro("__PTX__");
Justin Holewinski2c585b92012-05-24 17:43:12 +00001144 Builder.defineMacro("__NVPTX__");
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001145 }
1146 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1147 unsigned &NumRecords) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001148 Records = BuiltinInfo;
1149 NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001150 }
1151 virtual bool hasFeature(StringRef Feature) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001152 return Feature == "ptx" || Feature == "nvptx";
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001153 }
1154
1155 virtual void getGCCRegNames(const char * const *&Names,
1156 unsigned &NumNames) const;
1157 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1158 unsigned &NumAliases) const {
1159 // No aliases.
1160 Aliases = 0;
1161 NumAliases = 0;
1162 }
1163 virtual bool validateAsmConstraint(const char *&Name,
1164 TargetInfo::ConstraintInfo &info) const {
1165 // FIXME: implement
1166 return true;
1167 }
1168 virtual const char *getClobbers() const {
1169 // FIXME: Is this really right?
1170 return "";
1171 }
Meador Ingec5613b22012-06-16 03:34:49 +00001172 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001173 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00001174 return TargetInfo::CharPtrBuiltinVaList;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001175 }
1176 virtual bool setCPU(const std::string &Name) {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001177 return Name == "sm_10" || Name == "sm_13" || Name == "sm_20";
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001178 }
Justin Holewinski2c585b92012-05-24 17:43:12 +00001179 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1180 StringRef Name,
1181 bool Enabled) const;
1182 };
1183
1184 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1185#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1186#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1187 ALL_LANGUAGES },
1188#include "clang/Basic/BuiltinsNVPTX.def"
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001189 };
1190
1191 const char * const NVPTXTargetInfo::GCCRegNames[] = {
1192 "r0"
1193 };
1194
1195 void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names,
1196 unsigned &NumNames) const {
1197 Names = GCCRegNames;
1198 NumNames = llvm::array_lengthof(GCCRegNames);
1199 }
1200
Justin Holewinski2c585b92012-05-24 17:43:12 +00001201 bool NVPTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1202 StringRef Name,
1203 bool Enabled) const {
1204 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
1205 Name)) {
1206 Features[Name] = Enabled;
1207 return true;
1208 } else {
1209 return false;
1210 }
1211 }
1212
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001213 class NVPTX32TargetInfo : public NVPTXTargetInfo {
1214 public:
Justin Holewinski2c585b92012-05-24 17:43:12 +00001215 NVPTX32TargetInfo(const std::string& triple) : NVPTXTargetInfo(triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001216 PointerWidth = PointerAlign = 32;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001217 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001218 DescriptionString
1219 = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1220 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1221 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001222 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001223 };
1224
1225 class NVPTX64TargetInfo : public NVPTXTargetInfo {
1226 public:
Justin Holewinski2c585b92012-05-24 17:43:12 +00001227 NVPTX64TargetInfo(const std::string& triple) : NVPTXTargetInfo(triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001228 PointerWidth = PointerAlign = 64;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001229 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001230 DescriptionString
1231 = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1232 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1233 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001234 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001235 };
1236}
1237
1238namespace {
Eli Friedman6505a292012-10-12 23:32:00 +00001239
1240static const unsigned R600AddrSpaceMap[] = {
1241 1, // opencl_global
1242 3, // opencl_local
1243 2, // opencl_constant
1244 1, // cuda_device
1245 2, // cuda_constant
1246 3 // cuda_shared
1247};
1248
1249class R600TargetInfo : public TargetInfo {
1250public:
1251 R600TargetInfo(const std::string& triple) : TargetInfo(triple) {
1252 DescriptionString =
1253 "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16"
1254 "-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f80:32:32"
1255 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64"
1256 "-v96:128:128-v128:128:128-v192:256:256-v256:256:256"
1257 "-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1258 "-n8:16:32:64";
1259 AddrSpaceMap = &R600AddrSpaceMap;
1260 }
1261
1262 virtual const char * getClobbers() const {
1263 return "";
1264 }
1265
1266 virtual void getGCCRegNames(const char * const *&Names,
1267 unsigned &numNames) const {
1268 Names = NULL;
1269 numNames = 0;
1270 }
1271
1272 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1273 unsigned &NumAliases) const {
1274 Aliases = NULL;
1275 NumAliases = 0;
1276 }
1277
1278 virtual bool validateAsmConstraint(const char *&Name,
1279 TargetInfo::ConstraintInfo &info) const {
1280 return true;
1281 }
1282
1283 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1284 unsigned &NumRecords) const {
1285 Records = NULL;
1286 NumRecords = 0;
1287 }
1288
1289
1290 virtual void getTargetDefines(const LangOptions &Opts,
1291 MacroBuilder &Builder) const {
1292 Builder.defineMacro("__R600__");
1293 }
1294
1295 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1296 return TargetInfo::CharPtrBuiltinVaList;
1297 }
1298
1299};
1300
1301} // end anonymous namespace
1302
1303namespace {
Chris Lattner9cbeb632010-03-06 21:21:27 +00001304// MBlaze abstract base class
1305class MBlazeTargetInfo : public TargetInfo {
1306 static const char * const GCCRegNames[];
1307 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1308
1309public:
1310 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +00001311 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner9cbeb632010-03-06 21:21:27 +00001312 }
1313
1314 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1315 unsigned &NumRecords) const {
1316 // FIXME: Implement.
1317 Records = 0;
1318 NumRecords = 0;
1319 }
1320
1321 virtual void getTargetDefines(const LangOptions &Opts,
1322 MacroBuilder &Builder) const;
1323
Douglas Gregore727d212012-01-30 06:38:25 +00001324 virtual bool hasFeature(StringRef Feature) const {
1325 return Feature == "mblaze";
1326 }
1327
Meador Ingec5613b22012-06-16 03:34:49 +00001328 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1329 return TargetInfo::CharPtrBuiltinVaList;
Chris Lattner9cbeb632010-03-06 21:21:27 +00001330 }
1331 virtual const char *getTargetPrefix() const {
1332 return "mblaze";
1333 }
1334 virtual void getGCCRegNames(const char * const *&Names,
1335 unsigned &NumNames) const;
1336 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1337 unsigned &NumAliases) const;
1338 virtual bool validateAsmConstraint(const char *&Name,
1339 TargetInfo::ConstraintInfo &Info) const {
1340 switch (*Name) {
1341 default: return false;
1342 case 'O': // Zero
1343 return true;
1344 case 'b': // Base register
1345 case 'f': // Floating point register
1346 Info.setAllowsRegister();
1347 return true;
1348 }
1349 }
1350 virtual const char *getClobbers() const {
1351 return "";
1352 }
1353};
1354
1355/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1356/// #defines that are not tied to a specific subtarget.
1357void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1358 MacroBuilder &Builder) const {
1359 // Target identification.
1360 Builder.defineMacro("__microblaze__");
1361 Builder.defineMacro("_ARCH_MICROBLAZE");
1362 Builder.defineMacro("__MICROBLAZE__");
1363
1364 // Target properties.
1365 Builder.defineMacro("_BIG_ENDIAN");
1366 Builder.defineMacro("__BIG_ENDIAN__");
1367
1368 // Subtarget options.
1369 Builder.defineMacro("__REGISTER_PREFIX__", "");
1370}
1371
1372
1373const char * const MBlazeTargetInfo::GCCRegNames[] = {
1374 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1375 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1376 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1377 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1378 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1379 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1380 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1381 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1382 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1383 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1384};
1385
1386void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1387 unsigned &NumNames) const {
1388 Names = GCCRegNames;
1389 NumNames = llvm::array_lengthof(GCCRegNames);
1390}
1391
1392const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1393 { {"f0"}, "r0" },
1394 { {"f1"}, "r1" },
1395 { {"f2"}, "r2" },
1396 { {"f3"}, "r3" },
1397 { {"f4"}, "r4" },
1398 { {"f5"}, "r5" },
1399 { {"f6"}, "r6" },
1400 { {"f7"}, "r7" },
1401 { {"f8"}, "r8" },
1402 { {"f9"}, "r9" },
1403 { {"f10"}, "r10" },
1404 { {"f11"}, "r11" },
1405 { {"f12"}, "r12" },
1406 { {"f13"}, "r13" },
1407 { {"f14"}, "r14" },
1408 { {"f15"}, "r15" },
1409 { {"f16"}, "r16" },
1410 { {"f17"}, "r17" },
1411 { {"f18"}, "r18" },
1412 { {"f19"}, "r19" },
1413 { {"f20"}, "r20" },
1414 { {"f21"}, "r21" },
1415 { {"f22"}, "r22" },
1416 { {"f23"}, "r23" },
1417 { {"f24"}, "r24" },
1418 { {"f25"}, "r25" },
1419 { {"f26"}, "r26" },
1420 { {"f27"}, "r27" },
1421 { {"f28"}, "r28" },
1422 { {"f29"}, "r29" },
1423 { {"f30"}, "r30" },
1424 { {"f31"}, "r31" },
1425};
1426
1427void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1428 unsigned &NumAliases) const {
1429 Aliases = GCCRegAliases;
1430 NumAliases = llvm::array_lengthof(GCCRegAliases);
1431}
1432} // end anonymous namespace.
1433
1434namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001435// Namespace for x86 abstract base class
1436const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001437#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001438#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001439 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001440#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001441};
Eli Friedman61538a72008-05-20 14:21:01 +00001442
Nuno Lopes2550d702009-12-23 17:49:57 +00001443static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001444 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1445 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001446 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001447 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1448 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1449 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001450 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopherc5f9a012011-12-02 02:12:16 +00001451 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1452 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001453};
1454
Eric Christophercfd323d2011-06-21 00:05:20 +00001455const TargetInfo::AddlRegName AddlRegNames[] = {
1456 { { "al", "ah", "eax", "rax" }, 0 },
1457 { { "bl", "bh", "ebx", "rbx" }, 3 },
1458 { { "cl", "ch", "ecx", "rcx" }, 2 },
1459 { { "dl", "dh", "edx", "rdx" }, 1 },
1460 { { "esi", "rsi" }, 4 },
1461 { { "edi", "rdi" }, 5 },
1462 { { "esp", "rsp" }, 7 },
1463 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001464};
1465
1466// X86 target abstract base class; x86-32 and x86-64 are very close, so
1467// most of the implementation can be shared.
1468class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001469 enum X86SSEEnum {
Craig Topper05fe4b52012-01-09 09:19:09 +00001470 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2
Chris Lattner84f0ea82009-03-02 22:40:39 +00001471 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001472 enum MMX3DNowEnum {
1473 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1474 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001475
Eric Christophereea12d12010-04-02 23:50:19 +00001476 bool HasAES;
Craig Topper3c0bc152012-05-31 05:18:48 +00001477 bool HasPCLMUL;
Craig Topper31ceea02011-12-25 05:06:45 +00001478 bool HasLZCNT;
Benjamin Kramer84f30802012-07-07 09:39:18 +00001479 bool HasRDRND;
Craig Topper31ceea02011-12-25 05:06:45 +00001480 bool HasBMI;
1481 bool HasBMI2;
Craig Toppere14e08b2011-12-29 16:10:46 +00001482 bool HasPOPCNT;
Michael Liao463eb892012-11-10 05:17:46 +00001483 bool HasRTM;
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00001484 bool HasSSE4a;
Craig Topper6a511e12011-12-30 07:33:42 +00001485 bool HasFMA4;
Craig Topper2ae95072012-06-03 21:46:30 +00001486 bool HasFMA;
Craig Topperb6af69e2012-06-09 22:24:14 +00001487 bool HasXOP;
Manman Ren146e5a42012-10-11 00:59:55 +00001488 bool HasF16C;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001489
Chandler Carruth499d9722011-09-28 08:55:34 +00001490 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1491 ///
1492 /// Each enumeration represents a particular CPU supported by Clang. These
1493 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1494 enum CPUKind {
1495 CK_Generic,
1496
1497 /// \name i386
1498 /// i386-generation processors.
1499 //@{
1500 CK_i386,
1501 //@}
1502
1503 /// \name i486
1504 /// i486-generation processors.
1505 //@{
1506 CK_i486,
1507 CK_WinChipC6,
1508 CK_WinChip2,
1509 CK_C3,
1510 //@}
1511
1512 /// \name i586
1513 /// i586-generation processors, P5 microarchitecture based.
1514 //@{
1515 CK_i586,
1516 CK_Pentium,
1517 CK_PentiumMMX,
1518 //@}
1519
1520 /// \name i686
1521 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1522 //@{
1523 CK_i686,
1524 CK_PentiumPro,
1525 CK_Pentium2,
1526 CK_Pentium3,
1527 CK_Pentium3M,
1528 CK_PentiumM,
1529 CK_C3_2,
1530
1531 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1532 /// Clang however has some logic to suport this.
1533 // FIXME: Warn, deprecate, and potentially remove this.
1534 CK_Yonah,
1535 //@}
1536
1537 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001538 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001539 //@{
1540 CK_Pentium4,
1541 CK_Pentium4M,
1542 CK_Prescott,
1543 CK_Nocona,
1544 //@}
1545
1546 /// \name Core
1547 /// Core microarchitecture based processors.
1548 //@{
1549 CK_Core2,
1550
1551 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1552 /// codename which GCC no longer accepts as an option to -march, but Clang
1553 /// has some logic for recognizing it.
1554 // FIXME: Warn, deprecate, and potentially remove this.
1555 CK_Penryn,
1556 //@}
1557
1558 /// \name Atom
1559 /// Atom processors
1560 //@{
1561 CK_Atom,
1562 //@}
1563
1564 /// \name Nehalem
1565 /// Nehalem microarchitecture based processors.
1566 //@{
1567 CK_Corei7,
1568 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001569 CK_CoreAVXi,
Craig Topper2b03bb02011-12-17 19:55:21 +00001570 CK_CoreAVX2,
Chandler Carruth499d9722011-09-28 08:55:34 +00001571 //@}
1572
1573 /// \name K6
1574 /// K6 architecture processors.
1575 //@{
1576 CK_K6,
1577 CK_K6_2,
1578 CK_K6_3,
1579 //@}
1580
1581 /// \name K7
1582 /// K7 architecture processors.
1583 //@{
1584 CK_Athlon,
1585 CK_AthlonThunderbird,
1586 CK_Athlon4,
1587 CK_AthlonXP,
1588 CK_AthlonMP,
1589 //@}
1590
1591 /// \name K8
1592 /// K8 architecture processors.
1593 //@{
1594 CK_Athlon64,
1595 CK_Athlon64SSE3,
1596 CK_AthlonFX,
1597 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001598 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001599 CK_Opteron,
1600 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001601 CK_AMDFAM10,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001602 //@}
Chandler Carruth499d9722011-09-28 08:55:34 +00001603
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001604 /// \name Bobcat
1605 /// Bobcat architecture processors.
1606 //@{
1607 CK_BTVER1,
1608 //@}
1609
1610 /// \name Bulldozer
1611 /// Bulldozer architecture processors.
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001612 //@{
1613 CK_BDVER1,
1614 CK_BDVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001615 //@}
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001616
Chandler Carruth499d9722011-09-28 08:55:34 +00001617 /// This specification is deprecated and will be removed in the future.
1618 /// Users should prefer \see CK_K8.
1619 // FIXME: Warn on this when the CPU is set to it.
1620 CK_x86_64,
1621 //@}
1622
1623 /// \name Geode
1624 /// Geode processors.
1625 //@{
1626 CK_Geode
1627 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001628 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001629
Eli Friedman618234a2008-08-20 02:34:37 +00001630public:
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001631 X86TargetInfo(const std::string& triple)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001632 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Benjamin Kramer84f30802012-07-07 09:39:18 +00001633 HasAES(false), HasPCLMUL(false), HasLZCNT(false), HasRDRND(false),
Michael Liao463eb892012-11-10 05:17:46 +00001634 HasBMI(false), HasBMI2(false), HasPOPCNT(false), HasRTM(false),
1635 HasSSE4a(false), HasFMA4(false), HasFMA(false), HasXOP(false),
1636 HasF16C(false), CPU(CK_Generic) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00001637 BigEndian = false;
Eli Friedman618234a2008-08-20 02:34:37 +00001638 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001639 }
Benjamin Kramerb4066692011-12-28 15:47:06 +00001640 virtual unsigned getFloatEvalMethod() const {
1641 // X87 evaluates with 80 bits "long double" precision.
1642 return SSELevel == NoSSE ? 2 : 0;
1643 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001644 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1645 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001646 Records = BuiltinInfo;
1647 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001648 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001649 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001650 unsigned &NumNames) const {
1651 Names = GCCRegNames;
1652 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001653 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001654 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001655 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001656 Aliases = 0;
1657 NumAliases = 0;
1658 }
1659 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
Eric Christopher825d3862012-11-14 22:08:59 +00001660 unsigned &NumNames) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001661 Names = AddlRegNames;
1662 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001663 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001664 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001665 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001666 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001667 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001668 return "~{dirflag},~{fpsr},~{flags}";
1669 }
Chris Lattner33328642009-03-20 15:52:06 +00001670 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001671 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001672 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001673 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001674 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001675 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Douglas Gregore727d212012-01-30 06:38:25 +00001676 virtual bool hasFeature(StringRef Feature) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001677 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001678 virtual const char* getABI() const {
Derek Schuffbabaf312012-10-11 15:52:22 +00001679 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001680 return "avx";
Derek Schuffbabaf312012-10-11 15:52:22 +00001681 else if (getTriple().getArch() == llvm::Triple::x86 &&
1682 MMX3DNowLevel == NoMMX3DNow)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001683 return "no-mmx";
1684 return "";
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001685 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001686 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001687 CPU = llvm::StringSwitch<CPUKind>(Name)
1688 .Case("i386", CK_i386)
1689 .Case("i486", CK_i486)
1690 .Case("winchip-c6", CK_WinChipC6)
1691 .Case("winchip2", CK_WinChip2)
1692 .Case("c3", CK_C3)
1693 .Case("i586", CK_i586)
1694 .Case("pentium", CK_Pentium)
1695 .Case("pentium-mmx", CK_PentiumMMX)
1696 .Case("i686", CK_i686)
1697 .Case("pentiumpro", CK_PentiumPro)
1698 .Case("pentium2", CK_Pentium2)
1699 .Case("pentium3", CK_Pentium3)
1700 .Case("pentium3m", CK_Pentium3M)
1701 .Case("pentium-m", CK_PentiumM)
1702 .Case("c3-2", CK_C3_2)
1703 .Case("yonah", CK_Yonah)
1704 .Case("pentium4", CK_Pentium4)
1705 .Case("pentium4m", CK_Pentium4M)
1706 .Case("prescott", CK_Prescott)
1707 .Case("nocona", CK_Nocona)
1708 .Case("core2", CK_Core2)
1709 .Case("penryn", CK_Penryn)
1710 .Case("atom", CK_Atom)
1711 .Case("corei7", CK_Corei7)
1712 .Case("corei7-avx", CK_Corei7AVX)
1713 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper2b03bb02011-12-17 19:55:21 +00001714 .Case("core-avx2", CK_CoreAVX2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001715 .Case("k6", CK_K6)
1716 .Case("k6-2", CK_K6_2)
1717 .Case("k6-3", CK_K6_3)
1718 .Case("athlon", CK_Athlon)
1719 .Case("athlon-tbird", CK_AthlonThunderbird)
1720 .Case("athlon-4", CK_Athlon4)
1721 .Case("athlon-xp", CK_AthlonXP)
1722 .Case("athlon-mp", CK_AthlonMP)
1723 .Case("athlon64", CK_Athlon64)
1724 .Case("athlon64-sse3", CK_Athlon64SSE3)
1725 .Case("athlon-fx", CK_AthlonFX)
1726 .Case("k8", CK_K8)
1727 .Case("k8-sse3", CK_K8SSE3)
1728 .Case("opteron", CK_Opteron)
1729 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001730 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001731 .Case("btver1", CK_BTVER1)
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001732 .Case("bdver1", CK_BDVER1)
1733 .Case("bdver2", CK_BDVER2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001734 .Case("x86-64", CK_x86_64)
1735 .Case("geode", CK_Geode)
1736 .Default(CK_Generic);
1737
Chandler Carruth26a39142011-09-28 09:45:08 +00001738 // Perform any per-CPU checks necessary to determine if this CPU is
1739 // acceptable.
1740 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1741 // invalid without explaining *why*.
1742 switch (CPU) {
1743 case CK_Generic:
1744 // No processor selected!
1745 return false;
1746
1747 case CK_i386:
1748 case CK_i486:
1749 case CK_WinChipC6:
1750 case CK_WinChip2:
1751 case CK_C3:
1752 case CK_i586:
1753 case CK_Pentium:
1754 case CK_PentiumMMX:
1755 case CK_i686:
1756 case CK_PentiumPro:
1757 case CK_Pentium2:
1758 case CK_Pentium3:
1759 case CK_Pentium3M:
1760 case CK_PentiumM:
1761 case CK_Yonah:
1762 case CK_C3_2:
1763 case CK_Pentium4:
1764 case CK_Pentium4M:
1765 case CK_Prescott:
1766 case CK_K6:
1767 case CK_K6_2:
1768 case CK_K6_3:
1769 case CK_Athlon:
1770 case CK_AthlonThunderbird:
1771 case CK_Athlon4:
1772 case CK_AthlonXP:
1773 case CK_AthlonMP:
1774 case CK_Geode:
1775 // Only accept certain architectures when compiling in 32-bit mode.
Derek Schuffbabaf312012-10-11 15:52:22 +00001776 if (getTriple().getArch() != llvm::Triple::x86)
Chandler Carruth26a39142011-09-28 09:45:08 +00001777 return false;
1778
1779 // Fallthrough
1780 case CK_Nocona:
1781 case CK_Core2:
1782 case CK_Penryn:
1783 case CK_Atom:
1784 case CK_Corei7:
1785 case CK_Corei7AVX:
1786 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001787 case CK_CoreAVX2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001788 case CK_Athlon64:
1789 case CK_Athlon64SSE3:
1790 case CK_AthlonFX:
1791 case CK_K8:
1792 case CK_K8SSE3:
1793 case CK_Opteron:
1794 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00001795 case CK_AMDFAM10:
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001796 case CK_BTVER1:
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001797 case CK_BDVER1:
1798 case CK_BDVER2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001799 case CK_x86_64:
1800 return true;
1801 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001802 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001803 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00001804
1805 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
1806 // We accept all non-ARM calling conventions
1807 return (CC == CC_X86ThisCall ||
1808 CC == CC_X86FastCall ||
1809 CC == CC_X86StdCall ||
1810 CC == CC_C ||
Guy Benyei38980082012-12-25 08:53:55 +00001811 CC == CC_X86Pascal ||
1812 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballman82bfa192012-10-02 14:26:08 +00001813 }
1814
Aaron Ballmanfff32482012-12-09 17:45:41 +00001815 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {
1816 return MT == CCMT_Member ? CC_X86ThisCall : CC_C;
Aaron Ballman82bfa192012-10-02 14:26:08 +00001817 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001818};
Chris Lattner3daed522009-03-02 22:20:04 +00001819
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001820void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001821 // FIXME: This should not be here.
1822 Features["3dnow"] = false;
1823 Features["3dnowa"] = false;
1824 Features["mmx"] = false;
1825 Features["sse"] = false;
1826 Features["sse2"] = false;
1827 Features["sse3"] = false;
1828 Features["ssse3"] = false;
1829 Features["sse41"] = false;
1830 Features["sse42"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001831 Features["sse4a"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001832 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00001833 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001834 Features["avx"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001835 Features["avx2"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001836 Features["lzcnt"] = false;
Benjamin Kramer84f30802012-07-07 09:39:18 +00001837 Features["rdrand"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001838 Features["bmi"] = false;
1839 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001840 Features["popcnt"] = false;
Michael Liao463eb892012-11-10 05:17:46 +00001841 Features["rtm"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001842 Features["fma4"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00001843 Features["fma"] = false;
Craig Topperb6af69e2012-06-09 22:24:14 +00001844 Features["xop"] = false;
Manman Ren146e5a42012-10-11 00:59:55 +00001845 Features["f16c"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001846
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001847 // FIXME: This *really* should not be here.
1848
1849 // X86_64 always has SSE2.
Derek Schuffbabaf312012-10-11 15:52:22 +00001850 if (getTriple().getArch() == llvm::Triple::x86_64)
Eli Friedman612db2a2012-11-17 01:16:19 +00001851 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001852
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001853 switch (CPU) {
1854 case CK_Generic:
1855 case CK_i386:
1856 case CK_i486:
1857 case CK_i586:
1858 case CK_Pentium:
1859 case CK_i686:
1860 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001861 break;
1862 case CK_PentiumMMX:
1863 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001864 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001865 break;
1866 case CK_Pentium3:
1867 case CK_Pentium3M:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001868 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001869 break;
1870 case CK_PentiumM:
1871 case CK_Pentium4:
1872 case CK_Pentium4M:
1873 case CK_x86_64:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001874 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001875 break;
1876 case CK_Yonah:
1877 case CK_Prescott:
1878 case CK_Nocona:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001879 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001880 break;
1881 case CK_Core2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001882 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001883 break;
1884 case CK_Penryn:
Benjamin Kramerb3453a82012-01-04 14:36:57 +00001885 setFeatureEnabled(Features, "sse4.1", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001886 break;
1887 case CK_Atom:
Chandler Carruth49defe62011-09-28 10:36:46 +00001888 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001889 break;
1890 case CK_Corei7:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001891 setFeatureEnabled(Features, "sse4", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001892 break;
1893 case CK_Corei7AVX:
Benjamin Kramer84f30802012-07-07 09:39:18 +00001894 setFeatureEnabled(Features, "avx", true);
1895 setFeatureEnabled(Features, "aes", true);
1896 setFeatureEnabled(Features, "pclmul", true);
1897 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001898 case CK_CoreAVXi:
Craig Topperfd936302012-04-26 07:31:30 +00001899 setFeatureEnabled(Features, "avx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00001900 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00001901 setFeatureEnabled(Features, "pclmul", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00001902 setFeatureEnabled(Features, "rdrnd", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00001903 setFeatureEnabled(Features, "f16c", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001904 break;
Craig Topper2b03bb02011-12-17 19:55:21 +00001905 case CK_CoreAVX2:
Craig Topperfd936302012-04-26 07:31:30 +00001906 setFeatureEnabled(Features, "avx2", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00001907 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00001908 setFeatureEnabled(Features, "pclmul", true);
Craig Topper31ceea02011-12-25 05:06:45 +00001909 setFeatureEnabled(Features, "lzcnt", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00001910 setFeatureEnabled(Features, "rdrnd", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00001911 setFeatureEnabled(Features, "f16c", true);
Craig Topper31ceea02011-12-25 05:06:45 +00001912 setFeatureEnabled(Features, "bmi", true);
1913 setFeatureEnabled(Features, "bmi2", true);
Michael Liao463eb892012-11-10 05:17:46 +00001914 setFeatureEnabled(Features, "rtm", true);
Craig Topper2ae95072012-06-03 21:46:30 +00001915 setFeatureEnabled(Features, "fma", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00001916 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001917 case CK_K6:
1918 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001919 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001920 break;
1921 case CK_K6_2:
1922 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001923 case CK_WinChip2:
1924 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001925 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001926 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00001927 case CK_Athlon:
1928 case CK_AthlonThunderbird:
1929 case CK_Geode:
1930 setFeatureEnabled(Features, "3dnowa", true);
1931 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001932 case CK_Athlon4:
1933 case CK_AthlonXP:
1934 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001935 setFeatureEnabled(Features, "sse", true);
1936 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001937 break;
1938 case CK_K8:
1939 case CK_Opteron:
1940 case CK_Athlon64:
1941 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00001942 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001943 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001944 break;
1945 case CK_K8SSE3:
1946 case CK_OpteronSSE3:
1947 case CK_Athlon64SSE3:
Roman Divacky80b32b82011-10-30 13:47:56 +00001948 setFeatureEnabled(Features, "sse3", true);
1949 setFeatureEnabled(Features, "3dnowa", true);
1950 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00001951 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00001952 setFeatureEnabled(Features, "sse3", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00001953 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00001954 setFeatureEnabled(Features, "3dnowa", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00001955 setFeatureEnabled(Features, "lzcnt", true);
1956 setFeatureEnabled(Features, "popcnt", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001957 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001958 case CK_BTVER1:
1959 setFeatureEnabled(Features, "ssse3", true);
1960 setFeatureEnabled(Features, "sse4a", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00001961 setFeatureEnabled(Features, "lzcnt", true);
1962 setFeatureEnabled(Features, "popcnt", true);
Craig Topper90ea0362012-05-30 05:54:54 +00001963 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001964 case CK_BDVER1:
Craig Topperb6af69e2012-06-09 22:24:14 +00001965 setFeatureEnabled(Features, "xop", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00001966 setFeatureEnabled(Features, "lzcnt", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001967 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00001968 setFeatureEnabled(Features, "pclmul", true);
Eli Friedmanf5824992012-11-26 21:57:28 +00001969 break;
Eli Friedmanfaf35382012-11-17 01:43:10 +00001970 case CK_BDVER2:
1971 setFeatureEnabled(Features, "xop", true);
1972 setFeatureEnabled(Features, "lzcnt", true);
1973 setFeatureEnabled(Features, "aes", true);
1974 setFeatureEnabled(Features, "pclmul", true);
1975 setFeatureEnabled(Features, "bmi", true);
1976 setFeatureEnabled(Features, "fma", true);
1977 setFeatureEnabled(Features, "f16c", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001978 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001979 case CK_C3_2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001980 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001981 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001982 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001983}
1984
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001985bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001986 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001987 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00001988 // FIXME: This *really* should not be here. We need some way of translating
1989 // options into llvm subtarget features.
1990 if (!Features.count(Name) &&
Benjamin Kramer84f30802012-07-07 09:39:18 +00001991 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1" &&
1992 Name != "rdrnd"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001993 return false;
1994
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001995 // FIXME: this should probably use a switch with fall through.
1996
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001997 if (Enabled) {
1998 if (Name == "mmx")
1999 Features["mmx"] = true;
2000 else if (Name == "sse")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002001 Features["mmx"] = Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002002 else if (Name == "sse2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002003 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002004 else if (Name == "sse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002005 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2006 true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002007 else if (Name == "ssse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002008 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002009 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00002010 else if (Name == "sse4" || Name == "sse4.2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002011 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002012 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2013 Features["popcnt"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00002014 else if (Name == "sse4.1")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002015 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00002016 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002017 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002018 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002019 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002020 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00002021 else if (Name == "aes")
Craig Toppera7463c32012-06-03 21:56:22 +00002022 Features["sse"] = Features["sse2"] = Features["aes"] = true;
Craig Topper3c0bc152012-05-31 05:18:48 +00002023 else if (Name == "pclmul")
Craig Toppera7463c32012-06-03 21:56:22 +00002024 Features["sse"] = Features["sse2"] = Features["pclmul"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002025 else if (Name == "avx")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002026 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2027 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002028 Features["popcnt"] = Features["avx"] = true;
Craig Topper2b03bb02011-12-17 19:55:21 +00002029 else if (Name == "avx2")
2030 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2031 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002032 Features["popcnt"] = Features["avx"] = Features["avx2"] = true;
Craig Topper2ae95072012-06-03 21:46:30 +00002033 else if (Name == "fma")
2034 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2035 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2036 Features["popcnt"] = Features["avx"] = Features["fma"] = true;
Craig Topper6a511e12011-12-30 07:33:42 +00002037 else if (Name == "fma4")
Eli Friedman612db2a2012-11-17 01:16:19 +00002038 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00002039 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper90ea0362012-05-30 05:54:54 +00002040 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
2041 Features["fma4"] = true;
Craig Topperb6af69e2012-06-09 22:24:14 +00002042 else if (Name == "xop")
Eli Friedman612db2a2012-11-17 01:16:19 +00002043 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002044 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2045 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
2046 Features["fma4"] = Features["xop"] = true;
Roman Divacky80b32b82011-10-30 13:47:56 +00002047 else if (Name == "sse4a")
Craig Topper6a511e12011-12-30 07:33:42 +00002048 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper90ea0362012-05-30 05:54:54 +00002049 Features["sse4a"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00002050 else if (Name == "lzcnt")
2051 Features["lzcnt"] = true;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002052 else if (Name == "rdrnd")
2053 Features["rdrand"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00002054 else if (Name == "bmi")
2055 Features["bmi"] = true;
2056 else if (Name == "bmi2")
2057 Features["bmi2"] = true;
Craig Toppere14e08b2011-12-29 16:10:46 +00002058 else if (Name == "popcnt")
2059 Features["popcnt"] = true;
Manman Ren146e5a42012-10-11 00:59:55 +00002060 else if (Name == "f16c")
2061 Features["f16c"] = true;
Michael Liao463eb892012-11-10 05:17:46 +00002062 else if (Name == "rtm")
2063 Features["rtm"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002064 } else {
2065 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002066 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002067 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00002068 Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00002069 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002070 Features["sse4a"] = Features["avx"] = Features["avx2"] =
2071 Features["fma"] = Features["fma4"] = Features["aes"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002072 Features["pclmul"] = Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002073 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00002074 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Craig Toppera7463c32012-06-03 21:56:22 +00002075 Features["sse41"] = Features["sse42"] = Features["sse4a"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002076 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002077 Features["fma4"] = Features["aes"] = Features["pclmul"] =
2078 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002079 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00002080 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002081 Features["sse42"] = Features["sse4a"] = Features["avx"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002082 Features["avx2"] = Features["fma"] = Features["fma4"] =
2083 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002084 else if (Name == "ssse3")
Craig Topper31380fb2012-06-03 22:23:42 +00002085 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2086 Features["avx"] = Features["avx2"] = Features["fma"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00002087 else if (Name == "sse4" || Name == "sse4.1")
Craig Topper31380fb2012-06-03 22:23:42 +00002088 Features["sse41"] = Features["sse42"] = Features["avx"] =
2089 Features["avx2"] = Features["fma"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00002090 else if (Name == "sse4.2")
Craig Topper31380fb2012-06-03 22:23:42 +00002091 Features["sse42"] = Features["avx"] = Features["avx2"] =
2092 Features["fma"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002093 else if (Name == "3dnow")
2094 Features["3dnow"] = Features["3dnowa"] = false;
2095 else if (Name == "3dnowa")
2096 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00002097 else if (Name == "aes")
2098 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00002099 else if (Name == "pclmul")
2100 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002101 else if (Name == "avx")
Craig Topper2ae95072012-06-03 21:46:30 +00002102 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002103 Features["fma4"] = Features["xop"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00002104 else if (Name == "avx2")
2105 Features["avx2"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00002106 else if (Name == "fma")
2107 Features["fma"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00002108 else if (Name == "sse4a")
Craig Topperb6af69e2012-06-09 22:24:14 +00002109 Features["sse4a"] = Features["fma4"] = Features["xop"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002110 else if (Name == "lzcnt")
2111 Features["lzcnt"] = false;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002112 else if (Name == "rdrnd")
2113 Features["rdrand"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002114 else if (Name == "bmi")
2115 Features["bmi"] = false;
2116 else if (Name == "bmi2")
2117 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00002118 else if (Name == "popcnt")
2119 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00002120 else if (Name == "fma4")
Craig Topperb6af69e2012-06-09 22:24:14 +00002121 Features["fma4"] = Features["xop"] = false;
2122 else if (Name == "xop")
2123 Features["xop"] = false;
Manman Ren146e5a42012-10-11 00:59:55 +00002124 else if (Name == "f16c")
2125 Features["f16c"] = false;
Michael Liao463eb892012-11-10 05:17:46 +00002126 else if (Name == "rtm")
2127 Features["rtm"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002128 }
2129
2130 return true;
2131}
2132
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002133/// HandleTargetOptions - Perform initialization based on the user
2134/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00002135void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002136 // Remember the maximum enabled sselevel.
2137 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
2138 // Ignore disabled features.
2139 if (Features[i][0] == '-')
2140 continue;
2141
Benjamin Kramer713575a2012-03-05 15:10:44 +00002142 StringRef Feature = StringRef(Features[i]).substr(1);
2143
2144 if (Feature == "aes") {
Eric Christophereea12d12010-04-02 23:50:19 +00002145 HasAES = true;
2146 continue;
2147 }
2148
Craig Topper3c0bc152012-05-31 05:18:48 +00002149 if (Feature == "pclmul") {
2150 HasPCLMUL = true;
2151 continue;
2152 }
2153
Benjamin Kramer713575a2012-03-05 15:10:44 +00002154 if (Feature == "lzcnt") {
Craig Topper31ceea02011-12-25 05:06:45 +00002155 HasLZCNT = true;
2156 continue;
2157 }
2158
Benjamin Kramer84f30802012-07-07 09:39:18 +00002159 if (Feature == "rdrand") {
2160 HasRDRND = true;
2161 continue;
2162 }
2163
Benjamin Kramer713575a2012-03-05 15:10:44 +00002164 if (Feature == "bmi") {
Craig Topper31ceea02011-12-25 05:06:45 +00002165 HasBMI = true;
2166 continue;
2167 }
2168
Benjamin Kramer713575a2012-03-05 15:10:44 +00002169 if (Feature == "bmi2") {
Craig Topper31ceea02011-12-25 05:06:45 +00002170 HasBMI2 = true;
2171 continue;
2172 }
2173
Benjamin Kramer713575a2012-03-05 15:10:44 +00002174 if (Feature == "popcnt") {
Craig Toppere14e08b2011-12-29 16:10:46 +00002175 HasPOPCNT = true;
2176 continue;
2177 }
2178
Michael Liao463eb892012-11-10 05:17:46 +00002179 if (Feature == "rtm") {
2180 HasRTM = true;
2181 continue;
2182 }
2183
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002184 if (Feature == "sse4a") {
2185 HasSSE4a = true;
2186 continue;
2187 }
2188
Benjamin Kramer713575a2012-03-05 15:10:44 +00002189 if (Feature == "fma4") {
Craig Topper6a511e12011-12-30 07:33:42 +00002190 HasFMA4 = true;
2191 continue;
2192 }
2193
Craig Topper2ae95072012-06-03 21:46:30 +00002194 if (Feature == "fma") {
2195 HasFMA = true;
2196 continue;
2197 }
2198
Craig Topperb6af69e2012-06-09 22:24:14 +00002199 if (Feature == "xop") {
2200 HasXOP = true;
2201 continue;
2202 }
2203
Manman Ren146e5a42012-10-11 00:59:55 +00002204 if (Feature == "f16c") {
2205 HasF16C = true;
2206 continue;
2207 }
2208
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002209 assert(Features[i][0] == '+' && "Invalid target feature!");
Benjamin Kramer713575a2012-03-05 15:10:44 +00002210 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Craig Topper05fe4b52012-01-09 09:19:09 +00002211 .Case("avx2", AVX2)
2212 .Case("avx", AVX)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002213 .Case("sse42", SSE42)
2214 .Case("sse41", SSE41)
2215 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00002216 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002217 .Case("sse2", SSE2)
2218 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002219 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002220 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002221
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002222 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer713575a2012-03-05 15:10:44 +00002223 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002224 .Case("3dnowa", AMD3DNowAthlon)
2225 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002226 .Case("mmx", MMX)
2227 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002228
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002229 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002230 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002231
2232 // Don't tell the backend if we're turning off mmx; it will end up disabling
2233 // SSE, which we don't want.
2234 std::vector<std::string>::iterator it;
2235 it = std::find(Features.begin(), Features.end(), "-mmx");
2236 if (it != Features.end())
2237 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00002238}
Chris Lattnerc0f59212009-03-02 22:27:17 +00002239
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002240/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
2241/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00002242void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002243 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002244 // Target identification.
Derek Schuffbabaf312012-10-11 15:52:22 +00002245 if (getTriple().getArch() == llvm::Triple::x86_64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002246 Builder.defineMacro("__amd64__");
2247 Builder.defineMacro("__amd64");
2248 Builder.defineMacro("__x86_64");
2249 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002250 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00002251 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00002252 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002253
Chris Lattnerc0f59212009-03-02 22:27:17 +00002254 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002255 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
2256 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002257 switch (CPU) {
2258 case CK_Generic:
2259 break;
2260 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002261 // The rest are coming from the i386 define above.
2262 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002263 break;
2264 case CK_i486:
2265 case CK_WinChipC6:
2266 case CK_WinChip2:
2267 case CK_C3:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002268 defineCPUMacros(Builder, "i486");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002269 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00002270 case CK_PentiumMMX:
2271 Builder.defineMacro("__pentium_mmx__");
2272 Builder.defineMacro("__tune_pentium_mmx__");
2273 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002274 case CK_i586:
2275 case CK_Pentium:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002276 defineCPUMacros(Builder, "i586");
2277 defineCPUMacros(Builder, "pentium");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002278 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002279 case CK_Pentium3:
2280 case CK_Pentium3M:
2281 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002282 Builder.defineMacro("__tune_pentium3__");
2283 // Fallthrough
2284 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002285 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002286 Builder.defineMacro("__tune_pentium2__");
2287 // Fallthrough
2288 case CK_PentiumPro:
2289 Builder.defineMacro("__tune_i686__");
2290 Builder.defineMacro("__tune_pentiumpro__");
2291 // Fallthrough
2292 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002293 Builder.defineMacro("__i686");
2294 Builder.defineMacro("__i686__");
2295 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
2296 Builder.defineMacro("__pentiumpro");
2297 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002298 break;
2299 case CK_Pentium4:
2300 case CK_Pentium4M:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002301 defineCPUMacros(Builder, "pentium4");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002302 break;
2303 case CK_Yonah:
2304 case CK_Prescott:
2305 case CK_Nocona:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002306 defineCPUMacros(Builder, "nocona");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002307 break;
2308 case CK_Core2:
2309 case CK_Penryn:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002310 defineCPUMacros(Builder, "core2");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002311 break;
2312 case CK_Atom:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002313 defineCPUMacros(Builder, "atom");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002314 break;
2315 case CK_Corei7:
2316 case CK_Corei7AVX:
2317 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00002318 case CK_CoreAVX2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002319 defineCPUMacros(Builder, "corei7");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002320 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002321 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002322 Builder.defineMacro("__k6_2__");
2323 Builder.defineMacro("__tune_k6_2__");
2324 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002325 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002326 if (CPU != CK_K6_2) { // In case of fallthrough
2327 // FIXME: GCC may be enabling these in cases where some other k6
2328 // architecture is specified but -m3dnow is explicitly provided. The
2329 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002330 Builder.defineMacro("__k6_3__");
2331 Builder.defineMacro("__tune_k6_3__");
2332 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00002333 // Fallthrough
2334 case CK_K6:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002335 defineCPUMacros(Builder, "k6");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002336 break;
2337 case CK_Athlon:
2338 case CK_AthlonThunderbird:
2339 case CK_Athlon4:
2340 case CK_AthlonXP:
2341 case CK_AthlonMP:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002342 defineCPUMacros(Builder, "athlon");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002343 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002344 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002345 Builder.defineMacro("__tune_athlon_sse__");
2346 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002347 break;
2348 case CK_K8:
2349 case CK_K8SSE3:
2350 case CK_x86_64:
2351 case CK_Opteron:
2352 case CK_OpteronSSE3:
2353 case CK_Athlon64:
2354 case CK_Athlon64SSE3:
2355 case CK_AthlonFX:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002356 defineCPUMacros(Builder, "k8");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002357 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002358 case CK_AMDFAM10:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002359 defineCPUMacros(Builder, "amdfam10");
Roman Divacky01c770d2011-10-30 07:48:46 +00002360 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002361 case CK_BTVER1:
2362 defineCPUMacros(Builder, "btver1");
2363 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002364 case CK_BDVER1:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002365 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002366 break;
2367 case CK_BDVER2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002368 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002369 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002370 case CK_Geode:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002371 defineCPUMacros(Builder, "geode");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002372 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002373 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00002374
Chandler Carruth88c75b02011-09-28 09:54:07 +00002375 // Target properties.
2376 Builder.defineMacro("__LITTLE_ENDIAN__");
2377 Builder.defineMacro("__REGISTER_PREFIX__", "");
2378
Chris Lattner54175442009-04-19 17:32:33 +00002379 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2380 // functions in glibc header files that use FP Stack inline asm which the
2381 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00002382 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002383
Chandler Carruth88c75b02011-09-28 09:54:07 +00002384 if (HasAES)
2385 Builder.defineMacro("__AES__");
2386
Craig Topper3c0bc152012-05-31 05:18:48 +00002387 if (HasPCLMUL)
2388 Builder.defineMacro("__PCLMUL__");
2389
Craig Topper31ceea02011-12-25 05:06:45 +00002390 if (HasLZCNT)
2391 Builder.defineMacro("__LZCNT__");
2392
Benjamin Kramer84f30802012-07-07 09:39:18 +00002393 if (HasRDRND)
2394 Builder.defineMacro("__RDRND__");
2395
Craig Topper31ceea02011-12-25 05:06:45 +00002396 if (HasBMI)
2397 Builder.defineMacro("__BMI__");
2398
2399 if (HasBMI2)
2400 Builder.defineMacro("__BMI2__");
2401
Craig Toppere14e08b2011-12-29 16:10:46 +00002402 if (HasPOPCNT)
2403 Builder.defineMacro("__POPCNT__");
2404
Michael Liao463eb892012-11-10 05:17:46 +00002405 if (HasRTM)
2406 Builder.defineMacro("__RTM__");
2407
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002408 if (HasSSE4a)
2409 Builder.defineMacro("__SSE4A__");
2410
Craig Topper6a511e12011-12-30 07:33:42 +00002411 if (HasFMA4)
2412 Builder.defineMacro("__FMA4__");
2413
Craig Topper2ae95072012-06-03 21:46:30 +00002414 if (HasFMA)
2415 Builder.defineMacro("__FMA__");
2416
Craig Topperb6af69e2012-06-09 22:24:14 +00002417 if (HasXOP)
2418 Builder.defineMacro("__XOP__");
2419
Manman Ren146e5a42012-10-11 00:59:55 +00002420 if (HasF16C)
2421 Builder.defineMacro("__F16C__");
2422
Chris Lattner84f0ea82009-03-02 22:40:39 +00002423 // Each case falls through to the previous one here.
2424 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002425 case AVX2:
2426 Builder.defineMacro("__AVX2__");
2427 case AVX:
2428 Builder.defineMacro("__AVX__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002429 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00002430 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002431 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00002432 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002433 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002434 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002435 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002436 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002437 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00002438 Builder.defineMacro("__SSE2__");
2439 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00002440 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00002441 Builder.defineMacro("__SSE__");
2442 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002443 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00002444 break;
2445 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002446
Derek Schuffbabaf312012-10-11 15:52:22 +00002447 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002448 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002449 case AVX2:
2450 case AVX:
Michael J. Spencera764e832010-10-21 08:22:51 +00002451 case SSE42:
2452 case SSE41:
2453 case SSSE3:
2454 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002455 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002456 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002457 break;
2458 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002459 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002460 break;
2461 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002462 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002463 }
2464 }
2465
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002466 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002467 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002468 case AMD3DNowAthlon:
2469 Builder.defineMacro("__3dNOW_A__");
2470 case AMD3DNow:
2471 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002472 case MMX:
2473 Builder.defineMacro("__MMX__");
2474 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002475 break;
2476 }
Chris Lattnerc0f59212009-03-02 22:27:17 +00002477}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002478
Douglas Gregore727d212012-01-30 06:38:25 +00002479bool X86TargetInfo::hasFeature(StringRef Feature) const {
2480 return llvm::StringSwitch<bool>(Feature)
2481 .Case("aes", HasAES)
2482 .Case("avx", SSELevel >= AVX)
2483 .Case("avx2", SSELevel >= AVX2)
2484 .Case("bmi", HasBMI)
2485 .Case("bmi2", HasBMI2)
Craig Topper2ae95072012-06-03 21:46:30 +00002486 .Case("fma", HasFMA)
Douglas Gregore727d212012-01-30 06:38:25 +00002487 .Case("fma4", HasFMA4)
2488 .Case("lzcnt", HasLZCNT)
Benjamin Kramer84f30802012-07-07 09:39:18 +00002489 .Case("rdrnd", HasRDRND)
Douglas Gregore727d212012-01-30 06:38:25 +00002490 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
2491 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
2492 .Case("mmx", MMX3DNowLevel >= MMX)
Craig Topper3c0bc152012-05-31 05:18:48 +00002493 .Case("pclmul", HasPCLMUL)
Douglas Gregore727d212012-01-30 06:38:25 +00002494 .Case("popcnt", HasPOPCNT)
Michael Liao463eb892012-11-10 05:17:46 +00002495 .Case("rtm", HasRTM)
Douglas Gregore727d212012-01-30 06:38:25 +00002496 .Case("sse", SSELevel >= SSE1)
2497 .Case("sse2", SSELevel >= SSE2)
2498 .Case("sse3", SSELevel >= SSE3)
2499 .Case("ssse3", SSELevel >= SSSE3)
2500 .Case("sse41", SSELevel >= SSE41)
2501 .Case("sse42", SSELevel >= SSE42)
Craig Topper3c0bc152012-05-31 05:18:48 +00002502 .Case("sse4a", HasSSE4a)
Douglas Gregore727d212012-01-30 06:38:25 +00002503 .Case("x86", true)
Derek Schuffbabaf312012-10-11 15:52:22 +00002504 .Case("x86_32", getTriple().getArch() == llvm::Triple::x86)
2505 .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64)
Craig Topperb6af69e2012-06-09 22:24:14 +00002506 .Case("xop", HasXOP)
Manman Ren146e5a42012-10-11 00:59:55 +00002507 .Case("f16c", HasF16C)
Douglas Gregore727d212012-01-30 06:38:25 +00002508 .Default(false);
2509}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002510
Eli Friedman618234a2008-08-20 02:34:37 +00002511bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002512X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002513 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002514 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00002515 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00002516 case 'Y': // first letter of a pair:
2517 switch (*(Name+1)) {
2518 default: return false;
2519 case '0': // First SSE register.
2520 case 't': // Any SSE register, when SSE2 is enabled.
2521 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2522 case 'm': // any MMX register, when inter-unit moves enabled.
2523 break; // falls through to setAllowsRegister.
2524 }
Eli Friedman618234a2008-08-20 02:34:37 +00002525 case 'a': // eax.
2526 case 'b': // ebx.
2527 case 'c': // ecx.
2528 case 'd': // edx.
2529 case 'S': // esi.
2530 case 'D': // edi.
2531 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00002532 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00002533 case 't': // top of floating point stack.
2534 case 'u': // second from top of floating point stack.
2535 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00002536 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00002537 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00002538 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00002539 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2540 case 'l': // "Index" registers: any general register that can be used as an
2541 // index in a base+index memory access.
2542 Info.setAllowsRegister();
2543 return true;
2544 case 'C': // SSE floating point constant.
2545 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002546 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002547 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002548 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002549 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00002550 return true;
2551 }
2552}
2553
Dale Johannesenf6e2c202010-10-29 23:12:32 +00002554
Eli Friedman618234a2008-08-20 02:34:37 +00002555std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00002556X86TargetInfo::convertConstraint(const char *&Constraint) const {
2557 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00002558 case 'a': return std::string("{ax}");
2559 case 'b': return std::string("{bx}");
2560 case 'c': return std::string("{cx}");
2561 case 'd': return std::string("{dx}");
2562 case 'S': return std::string("{si}");
2563 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00002564 case 'p': // address
2565 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00002566 case 't': // top of floating point stack.
2567 return std::string("{st}");
2568 case 'u': // second from top of floating point stack.
2569 return std::string("{st(1)}"); // second from top of floating point stack.
2570 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00002571 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00002572 }
2573}
Eli Friedman618234a2008-08-20 02:34:37 +00002574} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00002575
2576namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002577// X86-32 generic target
2578class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00002579public:
Eli Friedman618234a2008-08-20 02:34:37 +00002580 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
2581 DoubleAlign = LongLongAlign = 32;
2582 LongDoubleWidth = 96;
2583 LongDoubleAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00002584 SuitableAlign = 128;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002585 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2586 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00002587 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00002588 SizeType = UnsignedInt;
2589 PtrDiffType = SignedInt;
2590 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002591 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002592
2593 // Use fpret for all types.
2594 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2595 (1 << TargetInfo::Double) |
2596 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002597
2598 // x86-32 has atomics up to 8 bytes
2599 // FIXME: Check that we actually have cmpxchg8b before setting
2600 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2601 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002602 }
Meador Ingec5613b22012-06-16 03:34:49 +00002603 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2604 return TargetInfo::CharPtrBuiltinVaList;
Eli Friedman618234a2008-08-20 02:34:37 +00002605 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002606
Chris Lattner21fb98e2009-09-23 06:06:36 +00002607 int getEHDataRegisterNumber(unsigned RegNo) const {
2608 if (RegNo == 0) return 0;
2609 if (RegNo == 1) return 2;
2610 return -1;
2611 }
Bill Wendling68fd6082012-11-12 06:42:51 +00002612 virtual bool validateInputSize(StringRef Constraint,
2613 unsigned Size) const {
2614 switch (Constraint[0]) {
2615 default: break;
2616 case 'a':
2617 case 'b':
2618 case 'c':
2619 case 'd':
Bill Wendlingf634bdf2012-11-12 18:52:32 +00002620 return Size <= 32;
Bill Wendling68fd6082012-11-12 06:42:51 +00002621 }
2622
2623 return true;
2624 }
Eli Friedman618234a2008-08-20 02:34:37 +00002625};
2626} // end anonymous namespace
2627
2628namespace {
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002629class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
2630public:
2631 NetBSDI386TargetInfo(const std::string &triple) :
2632 NetBSDTargetInfo<X86_32TargetInfo>(triple) {
2633 }
2634
2635 virtual unsigned getFloatEvalMethod() const {
2636 // NetBSD defaults to "double" rounding
2637 return 1;
2638 }
2639};
2640} // end anonymous namespace
2641
2642namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002643class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2644public:
2645 OpenBSDI386TargetInfo(const std::string& triple) :
2646 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2647 SizeType = UnsignedLong;
2648 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002649 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002650 }
2651};
2652} // end anonymous namespace
2653
2654namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00002655class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
2656public:
2657 BitrigI386TargetInfo(const std::string& triple) :
2658 BitrigTargetInfo<X86_32TargetInfo>(triple) {
2659 SizeType = UnsignedLong;
2660 IntPtrType = SignedLong;
2661 PtrDiffType = SignedLong;
2662 }
2663};
2664} // end anonymous namespace
2665
2666namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002667class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002668public:
Torok Edwin5f6c1942009-06-30 17:10:35 +00002669 DarwinI386TargetInfo(const std::string& triple) :
2670 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002671 LongDoubleWidth = 128;
2672 LongDoubleAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002673 SuitableAlign = 128;
Chad Rosierf9e9af72012-07-13 23:57:43 +00002674 MaxVectorAlign = 256;
Eli Friedman1afabd92009-03-29 20:31:09 +00002675 SizeType = UnsignedLong;
2676 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002677 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2678 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002679 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002680 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002681 }
2682
Eli Friedman618234a2008-08-20 02:34:37 +00002683};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002684} // end anonymous namespace
2685
2686namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002687// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002688class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002689public:
2690 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002691 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002692 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002693 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002694 DoubleAlign = LongLongAlign = 64;
2695 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 +00002696 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002697 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002698 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002699 virtual void getTargetDefines(const LangOptions &Opts,
2700 MacroBuilder &Builder) const {
2701 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2702 }
2703};
2704} // end anonymous namespace
2705
2706namespace {
2707
2708// x86-32 Windows Visual Studio target
2709class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2710public:
2711 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2712 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002713 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002714 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2715 }
2716 virtual void getTargetDefines(const LangOptions &Opts,
2717 MacroBuilder &Builder) const {
2718 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2719 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2720 // The value of the following reflects processor type.
2721 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2722 // We lost the original triple, so we use the default.
2723 Builder.defineMacro("_M_IX86", "600");
2724 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002725};
2726} // end anonymous namespace
2727
2728namespace {
2729// x86-32 MinGW target
2730class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2731public:
2732 MinGWX86_32TargetInfo(const std::string& triple)
2733 : WindowsX86_32TargetInfo(triple) {
2734 }
2735 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002736 MacroBuilder &Builder) const {
2737 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002738 DefineStd(Builder, "WIN32", Opts);
2739 DefineStd(Builder, "WINNT", Opts);
2740 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002741 Builder.defineMacro("__MSVCRT__");
2742 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002743
2744 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2745 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002746 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002747 // Provide "as-is" __declspec.
2748 Builder.defineMacro("__declspec", "__declspec");
2749 else
2750 // Provide alias of __attribute__ like mingw32-gcc.
2751 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002752 }
2753};
2754} // end anonymous namespace
2755
2756namespace {
2757// x86-32 Cygwin target
2758class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2759public:
2760 CygwinX86_32TargetInfo(const std::string& triple)
2761 : X86_32TargetInfo(triple) {
2762 TLSSupported = false;
2763 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002764 DoubleAlign = LongLongAlign = 64;
2765 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2766 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002767 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002768 }
2769 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002770 MacroBuilder &Builder) const {
2771 X86_32TargetInfo::getTargetDefines(Opts, Builder);
NAKAMURA Takumie72f4d92012-12-14 10:17:26 +00002772 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002773 Builder.defineMacro("__CYGWIN__");
2774 Builder.defineMacro("__CYGWIN32__");
2775 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00002776 if (Opts.CPlusPlus)
2777 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00002778 }
Eli Friedman29a30502008-08-21 01:40:19 +00002779};
2780} // end anonymous namespace
2781
2782namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002783// x86-32 Haiku target
2784class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2785public:
2786 HaikuX86_32TargetInfo(const std::string& triple)
2787 : X86_32TargetInfo(triple) {
2788 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00002789 IntPtrType = SignedLong;
2790 PtrDiffType = SignedLong;
Eli Friedman6902e412012-11-27 02:58:24 +00002791 ProcessIDType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00002792 this->UserLabelPrefix = "";
Benjamin Krameref7bcea2012-11-08 12:59:15 +00002793 this->TLSSupported = false;
Eli Friedmana7e68452010-08-22 01:00:03 +00002794 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00002795 virtual void getTargetDefines(const LangOptions &Opts,
2796 MacroBuilder &Builder) const {
2797 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2798 Builder.defineMacro("__INTEL__");
2799 Builder.defineMacro("__HAIKU__");
2800 }
2801};
2802} // end anonymous namespace
2803
Douglas Gregordca52262011-07-01 22:41:14 +00002804// RTEMS Target
2805template<typename Target>
2806class RTEMSTargetInfo : public OSTargetInfo<Target> {
2807protected:
2808 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2809 MacroBuilder &Builder) const {
2810 // RTEMS defines; list based off of gcc output
2811
Douglas Gregordca52262011-07-01 22:41:14 +00002812 Builder.defineMacro("__rtems__");
2813 Builder.defineMacro("__ELF__");
2814 }
2815public:
2816 RTEMSTargetInfo(const std::string &triple)
2817 : OSTargetInfo<Target>(triple) {
2818 this->UserLabelPrefix = "";
2819
2820 llvm::Triple Triple(triple);
2821 switch (Triple.getArch()) {
2822 default:
2823 case llvm::Triple::x86:
2824 // this->MCountName = ".mcount";
2825 break;
2826 case llvm::Triple::mips:
2827 case llvm::Triple::mipsel:
2828 case llvm::Triple::ppc:
2829 case llvm::Triple::ppc64:
2830 // this->MCountName = "_mcount";
2831 break;
2832 case llvm::Triple::arm:
2833 // this->MCountName = "__mcount";
2834 break;
2835 }
2836
2837 }
2838};
2839
2840namespace {
2841// x86-32 RTEMS target
2842class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2843public:
2844 RTEMSX86_32TargetInfo(const std::string& triple)
2845 : X86_32TargetInfo(triple) {
2846 SizeType = UnsignedLong;
2847 IntPtrType = SignedLong;
2848 PtrDiffType = SignedLong;
2849 this->UserLabelPrefix = "";
2850 }
2851 virtual void getTargetDefines(const LangOptions &Opts,
2852 MacroBuilder &Builder) const {
2853 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2854 Builder.defineMacro("__INTEL__");
2855 Builder.defineMacro("__rtems__");
2856 }
2857};
2858} // end anonymous namespace
2859
Chris Lattner86ed3a32010-04-11 19:29:39 +00002860namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002861// x86-64 generic target
2862class X86_64TargetInfo : public X86TargetInfo {
2863public:
Chris Lattner33328642009-03-20 15:52:06 +00002864 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00002865 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002866 LongDoubleWidth = 128;
2867 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00002868 LargeArrayMinWidth = 128;
2869 LargeArrayAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002870 SuitableAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00002871 IntMaxType = SignedLong;
2872 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002873 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002874 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00002875
Eli Friedmaned855cb2008-08-21 00:13:15 +00002876 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2877 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002878 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002879
2880 // Use fpret only for long double.
2881 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00002882
Anders Carlssoneea64802011-10-31 16:27:11 +00002883 // Use fp2ret for _Complex long double.
2884 ComplexLongDoubleUsesFP2Ret = true;
2885
Eli Friedman2be46072011-10-14 20:59:01 +00002886 // x86-64 has atomics up to 16 bytes.
2887 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
2888 // on CPUs with cmpxchg16b
2889 MaxAtomicPromoteWidth = 128;
2890 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00002891 }
Meador Ingec5613b22012-06-16 03:34:49 +00002892 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2893 return TargetInfo::X86_64ABIBuiltinVaList;
Anders Carlsson3346ae62007-11-24 23:38:12 +00002894 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002895
Chris Lattner21fb98e2009-09-23 06:06:36 +00002896 int getEHDataRegisterNumber(unsigned RegNo) const {
2897 if (RegNo == 0) return 0;
2898 if (RegNo == 1) return 1;
2899 return -1;
2900 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00002901
2902 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
Guy Benyei7266cf62013-01-10 10:41:05 +00002903 return (CC == CC_Default ||
2904 CC == CC_C ||
2905 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballman82bfa192012-10-02 14:26:08 +00002906 }
2907
Aaron Ballmanfff32482012-12-09 17:45:41 +00002908 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {
2909 return CC_C;
Aaron Ballman82bfa192012-10-02 14:26:08 +00002910 }
2911
Eli Friedman618234a2008-08-20 02:34:37 +00002912};
2913} // end anonymous namespace
2914
2915namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002916// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002917class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002918public:
2919 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002920 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002921 TLSSupported = false;
2922 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00002923 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00002924 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00002925 IntMaxType = SignedLongLong;
2926 UIntMaxType = UnsignedLongLong;
2927 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00002928 SizeType = UnsignedLongLong;
2929 PtrDiffType = SignedLongLong;
2930 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00002931 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002932 }
2933 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002934 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002935 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002936 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00002937 }
Meador Ingec5613b22012-06-16 03:34:49 +00002938 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2939 return TargetInfo::CharPtrBuiltinVaList;
NAKAMURA Takumi79521992011-01-17 22:56:23 +00002940 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002941};
2942} // end anonymous namespace
2943
2944namespace {
2945// x86-64 Windows Visual Studio target
2946class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2947public:
2948 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2949 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002950 LongDoubleWidth = LongDoubleAlign = 64;
2951 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00002952 }
2953 virtual void getTargetDefines(const LangOptions &Opts,
2954 MacroBuilder &Builder) const {
2955 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
2956 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00002957 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002958 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002959 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002960};
2961} // end anonymous namespace
2962
2963namespace {
2964// x86-64 MinGW target
2965class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2966public:
2967 MinGWX86_64TargetInfo(const std::string& triple)
2968 : WindowsX86_64TargetInfo(triple) {
2969 }
2970 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002971 MacroBuilder &Builder) const {
2972 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002973 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00002974 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00002975 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00002976 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002977
2978 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2979 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002980 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002981 // Provide "as-is" __declspec.
2982 Builder.defineMacro("__declspec", "__declspec");
2983 else
2984 // Provide alias of __attribute__ like mingw32-gcc.
2985 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002986 }
2987};
2988} // end anonymous namespace
2989
2990namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002991class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2992public:
Mike Stump1eb44332009-09-09 15:08:12 +00002993 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002994 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2995 Int64Type = SignedLongLong;
Chad Rosierf9e9af72012-07-13 23:57:43 +00002996 MaxVectorAlign = 256;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002997 }
2998};
2999} // end anonymous namespace
3000
3001namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00003002class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
3003public:
Mike Stump1eb44332009-09-09 15:08:12 +00003004 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman6036ebe2009-07-05 22:31:18 +00003005 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
3006 IntMaxType = SignedLongLong;
3007 UIntMaxType = UnsignedLongLong;
3008 Int64Type = SignedLongLong;
3009 }
3010};
3011} // end anonymous namespace
3012
3013namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00003014class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
3015public:
3016 BitrigX86_64TargetInfo(const std::string& triple)
3017 : BitrigTargetInfo<X86_64TargetInfo>(triple) {
3018 IntMaxType = SignedLongLong;
3019 UIntMaxType = UnsignedLongLong;
3020 Int64Type = SignedLongLong;
3021 }
3022};
3023} // end anonymous namespace
3024
3025namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00003026class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003027 // Possible FPU choices.
3028 enum FPUMode {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003029 VFP2FPU = (1 << 0),
3030 VFP3FPU = (1 << 1),
3031 VFP4FPU = (1 << 2),
3032 NeonFPU = (1 << 3)
Daniel Dunbara91320b2009-12-21 23:28:17 +00003033 };
3034
3035 static bool FPUModeIsVFP(FPUMode Mode) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003036 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU);
Daniel Dunbara91320b2009-12-21 23:28:17 +00003037 }
3038
3039 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3040 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003041
Daniel Dunbareac7c532009-12-18 18:42:37 +00003042 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003043
Bob Wilsoncfaab002012-09-29 23:52:52 +00003044 unsigned FPU : 4;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003045
Logan Chieneae5a8202012-10-10 06:56:20 +00003046 unsigned IsAAPCS : 1;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003047 unsigned IsThumb : 1;
3048
3049 // Initialized via features.
3050 unsigned SoftFloat : 1;
3051 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003052
Chris Lattner2752c012010-03-03 19:03:45 +00003053 static const Builtin::Info BuiltinInfo[];
3054
Chris Lattner393ff042008-04-21 18:56:49 +00003055public:
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003056 ARMTargetInfo(const std::string &TripleStr)
Logan Chieneae5a8202012-10-10 06:56:20 +00003057 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s"), IsAAPCS(true)
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003058 {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003059 BigEndian = false;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003060 SizeType = UnsignedInt;
3061 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00003062 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
3063 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003064
Chris Lattner9bffb072010-04-23 16:29:58 +00003065 // {} in inline assembly are neon specifiers, not assembly variant
3066 // specifiers.
3067 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00003068
Daniel Dunbareac7c532009-12-18 18:42:37 +00003069 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00003070 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003071 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003072 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3073 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003074 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
3075 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003076 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003077 } else {
3078 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3079 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003080 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003081 }
John McCallee79a4c2010-08-21 22:46:04 +00003082
3083 // ARM targets default to using the ARM C++ ABI.
3084 CXXABI = CXXABI_ARM;
Eli Friedman2be46072011-10-14 20:59:01 +00003085
3086 // ARM has atomics up to 8 bytes
3087 // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e
3088 MaxAtomicPromoteWidth = 64;
James Molloye45b9b72012-03-12 09:14:10 +00003089
3090 // Do force alignment of members that follow zero length bitfields. If
3091 // the alignment of the zero-length bitfield is greater than the member
3092 // that follows it, `bar', `bar' will be aligned as the type of the
3093 // zero length bitfield.
3094 UseZeroLengthBitfieldAlignment = true;
Eli Friedman61538a72008-05-20 14:21:01 +00003095 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003096 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00003097 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003098 ABI = Name;
3099
Daniel Dunbara2a41612009-09-14 00:02:24 +00003100 // The defaults (above) are for AAPCS, check if we need to change them.
3101 //
3102 // FIXME: We need support for -meabi... we could just mangle it into the
3103 // name.
3104 if (Name == "apcs-gnu") {
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003105 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Rafael Espindola27fa2362012-12-13 04:17:14 +00003106 // size_t is unsigned int on FreeBSD.
3107 if (getTriple().getOS() != llvm::Triple::FreeBSD)
3108 SizeType = UnsignedLong;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003109
James Molloya6d81f92011-11-23 13:35:08 +00003110 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
3111 WCharType = SignedInt;
3112
Daniel Dunbar684de632010-04-22 16:14:54 +00003113 // Do not respect the alignment of bit-field types when laying out
3114 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
3115 UseBitFieldTypeAlignment = false;
3116
Chad Rosier61a62212011-08-04 01:21:14 +00003117 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00003118 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
3119 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00003120 ZeroLengthBitfieldBoundary = 32;
3121
Logan Chieneae5a8202012-10-10 06:56:20 +00003122 IsAAPCS = false;
3123
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003124 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003125 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3126 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003127 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 +00003128 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003129 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003130 } else {
3131 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 +00003132 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003133 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003134 }
3135
Chad Rosier9f1210c2011-07-26 07:03:04 +00003136 // FIXME: Override "preferred align" for double and long long.
David Tweedb16abb12012-10-25 13:33:01 +00003137 } else if (Name == "aapcs" || Name == "aapcs-vfp") {
Logan Chieneae5a8202012-10-10 06:56:20 +00003138 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003139 // FIXME: Enumerated types are variable width in straight AAPCS.
3140 } else if (Name == "aapcs-linux") {
Logan Chieneae5a8202012-10-10 06:56:20 +00003141 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003142 } else
3143 return false;
3144
3145 return true;
3146 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003147
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003148 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003149 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
3150 Features["vfp2"] = true;
Bob Wilsoncfaab002012-09-29 23:52:52 +00003151 else if (CPU == "cortex-a8" || CPU == "cortex-a15" ||
3152 CPU == "cortex-a9" || CPU == "cortex-a9-mp")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003153 Features["neon"] = true;
Bob Wilsoncfaab002012-09-29 23:52:52 +00003154 else if (CPU == "swift") {
3155 Features["vfp4"] = true;
3156 Features["neon"] = true;
3157 }
Daniel Dunbara91320b2009-12-21 23:28:17 +00003158 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003159
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003160 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00003161 StringRef Name,
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003162 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00003163 if (Name == "soft-float" || Name == "soft-float-abi" ||
Bob Wilsoncfaab002012-09-29 23:52:52 +00003164 Name == "vfp2" || Name == "vfp3" || Name == "vfp4" || Name == "neon" ||
3165 Name == "d16" || Name == "neonfp") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003166 Features[Name] = Enabled;
3167 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003168 return false;
3169
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003170 return true;
3171 }
3172
3173 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003174 FPU = 0;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003175 SoftFloat = SoftFloatABI = false;
3176 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
3177 if (Features[i] == "+soft-float")
3178 SoftFloat = true;
3179 else if (Features[i] == "+soft-float-abi")
3180 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003181 else if (Features[i] == "+vfp2")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003182 FPU |= VFP2FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003183 else if (Features[i] == "+vfp3")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003184 FPU |= VFP3FPU;
3185 else if (Features[i] == "+vfp4")
3186 FPU |= VFP4FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003187 else if (Features[i] == "+neon")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003188 FPU |= NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003189 }
3190
3191 // Remove front-end specific options which the backend handles differently.
3192 std::vector<std::string>::iterator it;
3193 it = std::find(Features.begin(), Features.end(), "+soft-float");
3194 if (it != Features.end())
3195 Features.erase(it);
3196 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
3197 if (it != Features.end())
3198 Features.erase(it);
3199 }
3200
Douglas Gregore727d212012-01-30 06:38:25 +00003201 virtual bool hasFeature(StringRef Feature) const {
3202 return llvm::StringSwitch<bool>(Feature)
3203 .Case("arm", true)
3204 .Case("softfloat", SoftFloat)
3205 .Case("thumb", IsThumb)
3206 .Case("neon", FPU == NeonFPU && !SoftFloat &&
3207 StringRef(getCPUDefineSuffix(CPU)).startswith("7"))
3208 .Default(false);
3209 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003210 // FIXME: Should we actually have some table instead of these switches?
Chris Lattner5f9e2722011-07-23 10:55:15 +00003211 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00003212 return llvm::StringSwitch<const char*>(Name)
3213 .Cases("arm8", "arm810", "4")
3214 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
3215 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
3216 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
3217 .Case("ep9312", "4T")
3218 .Cases("arm10tdmi", "arm1020t", "5T")
3219 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
3220 .Case("arm926ej-s", "5TEJ")
3221 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
3222 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003223 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003224 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003225 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003226 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
Quentin Colombet74632aa2012-11-29 23:15:27 +00003227 .Cases("cortex-a5", "cortex-a8", "cortex-a9", "cortex-a15", "7A")
Quentin Colombetab137512012-12-21 17:57:47 +00003228 .Case("cortex-r5", "7R")
Bob Wilson336bfa32012-09-29 23:52:50 +00003229 .Case("cortex-a9-mp", "7F")
3230 .Case("swift", "7S")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003231 .Cases("cortex-m3", "cortex-m4", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00003232 .Case("cortex-m0", "6M")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003233 .Default(0);
3234 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003235 static const char *getCPUProfile(StringRef Name) {
3236 return llvm::StringSwitch<const char*>(Name)
3237 .Cases("cortex-a8", "cortex-a9", "A")
3238 .Cases("cortex-m3", "cortex-m4", "cortex-m0", "M")
Quentin Colombetab137512012-12-21 17:57:47 +00003239 .Case("cortex-r5", "R")
Anton Korobeynikov8b0703d2012-09-08 08:22:13 +00003240 .Default("");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003241 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003242 virtual bool setCPU(const std::string &Name) {
3243 if (!getCPUDefineSuffix(Name))
3244 return false;
3245
3246 CPU = Name;
3247 return true;
3248 }
Chris Lattner33328642009-03-20 15:52:06 +00003249 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003250 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00003251 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00003252 Builder.defineMacro("__arm");
3253 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003254
Chris Lattnerc0f59212009-03-02 22:27:17 +00003255 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00003256 Builder.defineMacro("__ARMEL__");
3257 Builder.defineMacro("__LITTLE_ENDIAN__");
3258 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003259
Chris Lattner5f9e2722011-07-23 10:55:15 +00003260 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00003261 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003262 Builder.defineMacro("__ARM_ARCH", CPUArch.substr(0, 1));
3263 StringRef CPUProfile = getCPUProfile(CPU);
3264 if (!CPUProfile.empty())
3265 Builder.defineMacro("__ARM_ARCH_PROFILE", CPUProfile);
3266
Mike Stump437bb4b2009-04-08 02:07:04 +00003267 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003268
Daniel Dunbareac7c532009-12-18 18:42:37 +00003269 // FIXME: It's more complicated than this and we don't really support
3270 // interworking.
3271 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00003272 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003273
David Tweedb16abb12012-10-25 13:33:01 +00003274 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
Daniel Dunbar849289e2012-10-22 18:51:13 +00003275 // M-class CPUs on Darwin follow AAPCS, but not EABI.
Daniel Dunbar4d3ee9b2012-10-22 18:56:43 +00003276 if (!(getTriple().isOSDarwin() && CPUProfile == "M"))
Daniel Dunbar849289e2012-10-22 18:51:13 +00003277 Builder.defineMacro("__ARM_EABI__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003278 Builder.defineMacro("__ARM_PCS", "1");
3279
David Tweedb16abb12012-10-25 13:33:01 +00003280 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003281 Builder.defineMacro("__ARM_PCS_VFP", "1");
3282 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003283
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003284 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00003285 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003286
3287 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00003288 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003289
Bob Wilson84f95cf2011-05-13 18:56:03 +00003290 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003291 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003292 Builder.defineMacro("__THUMBEL__");
3293 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00003294 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003295 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003296 }
3297
3298 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00003299 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00003300
Bob Wilsoncfaab002012-09-29 23:52:52 +00003301 if (FPUModeIsVFP((FPUMode) FPU)) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003302 Builder.defineMacro("__VFP_FP__");
Bob Wilsoncfaab002012-09-29 23:52:52 +00003303 if (FPU & VFP2FPU)
3304 Builder.defineMacro("__ARM_VFPV2__");
3305 if (FPU & VFP3FPU)
3306 Builder.defineMacro("__ARM_VFPV3__");
3307 if (FPU & VFP4FPU)
3308 Builder.defineMacro("__ARM_VFPV4__");
3309 }
3310
Daniel Dunbara91320b2009-12-21 23:28:17 +00003311 // This only gets set when Neon instructions are actually available, unlike
3312 // the VFP define, hence the soft float and arch check. This is subtly
3313 // different from gcc, we follow the intent which was that it should be set
3314 // when Neon instructions are actually available.
Bob Wilsoncfaab002012-09-29 23:52:52 +00003315 if ((FPU & NeonFPU) && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003316 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00003317 }
3318 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3319 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00003320 Records = BuiltinInfo;
3321 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00003322 }
Bob Wilson8b30a932012-01-26 22:14:27 +00003323 virtual bool isCLZForZeroUndef() const { return false; }
Meador Ingec5613b22012-06-16 03:34:49 +00003324 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Logan Chieneae5a8202012-10-10 06:56:20 +00003325 return IsAAPCS ? AAPCSABIBuiltinVaList : TargetInfo::VoidPtrBuiltinVaList;
Chris Lattner393ff042008-04-21 18:56:49 +00003326 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003327 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003328 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003329 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003330 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003331 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00003332 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003333 switch (*Name) {
Eric Christophera0dfca12012-08-16 23:50:41 +00003334 default: break;
Nate Begemanad487f42008-04-22 05:03:19 +00003335 case 'l': // r0-r7
3336 case 'h': // r8-r15
3337 case 'w': // VFP Floating point register single precision
3338 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00003339 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00003340 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00003341 case 'Q': // A memory address that is a single base register.
3342 Info.setAllowsMemory();
3343 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00003344 case 'U': // a memory reference...
3345 switch (Name[1]) {
3346 case 'q': // ...ARMV4 ldrsb
3347 case 'v': // ...VFP load/store (reg+constant offset)
3348 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00003349 case 't': // address valid for load/store opaque types wider
Eric Christopher825d3862012-11-14 22:08:59 +00003350 // than 128-bits
Eric Christopherdda231a2011-06-17 01:40:49 +00003351 case 'n': // valid address for Neon doubleword vector load/store
3352 case 'm': // valid address for Neon element and structure load/store
3353 case 's': // valid address for non-offset loads/stores of quad-word
Eric Christopher825d3862012-11-14 22:08:59 +00003354 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00003355 Info.setAllowsMemory();
3356 Name++;
3357 return true;
3358 }
Nate Begemanad487f42008-04-22 05:03:19 +00003359 }
Chris Lattner393ff042008-04-21 18:56:49 +00003360 return false;
3361 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00003362 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00003363 std::string R;
3364 switch (*Constraint) {
3365 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00003366 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00003367 Constraint++;
3368 break;
Eric Christopher283f4472011-06-17 00:40:18 +00003369 case 'p': // 'p' should be translated to 'r' by default.
3370 R = std::string("r");
3371 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00003372 default:
3373 return std::string(1, *Constraint);
3374 }
3375 return R;
3376 }
Bill Wendling50d46ca2012-10-25 23:28:48 +00003377 virtual bool validateConstraintModifier(StringRef Constraint,
3378 const char Modifier,
3379 unsigned Size) const {
Bill Wendlinge2dbaa92012-11-30 23:18:12 +00003380 bool isOutput = (Constraint[0] == '=');
Bill Wendling6e6330c2012-11-30 23:46:56 +00003381 bool isInOut = (Constraint[0] == '+');
Bill Wendlinge2dbaa92012-11-30 23:18:12 +00003382
Bill Wendling50d46ca2012-10-25 23:28:48 +00003383 // Strip off constraint modifiers.
3384 while (Constraint[0] == '=' ||
3385 Constraint[0] == '+' ||
3386 Constraint[0] == '&')
3387 Constraint = Constraint.substr(1);
3388
3389 switch (Constraint[0]) {
3390 default: break;
3391 case 'r': {
3392 switch (Modifier) {
3393 default:
Bill Wendling6e6330c2012-11-30 23:46:56 +00003394 return isInOut || (isOutput && Size >= 32) ||
3395 (!isOutput && !isInOut && Size <= 32);
Bill Wendling50d46ca2012-10-25 23:28:48 +00003396 case 'q':
3397 // A register of size 32 cannot fit a vector type.
3398 return false;
3399 }
3400 }
3401 }
3402
3403 return true;
3404 }
Chris Lattner393ff042008-04-21 18:56:49 +00003405 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00003406 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00003407 return "";
3408 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00003409
3410 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
3411 return (CC == CC_AAPCS || CC == CC_AAPCS_VFP) ? CCCR_OK : CCCR_Warning;
3412 }
Chris Lattner393ff042008-04-21 18:56:49 +00003413};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003414
3415const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003416 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003417 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003418 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
3419
3420 // Float registers
3421 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3422 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3423 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003424 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003425
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003426 // Double registers
3427 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3428 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00003429 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3430 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003431
3432 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00003433 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3434 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003435};
3436
3437void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003438 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003439 Names = GCCRegNames;
3440 NumNames = llvm::array_lengthof(GCCRegNames);
3441}
3442
3443const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003444 { { "a1" }, "r0" },
3445 { { "a2" }, "r1" },
3446 { { "a3" }, "r2" },
3447 { { "a4" }, "r3" },
3448 { { "v1" }, "r4" },
3449 { { "v2" }, "r5" },
3450 { { "v3" }, "r6" },
3451 { { "v4" }, "r7" },
3452 { { "v5" }, "r8" },
3453 { { "v6", "rfp" }, "r9" },
3454 { { "sl" }, "r10" },
3455 { { "fp" }, "r11" },
3456 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003457 { { "r13" }, "sp" },
3458 { { "r14" }, "lr" },
3459 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003460 // The S, D and Q registers overlap, but aren't really aliases; we
3461 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003462};
3463
3464void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3465 unsigned &NumAliases) const {
3466 Aliases = GCCRegAliases;
3467 NumAliases = llvm::array_lengthof(GCCRegAliases);
3468}
Chris Lattner2752c012010-03-03 19:03:45 +00003469
3470const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00003471#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00003472#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00003473 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00003474#include "clang/Basic/BuiltinsARM.def"
3475};
Chris Lattner393ff042008-04-21 18:56:49 +00003476} // end anonymous namespace.
3477
Eli Friedmana9f54962008-08-20 07:44:10 +00003478namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00003479class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003480 public DarwinTargetInfo<ARMTargetInfo> {
3481protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00003482 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00003483 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00003484 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00003485 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003486
Torok Edwin5f6c1942009-06-30 17:10:35 +00003487public:
Mike Stump1eb44332009-09-09 15:08:12 +00003488 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003489 : DarwinTargetInfo<ARMTargetInfo>(triple) {
3490 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00003491 // iOS always has 64-bit atomic instructions.
3492 // FIXME: This should be based off of the target features in ARMTargetInfo.
3493 MaxAtomicInlineWidth = 64;
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003494 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003495};
3496} // end anonymous namespace.
3497
Tony Linthicum96319392011-12-12 21:14:55 +00003498
3499namespace {
3500// Hexagon abstract base class
3501class HexagonTargetInfo : public TargetInfo {
3502 static const Builtin::Info BuiltinInfo[];
3503 static const char * const GCCRegNames[];
3504 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3505 std::string CPU;
3506public:
3507 HexagonTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003508 BigEndian = false;
Tony Linthicum96319392011-12-12 21:14:55 +00003509 DescriptionString = ("e-p:32:32:32-"
Anshuman Dasgupta1a090f12013-01-02 21:25:57 +00003510 "i64:64:64-i32:32:32-i16:16:16-i1:32:32-"
Sirish Pande5f9688b2012-05-10 20:19:54 +00003511 "f64:64:64-f32:32:32-a0:0-n32");
Tony Linthicum96319392011-12-12 21:14:55 +00003512
3513 // {} in inline assembly are packet specifiers, not assembly variant
3514 // specifiers.
3515 NoAsmVariants = true;
3516 }
3517
3518 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3519 unsigned &NumRecords) const {
3520 Records = BuiltinInfo;
3521 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
3522 }
3523
3524 virtual bool validateAsmConstraint(const char *&Name,
3525 TargetInfo::ConstraintInfo &Info) const {
3526 return true;
3527 }
3528
3529 virtual void getTargetDefines(const LangOptions &Opts,
3530 MacroBuilder &Builder) const;
3531
Douglas Gregore727d212012-01-30 06:38:25 +00003532 virtual bool hasFeature(StringRef Feature) const {
3533 return Feature == "hexagon";
3534 }
3535
Meador Ingec5613b22012-06-16 03:34:49 +00003536 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3537 return TargetInfo::CharPtrBuiltinVaList;
Tony Linthicum96319392011-12-12 21:14:55 +00003538 }
3539 virtual void getGCCRegNames(const char * const *&Names,
3540 unsigned &NumNames) const;
3541 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3542 unsigned &NumAliases) const;
3543 virtual const char *getClobbers() const {
3544 return "";
3545 }
Sebastian Pop43115d42012-01-13 20:37:10 +00003546
3547 static const char *getHexagonCPUSuffix(StringRef Name) {
3548 return llvm::StringSwitch<const char*>(Name)
3549 .Case("hexagonv2", "2")
3550 .Case("hexagonv3", "3")
3551 .Case("hexagonv4", "4")
Sirish Pande5f9688b2012-05-10 20:19:54 +00003552 .Case("hexagonv5", "5")
Sebastian Pop43115d42012-01-13 20:37:10 +00003553 .Default(0);
3554 }
3555
Tony Linthicum96319392011-12-12 21:14:55 +00003556 virtual bool setCPU(const std::string &Name) {
Sebastian Pop43115d42012-01-13 20:37:10 +00003557 if (!getHexagonCPUSuffix(Name))
3558 return false;
3559
Tony Linthicum96319392011-12-12 21:14:55 +00003560 CPU = Name;
3561 return true;
3562 }
3563};
3564
3565void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
3566 MacroBuilder &Builder) const {
3567 Builder.defineMacro("qdsp6");
3568 Builder.defineMacro("__qdsp6", "1");
3569 Builder.defineMacro("__qdsp6__", "1");
3570
3571 Builder.defineMacro("hexagon");
3572 Builder.defineMacro("__hexagon", "1");
3573 Builder.defineMacro("__hexagon__", "1");
3574
3575 if(CPU == "hexagonv1") {
3576 Builder.defineMacro("__HEXAGON_V1__");
3577 Builder.defineMacro("__HEXAGON_ARCH__", "1");
3578 if(Opts.HexagonQdsp6Compat) {
3579 Builder.defineMacro("__QDSP6_V1__");
3580 Builder.defineMacro("__QDSP6_ARCH__", "1");
3581 }
3582 }
3583 else if(CPU == "hexagonv2") {
3584 Builder.defineMacro("__HEXAGON_V2__");
3585 Builder.defineMacro("__HEXAGON_ARCH__", "2");
3586 if(Opts.HexagonQdsp6Compat) {
3587 Builder.defineMacro("__QDSP6_V2__");
3588 Builder.defineMacro("__QDSP6_ARCH__", "2");
3589 }
3590 }
3591 else if(CPU == "hexagonv3") {
3592 Builder.defineMacro("__HEXAGON_V3__");
3593 Builder.defineMacro("__HEXAGON_ARCH__", "3");
3594 if(Opts.HexagonQdsp6Compat) {
3595 Builder.defineMacro("__QDSP6_V3__");
3596 Builder.defineMacro("__QDSP6_ARCH__", "3");
3597 }
3598 }
3599 else if(CPU == "hexagonv4") {
3600 Builder.defineMacro("__HEXAGON_V4__");
3601 Builder.defineMacro("__HEXAGON_ARCH__", "4");
3602 if(Opts.HexagonQdsp6Compat) {
3603 Builder.defineMacro("__QDSP6_V4__");
3604 Builder.defineMacro("__QDSP6_ARCH__", "4");
3605 }
3606 }
Sirish Pande5f9688b2012-05-10 20:19:54 +00003607 else if(CPU == "hexagonv5") {
3608 Builder.defineMacro("__HEXAGON_V5__");
3609 Builder.defineMacro("__HEXAGON_ARCH__", "5");
3610 if(Opts.HexagonQdsp6Compat) {
3611 Builder.defineMacro("__QDSP6_V5__");
3612 Builder.defineMacro("__QDSP6_ARCH__", "5");
3613 }
3614 }
Tony Linthicum96319392011-12-12 21:14:55 +00003615}
3616
3617const char * const HexagonTargetInfo::GCCRegNames[] = {
3618 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3619 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3620 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3621 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
3622 "p0", "p1", "p2", "p3",
3623 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
3624};
3625
3626void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
3627 unsigned &NumNames) const {
3628 Names = GCCRegNames;
3629 NumNames = llvm::array_lengthof(GCCRegNames);
3630}
3631
3632
3633const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
3634 { { "sp" }, "r29" },
3635 { { "fp" }, "r30" },
3636 { { "lr" }, "r31" },
3637 };
3638
3639void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3640 unsigned &NumAliases) const {
3641 Aliases = GCCRegAliases;
3642 NumAliases = llvm::array_lengthof(GCCRegAliases);
3643}
3644
3645
3646const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
3647#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3648#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3649 ALL_LANGUAGES },
3650#include "clang/Basic/BuiltinsHexagon.def"
3651};
3652}
3653
3654
Reid Spencer5f016e22007-07-11 17:01:13 +00003655namespace {
Eli Friedman01b86682008-08-20 07:28:14 +00003656class SparcV8TargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00003657 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3658 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003659 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00003660public:
Eli Friedman01b86682008-08-20 07:28:14 +00003661 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
3662 // FIXME: Support Sparc quad-precision long double?
Eli Friedmaned855cb2008-08-21 00:13:15 +00003663 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 +00003664 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedman01b86682008-08-20 07:28:14 +00003665 }
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003666 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00003667 StringRef Name,
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003668 bool Enabled) const {
3669 if (Name == "soft-float")
3670 Features[Name] = Enabled;
3671 else
3672 return false;
3673
3674 return true;
3675 }
3676 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
3677 SoftFloat = false;
3678 for (unsigned i = 0, e = Features.size(); i != e; ++i)
3679 if (Features[i] == "+soft-float")
3680 SoftFloat = true;
3681 }
Chris Lattner33328642009-03-20 15:52:06 +00003682 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003683 MacroBuilder &Builder) const {
3684 DefineStd(Builder, "sparc", Opts);
3685 Builder.defineMacro("__sparcv8");
3686 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003687
3688 if (SoftFloat)
3689 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00003690 }
Douglas Gregore727d212012-01-30 06:38:25 +00003691
3692 virtual bool hasFeature(StringRef Feature) const {
3693 return llvm::StringSwitch<bool>(Feature)
3694 .Case("softfloat", SoftFloat)
3695 .Case("sparc", true)
3696 .Default(false);
3697 }
3698
Gabor Greif26658672008-02-21 16:29:08 +00003699 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3700 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003701 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00003702 }
Meador Ingec5613b22012-06-16 03:34:49 +00003703 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3704 return TargetInfo::VoidPtrBuiltinVaList;
Gabor Greif26658672008-02-21 16:29:08 +00003705 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003706 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003707 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003708 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003709 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003710 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00003711 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003712 // FIXME: Implement!
3713 return false;
Gabor Greif26658672008-02-21 16:29:08 +00003714 }
3715 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00003716 // FIXME: Implement!
3717 return "";
Gabor Greif26658672008-02-21 16:29:08 +00003718 }
3719};
3720
Chris Lattnere957f532009-01-27 01:58:38 +00003721const char * const SparcV8TargetInfo::GCCRegNames[] = {
3722 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3723 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3724 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3725 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
3726};
3727
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003728void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003729 unsigned &NumNames) const {
3730 Names = GCCRegNames;
3731 NumNames = llvm::array_lengthof(GCCRegNames);
3732}
3733
3734const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003735 { { "g0" }, "r0" },
3736 { { "g1" }, "r1" },
3737 { { "g2" }, "r2" },
3738 { { "g3" }, "r3" },
3739 { { "g4" }, "r4" },
3740 { { "g5" }, "r5" },
3741 { { "g6" }, "r6" },
3742 { { "g7" }, "r7" },
3743 { { "o0" }, "r8" },
3744 { { "o1" }, "r9" },
3745 { { "o2" }, "r10" },
3746 { { "o3" }, "r11" },
3747 { { "o4" }, "r12" },
3748 { { "o5" }, "r13" },
3749 { { "o6", "sp" }, "r14" },
3750 { { "o7" }, "r15" },
3751 { { "l0" }, "r16" },
3752 { { "l1" }, "r17" },
3753 { { "l2" }, "r18" },
3754 { { "l3" }, "r19" },
3755 { { "l4" }, "r20" },
3756 { { "l5" }, "r21" },
3757 { { "l6" }, "r22" },
3758 { { "l7" }, "r23" },
3759 { { "i0" }, "r24" },
3760 { { "i1" }, "r25" },
3761 { { "i2" }, "r26" },
3762 { { "i3" }, "r27" },
3763 { { "i4" }, "r28" },
3764 { { "i5" }, "r29" },
3765 { { "i6", "fp" }, "r30" },
3766 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00003767};
3768
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003769void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003770 unsigned &NumAliases) const {
3771 Aliases = GCCRegAliases;
3772 NumAliases = llvm::array_lengthof(GCCRegAliases);
3773}
Gabor Greif26658672008-02-21 16:29:08 +00003774} // end anonymous namespace.
3775
Eli Friedman01b86682008-08-20 07:28:14 +00003776namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003777class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
3778public:
3779 AuroraUXSparcV8TargetInfo(const std::string& triple) :
3780 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
3781 SizeType = UnsignedInt;
3782 PtrDiffType = SignedInt;
3783 }
3784};
Torok Edwin5f6c1942009-06-30 17:10:35 +00003785class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00003786public:
3787 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003788 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00003789 SizeType = UnsignedInt;
3790 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00003791 }
3792};
3793} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00003794
Chris Lattner2621fd12008-05-08 05:58:21 +00003795namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003796 class MSP430TargetInfo : public TargetInfo {
3797 static const char * const GCCRegNames[];
3798 public:
3799 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003800 BigEndian = false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003801 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00003802 IntWidth = 16; IntAlign = 16;
3803 LongWidth = 32; LongLongWidth = 64;
3804 LongAlign = LongLongAlign = 16;
3805 PointerWidth = 16; PointerAlign = 16;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003806 SuitableAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003807 SizeType = UnsignedInt;
3808 IntMaxType = SignedLong;
3809 UIntMaxType = UnsignedLong;
3810 IntPtrType = SignedShort;
3811 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00003812 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00003813 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003814 }
3815 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003816 MacroBuilder &Builder) const {
3817 Builder.defineMacro("MSP430");
3818 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003819 // FIXME: defines for different 'flavours' of MCU
3820 }
3821 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3822 unsigned &NumRecords) const {
3823 // FIXME: Implement.
3824 Records = 0;
3825 NumRecords = 0;
3826 }
Douglas Gregore727d212012-01-30 06:38:25 +00003827 virtual bool hasFeature(StringRef Feature) const {
3828 return Feature == "msp430";
3829 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003830 virtual void getGCCRegNames(const char * const *&Names,
3831 unsigned &NumNames) const;
3832 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3833 unsigned &NumAliases) const {
3834 // No aliases.
3835 Aliases = 0;
3836 NumAliases = 0;
3837 }
3838 virtual bool validateAsmConstraint(const char *&Name,
3839 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00003840 // No target constraints for now.
3841 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003842 }
3843 virtual const char *getClobbers() const {
3844 // FIXME: Is this really right?
3845 return "";
3846 }
Meador Ingec5613b22012-06-16 03:34:49 +00003847 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003848 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00003849 return TargetInfo::CharPtrBuiltinVaList;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003850 }
3851 };
3852
3853 const char * const MSP430TargetInfo::GCCRegNames[] = {
3854 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3855 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3856 };
3857
3858 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
3859 unsigned &NumNames) const {
3860 Names = GCCRegNames;
3861 NumNames = llvm::array_lengthof(GCCRegNames);
3862 }
3863}
3864
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00003865namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00003866
Mike Stump1eb44332009-09-09 15:08:12 +00003867 // LLVM and Clang cannot be used directly to output native binaries for
3868 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00003869 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00003870 //
3871 // TCE uses the llvm bitcode as input and uses it for generating customized
3872 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00003873 // publicly available in http://tce.cs.tut.fi
3874
Eli Friedman209f5bb2011-10-07 19:51:42 +00003875 static const unsigned TCEOpenCLAddrSpaceMap[] = {
3876 3, // opencl_global
3877 4, // opencl_local
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00003878 5, // opencl_constant
3879 0, // cuda_device
3880 0, // cuda_constant
3881 0 // cuda_shared
Eli Friedman209f5bb2011-10-07 19:51:42 +00003882 };
3883
Eli Friedmanb63decf2009-08-19 20:47:07 +00003884 class TCETargetInfo : public TargetInfo{
3885 public:
3886 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
3887 TLSSupported = false;
3888 IntWidth = 32;
3889 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003890 PointerWidth = 32;
3891 IntAlign = 32;
3892 LongAlign = LongLongAlign = 32;
3893 PointerAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003894 SuitableAlign = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003895 SizeType = UnsignedInt;
3896 IntMaxType = SignedLong;
3897 UIntMaxType = UnsignedLong;
3898 IntPtrType = SignedInt;
3899 PtrDiffType = SignedInt;
3900 FloatWidth = 32;
3901 FloatAlign = 32;
3902 DoubleWidth = 32;
3903 DoubleAlign = 32;
3904 LongDoubleWidth = 32;
3905 LongDoubleAlign = 32;
3906 FloatFormat = &llvm::APFloat::IEEEsingle;
3907 DoubleFormat = &llvm::APFloat::IEEEsingle;
3908 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00003909 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
3910 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00003911 "f32:32:32-f64:32:32-v64:32:32-"
3912 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00003913 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003914 }
3915
3916 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003917 MacroBuilder &Builder) const {
3918 DefineStd(Builder, "tce", Opts);
3919 Builder.defineMacro("__TCE__");
3920 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00003921 }
Douglas Gregore727d212012-01-30 06:38:25 +00003922 virtual bool hasFeature(StringRef Feature) const {
3923 return Feature == "tce";
3924 }
3925
Eli Friedmanb63decf2009-08-19 20:47:07 +00003926 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3927 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00003928 virtual const char *getClobbers() const {
3929 return "";
3930 }
Meador Ingec5613b22012-06-16 03:34:49 +00003931 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3932 return TargetInfo::VoidPtrBuiltinVaList;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003933 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003934 virtual void getGCCRegNames(const char * const *&Names,
3935 unsigned &NumNames) const {}
3936 virtual bool validateAsmConstraint(const char *&Name,
3937 TargetInfo::ConstraintInfo &info) const {
3938 return true;
3939 }
3940 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3941 unsigned &NumAliases) const {}
3942 };
3943}
3944
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003945namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003946class MipsTargetInfoBase : public TargetInfo {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00003947 static const Builtin::Info BuiltinInfo[];
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003948 std::string CPU;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00003949 bool IsMips16;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003950 enum MipsFloatABI {
3951 HardFloat, SingleFloat, SoftFloat
3952 } FloatABI;
Simon Atanasyana1b62272012-07-05 20:16:22 +00003953 enum DspRevEnum {
3954 NoDSP, DSP1, DSP2
3955 } DspRev;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003956
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003957protected:
3958 std::string ABI;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003959
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003960public:
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00003961 MipsTargetInfoBase(const std::string& triple,
3962 const std::string& ABIStr,
3963 const std::string& CPUStr)
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003964 : TargetInfo(triple),
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00003965 CPU(CPUStr),
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00003966 IsMips16(false),
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003967 FloatABI(HardFloat),
Simon Atanasyana1b62272012-07-05 20:16:22 +00003968 DspRev(NoDSP),
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003969 ABI(ABIStr)
3970 {}
3971
Eric Christophered734732010-03-02 02:41:08 +00003972 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003973 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00003974 virtual bool setCPU(const std::string &Name) {
3975 CPU = Name;
3976 return true;
3977 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003978 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00003979 Features[ABI] = true;
3980 Features[CPU] = true;
3981 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003982
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00003983 virtual void getTargetDefines(const LangOptions &Opts,
3984 MacroBuilder &Builder) const {
Simon Atanasyand4935a02012-08-29 19:14:58 +00003985 DefineStd(Builder, "mips", Opts);
3986 Builder.defineMacro("_mips");
3987 Builder.defineMacro("__REGISTER_PREFIX__", "");
3988
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003989 switch (FloatABI) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003990 case HardFloat:
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00003991 Builder.defineMacro("__mips_hard_float", Twine(1));
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003992 break;
3993 case SingleFloat:
3994 Builder.defineMacro("__mips_hard_float", Twine(1));
3995 Builder.defineMacro("__mips_single_float", Twine(1));
3996 break;
3997 case SoftFloat:
3998 Builder.defineMacro("__mips_soft_float", Twine(1));
3999 break;
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00004000 }
Simon Atanasyan90913892012-04-05 19:28:31 +00004001
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004002 if (IsMips16)
4003 Builder.defineMacro("__mips16", Twine(1));
4004
Simon Atanasyana1b62272012-07-05 20:16:22 +00004005 switch (DspRev) {
4006 default:
4007 break;
4008 case DSP1:
4009 Builder.defineMacro("__mips_dsp_rev", Twine(1));
4010 Builder.defineMacro("__mips_dsp", Twine(1));
4011 break;
4012 case DSP2:
4013 Builder.defineMacro("__mips_dsp_rev", Twine(2));
4014 Builder.defineMacro("__mips_dspr2", Twine(1));
4015 Builder.defineMacro("__mips_dsp", Twine(1));
4016 break;
4017 }
4018
Simon Atanasyan90913892012-04-05 19:28:31 +00004019 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
4020 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
4021 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
Simon Atanasyan260e5062012-08-29 15:17:29 +00004022
4023 Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
4024 Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004025 }
4026
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004027 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4028 unsigned &NumRecords) const {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004029 Records = BuiltinInfo;
4030 NumRecords = clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004031 }
Douglas Gregore727d212012-01-30 06:38:25 +00004032 virtual bool hasFeature(StringRef Feature) const {
4033 return Feature == "mips";
4034 }
Meador Ingec5613b22012-06-16 03:34:49 +00004035 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4036 return TargetInfo::VoidPtrBuiltinVaList;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004037 }
4038 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004039 unsigned &NumNames) const {
4040 static const char * const GCCRegNames[] = {
Eric Christopherd1f853d2012-03-27 19:56:11 +00004041 // CPU register names
4042 // Must match second column of GCCRegAliases
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004043 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
4044 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
4045 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004046 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",
4047 // Floating point register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004048 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
4049 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
4050 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
4051 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004052 // Hi/lo and condition register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004053 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
4054 "$fcc5","$fcc6","$fcc7"
4055 };
4056 Names = GCCRegNames;
4057 NumNames = llvm::array_lengthof(GCCRegNames);
4058 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004059 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004060 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004061 virtual bool validateAsmConstraint(const char *&Name,
4062 TargetInfo::ConstraintInfo &Info) const {
4063 switch (*Name) {
4064 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00004065 return false;
4066
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004067 case 'r': // CPU registers.
4068 case 'd': // Equivalent to "r" unless generating MIPS16 code.
4069 case 'y': // Equivalent to "r", backwards compatibility only.
4070 case 'f': // floating-point registers.
Eric Christopher0ea61642012-04-03 01:16:32 +00004071 case 'c': // $25 for indirect jumps
4072 case 'l': // lo register
4073 case 'x': // hilo register pair
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004074 Info.setAllowsRegister();
4075 return true;
4076 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004077 }
4078
4079 virtual const char *getClobbers() const {
4080 // FIXME: Implement!
4081 return "";
4082 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004083
4084 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
4085 StringRef Name,
4086 bool Enabled) const {
Simon Atanasyan8b2a5d22012-04-18 12:00:11 +00004087 if (Name == "soft-float" || Name == "single-float" ||
4088 Name == "o32" || Name == "n32" || Name == "n64" || Name == "eabi" ||
4089 Name == "mips32" || Name == "mips32r2" ||
Simon Atanasyan0b273ef2012-07-05 14:19:39 +00004090 Name == "mips64" || Name == "mips64r2" ||
Simon Atanasyand797a852012-07-05 19:23:00 +00004091 Name == "mips16" || Name == "dsp" || Name == "dspr2") {
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004092 Features[Name] = Enabled;
4093 return true;
4094 }
4095 return false;
4096 }
4097
4098 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004099 IsMips16 = false;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004100 FloatABI = HardFloat;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004101 DspRev = NoDSP;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004102
4103 for (std::vector<std::string>::iterator it = Features.begin(),
4104 ie = Features.end(); it != ie; ++it) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004105 if (*it == "+single-float")
4106 FloatABI = SingleFloat;
4107 else if (*it == "+soft-float")
4108 FloatABI = SoftFloat;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004109 else if (*it == "+mips16")
4110 IsMips16 = true;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004111 else if (*it == "+dsp")
4112 DspRev = std::max(DspRev, DSP1);
4113 else if (*it == "+dspr2")
4114 DspRev = std::max(DspRev, DSP2);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004115 }
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004116
4117 // Remove front-end specific option.
4118 std::vector<std::string>::iterator it =
4119 std::find(Features.begin(), Features.end(), "+soft-float");
4120 if (it != Features.end())
4121 Features.erase(it);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004122 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004123};
4124
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004125const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = {
4126#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4127#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4128 ALL_LANGUAGES },
4129#include "clang/Basic/BuiltinsMips.def"
4130};
4131
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004132class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004133public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004134 Mips32TargetInfoBase(const std::string& triple) :
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00004135 MipsTargetInfoBase(triple, "o32", "mips32") {
Akira Hatanaka148735e2011-11-05 01:48:34 +00004136 SizeType = UnsignedInt;
4137 PtrDiffType = SignedInt;
Akira Hatanakadbee9492013-01-18 21:58:11 +00004138 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Akira Hatanaka148735e2011-11-05 01:48:34 +00004139 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004140 virtual bool setABI(const std::string &Name) {
4141 if ((Name == "o32") || (Name == "eabi")) {
4142 ABI = Name;
4143 return true;
4144 } else
4145 return false;
4146 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004147 virtual void getTargetDefines(const LangOptions &Opts,
4148 MacroBuilder &Builder) const {
4149 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004150
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004151 if (ABI == "o32") {
4152 Builder.defineMacro("__mips_o32");
4153 Builder.defineMacro("_ABIO32", "1");
4154 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
4155 }
4156 else if (ABI == "eabi")
4157 Builder.defineMacro("__mips_eabi");
4158 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004159 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004160 }
4161 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4162 unsigned &NumAliases) const {
4163 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4164 { { "at" }, "$1" },
4165 { { "v0" }, "$2" },
4166 { { "v1" }, "$3" },
4167 { { "a0" }, "$4" },
4168 { { "a1" }, "$5" },
4169 { { "a2" }, "$6" },
4170 { { "a3" }, "$7" },
4171 { { "t0" }, "$8" },
4172 { { "t1" }, "$9" },
4173 { { "t2" }, "$10" },
4174 { { "t3" }, "$11" },
4175 { { "t4" }, "$12" },
4176 { { "t5" }, "$13" },
4177 { { "t6" }, "$14" },
4178 { { "t7" }, "$15" },
4179 { { "s0" }, "$16" },
4180 { { "s1" }, "$17" },
4181 { { "s2" }, "$18" },
4182 { { "s3" }, "$19" },
4183 { { "s4" }, "$20" },
4184 { { "s5" }, "$21" },
4185 { { "s6" }, "$22" },
4186 { { "s7" }, "$23" },
4187 { { "t8" }, "$24" },
4188 { { "t9" }, "$25" },
4189 { { "k0" }, "$26" },
4190 { { "k1" }, "$27" },
4191 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004192 { { "sp","$sp" }, "$29" },
4193 { { "fp","$fp" }, "$30" },
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004194 { { "ra" }, "$31" }
4195 };
4196 Aliases = GCCRegAliases;
4197 NumAliases = llvm::array_lengthof(GCCRegAliases);
4198 }
4199};
4200
4201class Mips32EBTargetInfo : public Mips32TargetInfoBase {
4202public:
4203 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
4204 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 +00004205 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004206 }
4207 virtual void getTargetDefines(const LangOptions &Opts,
4208 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004209 DefineStd(Builder, "MIPSEB", Opts);
4210 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004211 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004212 }
4213};
4214
4215class Mips32ELTargetInfo : public Mips32TargetInfoBase {
4216public:
4217 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004218 BigEndian = false;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004219 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 +00004220 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004221 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004222 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004223 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004224 DefineStd(Builder, "MIPSEL", Opts);
4225 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004226 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004227 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004228};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004229
4230class Mips64TargetInfoBase : public MipsTargetInfoBase {
4231 virtual void SetDescriptionString(const std::string &Name) = 0;
4232public:
4233 Mips64TargetInfoBase(const std::string& triple) :
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00004234 MipsTargetInfoBase(triple, "n64", "mips64") {
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004235 LongWidth = LongAlign = 64;
4236 PointerWidth = PointerAlign = 64;
4237 LongDoubleWidth = LongDoubleAlign = 128;
4238 LongDoubleFormat = &llvm::APFloat::IEEEquad;
David Chisnall6e399b42012-12-08 09:06:08 +00004239 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
4240 LongDoubleWidth = LongDoubleAlign = 64;
4241 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
4242 }
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004243 SuitableAlign = 128;
Akira Hatanakadbee9492013-01-18 21:58:11 +00004244 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004245 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004246 virtual bool setABI(const std::string &Name) {
4247 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004248
4249 if (Name != "n32" && Name != "n64")
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004250 return false;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004251
4252 ABI = Name;
4253
4254 if (Name == "n32") {
4255 LongWidth = LongAlign = 32;
4256 PointerWidth = PointerAlign = 32;
4257 }
4258
4259 return true;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004260 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004261 virtual void getTargetDefines(const LangOptions &Opts,
4262 MacroBuilder &Builder) const {
4263 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004264
Simon Atanasyan600a5132012-08-29 20:50:11 +00004265 Builder.defineMacro("__mips64");
4266 Builder.defineMacro("__mips64__");
4267
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004268 if (ABI == "n32") {
4269 Builder.defineMacro("__mips_n32");
4270 Builder.defineMacro("_ABIN32", "2");
4271 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
4272 }
4273 else if (ABI == "n64") {
4274 Builder.defineMacro("__mips_n64");
4275 Builder.defineMacro("_ABI64", "3");
4276 Builder.defineMacro("_MIPS_SIM", "_ABI64");
4277 }
4278 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004279 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004280 }
4281 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4282 unsigned &NumAliases) const {
4283 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4284 { { "at" }, "$1" },
4285 { { "v0" }, "$2" },
4286 { { "v1" }, "$3" },
4287 { { "a0" }, "$4" },
4288 { { "a1" }, "$5" },
4289 { { "a2" }, "$6" },
4290 { { "a3" }, "$7" },
4291 { { "a4" }, "$8" },
4292 { { "a5" }, "$9" },
4293 { { "a6" }, "$10" },
4294 { { "a7" }, "$11" },
4295 { { "t0" }, "$12" },
4296 { { "t1" }, "$13" },
4297 { { "t2" }, "$14" },
4298 { { "t3" }, "$15" },
4299 { { "s0" }, "$16" },
4300 { { "s1" }, "$17" },
4301 { { "s2" }, "$18" },
4302 { { "s3" }, "$19" },
4303 { { "s4" }, "$20" },
4304 { { "s5" }, "$21" },
4305 { { "s6" }, "$22" },
4306 { { "s7" }, "$23" },
4307 { { "t8" }, "$24" },
4308 { { "t9" }, "$25" },
4309 { { "k0" }, "$26" },
4310 { { "k1" }, "$27" },
4311 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004312 { { "sp","$sp" }, "$29" },
4313 { { "fp","$fp" }, "$30" },
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004314 { { "ra" }, "$31" }
4315 };
4316 Aliases = GCCRegAliases;
4317 NumAliases = llvm::array_lengthof(GCCRegAliases);
4318 }
4319};
4320
4321class Mips64EBTargetInfo : public Mips64TargetInfoBase {
4322 virtual void SetDescriptionString(const std::string &Name) {
4323 // Change DescriptionString only if ABI is n32.
4324 if (Name == "n32")
4325 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 +00004326 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004327 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004328 }
4329public:
4330 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
4331 // Default ABI is n64.
4332 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 +00004333 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004334 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004335 }
4336 virtual void getTargetDefines(const LangOptions &Opts,
4337 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004338 DefineStd(Builder, "MIPSEB", Opts);
4339 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004340 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004341 }
4342};
4343
4344class Mips64ELTargetInfo : public Mips64TargetInfoBase {
4345 virtual void SetDescriptionString(const std::string &Name) {
4346 // Change DescriptionString only if ABI is n32.
4347 if (Name == "n32")
4348 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 +00004349 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004350 "-v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004351 }
4352public:
4353 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004354 // Default ABI is n64.
4355 BigEndian = false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004356 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 +00004357 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004358 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004359 }
4360 virtual void getTargetDefines(const LangOptions &Opts,
4361 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004362 DefineStd(Builder, "MIPSEL", Opts);
4363 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004364 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004365 }
4366};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004367} // end anonymous namespace.
4368
Ivan Krasinef05abd2011-08-24 20:22:22 +00004369namespace {
4370class PNaClTargetInfo : public TargetInfo {
4371public:
4372 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004373 BigEndian = false;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004374 this->UserLabelPrefix = "";
4375 this->LongAlign = 32;
4376 this->LongWidth = 32;
4377 this->PointerAlign = 32;
4378 this->PointerWidth = 32;
4379 this->IntMaxType = TargetInfo::SignedLongLong;
4380 this->UIntMaxType = TargetInfo::UnsignedLongLong;
4381 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00004382 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00004383 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00004384 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00004385 this->SizeType = TargetInfo::UnsignedInt;
4386 this->PtrDiffType = TargetInfo::SignedInt;
4387 this->IntPtrType = TargetInfo::SignedInt;
David Meyerdd4a8892011-10-11 03:12:01 +00004388 this->RegParmMax = 2;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004389 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
4390 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
4391 }
4392
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004393 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00004394 }
4395 virtual void getArchDefines(const LangOptions &Opts,
4396 MacroBuilder &Builder) const {
4397 Builder.defineMacro("__le32__");
4398 Builder.defineMacro("__pnacl__");
4399 }
4400 virtual void getTargetDefines(const LangOptions &Opts,
4401 MacroBuilder &Builder) const {
Jan Wen Voungdde3bdb2012-03-29 00:05:59 +00004402 Builder.defineMacro("__LITTLE_ENDIAN__");
Ivan Krasinef05abd2011-08-24 20:22:22 +00004403 getArchDefines(Opts, Builder);
4404 }
Douglas Gregore727d212012-01-30 06:38:25 +00004405 virtual bool hasFeature(StringRef Feature) const {
4406 return Feature == "pnacl";
4407 }
Ivan Krasinef05abd2011-08-24 20:22:22 +00004408 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4409 unsigned &NumRecords) const {
4410 }
Meador Ingec5613b22012-06-16 03:34:49 +00004411 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4412 return TargetInfo::PNaClABIBuiltinVaList;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004413 }
4414 virtual void getGCCRegNames(const char * const *&Names,
4415 unsigned &NumNames) const;
4416 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4417 unsigned &NumAliases) const;
4418 virtual bool validateAsmConstraint(const char *&Name,
4419 TargetInfo::ConstraintInfo &Info) const {
4420 return false;
4421 }
4422
4423 virtual const char *getClobbers() const {
4424 return "";
4425 }
4426};
4427
4428void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
4429 unsigned &NumNames) const {
4430 Names = NULL;
4431 NumNames = 0;
4432}
4433
4434void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4435 unsigned &NumAliases) const {
4436 Aliases = NULL;
4437 NumAliases = 0;
4438}
4439} // end anonymous namespace.
4440
Guy Benyeibd5da3c2012-12-11 21:38:14 +00004441namespace {
4442 static const unsigned SPIRAddrSpaceMap[] = {
4443 1, // opencl_global
4444 3, // opencl_local
4445 2, // opencl_constant
4446 0, // cuda_device
4447 0, // cuda_constant
4448 0 // cuda_shared
4449 };
4450 class SPIRTargetInfo : public TargetInfo {
4451 static const char * const GCCRegNames[];
4452 static const Builtin::Info BuiltinInfo[];
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00004453 std::vector<StringRef> AvailableFeatures;
Guy Benyeibd5da3c2012-12-11 21:38:14 +00004454 public:
4455 SPIRTargetInfo(const std::string& triple) : TargetInfo(triple) {
4456 assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
4457 "SPIR target must use unknown OS");
4458 assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
4459 "SPIR target must use unknown environment type");
4460 BigEndian = false;
4461 TLSSupported = false;
4462 LongWidth = LongAlign = 64;
4463 AddrSpaceMap = &SPIRAddrSpaceMap;
4464 // Define available target features
4465 // These must be defined in sorted order!
4466 NoAsmVariants = true;
4467 }
4468 virtual void getTargetDefines(const LangOptions &Opts,
4469 MacroBuilder &Builder) const {
4470 DefineStd(Builder, "SPIR", Opts);
4471 }
4472 virtual bool hasFeature(StringRef Feature) const {
4473 return Feature == "spir";
4474 }
4475
4476 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4477 unsigned &NumRecords) const {}
4478 virtual const char *getClobbers() const {
4479 return "";
4480 }
4481 virtual void getGCCRegNames(const char * const *&Names,
4482 unsigned &NumNames) const {}
4483 virtual bool validateAsmConstraint(const char *&Name,
4484 TargetInfo::ConstraintInfo &info) const {
4485 return true;
4486 }
4487 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4488 unsigned &NumAliases) const {}
4489 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4490 return TargetInfo::VoidPtrBuiltinVaList;
4491 }
4492 };
4493
4494
4495 class SPIR32TargetInfo : public SPIRTargetInfo {
4496 public:
4497 SPIR32TargetInfo(const std::string& triple) : SPIRTargetInfo(triple) {
4498 PointerWidth = PointerAlign = 32;
4499 SizeType = TargetInfo::UnsignedInt;
4500 PtrDiffType = IntPtrType = TargetInfo::SignedInt;
4501 DescriptionString
Guy Benyei8a033572012-12-13 13:22:48 +00004502 = "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 +00004503 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-"
4504 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-"
4505 "v512:512:512-v1024:1024:1024";
4506 }
4507 };
4508
4509 class SPIR64TargetInfo : public SPIRTargetInfo {
4510 public:
4511 SPIR64TargetInfo(const std::string& triple) : SPIRTargetInfo(triple) {
4512 PointerWidth = PointerAlign = 64;
4513 SizeType = TargetInfo::UnsignedLong;
4514 PtrDiffType = IntPtrType = TargetInfo::SignedLong;
4515 DescriptionString
Guy Benyei8a033572012-12-13 13:22:48 +00004516 = "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 +00004517 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-"
4518 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-"
4519 "v512:512:512-v1024:1024:1024";
4520 }
4521 };
4522}
4523
Ivan Krasinef05abd2011-08-24 20:22:22 +00004524
Reid Spencer5f016e22007-07-11 17:01:13 +00004525//===----------------------------------------------------------------------===//
4526// Driver code
4527//===----------------------------------------------------------------------===//
4528
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004529static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004530 llvm::Triple Triple(T);
4531 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00004532
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004533 switch (Triple.getArch()) {
4534 default:
4535 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00004536
Tony Linthicum96319392011-12-12 21:14:55 +00004537 case llvm::Triple::hexagon:
4538 return new HexagonTargetInfo(T);
4539
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004540 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00004541 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004542 if (Triple.isOSDarwin())
4543 return new DarwinARMTargetInfo(T);
4544
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004545 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00004546 case llvm::Triple::Linux:
4547 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004548 case llvm::Triple::FreeBSD:
Torok Edwin5f6c1942009-06-30 17:10:35 +00004549 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004550 case llvm::Triple::NetBSD:
4551 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00004552 case llvm::Triple::OpenBSD:
4553 return new OpenBSDTargetInfo<ARMTargetInfo>(T);
Eli Friedman42f74f22012-08-08 23:57:20 +00004554 case llvm::Triple::Bitrig:
4555 return new BitrigTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00004556 case llvm::Triple::RTEMS:
4557 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Eli Bendersky441d9f72012-12-04 18:38:10 +00004558 case llvm::Triple::NaCl:
Derek Schuff7da46f92012-10-11 16:55:58 +00004559 return new NaClTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004560 default:
4561 return new ARMTargetInfo(T);
4562 }
Eli Friedman61538a72008-05-20 14:21:01 +00004563
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004564 case llvm::Triple::msp430:
4565 return new MSP430TargetInfo(T);
Eli Friedman61538a72008-05-20 14:21:01 +00004566
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004567 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004568 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004569 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004570 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004571 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004572 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004573 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004574 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004575 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004576 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004577 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004578 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004579 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004580
4581 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004582 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004583 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004584 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004585 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004586 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004587 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004588 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004589 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004590 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004591 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004592 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004593 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004594
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004595 case llvm::Triple::mips64:
4596 switch (os) {
4597 case llvm::Triple::Linux:
4598 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
4599 case llvm::Triple::RTEMS:
4600 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
4601 case llvm::Triple::FreeBSD:
4602 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
4603 case llvm::Triple::NetBSD:
4604 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00004605 case llvm::Triple::OpenBSD:
4606 return new OpenBSDTargetInfo<Mips64EBTargetInfo>(T);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004607 default:
4608 return new Mips64EBTargetInfo(T);
4609 }
4610
4611 case llvm::Triple::mips64el:
4612 switch (os) {
4613 case llvm::Triple::Linux:
4614 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
4615 case llvm::Triple::RTEMS:
4616 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
4617 case llvm::Triple::FreeBSD:
4618 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
4619 case llvm::Triple::NetBSD:
4620 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00004621 case llvm::Triple::OpenBSD:
4622 return new OpenBSDTargetInfo<Mips64ELTargetInfo>(T);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004623 default:
4624 return new Mips64ELTargetInfo(T);
4625 }
4626
Ivan Krasinef05abd2011-08-24 20:22:22 +00004627 case llvm::Triple::le32:
4628 switch (os) {
Eli Bendersky441d9f72012-12-04 18:38:10 +00004629 case llvm::Triple::NaCl:
Derek Schuff7da46f92012-10-11 16:55:58 +00004630 return new NaClTargetInfo<PNaClTargetInfo>(T);
Ivan Krasinef05abd2011-08-24 20:22:22 +00004631 default:
4632 return NULL;
4633 }
4634
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004635 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004636 if (Triple.isOSDarwin())
Roman Divackyc81f2a22011-01-06 08:27:10 +00004637 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004638 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00004639 case llvm::Triple::Linux:
4640 return new LinuxTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004641 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00004642 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004643 case llvm::Triple::NetBSD:
4644 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00004645 case llvm::Triple::OpenBSD:
4646 return new OpenBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004647 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00004648 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004649 default:
4650 return new PPC32TargetInfo(T);
4651 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004652
4653 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004654 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00004655 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004656 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00004657 case llvm::Triple::Linux:
4658 return new LinuxTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004659 case llvm::Triple::Lv2:
John Thompson3f6918a2009-11-19 17:18:50 +00004660 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004661 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00004662 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004663 case llvm::Triple::NetBSD:
4664 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
4665 default:
4666 return new PPC64TargetInfo(T);
4667 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004668
Peter Collingbourneedb66f32012-05-20 23:28:41 +00004669 case llvm::Triple::nvptx:
4670 return new NVPTX32TargetInfo(T);
4671 case llvm::Triple::nvptx64:
4672 return new NVPTX64TargetInfo(T);
4673
Chris Lattner9cbeb632010-03-06 21:21:27 +00004674 case llvm::Triple::mblaze:
4675 return new MBlazeTargetInfo(T);
4676
Eli Friedman6505a292012-10-12 23:32:00 +00004677 case llvm::Triple::r600:
4678 return new R600TargetInfo(T);
4679
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004680 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004681 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00004682 case llvm::Triple::Linux:
4683 return new LinuxTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004684 case llvm::Triple::AuroraUX:
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004685 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004686 case llvm::Triple::Solaris:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004687 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004688 case llvm::Triple::NetBSD:
4689 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00004690 case llvm::Triple::OpenBSD:
4691 return new OpenBSDTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004692 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00004693 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004694 default:
4695 return new SparcV8TargetInfo(T);
4696 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004697
Eli Friedmanb63decf2009-08-19 20:47:07 +00004698 case llvm::Triple::tce:
4699 return new TCETargetInfo(T);
4700
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004701 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004702 if (Triple.isOSDarwin())
4703 return new DarwinI386TargetInfo(T);
4704
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004705 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004706 case llvm::Triple::AuroraUX:
4707 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004708 case llvm::Triple::Linux:
4709 return new LinuxTargetInfo<X86_32TargetInfo>(T);
4710 case llvm::Triple::DragonFly:
4711 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
4712 case llvm::Triple::NetBSD:
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00004713 return new NetBSDI386TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004714 case llvm::Triple::OpenBSD:
4715 return new OpenBSDI386TargetInfo(T);
Eli Friedman42f74f22012-08-08 23:57:20 +00004716 case llvm::Triple::Bitrig:
4717 return new BitrigI386TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004718 case llvm::Triple::FreeBSD:
4719 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner38e317d2010-07-07 16:01:42 +00004720 case llvm::Triple::Minix:
4721 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004722 case llvm::Triple::Solaris:
4723 return new SolarisTargetInfo<X86_32TargetInfo>(T);
4724 case llvm::Triple::Cygwin:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004725 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004726 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004727 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004728 case llvm::Triple::Win32:
Michael J. Spencera764e832010-10-21 08:22:51 +00004729 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattner86ed3a32010-04-11 19:29:39 +00004730 case llvm::Triple::Haiku:
4731 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00004732 case llvm::Triple::RTEMS:
4733 return new RTEMSX86_32TargetInfo(T);
Eli Bendersky441d9f72012-12-04 18:38:10 +00004734 case llvm::Triple::NaCl:
Derek Schuff7da46f92012-10-11 16:55:58 +00004735 return new NaClTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004736 default:
4737 return new X86_32TargetInfo(T);
4738 }
4739
4740 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004741 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
4742 return new DarwinX86_64TargetInfo(T);
4743
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004744 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004745 case llvm::Triple::AuroraUX:
4746 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004747 case llvm::Triple::Linux:
4748 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner7a7ca282010-01-09 05:41:14 +00004749 case llvm::Triple::DragonFly:
4750 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004751 case llvm::Triple::NetBSD:
4752 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
4753 case llvm::Triple::OpenBSD:
4754 return new OpenBSDX86_64TargetInfo(T);
Eli Friedman42f74f22012-08-08 23:57:20 +00004755 case llvm::Triple::Bitrig:
4756 return new BitrigX86_64TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004757 case llvm::Triple::FreeBSD:
4758 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
4759 case llvm::Triple::Solaris:
4760 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00004761 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004762 return new MinGWX86_64TargetInfo(T);
4763 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004764 return new VisualStudioWindowsX86_64TargetInfo(T);
Eli Bendersky441d9f72012-12-04 18:38:10 +00004765 case llvm::Triple::NaCl:
Derek Schuff7da46f92012-10-11 16:55:58 +00004766 return new NaClTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004767 default:
4768 return new X86_64TargetInfo(T);
4769 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00004770
4771 case llvm::Triple::spir: {
4772 llvm::Triple Triple(T);
4773 if (Triple.getOS() != llvm::Triple::UnknownOS ||
4774 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
4775 return NULL;
4776 return new SPIR32TargetInfo(T);
4777 }
4778 case llvm::Triple::spir64: {
4779 llvm::Triple Triple(T);
4780 if (Triple.getOS() != llvm::Triple::UnknownOS ||
4781 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
4782 return NULL;
4783 return new SPIR64TargetInfo(T);
4784 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004785 }
Reid Spencer5f016e22007-07-11 17:01:13 +00004786}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004787
4788/// CreateTargetInfo - Return the target info object for the specified target
4789/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00004790TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Douglas Gregor49a87542012-11-16 04:24:59 +00004791 TargetOptions *Opts) {
4792 llvm::Triple Triple(Opts->Triple);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004793
4794 // Construct the target
Dylan Noblesmith6f42b622012-02-05 02:12:40 +00004795 OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004796 if (!Target) {
4797 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
4798 return 0;
4799 }
Douglas Gregor9a022bb2012-10-15 16:45:32 +00004800 Target->setTargetOpts(Opts);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004801
Daniel Dunbareac7c532009-12-18 18:42:37 +00004802 // Set the target CPU if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00004803 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
4804 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
Daniel Dunbareac7c532009-12-18 18:42:37 +00004805 return 0;
4806 }
4807
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004808 // Set the target ABI if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00004809 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
4810 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004811 return 0;
4812 }
4813
Charles Davis98b7c5c2010-06-11 01:06:47 +00004814 // Set the target C++ ABI.
Douglas Gregor49a87542012-11-16 04:24:59 +00004815 if (!Opts->CXXABI.empty() && !Target->setCXXABI(Opts->CXXABI)) {
4816 Diags.Report(diag::err_target_unknown_cxxabi) << Opts->CXXABI;
Charles Davis98b7c5c2010-06-11 01:06:47 +00004817 return 0;
4818 }
4819
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004820 // Compute the default target features, we need the target to handle this
4821 // because features may have dependencies on one another.
4822 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004823 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004824
4825 // Apply the user specified deltas.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004826 // First the enables.
Douglas Gregor57016dd2012-10-16 23:40:58 +00004827 for (std::vector<std::string>::const_iterator
Douglas Gregor49a87542012-11-16 04:24:59 +00004828 it = Opts->FeaturesAsWritten.begin(),
4829 ie = Opts->FeaturesAsWritten.end();
Douglas Gregor57016dd2012-10-16 23:40:58 +00004830 it != ie; ++it) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004831 const char *Name = it->c_str();
4832
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004833 if (Name[0] != '+')
4834 continue;
4835
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004836 // Apply the feature via the target.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004837 if (!Target->setFeatureEnabled(Features, Name + 1, true)) {
4838 Diags.Report(diag::err_target_invalid_feature) << Name;
4839 return 0;
4840 }
4841 }
4842
4843 // Then the disables.
Douglas Gregor57016dd2012-10-16 23:40:58 +00004844 for (std::vector<std::string>::const_iterator
Douglas Gregor49a87542012-11-16 04:24:59 +00004845 it = Opts->FeaturesAsWritten.begin(),
4846 ie = Opts->FeaturesAsWritten.end();
Douglas Gregor57016dd2012-10-16 23:40:58 +00004847 it != ie; ++it) {
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004848 const char *Name = it->c_str();
4849
4850 if (Name[0] == '+')
4851 continue;
4852
4853 // Apply the feature via the target.
4854 if (Name[0] != '-' ||
4855 !Target->setFeatureEnabled(Features, Name + 1, false)) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004856 Diags.Report(diag::err_target_invalid_feature) << Name;
4857 return 0;
4858 }
4859 }
4860
4861 // Add the features to the compile options.
4862 //
4863 // FIXME: If we are completely confident that we have the right set, we only
4864 // need to pass the minuses.
Douglas Gregor49a87542012-11-16 04:24:59 +00004865 Opts->Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004866 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
4867 ie = Features.end(); it != ie; ++it)
Douglas Gregor49a87542012-11-16 04:24:59 +00004868 Opts->Features.push_back((it->second ? "+" : "-") + it->first().str());
4869 Target->HandleTargetFeatures(Opts->Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004870
4871 return Target.take();
4872}