blob: 26a4f41442d2ce38d6b5611702ca8377508aef00 [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"
Chris Lattner797c3c42009-08-10 19:03:04 +000028#include "llvm/MC/MCSectionMachO.h"
David Blaikie9fe8c742011-09-23 05:35:21 +000029#include "llvm/Support/ErrorHandling.h"
Dale Johannesen1e592cb2010-10-29 23:24:33 +000030#include "llvm/Type.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.
Richard Smithca1b62a2012-11-05 21:48:12 +000097 if (Opts.SanitizeAddress) 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:
387 case llvm::Triple::sparc:
388 this->MCountName = "__mcount";
389 break;
390 case llvm::Triple::mips64:
391 case llvm::Triple::mips64el:
392 case llvm::Triple::ppc:
393 case llvm::Triple::sparcv9:
394 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
578 if (Opts.CPlusPlus0x) {
579 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 }
Eli Friedmane4277982008-08-20 23:11:40 +0000821};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000822
Eli Friedmane4277982008-08-20 23:11:40 +0000823const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000824#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000825#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000826 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000827#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000828};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000829
830
Chris Lattnerc0f59212009-03-02 22:27:17 +0000831/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
832/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000833void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000834 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000835 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000836 Builder.defineMacro("__ppc__");
837 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000838 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000839 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000840 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000841 Builder.defineMacro("_ARCH_PPC64");
Chris Lattnere03ae302010-02-16 18:14:57 +0000842 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000843 Builder.defineMacro("__ppc64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000844 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +0000845 Builder.defineMacro("__ppc__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000846 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000847
Chris Lattnerc0f59212009-03-02 22:27:17 +0000848 // Target properties.
Hans Wennborg5e601dc2012-08-02 13:45:48 +0000849 if (getTriple().getOS() != llvm::Triple::NetBSD &&
850 getTriple().getOS() != llvm::Triple::OpenBSD)
Joerg Sonnenberger7cd1de52011-07-05 14:56:12 +0000851 Builder.defineMacro("_BIG_ENDIAN");
Benjamin Kramera9992772010-01-09 17:55:51 +0000852 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000853
Chris Lattnerc0f59212009-03-02 22:27:17 +0000854 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000855 Builder.defineMacro("__NATURAL_ALIGNMENT__");
856 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000857
Chris Lattnerc0f59212009-03-02 22:27:17 +0000858 // FIXME: Should be controlled by command line option.
Benjamin Kramera9992772010-01-09 17:55:51 +0000859 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000860
John Thompson3f6918a2009-11-19 17:18:50 +0000861 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000862 Builder.defineMacro("__VEC__", "10206");
863 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000864 }
Hal Finkel02a84272012-06-11 22:35:19 +0000865
866 // CPU identification.
Hal Finkel39d5fa12012-07-03 16:51:04 +0000867 ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
868 .Case("440", ArchDefineName)
869 .Case("450", ArchDefineName | ArchDefine440)
870 .Case("601", ArchDefineName)
871 .Case("602", ArchDefineName | ArchDefinePpcgr)
872 .Case("603", ArchDefineName | ArchDefinePpcgr)
873 .Case("603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
874 .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
875 .Case("604", ArchDefineName | ArchDefinePpcgr)
876 .Case("604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
877 .Case("620", ArchDefineName | ArchDefinePpcgr)
878 .Case("7400", ArchDefineName | ArchDefinePpcgr)
879 .Case("7450", ArchDefineName | ArchDefinePpcgr)
880 .Case("750", ArchDefineName | ArchDefinePpcgr)
881 .Case("970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
882 | ArchDefinePpcsq)
883 .Case("pwr6", ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq)
884 .Case("pwr7", ArchDefineName | ArchDefinePwr6 | ArchDefinePpcgr
885 | ArchDefinePpcsq)
886 .Default(ArchDefineNone);
887
888 if (defs & ArchDefineName)
889 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
890 if (defs & ArchDefinePpcgr)
891 Builder.defineMacro("_ARCH_PPCGR");
892 if (defs & ArchDefinePpcsq)
893 Builder.defineMacro("_ARCH_PPCSQ");
894 if (defs & ArchDefine440)
Hal Finkel02a84272012-06-11 22:35:19 +0000895 Builder.defineMacro("_ARCH_440");
Hal Finkel39d5fa12012-07-03 16:51:04 +0000896 if (defs & ArchDefine603)
897 Builder.defineMacro("_ARCH_603");
898 if (defs & ArchDefine604)
899 Builder.defineMacro("_ARCH_604");
900 if (defs & (ArchDefinePwr4 | ArchDefinePwr6))
901 Builder.defineMacro("_ARCH_PWR4");
902 if (defs & ArchDefinePwr6) {
903 Builder.defineMacro("_ARCH_PWR5");
Hal Finkel02a84272012-06-11 22:35:19 +0000904 Builder.defineMacro("_ARCH_PWR6");
Hal Finkel02a84272012-06-11 22:35:19 +0000905 }
Chris Lattnerc0f59212009-03-02 22:27:17 +0000906}
907
Douglas Gregore727d212012-01-30 06:38:25 +0000908bool PPCTargetInfo::hasFeature(StringRef Feature) const {
909 return Feature == "powerpc";
910}
Chris Lattner393ff042008-04-21 18:56:49 +0000911
Douglas Gregore727d212012-01-30 06:38:25 +0000912
Eli Friedmane4277982008-08-20 23:11:40 +0000913const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +0000914 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
915 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
916 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
917 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
918 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
919 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
920 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
921 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +0000922 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000923 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +0000924 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000925 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
926 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
927 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
928 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +0000929 "vrsave", "vscr",
930 "spe_acc", "spefscr",
931 "sfp"
932};
Reid Spencer5f016e22007-07-11 17:01:13 +0000933
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000934void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000935 unsigned &NumNames) const {
936 Names = GCCRegNames;
937 NumNames = llvm::array_lengthof(GCCRegNames);
938}
Reid Spencer5f016e22007-07-11 17:01:13 +0000939
Eli Friedmane4277982008-08-20 23:11:40 +0000940const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
941 // While some of these aliases do map to different registers
942 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000943 { { "0" }, "r0" },
944 { { "1"}, "r1" },
945 { { "2" }, "r2" },
946 { { "3" }, "r3" },
947 { { "4" }, "r4" },
948 { { "5" }, "r5" },
949 { { "6" }, "r6" },
950 { { "7" }, "r7" },
951 { { "8" }, "r8" },
952 { { "9" }, "r9" },
953 { { "10" }, "r10" },
954 { { "11" }, "r11" },
955 { { "12" }, "r12" },
956 { { "13" }, "r13" },
957 { { "14" }, "r14" },
958 { { "15" }, "r15" },
959 { { "16" }, "r16" },
960 { { "17" }, "r17" },
961 { { "18" }, "r18" },
962 { { "19" }, "r19" },
963 { { "20" }, "r20" },
964 { { "21" }, "r21" },
965 { { "22" }, "r22" },
966 { { "23" }, "r23" },
967 { { "24" }, "r24" },
968 { { "25" }, "r25" },
969 { { "26" }, "r26" },
970 { { "27" }, "r27" },
971 { { "28" }, "r28" },
972 { { "29" }, "r29" },
973 { { "30" }, "r30" },
974 { { "31" }, "r31" },
975 { { "fr0" }, "f0" },
976 { { "fr1" }, "f1" },
977 { { "fr2" }, "f2" },
978 { { "fr3" }, "f3" },
979 { { "fr4" }, "f4" },
980 { { "fr5" }, "f5" },
981 { { "fr6" }, "f6" },
982 { { "fr7" }, "f7" },
983 { { "fr8" }, "f8" },
984 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +0000985 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000986 { { "fr11" }, "f11" },
987 { { "fr12" }, "f12" },
988 { { "fr13" }, "f13" },
989 { { "fr14" }, "f14" },
990 { { "fr15" }, "f15" },
991 { { "fr16" }, "f16" },
992 { { "fr17" }, "f17" },
993 { { "fr18" }, "f18" },
994 { { "fr19" }, "f19" },
995 { { "fr20" }, "f20" },
996 { { "fr21" }, "f21" },
997 { { "fr22" }, "f22" },
998 { { "fr23" }, "f23" },
999 { { "fr24" }, "f24" },
1000 { { "fr25" }, "f25" },
1001 { { "fr26" }, "f26" },
1002 { { "fr27" }, "f27" },
1003 { { "fr28" }, "f28" },
1004 { { "fr29" }, "f29" },
1005 { { "fr30" }, "f30" },
1006 { { "fr31" }, "f31" },
1007 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +00001008};
1009
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001010void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +00001011 unsigned &NumAliases) const {
1012 Aliases = GCCRegAliases;
1013 NumAliases = llvm::array_lengthof(GCCRegAliases);
1014}
1015} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00001016
1017namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001018class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001019public:
Chris Lattnere03ae302010-02-16 18:14:57 +00001020 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +00001021 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 +00001022 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +00001023
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001024 switch (getTriple().getOS()) {
Nico Weber6e1d2ea2012-01-31 02:07:33 +00001025 case llvm::Triple::Linux:
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001026 case llvm::Triple::FreeBSD:
1027 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001028 SizeType = UnsignedInt;
Hal Finkel178a9b82012-03-02 20:54:36 +00001029 PtrDiffType = SignedInt;
1030 IntPtrType = SignedInt;
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001031 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +00001032 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001033 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001034 }
Roman Divackye3d175d2012-03-13 16:53:54 +00001035
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001036 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1037 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001038 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001039 }
Roman Divackyc81f2a22011-01-06 08:27:10 +00001040 }
1041
Meador Ingec5613b22012-06-16 03:34:49 +00001042 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001043 // This is the ELF definition, and is overridden by the Darwin sub-target
Meador Ingec5613b22012-06-16 03:34:49 +00001044 return TargetInfo::PowerABIBuiltinVaList;
Eli Friedmaned855cb2008-08-21 00:13:15 +00001045 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001046};
1047} // end anonymous namespace.
1048
1049namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001050class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001051public:
Eli Friedmane4277982008-08-20 23:11:40 +00001052 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00001053 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00001054 IntMaxType = SignedLong;
1055 UIntMaxType = UnsignedLong;
1056 Int64Type = SignedLong;
Roman Divackye3d175d2012-03-13 16:53:54 +00001057
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001058 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1059 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001060 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001061 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1062 "i64:64:64-f32:32:32-f64:64:64-f128:64:64-"
1063 "v128:128:128-n32:64";
1064 } else
1065 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1066 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
1067 "v128:128:128-n32:64";
1068
Chris Lattnerf291b102008-05-09 06:17:04 +00001069 }
Meador Ingec5613b22012-06-16 03:34:49 +00001070 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1071 return TargetInfo::CharPtrBuiltinVaList;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001072 }
Eli Friedmane4277982008-08-20 23:11:40 +00001073};
1074} // end anonymous namespace.
1075
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001076
1077namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001078class DarwinPPC32TargetInfo :
1079 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001080public:
Roman Divackyc81f2a22011-01-06 08:27:10 +00001081 DarwinPPC32TargetInfo(const std::string& triple)
1082 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001083 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001084 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001085 LongLongAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001086 SuitableAlign = 128;
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001087 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1088 "i64:32:64-f32:32:32-f64:64:64-v128:128:128-n32";
Roman Divackyc81f2a22011-01-06 08:27:10 +00001089 }
Meador Ingec5613b22012-06-16 03:34:49 +00001090 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1091 return TargetInfo::CharPtrBuiltinVaList;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001092 }
1093};
1094
1095class DarwinPPC64TargetInfo :
1096 public DarwinTargetInfo<PPC64TargetInfo> {
1097public:
1098 DarwinPPC64TargetInfo(const std::string& triple)
1099 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
1100 HasAlignMac68kSupport = true;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001101 SuitableAlign = 128;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001102 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1103 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001104 }
1105};
1106} // end anonymous namespace.
1107
Reid Spencer5f016e22007-07-11 17:01:13 +00001108namespace {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001109 static const unsigned NVPTXAddrSpaceMap[] = {
1110 1, // opencl_global
1111 3, // opencl_local
1112 4, // opencl_constant
1113 1, // cuda_device
1114 4, // cuda_constant
1115 3, // cuda_shared
1116 };
1117 class NVPTXTargetInfo : public TargetInfo {
1118 static const char * const GCCRegNames[];
Justin Holewinski2c585b92012-05-24 17:43:12 +00001119 static const Builtin::Info BuiltinInfo[];
1120 std::vector<llvm::StringRef> AvailableFeatures;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001121 public:
1122 NVPTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
1123 BigEndian = false;
1124 TLSSupported = false;
1125 LongWidth = LongAlign = 64;
1126 AddrSpaceMap = &NVPTXAddrSpaceMap;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001127 // Define available target features
1128 // These must be defined in sorted order!
Justin Holewinski9903e942012-07-11 15:34:55 +00001129 NoAsmVariants = true;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001130 }
1131 virtual void getTargetDefines(const LangOptions &Opts,
1132 MacroBuilder &Builder) const {
1133 Builder.defineMacro("__PTX__");
Justin Holewinski2c585b92012-05-24 17:43:12 +00001134 Builder.defineMacro("__NVPTX__");
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001135 }
1136 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1137 unsigned &NumRecords) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001138 Records = BuiltinInfo;
1139 NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001140 }
1141 virtual bool hasFeature(StringRef Feature) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001142 return Feature == "ptx" || Feature == "nvptx";
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001143 }
1144
1145 virtual void getGCCRegNames(const char * const *&Names,
1146 unsigned &NumNames) const;
1147 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1148 unsigned &NumAliases) const {
1149 // No aliases.
1150 Aliases = 0;
1151 NumAliases = 0;
1152 }
1153 virtual bool validateAsmConstraint(const char *&Name,
1154 TargetInfo::ConstraintInfo &info) const {
1155 // FIXME: implement
1156 return true;
1157 }
1158 virtual const char *getClobbers() const {
1159 // FIXME: Is this really right?
1160 return "";
1161 }
Meador Ingec5613b22012-06-16 03:34:49 +00001162 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001163 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00001164 return TargetInfo::CharPtrBuiltinVaList;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001165 }
1166 virtual bool setCPU(const std::string &Name) {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001167 return Name == "sm_10" || Name == "sm_13" || Name == "sm_20";
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001168 }
Justin Holewinski2c585b92012-05-24 17:43:12 +00001169 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1170 StringRef Name,
1171 bool Enabled) const;
1172 };
1173
1174 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1175#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1176#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1177 ALL_LANGUAGES },
1178#include "clang/Basic/BuiltinsNVPTX.def"
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001179 };
1180
1181 const char * const NVPTXTargetInfo::GCCRegNames[] = {
1182 "r0"
1183 };
1184
1185 void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names,
1186 unsigned &NumNames) const {
1187 Names = GCCRegNames;
1188 NumNames = llvm::array_lengthof(GCCRegNames);
1189 }
1190
Justin Holewinski2c585b92012-05-24 17:43:12 +00001191 bool NVPTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1192 StringRef Name,
1193 bool Enabled) const {
1194 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
1195 Name)) {
1196 Features[Name] = Enabled;
1197 return true;
1198 } else {
1199 return false;
1200 }
1201 }
1202
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001203 class NVPTX32TargetInfo : public NVPTXTargetInfo {
1204 public:
Justin Holewinski2c585b92012-05-24 17:43:12 +00001205 NVPTX32TargetInfo(const std::string& triple) : NVPTXTargetInfo(triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001206 PointerWidth = PointerAlign = 32;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001207 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001208 DescriptionString
1209 = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1210 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1211 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001212 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001213 };
1214
1215 class NVPTX64TargetInfo : public NVPTXTargetInfo {
1216 public:
Justin Holewinski2c585b92012-05-24 17:43:12 +00001217 NVPTX64TargetInfo(const std::string& triple) : NVPTXTargetInfo(triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001218 PointerWidth = PointerAlign = 64;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001219 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001220 DescriptionString
1221 = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1222 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1223 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001224 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001225 };
1226}
1227
1228namespace {
Eli Friedman6505a292012-10-12 23:32:00 +00001229
1230static const unsigned R600AddrSpaceMap[] = {
1231 1, // opencl_global
1232 3, // opencl_local
1233 2, // opencl_constant
1234 1, // cuda_device
1235 2, // cuda_constant
1236 3 // cuda_shared
1237};
1238
1239class R600TargetInfo : public TargetInfo {
1240public:
1241 R600TargetInfo(const std::string& triple) : TargetInfo(triple) {
1242 DescriptionString =
1243 "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16"
1244 "-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f80:32:32"
1245 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64"
1246 "-v96:128:128-v128:128:128-v192:256:256-v256:256:256"
1247 "-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1248 "-n8:16:32:64";
1249 AddrSpaceMap = &R600AddrSpaceMap;
1250 }
1251
1252 virtual const char * getClobbers() const {
1253 return "";
1254 }
1255
1256 virtual void getGCCRegNames(const char * const *&Names,
1257 unsigned &numNames) const {
1258 Names = NULL;
1259 numNames = 0;
1260 }
1261
1262 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1263 unsigned &NumAliases) const {
1264 Aliases = NULL;
1265 NumAliases = 0;
1266 }
1267
1268 virtual bool validateAsmConstraint(const char *&Name,
1269 TargetInfo::ConstraintInfo &info) const {
1270 return true;
1271 }
1272
1273 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1274 unsigned &NumRecords) const {
1275 Records = NULL;
1276 NumRecords = 0;
1277 }
1278
1279
1280 virtual void getTargetDefines(const LangOptions &Opts,
1281 MacroBuilder &Builder) const {
1282 Builder.defineMacro("__R600__");
1283 }
1284
1285 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1286 return TargetInfo::CharPtrBuiltinVaList;
1287 }
1288
1289};
1290
1291} // end anonymous namespace
1292
1293namespace {
Chris Lattner9cbeb632010-03-06 21:21:27 +00001294// MBlaze abstract base class
1295class MBlazeTargetInfo : public TargetInfo {
1296 static const char * const GCCRegNames[];
1297 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1298
1299public:
1300 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +00001301 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner9cbeb632010-03-06 21:21:27 +00001302 }
1303
1304 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1305 unsigned &NumRecords) const {
1306 // FIXME: Implement.
1307 Records = 0;
1308 NumRecords = 0;
1309 }
1310
1311 virtual void getTargetDefines(const LangOptions &Opts,
1312 MacroBuilder &Builder) const;
1313
Douglas Gregore727d212012-01-30 06:38:25 +00001314 virtual bool hasFeature(StringRef Feature) const {
1315 return Feature == "mblaze";
1316 }
1317
Meador Ingec5613b22012-06-16 03:34:49 +00001318 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1319 return TargetInfo::CharPtrBuiltinVaList;
Chris Lattner9cbeb632010-03-06 21:21:27 +00001320 }
1321 virtual const char *getTargetPrefix() const {
1322 return "mblaze";
1323 }
1324 virtual void getGCCRegNames(const char * const *&Names,
1325 unsigned &NumNames) const;
1326 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1327 unsigned &NumAliases) const;
1328 virtual bool validateAsmConstraint(const char *&Name,
1329 TargetInfo::ConstraintInfo &Info) const {
1330 switch (*Name) {
1331 default: return false;
1332 case 'O': // Zero
1333 return true;
1334 case 'b': // Base register
1335 case 'f': // Floating point register
1336 Info.setAllowsRegister();
1337 return true;
1338 }
1339 }
1340 virtual const char *getClobbers() const {
1341 return "";
1342 }
1343};
1344
1345/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1346/// #defines that are not tied to a specific subtarget.
1347void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1348 MacroBuilder &Builder) const {
1349 // Target identification.
1350 Builder.defineMacro("__microblaze__");
1351 Builder.defineMacro("_ARCH_MICROBLAZE");
1352 Builder.defineMacro("__MICROBLAZE__");
1353
1354 // Target properties.
1355 Builder.defineMacro("_BIG_ENDIAN");
1356 Builder.defineMacro("__BIG_ENDIAN__");
1357
1358 // Subtarget options.
1359 Builder.defineMacro("__REGISTER_PREFIX__", "");
1360}
1361
1362
1363const char * const MBlazeTargetInfo::GCCRegNames[] = {
1364 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1365 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1366 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1367 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1368 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1369 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1370 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1371 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1372 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1373 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1374};
1375
1376void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1377 unsigned &NumNames) const {
1378 Names = GCCRegNames;
1379 NumNames = llvm::array_lengthof(GCCRegNames);
1380}
1381
1382const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1383 { {"f0"}, "r0" },
1384 { {"f1"}, "r1" },
1385 { {"f2"}, "r2" },
1386 { {"f3"}, "r3" },
1387 { {"f4"}, "r4" },
1388 { {"f5"}, "r5" },
1389 { {"f6"}, "r6" },
1390 { {"f7"}, "r7" },
1391 { {"f8"}, "r8" },
1392 { {"f9"}, "r9" },
1393 { {"f10"}, "r10" },
1394 { {"f11"}, "r11" },
1395 { {"f12"}, "r12" },
1396 { {"f13"}, "r13" },
1397 { {"f14"}, "r14" },
1398 { {"f15"}, "r15" },
1399 { {"f16"}, "r16" },
1400 { {"f17"}, "r17" },
1401 { {"f18"}, "r18" },
1402 { {"f19"}, "r19" },
1403 { {"f20"}, "r20" },
1404 { {"f21"}, "r21" },
1405 { {"f22"}, "r22" },
1406 { {"f23"}, "r23" },
1407 { {"f24"}, "r24" },
1408 { {"f25"}, "r25" },
1409 { {"f26"}, "r26" },
1410 { {"f27"}, "r27" },
1411 { {"f28"}, "r28" },
1412 { {"f29"}, "r29" },
1413 { {"f30"}, "r30" },
1414 { {"f31"}, "r31" },
1415};
1416
1417void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1418 unsigned &NumAliases) const {
1419 Aliases = GCCRegAliases;
1420 NumAliases = llvm::array_lengthof(GCCRegAliases);
1421}
1422} // end anonymous namespace.
1423
1424namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001425// Namespace for x86 abstract base class
1426const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001427#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001428#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001429 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001430#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001431};
Eli Friedman61538a72008-05-20 14:21:01 +00001432
Nuno Lopes2550d702009-12-23 17:49:57 +00001433static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001434 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1435 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001436 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001437 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1438 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1439 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001440 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopherc5f9a012011-12-02 02:12:16 +00001441 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1442 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001443};
1444
Eric Christophercfd323d2011-06-21 00:05:20 +00001445const TargetInfo::AddlRegName AddlRegNames[] = {
1446 { { "al", "ah", "eax", "rax" }, 0 },
1447 { { "bl", "bh", "ebx", "rbx" }, 3 },
1448 { { "cl", "ch", "ecx", "rcx" }, 2 },
1449 { { "dl", "dh", "edx", "rdx" }, 1 },
1450 { { "esi", "rsi" }, 4 },
1451 { { "edi", "rdi" }, 5 },
1452 { { "esp", "rsp" }, 7 },
1453 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001454};
1455
1456// X86 target abstract base class; x86-32 and x86-64 are very close, so
1457// most of the implementation can be shared.
1458class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001459 enum X86SSEEnum {
Craig Topper05fe4b52012-01-09 09:19:09 +00001460 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2
Chris Lattner84f0ea82009-03-02 22:40:39 +00001461 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001462 enum MMX3DNowEnum {
1463 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1464 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001465
Eric Christophereea12d12010-04-02 23:50:19 +00001466 bool HasAES;
Craig Topper3c0bc152012-05-31 05:18:48 +00001467 bool HasPCLMUL;
Craig Topper31ceea02011-12-25 05:06:45 +00001468 bool HasLZCNT;
Benjamin Kramer84f30802012-07-07 09:39:18 +00001469 bool HasRDRND;
Craig Topper31ceea02011-12-25 05:06:45 +00001470 bool HasBMI;
1471 bool HasBMI2;
Craig Toppere14e08b2011-12-29 16:10:46 +00001472 bool HasPOPCNT;
Michael Liao463eb892012-11-10 05:17:46 +00001473 bool HasRTM;
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00001474 bool HasSSE4a;
Craig Topper6a511e12011-12-30 07:33:42 +00001475 bool HasFMA4;
Craig Topper2ae95072012-06-03 21:46:30 +00001476 bool HasFMA;
Craig Topperb6af69e2012-06-09 22:24:14 +00001477 bool HasXOP;
Manman Ren146e5a42012-10-11 00:59:55 +00001478 bool HasF16C;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001479
Chandler Carruth499d9722011-09-28 08:55:34 +00001480 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1481 ///
1482 /// Each enumeration represents a particular CPU supported by Clang. These
1483 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1484 enum CPUKind {
1485 CK_Generic,
1486
1487 /// \name i386
1488 /// i386-generation processors.
1489 //@{
1490 CK_i386,
1491 //@}
1492
1493 /// \name i486
1494 /// i486-generation processors.
1495 //@{
1496 CK_i486,
1497 CK_WinChipC6,
1498 CK_WinChip2,
1499 CK_C3,
1500 //@}
1501
1502 /// \name i586
1503 /// i586-generation processors, P5 microarchitecture based.
1504 //@{
1505 CK_i586,
1506 CK_Pentium,
1507 CK_PentiumMMX,
1508 //@}
1509
1510 /// \name i686
1511 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1512 //@{
1513 CK_i686,
1514 CK_PentiumPro,
1515 CK_Pentium2,
1516 CK_Pentium3,
1517 CK_Pentium3M,
1518 CK_PentiumM,
1519 CK_C3_2,
1520
1521 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1522 /// Clang however has some logic to suport this.
1523 // FIXME: Warn, deprecate, and potentially remove this.
1524 CK_Yonah,
1525 //@}
1526
1527 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001528 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001529 //@{
1530 CK_Pentium4,
1531 CK_Pentium4M,
1532 CK_Prescott,
1533 CK_Nocona,
1534 //@}
1535
1536 /// \name Core
1537 /// Core microarchitecture based processors.
1538 //@{
1539 CK_Core2,
1540
1541 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1542 /// codename which GCC no longer accepts as an option to -march, but Clang
1543 /// has some logic for recognizing it.
1544 // FIXME: Warn, deprecate, and potentially remove this.
1545 CK_Penryn,
1546 //@}
1547
1548 /// \name Atom
1549 /// Atom processors
1550 //@{
1551 CK_Atom,
1552 //@}
1553
1554 /// \name Nehalem
1555 /// Nehalem microarchitecture based processors.
1556 //@{
1557 CK_Corei7,
1558 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001559 CK_CoreAVXi,
Craig Topper2b03bb02011-12-17 19:55:21 +00001560 CK_CoreAVX2,
Chandler Carruth499d9722011-09-28 08:55:34 +00001561 //@}
1562
1563 /// \name K6
1564 /// K6 architecture processors.
1565 //@{
1566 CK_K6,
1567 CK_K6_2,
1568 CK_K6_3,
1569 //@}
1570
1571 /// \name K7
1572 /// K7 architecture processors.
1573 //@{
1574 CK_Athlon,
1575 CK_AthlonThunderbird,
1576 CK_Athlon4,
1577 CK_AthlonXP,
1578 CK_AthlonMP,
1579 //@}
1580
1581 /// \name K8
1582 /// K8 architecture processors.
1583 //@{
1584 CK_Athlon64,
1585 CK_Athlon64SSE3,
1586 CK_AthlonFX,
1587 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001588 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001589 CK_Opteron,
1590 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001591 CK_AMDFAM10,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001592 //@}
Chandler Carruth499d9722011-09-28 08:55:34 +00001593
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001594 /// \name Bobcat
1595 /// Bobcat architecture processors.
1596 //@{
1597 CK_BTVER1,
1598 //@}
1599
1600 /// \name Bulldozer
1601 /// Bulldozer architecture processors.
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001602 //@{
1603 CK_BDVER1,
1604 CK_BDVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001605 //@}
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001606
Chandler Carruth499d9722011-09-28 08:55:34 +00001607 /// This specification is deprecated and will be removed in the future.
1608 /// Users should prefer \see CK_K8.
1609 // FIXME: Warn on this when the CPU is set to it.
1610 CK_x86_64,
1611 //@}
1612
1613 /// \name Geode
1614 /// Geode processors.
1615 //@{
1616 CK_Geode
1617 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001618 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001619
Eli Friedman618234a2008-08-20 02:34:37 +00001620public:
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001621 X86TargetInfo(const std::string& triple)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001622 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Benjamin Kramer84f30802012-07-07 09:39:18 +00001623 HasAES(false), HasPCLMUL(false), HasLZCNT(false), HasRDRND(false),
Michael Liao463eb892012-11-10 05:17:46 +00001624 HasBMI(false), HasBMI2(false), HasPOPCNT(false), HasRTM(false),
1625 HasSSE4a(false), HasFMA4(false), HasFMA(false), HasXOP(false),
1626 HasF16C(false), CPU(CK_Generic) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00001627 BigEndian = false;
Eli Friedman618234a2008-08-20 02:34:37 +00001628 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001629 }
Benjamin Kramerb4066692011-12-28 15:47:06 +00001630 virtual unsigned getFloatEvalMethod() const {
1631 // X87 evaluates with 80 bits "long double" precision.
1632 return SSELevel == NoSSE ? 2 : 0;
1633 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001634 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1635 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001636 Records = BuiltinInfo;
1637 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001638 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001639 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001640 unsigned &NumNames) const {
1641 Names = GCCRegNames;
1642 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001643 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001644 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001645 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001646 Aliases = 0;
1647 NumAliases = 0;
1648 }
1649 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1650 unsigned &NumNames) const {
1651 Names = AddlRegNames;
1652 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001653 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001654 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001655 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001656 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001657 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001658 return "~{dirflag},~{fpsr},~{flags}";
1659 }
Chris Lattner33328642009-03-20 15:52:06 +00001660 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001661 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001662 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001663 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001664 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001665 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Douglas Gregore727d212012-01-30 06:38:25 +00001666 virtual bool hasFeature(StringRef Feature) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001667 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001668 virtual const char* getABI() const {
Derek Schuffbabaf312012-10-11 15:52:22 +00001669 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001670 return "avx";
Derek Schuffbabaf312012-10-11 15:52:22 +00001671 else if (getTriple().getArch() == llvm::Triple::x86 &&
1672 MMX3DNowLevel == NoMMX3DNow)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001673 return "no-mmx";
1674 return "";
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001675 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001676 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001677 CPU = llvm::StringSwitch<CPUKind>(Name)
1678 .Case("i386", CK_i386)
1679 .Case("i486", CK_i486)
1680 .Case("winchip-c6", CK_WinChipC6)
1681 .Case("winchip2", CK_WinChip2)
1682 .Case("c3", CK_C3)
1683 .Case("i586", CK_i586)
1684 .Case("pentium", CK_Pentium)
1685 .Case("pentium-mmx", CK_PentiumMMX)
1686 .Case("i686", CK_i686)
1687 .Case("pentiumpro", CK_PentiumPro)
1688 .Case("pentium2", CK_Pentium2)
1689 .Case("pentium3", CK_Pentium3)
1690 .Case("pentium3m", CK_Pentium3M)
1691 .Case("pentium-m", CK_PentiumM)
1692 .Case("c3-2", CK_C3_2)
1693 .Case("yonah", CK_Yonah)
1694 .Case("pentium4", CK_Pentium4)
1695 .Case("pentium4m", CK_Pentium4M)
1696 .Case("prescott", CK_Prescott)
1697 .Case("nocona", CK_Nocona)
1698 .Case("core2", CK_Core2)
1699 .Case("penryn", CK_Penryn)
1700 .Case("atom", CK_Atom)
1701 .Case("corei7", CK_Corei7)
1702 .Case("corei7-avx", CK_Corei7AVX)
1703 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper2b03bb02011-12-17 19:55:21 +00001704 .Case("core-avx2", CK_CoreAVX2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001705 .Case("k6", CK_K6)
1706 .Case("k6-2", CK_K6_2)
1707 .Case("k6-3", CK_K6_3)
1708 .Case("athlon", CK_Athlon)
1709 .Case("athlon-tbird", CK_AthlonThunderbird)
1710 .Case("athlon-4", CK_Athlon4)
1711 .Case("athlon-xp", CK_AthlonXP)
1712 .Case("athlon-mp", CK_AthlonMP)
1713 .Case("athlon64", CK_Athlon64)
1714 .Case("athlon64-sse3", CK_Athlon64SSE3)
1715 .Case("athlon-fx", CK_AthlonFX)
1716 .Case("k8", CK_K8)
1717 .Case("k8-sse3", CK_K8SSE3)
1718 .Case("opteron", CK_Opteron)
1719 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001720 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001721 .Case("btver1", CK_BTVER1)
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001722 .Case("bdver1", CK_BDVER1)
1723 .Case("bdver2", CK_BDVER2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001724 .Case("x86-64", CK_x86_64)
1725 .Case("geode", CK_Geode)
1726 .Default(CK_Generic);
1727
Chandler Carruth26a39142011-09-28 09:45:08 +00001728 // Perform any per-CPU checks necessary to determine if this CPU is
1729 // acceptable.
1730 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1731 // invalid without explaining *why*.
1732 switch (CPU) {
1733 case CK_Generic:
1734 // No processor selected!
1735 return false;
1736
1737 case CK_i386:
1738 case CK_i486:
1739 case CK_WinChipC6:
1740 case CK_WinChip2:
1741 case CK_C3:
1742 case CK_i586:
1743 case CK_Pentium:
1744 case CK_PentiumMMX:
1745 case CK_i686:
1746 case CK_PentiumPro:
1747 case CK_Pentium2:
1748 case CK_Pentium3:
1749 case CK_Pentium3M:
1750 case CK_PentiumM:
1751 case CK_Yonah:
1752 case CK_C3_2:
1753 case CK_Pentium4:
1754 case CK_Pentium4M:
1755 case CK_Prescott:
1756 case CK_K6:
1757 case CK_K6_2:
1758 case CK_K6_3:
1759 case CK_Athlon:
1760 case CK_AthlonThunderbird:
1761 case CK_Athlon4:
1762 case CK_AthlonXP:
1763 case CK_AthlonMP:
1764 case CK_Geode:
1765 // Only accept certain architectures when compiling in 32-bit mode.
Derek Schuffbabaf312012-10-11 15:52:22 +00001766 if (getTriple().getArch() != llvm::Triple::x86)
Chandler Carruth26a39142011-09-28 09:45:08 +00001767 return false;
1768
1769 // Fallthrough
1770 case CK_Nocona:
1771 case CK_Core2:
1772 case CK_Penryn:
1773 case CK_Atom:
1774 case CK_Corei7:
1775 case CK_Corei7AVX:
1776 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001777 case CK_CoreAVX2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001778 case CK_Athlon64:
1779 case CK_Athlon64SSE3:
1780 case CK_AthlonFX:
1781 case CK_K8:
1782 case CK_K8SSE3:
1783 case CK_Opteron:
1784 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00001785 case CK_AMDFAM10:
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001786 case CK_BTVER1:
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001787 case CK_BDVER1:
1788 case CK_BDVER2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001789 case CK_x86_64:
1790 return true;
1791 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001792 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001793 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00001794
1795 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
1796 // We accept all non-ARM calling conventions
1797 return (CC == CC_X86ThisCall ||
1798 CC == CC_X86FastCall ||
1799 CC == CC_X86StdCall ||
1800 CC == CC_C ||
1801 CC == CC_X86Pascal) ? CCCR_OK : CCCR_Warning;
1802 }
1803
1804 virtual CallingConv getDefaultCallingConv() const {
1805 return CC_C;
1806 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001807};
Chris Lattner3daed522009-03-02 22:20:04 +00001808
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001809void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001810 // FIXME: This should not be here.
1811 Features["3dnow"] = false;
1812 Features["3dnowa"] = false;
1813 Features["mmx"] = false;
1814 Features["sse"] = false;
1815 Features["sse2"] = false;
1816 Features["sse3"] = false;
1817 Features["ssse3"] = false;
1818 Features["sse41"] = false;
1819 Features["sse42"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001820 Features["sse4a"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001821 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00001822 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001823 Features["avx"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001824 Features["avx2"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001825 Features["lzcnt"] = false;
Benjamin Kramer84f30802012-07-07 09:39:18 +00001826 Features["rdrand"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001827 Features["bmi"] = false;
1828 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001829 Features["popcnt"] = false;
Michael Liao463eb892012-11-10 05:17:46 +00001830 Features["rtm"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001831 Features["fma4"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00001832 Features["fma"] = false;
Craig Topperb6af69e2012-06-09 22:24:14 +00001833 Features["xop"] = false;
Manman Ren146e5a42012-10-11 00:59:55 +00001834 Features["f16c"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001835
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001836 // FIXME: This *really* should not be here.
1837
1838 // X86_64 always has SSE2.
Derek Schuffbabaf312012-10-11 15:52:22 +00001839 if (getTriple().getArch() == llvm::Triple::x86_64)
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001840 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1841
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001842 switch (CPU) {
1843 case CK_Generic:
1844 case CK_i386:
1845 case CK_i486:
1846 case CK_i586:
1847 case CK_Pentium:
1848 case CK_i686:
1849 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001850 break;
1851 case CK_PentiumMMX:
1852 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001853 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001854 break;
1855 case CK_Pentium3:
1856 case CK_Pentium3M:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001857 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001858 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001859 break;
1860 case CK_PentiumM:
1861 case CK_Pentium4:
1862 case CK_Pentium4M:
1863 case CK_x86_64:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001864 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001865 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001866 break;
1867 case CK_Yonah:
1868 case CK_Prescott:
1869 case CK_Nocona:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001870 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001871 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001872 break;
1873 case CK_Core2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001874 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001875 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001876 break;
1877 case CK_Penryn:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001878 setFeatureEnabled(Features, "mmx", true);
Benjamin Kramerb3453a82012-01-04 14:36:57 +00001879 setFeatureEnabled(Features, "sse4.1", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001880 break;
1881 case CK_Atom:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001882 setFeatureEnabled(Features, "mmx", true);
Chandler Carruth49defe62011-09-28 10:36:46 +00001883 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001884 break;
1885 case CK_Corei7:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001886 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001887 setFeatureEnabled(Features, "sse4", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001888 break;
1889 case CK_Corei7AVX:
Benjamin Kramer84f30802012-07-07 09:39:18 +00001890 setFeatureEnabled(Features, "mmx", true);
1891 setFeatureEnabled(Features, "avx", true);
1892 setFeatureEnabled(Features, "aes", true);
1893 setFeatureEnabled(Features, "pclmul", true);
1894 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001895 case CK_CoreAVXi:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001896 setFeatureEnabled(Features, "mmx", true);
Craig Topperfd936302012-04-26 07:31:30 +00001897 setFeatureEnabled(Features, "avx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00001898 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00001899 setFeatureEnabled(Features, "pclmul", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00001900 setFeatureEnabled(Features, "rdrnd", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001901 break;
Craig Topper2b03bb02011-12-17 19:55:21 +00001902 case CK_CoreAVX2:
1903 setFeatureEnabled(Features, "mmx", true);
Craig Topperfd936302012-04-26 07:31:30 +00001904 setFeatureEnabled(Features, "avx2", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00001905 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00001906 setFeatureEnabled(Features, "pclmul", true);
Craig Topper31ceea02011-12-25 05:06:45 +00001907 setFeatureEnabled(Features, "lzcnt", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00001908 setFeatureEnabled(Features, "rdrnd", true);
Craig Topper31ceea02011-12-25 05:06:45 +00001909 setFeatureEnabled(Features, "bmi", true);
1910 setFeatureEnabled(Features, "bmi2", true);
Michael Liao463eb892012-11-10 05:17:46 +00001911 setFeatureEnabled(Features, "rtm", true);
Craig Topper2ae95072012-06-03 21:46:30 +00001912 setFeatureEnabled(Features, "fma", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00001913 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001914 case CK_K6:
1915 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001916 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001917 break;
1918 case CK_K6_2:
1919 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001920 case CK_WinChip2:
1921 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001922 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001923 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00001924 case CK_Athlon:
1925 case CK_AthlonThunderbird:
1926 case CK_Geode:
1927 setFeatureEnabled(Features, "3dnowa", true);
1928 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001929 case CK_Athlon4:
1930 case CK_AthlonXP:
1931 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001932 setFeatureEnabled(Features, "sse", true);
1933 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001934 break;
1935 case CK_K8:
1936 case CK_Opteron:
1937 case CK_Athlon64:
1938 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00001939 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001940 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001941 break;
1942 case CK_K8SSE3:
1943 case CK_OpteronSSE3:
1944 case CK_Athlon64SSE3:
Roman Divacky80b32b82011-10-30 13:47:56 +00001945 setFeatureEnabled(Features, "sse3", true);
1946 setFeatureEnabled(Features, "3dnowa", true);
1947 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00001948 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00001949 setFeatureEnabled(Features, "sse3", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00001950 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00001951 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001952 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001953 case CK_BTVER1:
1954 setFeatureEnabled(Features, "ssse3", true);
1955 setFeatureEnabled(Features, "sse4a", true);
Craig Topper90ea0362012-05-30 05:54:54 +00001956 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001957 case CK_BDVER1:
1958 case CK_BDVER2:
Craig Topper70d9b162012-05-01 07:18:03 +00001959 setFeatureEnabled(Features, "avx", true);
Craig Topperb6af69e2012-06-09 22:24:14 +00001960 setFeatureEnabled(Features, "xop", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001961 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00001962 setFeatureEnabled(Features, "pclmul", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001963 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001964 case CK_C3_2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001965 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001966 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001967 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001968 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001969}
1970
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001971bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001972 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001973 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00001974 // FIXME: This *really* should not be here. We need some way of translating
1975 // options into llvm subtarget features.
1976 if (!Features.count(Name) &&
Benjamin Kramer84f30802012-07-07 09:39:18 +00001977 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1" &&
1978 Name != "rdrnd"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001979 return false;
1980
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001981 // FIXME: this should probably use a switch with fall through.
1982
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001983 if (Enabled) {
1984 if (Name == "mmx")
1985 Features["mmx"] = true;
1986 else if (Name == "sse")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001987 Features["mmx"] = Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001988 else if (Name == "sse2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001989 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001990 else if (Name == "sse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001991 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1992 true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001993 else if (Name == "ssse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001994 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001995 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001996 else if (Name == "sse4" || Name == "sse4.2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001997 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001998 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1999 Features["popcnt"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00002000 else if (Name == "sse4.1")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002001 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00002002 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002003 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002004 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002005 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002006 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00002007 else if (Name == "aes")
Craig Toppera7463c32012-06-03 21:56:22 +00002008 Features["sse"] = Features["sse2"] = Features["aes"] = true;
Craig Topper3c0bc152012-05-31 05:18:48 +00002009 else if (Name == "pclmul")
Craig Toppera7463c32012-06-03 21:56:22 +00002010 Features["sse"] = Features["sse2"] = Features["pclmul"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002011 else if (Name == "avx")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002012 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2013 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002014 Features["popcnt"] = Features["avx"] = true;
Craig Topper2b03bb02011-12-17 19:55:21 +00002015 else if (Name == "avx2")
2016 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2017 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002018 Features["popcnt"] = Features["avx"] = Features["avx2"] = true;
Craig Topper2ae95072012-06-03 21:46:30 +00002019 else if (Name == "fma")
2020 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2021 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2022 Features["popcnt"] = Features["avx"] = Features["fma"] = true;
Craig Topper6a511e12011-12-30 07:33:42 +00002023 else if (Name == "fma4")
2024 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2025 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper90ea0362012-05-30 05:54:54 +00002026 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
2027 Features["fma4"] = true;
Craig Topperb6af69e2012-06-09 22:24:14 +00002028 else if (Name == "xop")
2029 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2030 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2031 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
2032 Features["fma4"] = Features["xop"] = true;
Roman Divacky80b32b82011-10-30 13:47:56 +00002033 else if (Name == "sse4a")
Craig Topper6a511e12011-12-30 07:33:42 +00002034 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper90ea0362012-05-30 05:54:54 +00002035 Features["sse4a"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00002036 else if (Name == "lzcnt")
2037 Features["lzcnt"] = true;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002038 else if (Name == "rdrnd")
2039 Features["rdrand"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00002040 else if (Name == "bmi")
2041 Features["bmi"] = true;
2042 else if (Name == "bmi2")
2043 Features["bmi2"] = true;
Craig Toppere14e08b2011-12-29 16:10:46 +00002044 else if (Name == "popcnt")
2045 Features["popcnt"] = true;
Manman Ren146e5a42012-10-11 00:59:55 +00002046 else if (Name == "f16c")
2047 Features["f16c"] = true;
Michael Liao463eb892012-11-10 05:17:46 +00002048 else if (Name == "rtm")
2049 Features["rtm"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002050 } else {
2051 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002052 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002053 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00002054 Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00002055 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002056 Features["sse4a"] = Features["avx"] = Features["avx2"] =
2057 Features["fma"] = Features["fma4"] = Features["aes"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002058 Features["pclmul"] = Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002059 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00002060 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Craig Toppera7463c32012-06-03 21:56:22 +00002061 Features["sse41"] = Features["sse42"] = Features["sse4a"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002062 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002063 Features["fma4"] = Features["aes"] = Features["pclmul"] =
2064 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002065 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00002066 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002067 Features["sse42"] = Features["sse4a"] = Features["avx"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002068 Features["avx2"] = Features["fma"] = Features["fma4"] =
2069 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002070 else if (Name == "ssse3")
Craig Topper31380fb2012-06-03 22:23:42 +00002071 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2072 Features["avx"] = Features["avx2"] = Features["fma"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00002073 else if (Name == "sse4" || Name == "sse4.1")
Craig Topper31380fb2012-06-03 22:23:42 +00002074 Features["sse41"] = Features["sse42"] = Features["avx"] =
2075 Features["avx2"] = Features["fma"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00002076 else if (Name == "sse4.2")
Craig Topper31380fb2012-06-03 22:23:42 +00002077 Features["sse42"] = Features["avx"] = Features["avx2"] =
2078 Features["fma"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002079 else if (Name == "3dnow")
2080 Features["3dnow"] = Features["3dnowa"] = false;
2081 else if (Name == "3dnowa")
2082 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00002083 else if (Name == "aes")
2084 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00002085 else if (Name == "pclmul")
2086 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002087 else if (Name == "avx")
Craig Topper2ae95072012-06-03 21:46:30 +00002088 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002089 Features["fma4"] = Features["xop"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00002090 else if (Name == "avx2")
2091 Features["avx2"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00002092 else if (Name == "fma")
2093 Features["fma"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00002094 else if (Name == "sse4a")
Craig Topperb6af69e2012-06-09 22:24:14 +00002095 Features["sse4a"] = Features["fma4"] = Features["xop"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002096 else if (Name == "lzcnt")
2097 Features["lzcnt"] = false;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002098 else if (Name == "rdrnd")
2099 Features["rdrand"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002100 else if (Name == "bmi")
2101 Features["bmi"] = false;
2102 else if (Name == "bmi2")
2103 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00002104 else if (Name == "popcnt")
2105 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00002106 else if (Name == "fma4")
Craig Topperb6af69e2012-06-09 22:24:14 +00002107 Features["fma4"] = Features["xop"] = false;
2108 else if (Name == "xop")
2109 Features["xop"] = false;
Manman Ren146e5a42012-10-11 00:59:55 +00002110 else if (Name == "f16c")
2111 Features["f16c"] = false;
Michael Liao463eb892012-11-10 05:17:46 +00002112 else if (Name == "rtm")
2113 Features["rtm"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002114 }
2115
2116 return true;
2117}
2118
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002119/// HandleTargetOptions - Perform initialization based on the user
2120/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00002121void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002122 // Remember the maximum enabled sselevel.
2123 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
2124 // Ignore disabled features.
2125 if (Features[i][0] == '-')
2126 continue;
2127
Benjamin Kramer713575a2012-03-05 15:10:44 +00002128 StringRef Feature = StringRef(Features[i]).substr(1);
2129
2130 if (Feature == "aes") {
Eric Christophereea12d12010-04-02 23:50:19 +00002131 HasAES = true;
2132 continue;
2133 }
2134
Craig Topper3c0bc152012-05-31 05:18:48 +00002135 if (Feature == "pclmul") {
2136 HasPCLMUL = true;
2137 continue;
2138 }
2139
Benjamin Kramer713575a2012-03-05 15:10:44 +00002140 if (Feature == "lzcnt") {
Craig Topper31ceea02011-12-25 05:06:45 +00002141 HasLZCNT = true;
2142 continue;
2143 }
2144
Benjamin Kramer84f30802012-07-07 09:39:18 +00002145 if (Feature == "rdrand") {
2146 HasRDRND = true;
2147 continue;
2148 }
2149
Benjamin Kramer713575a2012-03-05 15:10:44 +00002150 if (Feature == "bmi") {
Craig Topper31ceea02011-12-25 05:06:45 +00002151 HasBMI = true;
2152 continue;
2153 }
2154
Benjamin Kramer713575a2012-03-05 15:10:44 +00002155 if (Feature == "bmi2") {
Craig Topper31ceea02011-12-25 05:06:45 +00002156 HasBMI2 = true;
2157 continue;
2158 }
2159
Benjamin Kramer713575a2012-03-05 15:10:44 +00002160 if (Feature == "popcnt") {
Craig Toppere14e08b2011-12-29 16:10:46 +00002161 HasPOPCNT = true;
2162 continue;
2163 }
2164
Michael Liao463eb892012-11-10 05:17:46 +00002165 if (Feature == "rtm") {
2166 HasRTM = true;
2167 continue;
2168 }
2169
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002170 if (Feature == "sse4a") {
2171 HasSSE4a = true;
2172 continue;
2173 }
2174
Benjamin Kramer713575a2012-03-05 15:10:44 +00002175 if (Feature == "fma4") {
Craig Topper6a511e12011-12-30 07:33:42 +00002176 HasFMA4 = true;
2177 continue;
2178 }
2179
Craig Topper2ae95072012-06-03 21:46:30 +00002180 if (Feature == "fma") {
2181 HasFMA = true;
2182 continue;
2183 }
2184
Craig Topperb6af69e2012-06-09 22:24:14 +00002185 if (Feature == "xop") {
2186 HasXOP = true;
2187 continue;
2188 }
2189
Manman Ren146e5a42012-10-11 00:59:55 +00002190 if (Feature == "f16c") {
2191 HasF16C = true;
2192 continue;
2193 }
2194
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002195 assert(Features[i][0] == '+' && "Invalid target feature!");
Benjamin Kramer713575a2012-03-05 15:10:44 +00002196 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Craig Topper05fe4b52012-01-09 09:19:09 +00002197 .Case("avx2", AVX2)
2198 .Case("avx", AVX)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002199 .Case("sse42", SSE42)
2200 .Case("sse41", SSE41)
2201 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00002202 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002203 .Case("sse2", SSE2)
2204 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002205 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002206 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002207
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002208 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer713575a2012-03-05 15:10:44 +00002209 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002210 .Case("3dnowa", AMD3DNowAthlon)
2211 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002212 .Case("mmx", MMX)
2213 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002214
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002215 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002216 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002217
2218 // Don't tell the backend if we're turning off mmx; it will end up disabling
2219 // SSE, which we don't want.
2220 std::vector<std::string>::iterator it;
2221 it = std::find(Features.begin(), Features.end(), "-mmx");
2222 if (it != Features.end())
2223 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00002224}
Chris Lattnerc0f59212009-03-02 22:27:17 +00002225
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002226/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
2227/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00002228void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002229 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002230 // Target identification.
Derek Schuffbabaf312012-10-11 15:52:22 +00002231 if (getTriple().getArch() == llvm::Triple::x86_64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002232 Builder.defineMacro("__amd64__");
2233 Builder.defineMacro("__amd64");
2234 Builder.defineMacro("__x86_64");
2235 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002236 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00002237 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00002238 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002239
Chris Lattnerc0f59212009-03-02 22:27:17 +00002240 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002241 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
2242 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002243 switch (CPU) {
2244 case CK_Generic:
2245 break;
2246 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002247 // The rest are coming from the i386 define above.
2248 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002249 break;
2250 case CK_i486:
2251 case CK_WinChipC6:
2252 case CK_WinChip2:
2253 case CK_C3:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002254 defineCPUMacros(Builder, "i486");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002255 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00002256 case CK_PentiumMMX:
2257 Builder.defineMacro("__pentium_mmx__");
2258 Builder.defineMacro("__tune_pentium_mmx__");
2259 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002260 case CK_i586:
2261 case CK_Pentium:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002262 defineCPUMacros(Builder, "i586");
2263 defineCPUMacros(Builder, "pentium");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002264 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002265 case CK_Pentium3:
2266 case CK_Pentium3M:
2267 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002268 Builder.defineMacro("__tune_pentium3__");
2269 // Fallthrough
2270 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002271 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002272 Builder.defineMacro("__tune_pentium2__");
2273 // Fallthrough
2274 case CK_PentiumPro:
2275 Builder.defineMacro("__tune_i686__");
2276 Builder.defineMacro("__tune_pentiumpro__");
2277 // Fallthrough
2278 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002279 Builder.defineMacro("__i686");
2280 Builder.defineMacro("__i686__");
2281 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
2282 Builder.defineMacro("__pentiumpro");
2283 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002284 break;
2285 case CK_Pentium4:
2286 case CK_Pentium4M:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002287 defineCPUMacros(Builder, "pentium4");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002288 break;
2289 case CK_Yonah:
2290 case CK_Prescott:
2291 case CK_Nocona:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002292 defineCPUMacros(Builder, "nocona");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002293 break;
2294 case CK_Core2:
2295 case CK_Penryn:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002296 defineCPUMacros(Builder, "core2");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002297 break;
2298 case CK_Atom:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002299 defineCPUMacros(Builder, "atom");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002300 break;
2301 case CK_Corei7:
2302 case CK_Corei7AVX:
2303 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00002304 case CK_CoreAVX2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002305 defineCPUMacros(Builder, "corei7");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002306 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002307 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002308 Builder.defineMacro("__k6_2__");
2309 Builder.defineMacro("__tune_k6_2__");
2310 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002311 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002312 if (CPU != CK_K6_2) { // In case of fallthrough
2313 // FIXME: GCC may be enabling these in cases where some other k6
2314 // architecture is specified but -m3dnow is explicitly provided. The
2315 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002316 Builder.defineMacro("__k6_3__");
2317 Builder.defineMacro("__tune_k6_3__");
2318 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00002319 // Fallthrough
2320 case CK_K6:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002321 defineCPUMacros(Builder, "k6");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002322 break;
2323 case CK_Athlon:
2324 case CK_AthlonThunderbird:
2325 case CK_Athlon4:
2326 case CK_AthlonXP:
2327 case CK_AthlonMP:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002328 defineCPUMacros(Builder, "athlon");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002329 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002330 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002331 Builder.defineMacro("__tune_athlon_sse__");
2332 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002333 break;
2334 case CK_K8:
2335 case CK_K8SSE3:
2336 case CK_x86_64:
2337 case CK_Opteron:
2338 case CK_OpteronSSE3:
2339 case CK_Athlon64:
2340 case CK_Athlon64SSE3:
2341 case CK_AthlonFX:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002342 defineCPUMacros(Builder, "k8");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002343 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002344 case CK_AMDFAM10:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002345 defineCPUMacros(Builder, "amdfam10");
Roman Divacky01c770d2011-10-30 07:48:46 +00002346 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002347 case CK_BTVER1:
2348 defineCPUMacros(Builder, "btver1");
2349 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002350 case CK_BDVER1:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002351 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002352 break;
2353 case CK_BDVER2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002354 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002355 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002356 case CK_Geode:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002357 defineCPUMacros(Builder, "geode");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002358 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002359 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00002360
Chandler Carruth88c75b02011-09-28 09:54:07 +00002361 // Target properties.
2362 Builder.defineMacro("__LITTLE_ENDIAN__");
2363 Builder.defineMacro("__REGISTER_PREFIX__", "");
2364
Chris Lattner54175442009-04-19 17:32:33 +00002365 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2366 // functions in glibc header files that use FP Stack inline asm which the
2367 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00002368 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002369
Chandler Carruth88c75b02011-09-28 09:54:07 +00002370 if (HasAES)
2371 Builder.defineMacro("__AES__");
2372
Craig Topper3c0bc152012-05-31 05:18:48 +00002373 if (HasPCLMUL)
2374 Builder.defineMacro("__PCLMUL__");
2375
Craig Topper31ceea02011-12-25 05:06:45 +00002376 if (HasLZCNT)
2377 Builder.defineMacro("__LZCNT__");
2378
Benjamin Kramer84f30802012-07-07 09:39:18 +00002379 if (HasRDRND)
2380 Builder.defineMacro("__RDRND__");
2381
Craig Topper31ceea02011-12-25 05:06:45 +00002382 if (HasBMI)
2383 Builder.defineMacro("__BMI__");
2384
2385 if (HasBMI2)
2386 Builder.defineMacro("__BMI2__");
2387
Craig Toppere14e08b2011-12-29 16:10:46 +00002388 if (HasPOPCNT)
2389 Builder.defineMacro("__POPCNT__");
2390
Michael Liao463eb892012-11-10 05:17:46 +00002391 if (HasRTM)
2392 Builder.defineMacro("__RTM__");
2393
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002394 if (HasSSE4a)
2395 Builder.defineMacro("__SSE4A__");
2396
Craig Topper6a511e12011-12-30 07:33:42 +00002397 if (HasFMA4)
2398 Builder.defineMacro("__FMA4__");
2399
Craig Topper2ae95072012-06-03 21:46:30 +00002400 if (HasFMA)
2401 Builder.defineMacro("__FMA__");
2402
Craig Topperb6af69e2012-06-09 22:24:14 +00002403 if (HasXOP)
2404 Builder.defineMacro("__XOP__");
2405
Manman Ren146e5a42012-10-11 00:59:55 +00002406 if (HasF16C)
2407 Builder.defineMacro("__F16C__");
2408
Chris Lattner84f0ea82009-03-02 22:40:39 +00002409 // Each case falls through to the previous one here.
2410 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002411 case AVX2:
2412 Builder.defineMacro("__AVX2__");
2413 case AVX:
2414 Builder.defineMacro("__AVX__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002415 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00002416 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002417 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00002418 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002419 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002420 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002421 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002422 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002423 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00002424 Builder.defineMacro("__SSE2__");
2425 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00002426 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00002427 Builder.defineMacro("__SSE__");
2428 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002429 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00002430 break;
2431 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002432
Derek Schuffbabaf312012-10-11 15:52:22 +00002433 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002434 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002435 case AVX2:
2436 case AVX:
Michael J. Spencera764e832010-10-21 08:22:51 +00002437 case SSE42:
2438 case SSE41:
2439 case SSSE3:
2440 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002441 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002442 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002443 break;
2444 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002445 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002446 break;
2447 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002448 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002449 }
2450 }
2451
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002452 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002453 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002454 case AMD3DNowAthlon:
2455 Builder.defineMacro("__3dNOW_A__");
2456 case AMD3DNow:
2457 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002458 case MMX:
2459 Builder.defineMacro("__MMX__");
2460 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002461 break;
2462 }
Chris Lattnerc0f59212009-03-02 22:27:17 +00002463}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002464
Douglas Gregore727d212012-01-30 06:38:25 +00002465bool X86TargetInfo::hasFeature(StringRef Feature) const {
2466 return llvm::StringSwitch<bool>(Feature)
2467 .Case("aes", HasAES)
2468 .Case("avx", SSELevel >= AVX)
2469 .Case("avx2", SSELevel >= AVX2)
2470 .Case("bmi", HasBMI)
2471 .Case("bmi2", HasBMI2)
Craig Topper2ae95072012-06-03 21:46:30 +00002472 .Case("fma", HasFMA)
Douglas Gregore727d212012-01-30 06:38:25 +00002473 .Case("fma4", HasFMA4)
2474 .Case("lzcnt", HasLZCNT)
Benjamin Kramer84f30802012-07-07 09:39:18 +00002475 .Case("rdrnd", HasRDRND)
Douglas Gregore727d212012-01-30 06:38:25 +00002476 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
2477 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
2478 .Case("mmx", MMX3DNowLevel >= MMX)
Craig Topper3c0bc152012-05-31 05:18:48 +00002479 .Case("pclmul", HasPCLMUL)
Douglas Gregore727d212012-01-30 06:38:25 +00002480 .Case("popcnt", HasPOPCNT)
Michael Liao463eb892012-11-10 05:17:46 +00002481 .Case("rtm", HasRTM)
Douglas Gregore727d212012-01-30 06:38:25 +00002482 .Case("sse", SSELevel >= SSE1)
2483 .Case("sse2", SSELevel >= SSE2)
2484 .Case("sse3", SSELevel >= SSE3)
2485 .Case("ssse3", SSELevel >= SSSE3)
2486 .Case("sse41", SSELevel >= SSE41)
2487 .Case("sse42", SSELevel >= SSE42)
Craig Topper3c0bc152012-05-31 05:18:48 +00002488 .Case("sse4a", HasSSE4a)
Douglas Gregore727d212012-01-30 06:38:25 +00002489 .Case("x86", true)
Derek Schuffbabaf312012-10-11 15:52:22 +00002490 .Case("x86_32", getTriple().getArch() == llvm::Triple::x86)
2491 .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64)
Craig Topperb6af69e2012-06-09 22:24:14 +00002492 .Case("xop", HasXOP)
Manman Ren146e5a42012-10-11 00:59:55 +00002493 .Case("f16c", HasF16C)
Douglas Gregore727d212012-01-30 06:38:25 +00002494 .Default(false);
2495}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002496
Eli Friedman618234a2008-08-20 02:34:37 +00002497bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002498X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002499 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002500 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00002501 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00002502 case 'Y': // first letter of a pair:
2503 switch (*(Name+1)) {
2504 default: return false;
2505 case '0': // First SSE register.
2506 case 't': // Any SSE register, when SSE2 is enabled.
2507 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2508 case 'm': // any MMX register, when inter-unit moves enabled.
2509 break; // falls through to setAllowsRegister.
2510 }
Eli Friedman618234a2008-08-20 02:34:37 +00002511 case 'a': // eax.
2512 case 'b': // ebx.
2513 case 'c': // ecx.
2514 case 'd': // edx.
2515 case 'S': // esi.
2516 case 'D': // edi.
2517 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00002518 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00002519 case 't': // top of floating point stack.
2520 case 'u': // second from top of floating point stack.
2521 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00002522 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00002523 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00002524 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00002525 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2526 case 'l': // "Index" registers: any general register that can be used as an
2527 // index in a base+index memory access.
2528 Info.setAllowsRegister();
2529 return true;
2530 case 'C': // SSE floating point constant.
2531 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002532 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002533 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002534 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002535 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00002536 return true;
2537 }
2538}
2539
Dale Johannesenf6e2c202010-10-29 23:12:32 +00002540
Eli Friedman618234a2008-08-20 02:34:37 +00002541std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00002542X86TargetInfo::convertConstraint(const char *&Constraint) const {
2543 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00002544 case 'a': return std::string("{ax}");
2545 case 'b': return std::string("{bx}");
2546 case 'c': return std::string("{cx}");
2547 case 'd': return std::string("{dx}");
2548 case 'S': return std::string("{si}");
2549 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00002550 case 'p': // address
2551 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00002552 case 't': // top of floating point stack.
2553 return std::string("{st}");
2554 case 'u': // second from top of floating point stack.
2555 return std::string("{st(1)}"); // second from top of floating point stack.
2556 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00002557 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00002558 }
2559}
Eli Friedman618234a2008-08-20 02:34:37 +00002560} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00002561
2562namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002563// X86-32 generic target
2564class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00002565public:
Eli Friedman618234a2008-08-20 02:34:37 +00002566 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
2567 DoubleAlign = LongLongAlign = 32;
2568 LongDoubleWidth = 96;
2569 LongDoubleAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00002570 SuitableAlign = 128;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002571 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2572 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00002573 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00002574 SizeType = UnsignedInt;
2575 PtrDiffType = SignedInt;
2576 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002577 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002578
2579 // Use fpret for all types.
2580 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2581 (1 << TargetInfo::Double) |
2582 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002583
2584 // x86-32 has atomics up to 8 bytes
2585 // FIXME: Check that we actually have cmpxchg8b before setting
2586 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2587 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002588 }
Meador Ingec5613b22012-06-16 03:34:49 +00002589 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2590 return TargetInfo::CharPtrBuiltinVaList;
Eli Friedman618234a2008-08-20 02:34:37 +00002591 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002592
Chris Lattner21fb98e2009-09-23 06:06:36 +00002593 int getEHDataRegisterNumber(unsigned RegNo) const {
2594 if (RegNo == 0) return 0;
2595 if (RegNo == 1) return 2;
2596 return -1;
2597 }
Eli Friedman618234a2008-08-20 02:34:37 +00002598};
2599} // end anonymous namespace
2600
2601namespace {
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002602class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
2603public:
2604 NetBSDI386TargetInfo(const std::string &triple) :
2605 NetBSDTargetInfo<X86_32TargetInfo>(triple) {
2606 }
2607
2608 virtual unsigned getFloatEvalMethod() const {
2609 // NetBSD defaults to "double" rounding
2610 return 1;
2611 }
2612};
2613} // end anonymous namespace
2614
2615namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002616class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2617public:
2618 OpenBSDI386TargetInfo(const std::string& triple) :
2619 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2620 SizeType = UnsignedLong;
2621 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002622 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002623 }
2624};
2625} // end anonymous namespace
2626
2627namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00002628class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
2629public:
2630 BitrigI386TargetInfo(const std::string& triple) :
2631 BitrigTargetInfo<X86_32TargetInfo>(triple) {
2632 SizeType = UnsignedLong;
2633 IntPtrType = SignedLong;
2634 PtrDiffType = SignedLong;
2635 }
2636};
2637} // end anonymous namespace
2638
2639namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002640class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002641public:
Torok Edwin5f6c1942009-06-30 17:10:35 +00002642 DarwinI386TargetInfo(const std::string& triple) :
2643 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002644 LongDoubleWidth = 128;
2645 LongDoubleAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002646 SuitableAlign = 128;
Chad Rosierf9e9af72012-07-13 23:57:43 +00002647 MaxVectorAlign = 256;
Eli Friedman1afabd92009-03-29 20:31:09 +00002648 SizeType = UnsignedLong;
2649 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002650 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2651 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002652 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002653 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002654 }
2655
Eli Friedman618234a2008-08-20 02:34:37 +00002656};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002657} // end anonymous namespace
2658
2659namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002660// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002661class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002662public:
2663 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002664 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002665 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002666 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002667 DoubleAlign = LongLongAlign = 64;
2668 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 +00002669 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002670 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002671 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002672 virtual void getTargetDefines(const LangOptions &Opts,
2673 MacroBuilder &Builder) const {
2674 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2675 }
2676};
2677} // end anonymous namespace
2678
2679namespace {
2680
2681// x86-32 Windows Visual Studio target
2682class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2683public:
2684 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2685 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002686 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002687 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2688 }
2689 virtual void getTargetDefines(const LangOptions &Opts,
2690 MacroBuilder &Builder) const {
2691 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2692 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2693 // The value of the following reflects processor type.
2694 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2695 // We lost the original triple, so we use the default.
2696 Builder.defineMacro("_M_IX86", "600");
2697 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002698};
2699} // end anonymous namespace
2700
2701namespace {
2702// x86-32 MinGW target
2703class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2704public:
2705 MinGWX86_32TargetInfo(const std::string& triple)
2706 : WindowsX86_32TargetInfo(triple) {
2707 }
2708 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002709 MacroBuilder &Builder) const {
2710 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002711 DefineStd(Builder, "WIN32", Opts);
2712 DefineStd(Builder, "WINNT", Opts);
2713 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002714 Builder.defineMacro("__MSVCRT__");
2715 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002716
2717 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2718 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002719 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002720 // Provide "as-is" __declspec.
2721 Builder.defineMacro("__declspec", "__declspec");
2722 else
2723 // Provide alias of __attribute__ like mingw32-gcc.
2724 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002725 }
2726};
2727} // end anonymous namespace
2728
2729namespace {
2730// x86-32 Cygwin target
2731class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2732public:
2733 CygwinX86_32TargetInfo(const std::string& triple)
2734 : X86_32TargetInfo(triple) {
2735 TLSSupported = false;
2736 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002737 DoubleAlign = LongLongAlign = 64;
2738 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2739 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002740 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002741 }
2742 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002743 MacroBuilder &Builder) const {
2744 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2745 Builder.defineMacro("__CYGWIN__");
2746 Builder.defineMacro("__CYGWIN32__");
2747 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00002748 if (Opts.CPlusPlus)
2749 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00002750 }
Eli Friedman29a30502008-08-21 01:40:19 +00002751};
2752} // end anonymous namespace
2753
2754namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002755// x86-32 Haiku target
2756class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2757public:
2758 HaikuX86_32TargetInfo(const std::string& triple)
2759 : X86_32TargetInfo(triple) {
2760 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00002761 IntPtrType = SignedLong;
2762 PtrDiffType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00002763 this->UserLabelPrefix = "";
Benjamin Krameref7bcea2012-11-08 12:59:15 +00002764 this->TLSSupported = false;
Eli Friedmana7e68452010-08-22 01:00:03 +00002765 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00002766 virtual void getTargetDefines(const LangOptions &Opts,
2767 MacroBuilder &Builder) const {
2768 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2769 Builder.defineMacro("__INTEL__");
2770 Builder.defineMacro("__HAIKU__");
2771 }
2772};
2773} // end anonymous namespace
2774
Douglas Gregordca52262011-07-01 22:41:14 +00002775// RTEMS Target
2776template<typename Target>
2777class RTEMSTargetInfo : public OSTargetInfo<Target> {
2778protected:
2779 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2780 MacroBuilder &Builder) const {
2781 // RTEMS defines; list based off of gcc output
2782
Douglas Gregordca52262011-07-01 22:41:14 +00002783 Builder.defineMacro("__rtems__");
2784 Builder.defineMacro("__ELF__");
2785 }
2786public:
2787 RTEMSTargetInfo(const std::string &triple)
2788 : OSTargetInfo<Target>(triple) {
2789 this->UserLabelPrefix = "";
2790
2791 llvm::Triple Triple(triple);
2792 switch (Triple.getArch()) {
2793 default:
2794 case llvm::Triple::x86:
2795 // this->MCountName = ".mcount";
2796 break;
2797 case llvm::Triple::mips:
2798 case llvm::Triple::mipsel:
2799 case llvm::Triple::ppc:
2800 case llvm::Triple::ppc64:
2801 // this->MCountName = "_mcount";
2802 break;
2803 case llvm::Triple::arm:
2804 // this->MCountName = "__mcount";
2805 break;
2806 }
2807
2808 }
2809};
2810
2811namespace {
2812// x86-32 RTEMS target
2813class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2814public:
2815 RTEMSX86_32TargetInfo(const std::string& triple)
2816 : X86_32TargetInfo(triple) {
2817 SizeType = UnsignedLong;
2818 IntPtrType = SignedLong;
2819 PtrDiffType = SignedLong;
2820 this->UserLabelPrefix = "";
2821 }
2822 virtual void getTargetDefines(const LangOptions &Opts,
2823 MacroBuilder &Builder) const {
2824 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2825 Builder.defineMacro("__INTEL__");
2826 Builder.defineMacro("__rtems__");
2827 }
2828};
2829} // end anonymous namespace
2830
Chris Lattner86ed3a32010-04-11 19:29:39 +00002831namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002832// x86-64 generic target
2833class X86_64TargetInfo : public X86TargetInfo {
2834public:
Chris Lattner33328642009-03-20 15:52:06 +00002835 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00002836 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002837 LongDoubleWidth = 128;
2838 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00002839 LargeArrayMinWidth = 128;
2840 LargeArrayAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002841 SuitableAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00002842 IntMaxType = SignedLong;
2843 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002844 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002845 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00002846
Eli Friedmaned855cb2008-08-21 00:13:15 +00002847 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2848 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002849 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002850
2851 // Use fpret only for long double.
2852 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00002853
Anders Carlssoneea64802011-10-31 16:27:11 +00002854 // Use fp2ret for _Complex long double.
2855 ComplexLongDoubleUsesFP2Ret = true;
2856
Eli Friedman2be46072011-10-14 20:59:01 +00002857 // x86-64 has atomics up to 16 bytes.
2858 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
2859 // on CPUs with cmpxchg16b
2860 MaxAtomicPromoteWidth = 128;
2861 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00002862 }
Meador Ingec5613b22012-06-16 03:34:49 +00002863 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2864 return TargetInfo::X86_64ABIBuiltinVaList;
Anders Carlsson3346ae62007-11-24 23:38:12 +00002865 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002866
Chris Lattner21fb98e2009-09-23 06:06:36 +00002867 int getEHDataRegisterNumber(unsigned RegNo) const {
2868 if (RegNo == 0) return 0;
2869 if (RegNo == 1) return 1;
2870 return -1;
2871 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00002872
2873 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
2874 return TargetInfo::checkCallingConvention(CC);
2875 }
2876
2877 virtual CallingConv getDefaultCallingConv() const {
2878 return CC_Default;
2879 }
2880
Eli Friedman618234a2008-08-20 02:34:37 +00002881};
2882} // end anonymous namespace
2883
2884namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002885// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002886class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002887public:
2888 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002889 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002890 TLSSupported = false;
2891 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00002892 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00002893 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00002894 IntMaxType = SignedLongLong;
2895 UIntMaxType = UnsignedLongLong;
2896 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00002897 SizeType = UnsignedLongLong;
2898 PtrDiffType = SignedLongLong;
2899 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00002900 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002901 }
2902 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002903 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002904 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002905 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00002906 }
Meador Ingec5613b22012-06-16 03:34:49 +00002907 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2908 return TargetInfo::CharPtrBuiltinVaList;
NAKAMURA Takumi79521992011-01-17 22:56:23 +00002909 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002910};
2911} // end anonymous namespace
2912
2913namespace {
2914// x86-64 Windows Visual Studio target
2915class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2916public:
2917 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2918 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002919 LongDoubleWidth = LongDoubleAlign = 64;
2920 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00002921 }
2922 virtual void getTargetDefines(const LangOptions &Opts,
2923 MacroBuilder &Builder) const {
2924 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
2925 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00002926 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002927 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002928 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002929};
2930} // end anonymous namespace
2931
2932namespace {
2933// x86-64 MinGW target
2934class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2935public:
2936 MinGWX86_64TargetInfo(const std::string& triple)
2937 : WindowsX86_64TargetInfo(triple) {
2938 }
2939 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002940 MacroBuilder &Builder) const {
2941 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002942 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00002943 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00002944 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00002945 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002946
2947 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2948 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002949 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002950 // Provide "as-is" __declspec.
2951 Builder.defineMacro("__declspec", "__declspec");
2952 else
2953 // Provide alias of __attribute__ like mingw32-gcc.
2954 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002955 }
2956};
2957} // end anonymous namespace
2958
2959namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002960class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2961public:
Mike Stump1eb44332009-09-09 15:08:12 +00002962 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002963 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2964 Int64Type = SignedLongLong;
Chad Rosierf9e9af72012-07-13 23:57:43 +00002965 MaxVectorAlign = 256;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002966 }
2967};
2968} // end anonymous namespace
2969
2970namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00002971class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
2972public:
Mike Stump1eb44332009-09-09 15:08:12 +00002973 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman6036ebe2009-07-05 22:31:18 +00002974 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
2975 IntMaxType = SignedLongLong;
2976 UIntMaxType = UnsignedLongLong;
2977 Int64Type = SignedLongLong;
2978 }
2979};
2980} // end anonymous namespace
2981
2982namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00002983class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
2984public:
2985 BitrigX86_64TargetInfo(const std::string& triple)
2986 : BitrigTargetInfo<X86_64TargetInfo>(triple) {
2987 IntMaxType = SignedLongLong;
2988 UIntMaxType = UnsignedLongLong;
2989 Int64Type = SignedLongLong;
2990 }
2991};
2992} // end anonymous namespace
2993
2994namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00002995class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002996 // Possible FPU choices.
2997 enum FPUMode {
Bob Wilsoncfaab002012-09-29 23:52:52 +00002998 VFP2FPU = (1 << 0),
2999 VFP3FPU = (1 << 1),
3000 VFP4FPU = (1 << 2),
3001 NeonFPU = (1 << 3)
Daniel Dunbara91320b2009-12-21 23:28:17 +00003002 };
3003
3004 static bool FPUModeIsVFP(FPUMode Mode) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003005 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU);
Daniel Dunbara91320b2009-12-21 23:28:17 +00003006 }
3007
3008 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3009 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003010
Daniel Dunbareac7c532009-12-18 18:42:37 +00003011 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003012
Bob Wilsoncfaab002012-09-29 23:52:52 +00003013 unsigned FPU : 4;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003014
Logan Chieneae5a8202012-10-10 06:56:20 +00003015 unsigned IsAAPCS : 1;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003016 unsigned IsThumb : 1;
3017
3018 // Initialized via features.
3019 unsigned SoftFloat : 1;
3020 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003021
Chris Lattner2752c012010-03-03 19:03:45 +00003022 static const Builtin::Info BuiltinInfo[];
3023
Chris Lattner393ff042008-04-21 18:56:49 +00003024public:
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003025 ARMTargetInfo(const std::string &TripleStr)
Logan Chieneae5a8202012-10-10 06:56:20 +00003026 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s"), IsAAPCS(true)
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003027 {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003028 BigEndian = false;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003029 SizeType = UnsignedInt;
3030 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00003031 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
3032 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003033
Chris Lattner9bffb072010-04-23 16:29:58 +00003034 // {} in inline assembly are neon specifiers, not assembly variant
3035 // specifiers.
3036 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00003037
Daniel Dunbareac7c532009-12-18 18:42:37 +00003038 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00003039 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003040 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003041 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3042 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003043 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
3044 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003045 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003046 } else {
3047 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3048 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003049 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003050 }
John McCallee79a4c2010-08-21 22:46:04 +00003051
3052 // ARM targets default to using the ARM C++ ABI.
3053 CXXABI = CXXABI_ARM;
Eli Friedman2be46072011-10-14 20:59:01 +00003054
3055 // ARM has atomics up to 8 bytes
3056 // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e
3057 MaxAtomicPromoteWidth = 64;
James Molloye45b9b72012-03-12 09:14:10 +00003058
3059 // Do force alignment of members that follow zero length bitfields. If
3060 // the alignment of the zero-length bitfield is greater than the member
3061 // that follows it, `bar', `bar' will be aligned as the type of the
3062 // zero length bitfield.
3063 UseZeroLengthBitfieldAlignment = true;
Eli Friedman61538a72008-05-20 14:21:01 +00003064 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003065 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00003066 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003067 ABI = Name;
3068
Daniel Dunbara2a41612009-09-14 00:02:24 +00003069 // The defaults (above) are for AAPCS, check if we need to change them.
3070 //
3071 // FIXME: We need support for -meabi... we could just mangle it into the
3072 // name.
3073 if (Name == "apcs-gnu") {
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003074 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003075 SizeType = UnsignedLong;
3076
James Molloya6d81f92011-11-23 13:35:08 +00003077 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
3078 WCharType = SignedInt;
3079
Daniel Dunbar684de632010-04-22 16:14:54 +00003080 // Do not respect the alignment of bit-field types when laying out
3081 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
3082 UseBitFieldTypeAlignment = false;
3083
Chad Rosier61a62212011-08-04 01:21:14 +00003084 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00003085 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
3086 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00003087 ZeroLengthBitfieldBoundary = 32;
3088
Logan Chieneae5a8202012-10-10 06:56:20 +00003089 IsAAPCS = false;
3090
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003091 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003092 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3093 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003094 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 +00003095 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003096 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003097 } else {
3098 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 +00003099 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003100 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003101 }
3102
Chad Rosier9f1210c2011-07-26 07:03:04 +00003103 // FIXME: Override "preferred align" for double and long long.
David Tweedb16abb12012-10-25 13:33:01 +00003104 } else if (Name == "aapcs" || Name == "aapcs-vfp") {
Logan Chieneae5a8202012-10-10 06:56:20 +00003105 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003106 // FIXME: Enumerated types are variable width in straight AAPCS.
3107 } else if (Name == "aapcs-linux") {
Logan Chieneae5a8202012-10-10 06:56:20 +00003108 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003109 } else
3110 return false;
3111
3112 return true;
3113 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003114
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003115 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003116 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
3117 Features["vfp2"] = true;
Bob Wilsoncfaab002012-09-29 23:52:52 +00003118 else if (CPU == "cortex-a8" || CPU == "cortex-a15" ||
3119 CPU == "cortex-a9" || CPU == "cortex-a9-mp")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003120 Features["neon"] = true;
Bob Wilsoncfaab002012-09-29 23:52:52 +00003121 else if (CPU == "swift") {
3122 Features["vfp4"] = true;
3123 Features["neon"] = true;
3124 }
Daniel Dunbara91320b2009-12-21 23:28:17 +00003125 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003126
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003127 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00003128 StringRef Name,
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003129 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00003130 if (Name == "soft-float" || Name == "soft-float-abi" ||
Bob Wilsoncfaab002012-09-29 23:52:52 +00003131 Name == "vfp2" || Name == "vfp3" || Name == "vfp4" || Name == "neon" ||
3132 Name == "d16" || Name == "neonfp") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003133 Features[Name] = Enabled;
3134 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003135 return false;
3136
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003137 return true;
3138 }
3139
3140 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003141 FPU = 0;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003142 SoftFloat = SoftFloatABI = false;
3143 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
3144 if (Features[i] == "+soft-float")
3145 SoftFloat = true;
3146 else if (Features[i] == "+soft-float-abi")
3147 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003148 else if (Features[i] == "+vfp2")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003149 FPU |= VFP2FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003150 else if (Features[i] == "+vfp3")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003151 FPU |= VFP3FPU;
3152 else if (Features[i] == "+vfp4")
3153 FPU |= VFP4FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003154 else if (Features[i] == "+neon")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003155 FPU |= NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003156 }
3157
3158 // Remove front-end specific options which the backend handles differently.
3159 std::vector<std::string>::iterator it;
3160 it = std::find(Features.begin(), Features.end(), "+soft-float");
3161 if (it != Features.end())
3162 Features.erase(it);
3163 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
3164 if (it != Features.end())
3165 Features.erase(it);
3166 }
3167
Douglas Gregore727d212012-01-30 06:38:25 +00003168 virtual bool hasFeature(StringRef Feature) const {
3169 return llvm::StringSwitch<bool>(Feature)
3170 .Case("arm", true)
3171 .Case("softfloat", SoftFloat)
3172 .Case("thumb", IsThumb)
3173 .Case("neon", FPU == NeonFPU && !SoftFloat &&
3174 StringRef(getCPUDefineSuffix(CPU)).startswith("7"))
3175 .Default(false);
3176 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003177 // FIXME: Should we actually have some table instead of these switches?
Chris Lattner5f9e2722011-07-23 10:55:15 +00003178 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00003179 return llvm::StringSwitch<const char*>(Name)
3180 .Cases("arm8", "arm810", "4")
3181 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
3182 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
3183 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
3184 .Case("ep9312", "4T")
3185 .Cases("arm10tdmi", "arm1020t", "5T")
3186 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
3187 .Case("arm926ej-s", "5TEJ")
3188 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
3189 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003190 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003191 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003192 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003193 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
Silviu Baranga2df67ea2012-09-13 15:06:00 +00003194 .Cases("cortex-a8", "cortex-a9", "cortex-a15", "7A")
Bob Wilson336bfa32012-09-29 23:52:50 +00003195 .Case("cortex-a9-mp", "7F")
3196 .Case("swift", "7S")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003197 .Cases("cortex-m3", "cortex-m4", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00003198 .Case("cortex-m0", "6M")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003199 .Default(0);
3200 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003201 static const char *getCPUProfile(StringRef Name) {
3202 return llvm::StringSwitch<const char*>(Name)
3203 .Cases("cortex-a8", "cortex-a9", "A")
3204 .Cases("cortex-m3", "cortex-m4", "cortex-m0", "M")
Anton Korobeynikov8b0703d2012-09-08 08:22:13 +00003205 .Default("");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003206 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003207 virtual bool setCPU(const std::string &Name) {
3208 if (!getCPUDefineSuffix(Name))
3209 return false;
3210
3211 CPU = Name;
3212 return true;
3213 }
Chris Lattner33328642009-03-20 15:52:06 +00003214 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003215 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00003216 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00003217 Builder.defineMacro("__arm");
3218 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003219
Chris Lattnerc0f59212009-03-02 22:27:17 +00003220 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00003221 Builder.defineMacro("__ARMEL__");
3222 Builder.defineMacro("__LITTLE_ENDIAN__");
3223 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003224
Chris Lattner5f9e2722011-07-23 10:55:15 +00003225 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00003226 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003227 Builder.defineMacro("__ARM_ARCH", CPUArch.substr(0, 1));
3228 StringRef CPUProfile = getCPUProfile(CPU);
3229 if (!CPUProfile.empty())
3230 Builder.defineMacro("__ARM_ARCH_PROFILE", CPUProfile);
3231
Mike Stump437bb4b2009-04-08 02:07:04 +00003232 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003233
Daniel Dunbareac7c532009-12-18 18:42:37 +00003234 // FIXME: It's more complicated than this and we don't really support
3235 // interworking.
3236 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00003237 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003238
David Tweedb16abb12012-10-25 13:33:01 +00003239 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
Daniel Dunbar849289e2012-10-22 18:51:13 +00003240 // M-class CPUs on Darwin follow AAPCS, but not EABI.
Daniel Dunbar4d3ee9b2012-10-22 18:56:43 +00003241 if (!(getTriple().isOSDarwin() && CPUProfile == "M"))
Daniel Dunbar849289e2012-10-22 18:51:13 +00003242 Builder.defineMacro("__ARM_EABI__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003243 Builder.defineMacro("__ARM_PCS", "1");
3244
David Tweedb16abb12012-10-25 13:33:01 +00003245 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003246 Builder.defineMacro("__ARM_PCS_VFP", "1");
3247 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003248
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003249 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00003250 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003251
3252 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00003253 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003254
Bob Wilson84f95cf2011-05-13 18:56:03 +00003255 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003256 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003257 Builder.defineMacro("__THUMBEL__");
3258 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00003259 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003260 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003261 }
3262
3263 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00003264 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00003265
Bob Wilsoncfaab002012-09-29 23:52:52 +00003266 if (FPUModeIsVFP((FPUMode) FPU)) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003267 Builder.defineMacro("__VFP_FP__");
Bob Wilsoncfaab002012-09-29 23:52:52 +00003268 if (FPU & VFP2FPU)
3269 Builder.defineMacro("__ARM_VFPV2__");
3270 if (FPU & VFP3FPU)
3271 Builder.defineMacro("__ARM_VFPV3__");
3272 if (FPU & VFP4FPU)
3273 Builder.defineMacro("__ARM_VFPV4__");
3274 }
3275
Daniel Dunbara91320b2009-12-21 23:28:17 +00003276 // This only gets set when Neon instructions are actually available, unlike
3277 // the VFP define, hence the soft float and arch check. This is subtly
3278 // different from gcc, we follow the intent which was that it should be set
3279 // when Neon instructions are actually available.
Bob Wilsoncfaab002012-09-29 23:52:52 +00003280 if ((FPU & NeonFPU) && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003281 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00003282 }
3283 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3284 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00003285 Records = BuiltinInfo;
3286 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00003287 }
Bob Wilson8b30a932012-01-26 22:14:27 +00003288 virtual bool isCLZForZeroUndef() const { return false; }
Meador Ingec5613b22012-06-16 03:34:49 +00003289 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Logan Chieneae5a8202012-10-10 06:56:20 +00003290 return IsAAPCS ? AAPCSABIBuiltinVaList : TargetInfo::VoidPtrBuiltinVaList;
Chris Lattner393ff042008-04-21 18:56:49 +00003291 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003292 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003293 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003294 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003295 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003296 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00003297 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003298 switch (*Name) {
Eric Christophera0dfca12012-08-16 23:50:41 +00003299 default: break;
Nate Begemanad487f42008-04-22 05:03:19 +00003300 case 'l': // r0-r7
3301 case 'h': // r8-r15
3302 case 'w': // VFP Floating point register single precision
3303 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00003304 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00003305 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00003306 case 'Q': // A memory address that is a single base register.
3307 Info.setAllowsMemory();
3308 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00003309 case 'U': // a memory reference...
3310 switch (Name[1]) {
3311 case 'q': // ...ARMV4 ldrsb
3312 case 'v': // ...VFP load/store (reg+constant offset)
3313 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00003314 case 't': // address valid for load/store opaque types wider
3315 // than 128-bits
3316 case 'n': // valid address for Neon doubleword vector load/store
3317 case 'm': // valid address for Neon element and structure load/store
3318 case 's': // valid address for non-offset loads/stores of quad-word
3319 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00003320 Info.setAllowsMemory();
3321 Name++;
3322 return true;
3323 }
Nate Begemanad487f42008-04-22 05:03:19 +00003324 }
Chris Lattner393ff042008-04-21 18:56:49 +00003325 return false;
3326 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00003327 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00003328 std::string R;
3329 switch (*Constraint) {
3330 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00003331 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00003332 Constraint++;
3333 break;
Eric Christopher283f4472011-06-17 00:40:18 +00003334 case 'p': // 'p' should be translated to 'r' by default.
3335 R = std::string("r");
3336 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00003337 default:
3338 return std::string(1, *Constraint);
3339 }
3340 return R;
3341 }
Bill Wendling50d46ca2012-10-25 23:28:48 +00003342 virtual bool validateConstraintModifier(StringRef Constraint,
3343 const char Modifier,
3344 unsigned Size) const {
3345 // Strip off constraint modifiers.
3346 while (Constraint[0] == '=' ||
3347 Constraint[0] == '+' ||
3348 Constraint[0] == '&')
3349 Constraint = Constraint.substr(1);
3350
3351 switch (Constraint[0]) {
3352 default: break;
3353 case 'r': {
3354 switch (Modifier) {
3355 default:
3356 return Size == 32;
3357 case 'q':
3358 // A register of size 32 cannot fit a vector type.
3359 return false;
3360 }
3361 }
3362 }
3363
3364 return true;
3365 }
Chris Lattner393ff042008-04-21 18:56:49 +00003366 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00003367 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00003368 return "";
3369 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00003370
3371 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
3372 return (CC == CC_AAPCS || CC == CC_AAPCS_VFP) ? CCCR_OK : CCCR_Warning;
3373 }
Chris Lattner393ff042008-04-21 18:56:49 +00003374};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003375
3376const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003377 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003378 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003379 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
3380
3381 // Float registers
3382 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3383 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3384 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003385 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003386
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003387 // Double registers
3388 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3389 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00003390 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3391 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003392
3393 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00003394 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3395 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003396};
3397
3398void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003399 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003400 Names = GCCRegNames;
3401 NumNames = llvm::array_lengthof(GCCRegNames);
3402}
3403
3404const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003405 { { "a1" }, "r0" },
3406 { { "a2" }, "r1" },
3407 { { "a3" }, "r2" },
3408 { { "a4" }, "r3" },
3409 { { "v1" }, "r4" },
3410 { { "v2" }, "r5" },
3411 { { "v3" }, "r6" },
3412 { { "v4" }, "r7" },
3413 { { "v5" }, "r8" },
3414 { { "v6", "rfp" }, "r9" },
3415 { { "sl" }, "r10" },
3416 { { "fp" }, "r11" },
3417 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003418 { { "r13" }, "sp" },
3419 { { "r14" }, "lr" },
3420 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003421 // The S, D and Q registers overlap, but aren't really aliases; we
3422 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003423};
3424
3425void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3426 unsigned &NumAliases) const {
3427 Aliases = GCCRegAliases;
3428 NumAliases = llvm::array_lengthof(GCCRegAliases);
3429}
Chris Lattner2752c012010-03-03 19:03:45 +00003430
3431const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00003432#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00003433#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00003434 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00003435#include "clang/Basic/BuiltinsARM.def"
3436};
Chris Lattner393ff042008-04-21 18:56:49 +00003437} // end anonymous namespace.
3438
Eli Friedmana9f54962008-08-20 07:44:10 +00003439namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00003440class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003441 public DarwinTargetInfo<ARMTargetInfo> {
3442protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00003443 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00003444 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00003445 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00003446 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003447
Torok Edwin5f6c1942009-06-30 17:10:35 +00003448public:
Mike Stump1eb44332009-09-09 15:08:12 +00003449 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003450 : DarwinTargetInfo<ARMTargetInfo>(triple) {
3451 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00003452 // iOS always has 64-bit atomic instructions.
3453 // FIXME: This should be based off of the target features in ARMTargetInfo.
3454 MaxAtomicInlineWidth = 64;
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003455 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003456};
3457} // end anonymous namespace.
3458
Tony Linthicum96319392011-12-12 21:14:55 +00003459
3460namespace {
3461// Hexagon abstract base class
3462class HexagonTargetInfo : public TargetInfo {
3463 static const Builtin::Info BuiltinInfo[];
3464 static const char * const GCCRegNames[];
3465 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3466 std::string CPU;
3467public:
3468 HexagonTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003469 BigEndian = false;
Tony Linthicum96319392011-12-12 21:14:55 +00003470 DescriptionString = ("e-p:32:32:32-"
Sirish Pande5f9688b2012-05-10 20:19:54 +00003471 "i64:64:64-i32:32:32-i16:16:16-i1:32:32"
3472 "f64:64:64-f32:32:32-a0:0-n32");
Tony Linthicum96319392011-12-12 21:14:55 +00003473
3474 // {} in inline assembly are packet specifiers, not assembly variant
3475 // specifiers.
3476 NoAsmVariants = true;
3477 }
3478
3479 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3480 unsigned &NumRecords) const {
3481 Records = BuiltinInfo;
3482 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
3483 }
3484
3485 virtual bool validateAsmConstraint(const char *&Name,
3486 TargetInfo::ConstraintInfo &Info) const {
3487 return true;
3488 }
3489
3490 virtual void getTargetDefines(const LangOptions &Opts,
3491 MacroBuilder &Builder) const;
3492
Douglas Gregore727d212012-01-30 06:38:25 +00003493 virtual bool hasFeature(StringRef Feature) const {
3494 return Feature == "hexagon";
3495 }
3496
Meador Ingec5613b22012-06-16 03:34:49 +00003497 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3498 return TargetInfo::CharPtrBuiltinVaList;
Tony Linthicum96319392011-12-12 21:14:55 +00003499 }
3500 virtual void getGCCRegNames(const char * const *&Names,
3501 unsigned &NumNames) const;
3502 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3503 unsigned &NumAliases) const;
3504 virtual const char *getClobbers() const {
3505 return "";
3506 }
Sebastian Pop43115d42012-01-13 20:37:10 +00003507
3508 static const char *getHexagonCPUSuffix(StringRef Name) {
3509 return llvm::StringSwitch<const char*>(Name)
3510 .Case("hexagonv2", "2")
3511 .Case("hexagonv3", "3")
3512 .Case("hexagonv4", "4")
Sirish Pande5f9688b2012-05-10 20:19:54 +00003513 .Case("hexagonv5", "5")
Sebastian Pop43115d42012-01-13 20:37:10 +00003514 .Default(0);
3515 }
3516
Tony Linthicum96319392011-12-12 21:14:55 +00003517 virtual bool setCPU(const std::string &Name) {
Sebastian Pop43115d42012-01-13 20:37:10 +00003518 if (!getHexagonCPUSuffix(Name))
3519 return false;
3520
Tony Linthicum96319392011-12-12 21:14:55 +00003521 CPU = Name;
3522 return true;
3523 }
3524};
3525
3526void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
3527 MacroBuilder &Builder) const {
3528 Builder.defineMacro("qdsp6");
3529 Builder.defineMacro("__qdsp6", "1");
3530 Builder.defineMacro("__qdsp6__", "1");
3531
3532 Builder.defineMacro("hexagon");
3533 Builder.defineMacro("__hexagon", "1");
3534 Builder.defineMacro("__hexagon__", "1");
3535
3536 if(CPU == "hexagonv1") {
3537 Builder.defineMacro("__HEXAGON_V1__");
3538 Builder.defineMacro("__HEXAGON_ARCH__", "1");
3539 if(Opts.HexagonQdsp6Compat) {
3540 Builder.defineMacro("__QDSP6_V1__");
3541 Builder.defineMacro("__QDSP6_ARCH__", "1");
3542 }
3543 }
3544 else if(CPU == "hexagonv2") {
3545 Builder.defineMacro("__HEXAGON_V2__");
3546 Builder.defineMacro("__HEXAGON_ARCH__", "2");
3547 if(Opts.HexagonQdsp6Compat) {
3548 Builder.defineMacro("__QDSP6_V2__");
3549 Builder.defineMacro("__QDSP6_ARCH__", "2");
3550 }
3551 }
3552 else if(CPU == "hexagonv3") {
3553 Builder.defineMacro("__HEXAGON_V3__");
3554 Builder.defineMacro("__HEXAGON_ARCH__", "3");
3555 if(Opts.HexagonQdsp6Compat) {
3556 Builder.defineMacro("__QDSP6_V3__");
3557 Builder.defineMacro("__QDSP6_ARCH__", "3");
3558 }
3559 }
3560 else if(CPU == "hexagonv4") {
3561 Builder.defineMacro("__HEXAGON_V4__");
3562 Builder.defineMacro("__HEXAGON_ARCH__", "4");
3563 if(Opts.HexagonQdsp6Compat) {
3564 Builder.defineMacro("__QDSP6_V4__");
3565 Builder.defineMacro("__QDSP6_ARCH__", "4");
3566 }
3567 }
Sirish Pande5f9688b2012-05-10 20:19:54 +00003568 else if(CPU == "hexagonv5") {
3569 Builder.defineMacro("__HEXAGON_V5__");
3570 Builder.defineMacro("__HEXAGON_ARCH__", "5");
3571 if(Opts.HexagonQdsp6Compat) {
3572 Builder.defineMacro("__QDSP6_V5__");
3573 Builder.defineMacro("__QDSP6_ARCH__", "5");
3574 }
3575 }
Tony Linthicum96319392011-12-12 21:14:55 +00003576}
3577
3578const char * const HexagonTargetInfo::GCCRegNames[] = {
3579 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3580 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3581 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3582 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
3583 "p0", "p1", "p2", "p3",
3584 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
3585};
3586
3587void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
3588 unsigned &NumNames) const {
3589 Names = GCCRegNames;
3590 NumNames = llvm::array_lengthof(GCCRegNames);
3591}
3592
3593
3594const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
3595 { { "sp" }, "r29" },
3596 { { "fp" }, "r30" },
3597 { { "lr" }, "r31" },
3598 };
3599
3600void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3601 unsigned &NumAliases) const {
3602 Aliases = GCCRegAliases;
3603 NumAliases = llvm::array_lengthof(GCCRegAliases);
3604}
3605
3606
3607const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
3608#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3609#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3610 ALL_LANGUAGES },
3611#include "clang/Basic/BuiltinsHexagon.def"
3612};
3613}
3614
3615
Reid Spencer5f016e22007-07-11 17:01:13 +00003616namespace {
Eli Friedman01b86682008-08-20 07:28:14 +00003617class SparcV8TargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00003618 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3619 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003620 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00003621public:
Eli Friedman01b86682008-08-20 07:28:14 +00003622 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
3623 // FIXME: Support Sparc quad-precision long double?
Eli Friedmaned855cb2008-08-21 00:13:15 +00003624 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 +00003625 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedman01b86682008-08-20 07:28:14 +00003626 }
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003627 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00003628 StringRef Name,
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003629 bool Enabled) const {
3630 if (Name == "soft-float")
3631 Features[Name] = Enabled;
3632 else
3633 return false;
3634
3635 return true;
3636 }
3637 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
3638 SoftFloat = false;
3639 for (unsigned i = 0, e = Features.size(); i != e; ++i)
3640 if (Features[i] == "+soft-float")
3641 SoftFloat = true;
3642 }
Chris Lattner33328642009-03-20 15:52:06 +00003643 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003644 MacroBuilder &Builder) const {
3645 DefineStd(Builder, "sparc", Opts);
3646 Builder.defineMacro("__sparcv8");
3647 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003648
3649 if (SoftFloat)
3650 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00003651 }
Douglas Gregore727d212012-01-30 06:38:25 +00003652
3653 virtual bool hasFeature(StringRef Feature) const {
3654 return llvm::StringSwitch<bool>(Feature)
3655 .Case("softfloat", SoftFloat)
3656 .Case("sparc", true)
3657 .Default(false);
3658 }
3659
Gabor Greif26658672008-02-21 16:29:08 +00003660 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3661 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003662 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00003663 }
Meador Ingec5613b22012-06-16 03:34:49 +00003664 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3665 return TargetInfo::VoidPtrBuiltinVaList;
Gabor Greif26658672008-02-21 16:29:08 +00003666 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003667 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003668 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003669 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003670 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003671 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00003672 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003673 // FIXME: Implement!
3674 return false;
Gabor Greif26658672008-02-21 16:29:08 +00003675 }
3676 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00003677 // FIXME: Implement!
3678 return "";
Gabor Greif26658672008-02-21 16:29:08 +00003679 }
3680};
3681
Chris Lattnere957f532009-01-27 01:58:38 +00003682const char * const SparcV8TargetInfo::GCCRegNames[] = {
3683 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3684 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3685 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3686 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
3687};
3688
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003689void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003690 unsigned &NumNames) const {
3691 Names = GCCRegNames;
3692 NumNames = llvm::array_lengthof(GCCRegNames);
3693}
3694
3695const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003696 { { "g0" }, "r0" },
3697 { { "g1" }, "r1" },
3698 { { "g2" }, "r2" },
3699 { { "g3" }, "r3" },
3700 { { "g4" }, "r4" },
3701 { { "g5" }, "r5" },
3702 { { "g6" }, "r6" },
3703 { { "g7" }, "r7" },
3704 { { "o0" }, "r8" },
3705 { { "o1" }, "r9" },
3706 { { "o2" }, "r10" },
3707 { { "o3" }, "r11" },
3708 { { "o4" }, "r12" },
3709 { { "o5" }, "r13" },
3710 { { "o6", "sp" }, "r14" },
3711 { { "o7" }, "r15" },
3712 { { "l0" }, "r16" },
3713 { { "l1" }, "r17" },
3714 { { "l2" }, "r18" },
3715 { { "l3" }, "r19" },
3716 { { "l4" }, "r20" },
3717 { { "l5" }, "r21" },
3718 { { "l6" }, "r22" },
3719 { { "l7" }, "r23" },
3720 { { "i0" }, "r24" },
3721 { { "i1" }, "r25" },
3722 { { "i2" }, "r26" },
3723 { { "i3" }, "r27" },
3724 { { "i4" }, "r28" },
3725 { { "i5" }, "r29" },
3726 { { "i6", "fp" }, "r30" },
3727 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00003728};
3729
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003730void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003731 unsigned &NumAliases) const {
3732 Aliases = GCCRegAliases;
3733 NumAliases = llvm::array_lengthof(GCCRegAliases);
3734}
Gabor Greif26658672008-02-21 16:29:08 +00003735} // end anonymous namespace.
3736
Eli Friedman01b86682008-08-20 07:28:14 +00003737namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003738class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
3739public:
3740 AuroraUXSparcV8TargetInfo(const std::string& triple) :
3741 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
3742 SizeType = UnsignedInt;
3743 PtrDiffType = SignedInt;
3744 }
3745};
Torok Edwin5f6c1942009-06-30 17:10:35 +00003746class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00003747public:
3748 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003749 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00003750 SizeType = UnsignedInt;
3751 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00003752 }
3753};
3754} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00003755
Chris Lattner2621fd12008-05-08 05:58:21 +00003756namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003757 class MSP430TargetInfo : public TargetInfo {
3758 static const char * const GCCRegNames[];
3759 public:
3760 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003761 BigEndian = false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003762 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00003763 IntWidth = 16; IntAlign = 16;
3764 LongWidth = 32; LongLongWidth = 64;
3765 LongAlign = LongLongAlign = 16;
3766 PointerWidth = 16; PointerAlign = 16;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003767 SuitableAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003768 SizeType = UnsignedInt;
3769 IntMaxType = SignedLong;
3770 UIntMaxType = UnsignedLong;
3771 IntPtrType = SignedShort;
3772 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00003773 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00003774 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003775 }
3776 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003777 MacroBuilder &Builder) const {
3778 Builder.defineMacro("MSP430");
3779 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003780 // FIXME: defines for different 'flavours' of MCU
3781 }
3782 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3783 unsigned &NumRecords) const {
3784 // FIXME: Implement.
3785 Records = 0;
3786 NumRecords = 0;
3787 }
Douglas Gregore727d212012-01-30 06:38:25 +00003788 virtual bool hasFeature(StringRef Feature) const {
3789 return Feature == "msp430";
3790 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003791 virtual void getGCCRegNames(const char * const *&Names,
3792 unsigned &NumNames) const;
3793 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3794 unsigned &NumAliases) const {
3795 // No aliases.
3796 Aliases = 0;
3797 NumAliases = 0;
3798 }
3799 virtual bool validateAsmConstraint(const char *&Name,
3800 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00003801 // No target constraints for now.
3802 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003803 }
3804 virtual const char *getClobbers() const {
3805 // FIXME: Is this really right?
3806 return "";
3807 }
Meador Ingec5613b22012-06-16 03:34:49 +00003808 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003809 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00003810 return TargetInfo::CharPtrBuiltinVaList;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003811 }
3812 };
3813
3814 const char * const MSP430TargetInfo::GCCRegNames[] = {
3815 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3816 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3817 };
3818
3819 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
3820 unsigned &NumNames) const {
3821 Names = GCCRegNames;
3822 NumNames = llvm::array_lengthof(GCCRegNames);
3823 }
3824}
3825
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00003826namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00003827
Mike Stump1eb44332009-09-09 15:08:12 +00003828 // LLVM and Clang cannot be used directly to output native binaries for
3829 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00003830 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00003831 //
3832 // TCE uses the llvm bitcode as input and uses it for generating customized
3833 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00003834 // publicly available in http://tce.cs.tut.fi
3835
Eli Friedman209f5bb2011-10-07 19:51:42 +00003836 static const unsigned TCEOpenCLAddrSpaceMap[] = {
3837 3, // opencl_global
3838 4, // opencl_local
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00003839 5, // opencl_constant
3840 0, // cuda_device
3841 0, // cuda_constant
3842 0 // cuda_shared
Eli Friedman209f5bb2011-10-07 19:51:42 +00003843 };
3844
Eli Friedmanb63decf2009-08-19 20:47:07 +00003845 class TCETargetInfo : public TargetInfo{
3846 public:
3847 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
3848 TLSSupported = false;
3849 IntWidth = 32;
3850 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003851 PointerWidth = 32;
3852 IntAlign = 32;
3853 LongAlign = LongLongAlign = 32;
3854 PointerAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003855 SuitableAlign = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003856 SizeType = UnsignedInt;
3857 IntMaxType = SignedLong;
3858 UIntMaxType = UnsignedLong;
3859 IntPtrType = SignedInt;
3860 PtrDiffType = SignedInt;
3861 FloatWidth = 32;
3862 FloatAlign = 32;
3863 DoubleWidth = 32;
3864 DoubleAlign = 32;
3865 LongDoubleWidth = 32;
3866 LongDoubleAlign = 32;
3867 FloatFormat = &llvm::APFloat::IEEEsingle;
3868 DoubleFormat = &llvm::APFloat::IEEEsingle;
3869 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00003870 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
3871 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00003872 "f32:32:32-f64:32:32-v64:32:32-"
3873 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00003874 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003875 }
3876
3877 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003878 MacroBuilder &Builder) const {
3879 DefineStd(Builder, "tce", Opts);
3880 Builder.defineMacro("__TCE__");
3881 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00003882 }
Douglas Gregore727d212012-01-30 06:38:25 +00003883 virtual bool hasFeature(StringRef Feature) const {
3884 return Feature == "tce";
3885 }
3886
Eli Friedmanb63decf2009-08-19 20:47:07 +00003887 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3888 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00003889 virtual const char *getClobbers() const {
3890 return "";
3891 }
Meador Ingec5613b22012-06-16 03:34:49 +00003892 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3893 return TargetInfo::VoidPtrBuiltinVaList;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003894 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003895 virtual void getGCCRegNames(const char * const *&Names,
3896 unsigned &NumNames) const {}
3897 virtual bool validateAsmConstraint(const char *&Name,
3898 TargetInfo::ConstraintInfo &info) const {
3899 return true;
3900 }
3901 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3902 unsigned &NumAliases) const {}
3903 };
3904}
3905
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003906namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003907class MipsTargetInfoBase : public TargetInfo {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00003908 static const Builtin::Info BuiltinInfo[];
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003909 std::string CPU;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00003910 bool IsMips16;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003911 enum MipsFloatABI {
3912 HardFloat, SingleFloat, SoftFloat
3913 } FloatABI;
Simon Atanasyana1b62272012-07-05 20:16:22 +00003914 enum DspRevEnum {
3915 NoDSP, DSP1, DSP2
3916 } DspRev;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003917
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003918protected:
3919 std::string ABI;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003920
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003921public:
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00003922 MipsTargetInfoBase(const std::string& triple,
3923 const std::string& ABIStr,
3924 const std::string& CPUStr)
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003925 : TargetInfo(triple),
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00003926 CPU(CPUStr),
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00003927 IsMips16(false),
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003928 FloatABI(HardFloat),
Simon Atanasyana1b62272012-07-05 20:16:22 +00003929 DspRev(NoDSP),
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003930 ABI(ABIStr)
3931 {}
3932
Eric Christophered734732010-03-02 02:41:08 +00003933 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003934 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00003935 virtual bool setCPU(const std::string &Name) {
3936 CPU = Name;
3937 return true;
3938 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003939 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00003940 Features[ABI] = true;
3941 Features[CPU] = true;
3942 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003943
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00003944 virtual void getTargetDefines(const LangOptions &Opts,
3945 MacroBuilder &Builder) const {
Simon Atanasyand4935a02012-08-29 19:14:58 +00003946 DefineStd(Builder, "mips", Opts);
3947 Builder.defineMacro("_mips");
3948 Builder.defineMacro("__REGISTER_PREFIX__", "");
3949
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003950 switch (FloatABI) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003951 case HardFloat:
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00003952 Builder.defineMacro("__mips_hard_float", Twine(1));
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003953 break;
3954 case SingleFloat:
3955 Builder.defineMacro("__mips_hard_float", Twine(1));
3956 Builder.defineMacro("__mips_single_float", Twine(1));
3957 break;
3958 case SoftFloat:
3959 Builder.defineMacro("__mips_soft_float", Twine(1));
3960 break;
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00003961 }
Simon Atanasyan90913892012-04-05 19:28:31 +00003962
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00003963 if (IsMips16)
3964 Builder.defineMacro("__mips16", Twine(1));
3965
Simon Atanasyana1b62272012-07-05 20:16:22 +00003966 switch (DspRev) {
3967 default:
3968 break;
3969 case DSP1:
3970 Builder.defineMacro("__mips_dsp_rev", Twine(1));
3971 Builder.defineMacro("__mips_dsp", Twine(1));
3972 break;
3973 case DSP2:
3974 Builder.defineMacro("__mips_dsp_rev", Twine(2));
3975 Builder.defineMacro("__mips_dspr2", Twine(1));
3976 Builder.defineMacro("__mips_dsp", Twine(1));
3977 break;
3978 }
3979
Simon Atanasyan90913892012-04-05 19:28:31 +00003980 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
3981 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
3982 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
Simon Atanasyan260e5062012-08-29 15:17:29 +00003983
3984 Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
3985 Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003986 }
3987
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003988 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3989 unsigned &NumRecords) const {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00003990 Records = BuiltinInfo;
3991 NumRecords = clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003992 }
Douglas Gregore727d212012-01-30 06:38:25 +00003993 virtual bool hasFeature(StringRef Feature) const {
3994 return Feature == "mips";
3995 }
Meador Ingec5613b22012-06-16 03:34:49 +00003996 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3997 return TargetInfo::VoidPtrBuiltinVaList;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003998 }
3999 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004000 unsigned &NumNames) const {
4001 static const char * const GCCRegNames[] = {
Eric Christopherd1f853d2012-03-27 19:56:11 +00004002 // CPU register names
4003 // Must match second column of GCCRegAliases
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004004 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
4005 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
4006 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004007 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",
4008 // Floating point register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004009 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
4010 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
4011 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
4012 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004013 // Hi/lo and condition register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004014 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
4015 "$fcc5","$fcc6","$fcc7"
4016 };
4017 Names = GCCRegNames;
4018 NumNames = llvm::array_lengthof(GCCRegNames);
4019 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004020 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004021 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004022 virtual bool validateAsmConstraint(const char *&Name,
4023 TargetInfo::ConstraintInfo &Info) const {
4024 switch (*Name) {
4025 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00004026 return false;
4027
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004028 case 'r': // CPU registers.
4029 case 'd': // Equivalent to "r" unless generating MIPS16 code.
4030 case 'y': // Equivalent to "r", backwards compatibility only.
4031 case 'f': // floating-point registers.
Eric Christopher0ea61642012-04-03 01:16:32 +00004032 case 'c': // $25 for indirect jumps
4033 case 'l': // lo register
4034 case 'x': // hilo register pair
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004035 Info.setAllowsRegister();
4036 return true;
4037 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004038 }
4039
4040 virtual const char *getClobbers() const {
4041 // FIXME: Implement!
4042 return "";
4043 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004044
4045 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
4046 StringRef Name,
4047 bool Enabled) const {
Simon Atanasyan8b2a5d22012-04-18 12:00:11 +00004048 if (Name == "soft-float" || Name == "single-float" ||
4049 Name == "o32" || Name == "n32" || Name == "n64" || Name == "eabi" ||
4050 Name == "mips32" || Name == "mips32r2" ||
Simon Atanasyan0b273ef2012-07-05 14:19:39 +00004051 Name == "mips64" || Name == "mips64r2" ||
Simon Atanasyand797a852012-07-05 19:23:00 +00004052 Name == "mips16" || Name == "dsp" || Name == "dspr2") {
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004053 Features[Name] = Enabled;
4054 return true;
4055 }
4056 return false;
4057 }
4058
4059 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004060 IsMips16 = false;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004061 FloatABI = HardFloat;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004062 DspRev = NoDSP;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004063
4064 for (std::vector<std::string>::iterator it = Features.begin(),
4065 ie = Features.end(); it != ie; ++it) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004066 if (*it == "+single-float")
4067 FloatABI = SingleFloat;
4068 else if (*it == "+soft-float")
4069 FloatABI = SoftFloat;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004070 else if (*it == "+mips16")
4071 IsMips16 = true;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004072 else if (*it == "+dsp")
4073 DspRev = std::max(DspRev, DSP1);
4074 else if (*it == "+dspr2")
4075 DspRev = std::max(DspRev, DSP2);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004076 }
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004077
4078 // Remove front-end specific option.
4079 std::vector<std::string>::iterator it =
4080 std::find(Features.begin(), Features.end(), "+soft-float");
4081 if (it != Features.end())
4082 Features.erase(it);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004083 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004084};
4085
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004086const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = {
4087#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4088#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4089 ALL_LANGUAGES },
4090#include "clang/Basic/BuiltinsMips.def"
4091};
4092
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004093class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004094public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004095 Mips32TargetInfoBase(const std::string& triple) :
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00004096 MipsTargetInfoBase(triple, "o32", "mips32") {
Akira Hatanaka148735e2011-11-05 01:48:34 +00004097 SizeType = UnsignedInt;
4098 PtrDiffType = SignedInt;
4099 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004100 virtual bool setABI(const std::string &Name) {
4101 if ((Name == "o32") || (Name == "eabi")) {
4102 ABI = Name;
4103 return true;
4104 } else
4105 return false;
4106 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004107 virtual void getTargetDefines(const LangOptions &Opts,
4108 MacroBuilder &Builder) const {
4109 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004110
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004111 if (ABI == "o32") {
4112 Builder.defineMacro("__mips_o32");
4113 Builder.defineMacro("_ABIO32", "1");
4114 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
4115 }
4116 else if (ABI == "eabi")
4117 Builder.defineMacro("__mips_eabi");
4118 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004119 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004120 }
4121 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4122 unsigned &NumAliases) const {
4123 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4124 { { "at" }, "$1" },
4125 { { "v0" }, "$2" },
4126 { { "v1" }, "$3" },
4127 { { "a0" }, "$4" },
4128 { { "a1" }, "$5" },
4129 { { "a2" }, "$6" },
4130 { { "a3" }, "$7" },
4131 { { "t0" }, "$8" },
4132 { { "t1" }, "$9" },
4133 { { "t2" }, "$10" },
4134 { { "t3" }, "$11" },
4135 { { "t4" }, "$12" },
4136 { { "t5" }, "$13" },
4137 { { "t6" }, "$14" },
4138 { { "t7" }, "$15" },
4139 { { "s0" }, "$16" },
4140 { { "s1" }, "$17" },
4141 { { "s2" }, "$18" },
4142 { { "s3" }, "$19" },
4143 { { "s4" }, "$20" },
4144 { { "s5" }, "$21" },
4145 { { "s6" }, "$22" },
4146 { { "s7" }, "$23" },
4147 { { "t8" }, "$24" },
4148 { { "t9" }, "$25" },
4149 { { "k0" }, "$26" },
4150 { { "k1" }, "$27" },
4151 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004152 { { "sp","$sp" }, "$29" },
4153 { { "fp","$fp" }, "$30" },
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004154 { { "ra" }, "$31" }
4155 };
4156 Aliases = GCCRegAliases;
4157 NumAliases = llvm::array_lengthof(GCCRegAliases);
4158 }
4159};
4160
4161class Mips32EBTargetInfo : public Mips32TargetInfoBase {
4162public:
4163 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
4164 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
4165 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
4166 }
4167 virtual void getTargetDefines(const LangOptions &Opts,
4168 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004169 DefineStd(Builder, "MIPSEB", Opts);
4170 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004171 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004172 }
4173};
4174
4175class Mips32ELTargetInfo : public Mips32TargetInfoBase {
4176public:
4177 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004178 BigEndian = false;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004179 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanaka619e8872011-06-02 00:09:17 +00004180 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004181 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004182 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004183 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004184 DefineStd(Builder, "MIPSEL", Opts);
4185 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004186 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004187 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004188};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004189
4190class Mips64TargetInfoBase : public MipsTargetInfoBase {
4191 virtual void SetDescriptionString(const std::string &Name) = 0;
4192public:
4193 Mips64TargetInfoBase(const std::string& triple) :
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00004194 MipsTargetInfoBase(triple, "n64", "mips64") {
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004195 LongWidth = LongAlign = 64;
4196 PointerWidth = PointerAlign = 64;
4197 LongDoubleWidth = LongDoubleAlign = 128;
4198 LongDoubleFormat = &llvm::APFloat::IEEEquad;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004199 SuitableAlign = 128;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004200 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004201 virtual bool setABI(const std::string &Name) {
4202 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004203
4204 if (Name != "n32" && Name != "n64")
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004205 return false;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004206
4207 ABI = Name;
4208
4209 if (Name == "n32") {
4210 LongWidth = LongAlign = 32;
4211 PointerWidth = PointerAlign = 32;
4212 }
4213
4214 return true;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004215 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004216 virtual void getTargetDefines(const LangOptions &Opts,
4217 MacroBuilder &Builder) const {
4218 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004219
Simon Atanasyan600a5132012-08-29 20:50:11 +00004220 Builder.defineMacro("__mips64");
4221 Builder.defineMacro("__mips64__");
4222
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004223 if (ABI == "n32") {
4224 Builder.defineMacro("__mips_n32");
4225 Builder.defineMacro("_ABIN32", "2");
4226 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
4227 }
4228 else if (ABI == "n64") {
4229 Builder.defineMacro("__mips_n64");
4230 Builder.defineMacro("_ABI64", "3");
4231 Builder.defineMacro("_MIPS_SIM", "_ABI64");
4232 }
4233 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004234 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004235 }
4236 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4237 unsigned &NumAliases) const {
4238 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4239 { { "at" }, "$1" },
4240 { { "v0" }, "$2" },
4241 { { "v1" }, "$3" },
4242 { { "a0" }, "$4" },
4243 { { "a1" }, "$5" },
4244 { { "a2" }, "$6" },
4245 { { "a3" }, "$7" },
4246 { { "a4" }, "$8" },
4247 { { "a5" }, "$9" },
4248 { { "a6" }, "$10" },
4249 { { "a7" }, "$11" },
4250 { { "t0" }, "$12" },
4251 { { "t1" }, "$13" },
4252 { { "t2" }, "$14" },
4253 { { "t3" }, "$15" },
4254 { { "s0" }, "$16" },
4255 { { "s1" }, "$17" },
4256 { { "s2" }, "$18" },
4257 { { "s3" }, "$19" },
4258 { { "s4" }, "$20" },
4259 { { "s5" }, "$21" },
4260 { { "s6" }, "$22" },
4261 { { "s7" }, "$23" },
4262 { { "t8" }, "$24" },
4263 { { "t9" }, "$25" },
4264 { { "k0" }, "$26" },
4265 { { "k1" }, "$27" },
4266 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004267 { { "sp","$sp" }, "$29" },
4268 { { "fp","$fp" }, "$30" },
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004269 { { "ra" }, "$31" }
4270 };
4271 Aliases = GCCRegAliases;
4272 NumAliases = llvm::array_lengthof(GCCRegAliases);
4273 }
4274};
4275
4276class Mips64EBTargetInfo : public Mips64TargetInfoBase {
4277 virtual void SetDescriptionString(const std::string &Name) {
4278 // Change DescriptionString only if ABI is n32.
4279 if (Name == "n32")
4280 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 +00004281 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
4282 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004283 }
4284public:
4285 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
4286 // Default ABI is n64.
4287 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 +00004288 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
4289 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004290 }
4291 virtual void getTargetDefines(const LangOptions &Opts,
4292 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004293 DefineStd(Builder, "MIPSEB", Opts);
4294 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004295 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004296 }
4297};
4298
4299class Mips64ELTargetInfo : public Mips64TargetInfoBase {
4300 virtual void SetDescriptionString(const std::string &Name) {
4301 // Change DescriptionString only if ABI is n32.
4302 if (Name == "n32")
4303 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 +00004304 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
4305 "-v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004306 }
4307public:
4308 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004309 // Default ABI is n64.
4310 BigEndian = false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004311 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 +00004312 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
4313 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004314 }
4315 virtual void getTargetDefines(const LangOptions &Opts,
4316 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004317 DefineStd(Builder, "MIPSEL", Opts);
4318 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004319 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004320 }
4321};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004322} // end anonymous namespace.
4323
Ivan Krasinef05abd2011-08-24 20:22:22 +00004324namespace {
4325class PNaClTargetInfo : public TargetInfo {
4326public:
4327 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004328 BigEndian = false;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004329 this->UserLabelPrefix = "";
4330 this->LongAlign = 32;
4331 this->LongWidth = 32;
4332 this->PointerAlign = 32;
4333 this->PointerWidth = 32;
4334 this->IntMaxType = TargetInfo::SignedLongLong;
4335 this->UIntMaxType = TargetInfo::UnsignedLongLong;
4336 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00004337 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00004338 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00004339 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00004340 this->SizeType = TargetInfo::UnsignedInt;
4341 this->PtrDiffType = TargetInfo::SignedInt;
4342 this->IntPtrType = TargetInfo::SignedInt;
David Meyerdd4a8892011-10-11 03:12:01 +00004343 this->RegParmMax = 2;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004344 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
4345 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
4346 }
4347
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004348 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00004349 }
4350 virtual void getArchDefines(const LangOptions &Opts,
4351 MacroBuilder &Builder) const {
4352 Builder.defineMacro("__le32__");
4353 Builder.defineMacro("__pnacl__");
4354 }
4355 virtual void getTargetDefines(const LangOptions &Opts,
4356 MacroBuilder &Builder) const {
Jan Wen Voungdde3bdb2012-03-29 00:05:59 +00004357 Builder.defineMacro("__LITTLE_ENDIAN__");
Ivan Krasinef05abd2011-08-24 20:22:22 +00004358 getArchDefines(Opts, Builder);
4359 }
Douglas Gregore727d212012-01-30 06:38:25 +00004360 virtual bool hasFeature(StringRef Feature) const {
4361 return Feature == "pnacl";
4362 }
Ivan Krasinef05abd2011-08-24 20:22:22 +00004363 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4364 unsigned &NumRecords) const {
4365 }
Meador Ingec5613b22012-06-16 03:34:49 +00004366 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4367 return TargetInfo::PNaClABIBuiltinVaList;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004368 }
4369 virtual void getGCCRegNames(const char * const *&Names,
4370 unsigned &NumNames) const;
4371 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4372 unsigned &NumAliases) const;
4373 virtual bool validateAsmConstraint(const char *&Name,
4374 TargetInfo::ConstraintInfo &Info) const {
4375 return false;
4376 }
4377
4378 virtual const char *getClobbers() const {
4379 return "";
4380 }
4381};
4382
4383void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
4384 unsigned &NumNames) const {
4385 Names = NULL;
4386 NumNames = 0;
4387}
4388
4389void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4390 unsigned &NumAliases) const {
4391 Aliases = NULL;
4392 NumAliases = 0;
4393}
4394} // end anonymous namespace.
4395
4396
Reid Spencer5f016e22007-07-11 17:01:13 +00004397//===----------------------------------------------------------------------===//
4398// Driver code
4399//===----------------------------------------------------------------------===//
4400
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004401static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004402 llvm::Triple Triple(T);
4403 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00004404
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004405 switch (Triple.getArch()) {
4406 default:
4407 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00004408
Tony Linthicum96319392011-12-12 21:14:55 +00004409 case llvm::Triple::hexagon:
4410 return new HexagonTargetInfo(T);
4411
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004412 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00004413 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004414 if (Triple.isOSDarwin())
4415 return new DarwinARMTargetInfo(T);
4416
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004417 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00004418 case llvm::Triple::Linux:
4419 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004420 case llvm::Triple::FreeBSD:
Torok Edwin5f6c1942009-06-30 17:10:35 +00004421 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004422 case llvm::Triple::NetBSD:
4423 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00004424 case llvm::Triple::OpenBSD:
4425 return new OpenBSDTargetInfo<ARMTargetInfo>(T);
Eli Friedman42f74f22012-08-08 23:57:20 +00004426 case llvm::Triple::Bitrig:
4427 return new BitrigTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00004428 case llvm::Triple::RTEMS:
4429 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Derek Schuff7da46f92012-10-11 16:55:58 +00004430 case llvm::Triple::NativeClient:
4431 return new NaClTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004432 default:
4433 return new ARMTargetInfo(T);
4434 }
Eli Friedman61538a72008-05-20 14:21:01 +00004435
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004436 case llvm::Triple::msp430:
4437 return new MSP430TargetInfo(T);
Eli Friedman61538a72008-05-20 14:21:01 +00004438
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004439 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004440 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004441 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004442 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004443 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004444 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004445 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004446 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004447 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004448 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004449 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004450 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004451 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004452
4453 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004454 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004455 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004456 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004457 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004458 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004459 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004460 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004461 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004462 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004463 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004464 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004465 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004466
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004467 case llvm::Triple::mips64:
4468 switch (os) {
4469 case llvm::Triple::Linux:
4470 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
4471 case llvm::Triple::RTEMS:
4472 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
4473 case llvm::Triple::FreeBSD:
4474 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
4475 case llvm::Triple::NetBSD:
4476 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00004477 case llvm::Triple::OpenBSD:
4478 return new OpenBSDTargetInfo<Mips64EBTargetInfo>(T);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004479 default:
4480 return new Mips64EBTargetInfo(T);
4481 }
4482
4483 case llvm::Triple::mips64el:
4484 switch (os) {
4485 case llvm::Triple::Linux:
4486 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
4487 case llvm::Triple::RTEMS:
4488 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
4489 case llvm::Triple::FreeBSD:
4490 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
4491 case llvm::Triple::NetBSD:
4492 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00004493 case llvm::Triple::OpenBSD:
4494 return new OpenBSDTargetInfo<Mips64ELTargetInfo>(T);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004495 default:
4496 return new Mips64ELTargetInfo(T);
4497 }
4498
Ivan Krasinef05abd2011-08-24 20:22:22 +00004499 case llvm::Triple::le32:
4500 switch (os) {
4501 case llvm::Triple::NativeClient:
Derek Schuff7da46f92012-10-11 16:55:58 +00004502 return new NaClTargetInfo<PNaClTargetInfo>(T);
Ivan Krasinef05abd2011-08-24 20:22:22 +00004503 default:
4504 return NULL;
4505 }
4506
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004507 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004508 if (Triple.isOSDarwin())
Roman Divackyc81f2a22011-01-06 08:27:10 +00004509 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004510 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00004511 case llvm::Triple::Linux:
4512 return new LinuxTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004513 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00004514 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004515 case llvm::Triple::NetBSD:
4516 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00004517 case llvm::Triple::OpenBSD:
4518 return new OpenBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004519 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00004520 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004521 default:
4522 return new PPC32TargetInfo(T);
4523 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004524
4525 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004526 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00004527 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004528 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00004529 case llvm::Triple::Linux:
4530 return new LinuxTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004531 case llvm::Triple::Lv2:
John Thompson3f6918a2009-11-19 17:18:50 +00004532 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004533 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00004534 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004535 case llvm::Triple::NetBSD:
4536 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
4537 default:
4538 return new PPC64TargetInfo(T);
4539 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004540
Peter Collingbourneedb66f32012-05-20 23:28:41 +00004541 case llvm::Triple::nvptx:
4542 return new NVPTX32TargetInfo(T);
4543 case llvm::Triple::nvptx64:
4544 return new NVPTX64TargetInfo(T);
4545
Chris Lattner9cbeb632010-03-06 21:21:27 +00004546 case llvm::Triple::mblaze:
4547 return new MBlazeTargetInfo(T);
4548
Eli Friedman6505a292012-10-12 23:32:00 +00004549 case llvm::Triple::r600:
4550 return new R600TargetInfo(T);
4551
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004552 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004553 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00004554 case llvm::Triple::Linux:
4555 return new LinuxTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004556 case llvm::Triple::AuroraUX:
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004557 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004558 case llvm::Triple::Solaris:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004559 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004560 case llvm::Triple::NetBSD:
4561 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00004562 case llvm::Triple::OpenBSD:
4563 return new OpenBSDTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004564 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00004565 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004566 default:
4567 return new SparcV8TargetInfo(T);
4568 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004569
John Thompson3f6918a2009-11-19 17:18:50 +00004570 // FIXME: Need a real SPU target.
4571 case llvm::Triple::cellspu:
4572 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
4573
Eli Friedmanb63decf2009-08-19 20:47:07 +00004574 case llvm::Triple::tce:
4575 return new TCETargetInfo(T);
4576
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004577 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004578 if (Triple.isOSDarwin())
4579 return new DarwinI386TargetInfo(T);
4580
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004581 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004582 case llvm::Triple::AuroraUX:
4583 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004584 case llvm::Triple::Linux:
4585 return new LinuxTargetInfo<X86_32TargetInfo>(T);
4586 case llvm::Triple::DragonFly:
4587 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
4588 case llvm::Triple::NetBSD:
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00004589 return new NetBSDI386TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004590 case llvm::Triple::OpenBSD:
4591 return new OpenBSDI386TargetInfo(T);
Eli Friedman42f74f22012-08-08 23:57:20 +00004592 case llvm::Triple::Bitrig:
4593 return new BitrigI386TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004594 case llvm::Triple::FreeBSD:
4595 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner38e317d2010-07-07 16:01:42 +00004596 case llvm::Triple::Minix:
4597 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004598 case llvm::Triple::Solaris:
4599 return new SolarisTargetInfo<X86_32TargetInfo>(T);
4600 case llvm::Triple::Cygwin:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004601 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004602 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004603 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004604 case llvm::Triple::Win32:
Michael J. Spencera764e832010-10-21 08:22:51 +00004605 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattner86ed3a32010-04-11 19:29:39 +00004606 case llvm::Triple::Haiku:
4607 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00004608 case llvm::Triple::RTEMS:
4609 return new RTEMSX86_32TargetInfo(T);
Derek Schuff7da46f92012-10-11 16:55:58 +00004610 case llvm::Triple::NativeClient:
4611 return new NaClTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004612 default:
4613 return new X86_32TargetInfo(T);
4614 }
4615
4616 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004617 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
4618 return new DarwinX86_64TargetInfo(T);
4619
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004620 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004621 case llvm::Triple::AuroraUX:
4622 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004623 case llvm::Triple::Linux:
4624 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner7a7ca282010-01-09 05:41:14 +00004625 case llvm::Triple::DragonFly:
4626 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004627 case llvm::Triple::NetBSD:
4628 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
4629 case llvm::Triple::OpenBSD:
4630 return new OpenBSDX86_64TargetInfo(T);
Eli Friedman42f74f22012-08-08 23:57:20 +00004631 case llvm::Triple::Bitrig:
4632 return new BitrigX86_64TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004633 case llvm::Triple::FreeBSD:
4634 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
4635 case llvm::Triple::Solaris:
4636 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00004637 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004638 return new MinGWX86_64TargetInfo(T);
4639 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004640 return new VisualStudioWindowsX86_64TargetInfo(T);
Derek Schuff7da46f92012-10-11 16:55:58 +00004641 case llvm::Triple::NativeClient:
4642 return new NaClTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004643 default:
4644 return new X86_64TargetInfo(T);
4645 }
4646 }
Reid Spencer5f016e22007-07-11 17:01:13 +00004647}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004648
4649/// CreateTargetInfo - Return the target info object for the specified target
4650/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00004651TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004652 TargetOptions &Opts) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004653 llvm::Triple Triple(Opts.Triple);
4654
4655 // Construct the target
Dylan Noblesmith6f42b622012-02-05 02:12:40 +00004656 OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004657 if (!Target) {
4658 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
4659 return 0;
4660 }
Douglas Gregor9a022bb2012-10-15 16:45:32 +00004661 Target->setTargetOpts(Opts);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004662
Daniel Dunbareac7c532009-12-18 18:42:37 +00004663 // Set the target CPU if specified.
4664 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
4665 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
4666 return 0;
4667 }
4668
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004669 // Set the target ABI if specified.
4670 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
4671 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
4672 return 0;
4673 }
4674
Charles Davis98b7c5c2010-06-11 01:06:47 +00004675 // Set the target C++ ABI.
John McCallee79a4c2010-08-21 22:46:04 +00004676 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davis98b7c5c2010-06-11 01:06:47 +00004677 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
4678 return 0;
4679 }
4680
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004681 // Compute the default target features, we need the target to handle this
4682 // because features may have dependencies on one another.
4683 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004684 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004685
4686 // Apply the user specified deltas.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004687 // First the enables.
Douglas Gregor57016dd2012-10-16 23:40:58 +00004688 for (std::vector<std::string>::const_iterator
4689 it = Opts.FeaturesAsWritten.begin(),
4690 ie = Opts.FeaturesAsWritten.end();
4691 it != ie; ++it) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004692 const char *Name = it->c_str();
4693
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004694 if (Name[0] != '+')
4695 continue;
4696
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004697 // Apply the feature via the target.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004698 if (!Target->setFeatureEnabled(Features, Name + 1, true)) {
4699 Diags.Report(diag::err_target_invalid_feature) << Name;
4700 return 0;
4701 }
4702 }
4703
4704 // Then the disables.
Douglas Gregor57016dd2012-10-16 23:40:58 +00004705 for (std::vector<std::string>::const_iterator
4706 it = Opts.FeaturesAsWritten.begin(),
4707 ie = Opts.FeaturesAsWritten.end();
4708 it != ie; ++it) {
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004709 const char *Name = it->c_str();
4710
4711 if (Name[0] == '+')
4712 continue;
4713
4714 // Apply the feature via the target.
4715 if (Name[0] != '-' ||
4716 !Target->setFeatureEnabled(Features, Name + 1, false)) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004717 Diags.Report(diag::err_target_invalid_feature) << Name;
4718 return 0;
4719 }
4720 }
4721
4722 // Add the features to the compile options.
4723 //
4724 // FIXME: If we are completely confident that we have the right set, we only
4725 // need to pass the minuses.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004726 Opts.Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004727 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
4728 ie = Features.end(); it != ie; ++it)
Benjamin Kramer713575a2012-03-05 15:10:44 +00004729 Opts.Features.push_back((it->second ? "+" : "-") + it->first().str());
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004730 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004731
4732 return Target.take();
4733}