blob: 95f7d5810242e4bfcc0eb6abebb0355fc0803238 [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:
Eric Christopher825d3862012-11-14 22:08:59 +0000387 case llvm::Triple::sparc:
Eli Friedman62d829a2011-12-15 02:15:56 +0000388 this->MCountName = "__mcount";
389 break;
390 case llvm::Triple::mips64:
391 case llvm::Triple::mips64el:
392 case llvm::Triple::ppc:
Eric Christopher825d3862012-11-14 22:08:59 +0000393 case llvm::Triple::sparcv9:
Eli Friedman62d829a2011-12-15 02:15:56 +0000394 this->MCountName = "_mcount";
395 break;
396 }
397 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000398};
399
Eli Friedman42f74f22012-08-08 23:57:20 +0000400// Bitrig Target
401template<typename Target>
402class BitrigTargetInfo : public OSTargetInfo<Target> {
403protected:
404 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
405 MacroBuilder &Builder) const {
406 // Bitrig defines; list based off of gcc output
407
408 Builder.defineMacro("__Bitrig__");
409 DefineStd(Builder, "unix", Opts);
410 Builder.defineMacro("__ELF__");
411 if (Opts.POSIXThreads)
412 Builder.defineMacro("_REENTRANT");
413 }
414public:
415 BitrigTargetInfo(const std::string &triple)
416 : OSTargetInfo<Target>(triple) {
417 this->UserLabelPrefix = "";
418 this->TLSSupported = false;
419 this->MCountName = "__mcount";
420 }
421};
422
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000423// PSP Target
424template<typename Target>
425class PSPTargetInfo : public OSTargetInfo<Target> {
426protected:
427 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000428 MacroBuilder &Builder) const {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000429 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramera9992772010-01-09 17:55:51 +0000430 Builder.defineMacro("PSP");
431 Builder.defineMacro("_PSP");
432 Builder.defineMacro("__psp__");
433 Builder.defineMacro("__ELF__");
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000434 }
435public:
436 PSPTargetInfo(const std::string& triple)
437 : OSTargetInfo<Target>(triple) {
438 this->UserLabelPrefix = "";
439 }
440};
441
John Thompson3f6918a2009-11-19 17:18:50 +0000442// PS3 PPU Target
443template<typename Target>
444class PS3PPUTargetInfo : public OSTargetInfo<Target> {
445protected:
446 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000447 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000448 // PS3 PPU defines.
John Thompsonfb457972010-03-25 16:18:32 +0000449 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000450 Builder.defineMacro("__PPU__");
451 Builder.defineMacro("__CELLOS_LV2__");
452 Builder.defineMacro("__ELF__");
453 Builder.defineMacro("__LP32__");
John Thompson8e6065a2010-06-24 22:44:13 +0000454 Builder.defineMacro("_ARCH_PPC64");
455 Builder.defineMacro("__powerpc64__");
John Thompson3f6918a2009-11-19 17:18:50 +0000456 }
457public:
458 PS3PPUTargetInfo(const std::string& triple)
459 : OSTargetInfo<Target>(triple) {
460 this->UserLabelPrefix = "";
Nick Lewycky99520702011-12-16 22:32:39 +0000461 this->LongWidth = this->LongAlign = 32;
462 this->PointerWidth = this->PointerAlign = 32;
John Thompson8e6065a2010-06-24 22:44:13 +0000463 this->IntMaxType = TargetInfo::SignedLongLong;
464 this->UIntMaxType = TargetInfo::UnsignedLongLong;
465 this->Int64Type = TargetInfo::SignedLongLong;
John Thompsonec387af2009-12-18 14:21:08 +0000466 this->SizeType = TargetInfo::UnsignedInt;
John Thompson8e6065a2010-06-24 22:44:13 +0000467 this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Nick Lewycky99520702011-12-16 22:32:39 +0000468 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompson3f6918a2009-11-19 17:18:50 +0000469 }
470};
471
472// FIXME: Need a real SPU target.
473// PS3 SPU Target
474template<typename Target>
475class PS3SPUTargetInfo : public OSTargetInfo<Target> {
476protected:
477 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000478 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000479 // PS3 PPU defines.
Benjamin Kramera9992772010-01-09 17:55:51 +0000480 Builder.defineMacro("__SPU__");
481 Builder.defineMacro("__ELF__");
John Thompson3f6918a2009-11-19 17:18:50 +0000482 }
483public:
484 PS3SPUTargetInfo(const std::string& triple)
485 : OSTargetInfo<Target>(triple) {
486 this->UserLabelPrefix = "";
487 }
488};
489
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000490// AuroraUX target
491template<typename Target>
492class AuroraUXTargetInfo : public OSTargetInfo<Target> {
493protected:
494 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000495 MacroBuilder &Builder) const {
496 DefineStd(Builder, "sun", Opts);
497 DefineStd(Builder, "unix", Opts);
498 Builder.defineMacro("__ELF__");
499 Builder.defineMacro("__svr4__");
500 Builder.defineMacro("__SVR4");
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000501 }
502public:
503 AuroraUXTargetInfo(const std::string& triple)
504 : OSTargetInfo<Target>(triple) {
505 this->UserLabelPrefix = "";
506 this->WCharType = this->SignedLong;
507 // FIXME: WIntType should be SignedLong
508 }
509};
510
Torok Edwin5f6c1942009-06-30 17:10:35 +0000511// Solaris target
512template<typename Target>
513class SolarisTargetInfo : public OSTargetInfo<Target> {
514protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000515 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000516 MacroBuilder &Builder) const {
517 DefineStd(Builder, "sun", Opts);
518 DefineStd(Builder, "unix", Opts);
519 Builder.defineMacro("__ELF__");
520 Builder.defineMacro("__svr4__");
521 Builder.defineMacro("__SVR4");
David Chisnall165329c2012-02-28 17:10:04 +0000522 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
523 // newer, but to 500 for everything else. feature_test.h has a check to
524 // ensure that you are not using C99 with an old version of X/Open or C89
525 // with a new version.
526 if (Opts.C99 || Opts.C11)
527 Builder.defineMacro("_XOPEN_SOURCE", "600");
528 else
529 Builder.defineMacro("_XOPEN_SOURCE", "500");
David Chisnallb4f0bd62012-03-02 10:49:52 +0000530 if (Opts.CPlusPlus)
David Chisnall165329c2012-02-28 17:10:04 +0000531 Builder.defineMacro("__C99FEATURES__");
David Chisnall48fad492012-02-17 18:35:11 +0000532 Builder.defineMacro("_LARGEFILE_SOURCE");
533 Builder.defineMacro("_LARGEFILE64_SOURCE");
534 Builder.defineMacro("__EXTENSIONS__");
David Chisnall165329c2012-02-28 17:10:04 +0000535 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000536 }
537public:
Mike Stump1eb44332009-09-09 15:08:12 +0000538 SolarisTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000539 : OSTargetInfo<Target>(triple) {
540 this->UserLabelPrefix = "";
David Chisnallfb027842012-03-28 18:04:14 +0000541 this->WCharType = this->SignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000542 // FIXME: WIntType should be SignedLong
543 }
544};
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000545
546// Windows target
547template<typename Target>
548class WindowsTargetInfo : public OSTargetInfo<Target> {
549protected:
550 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
551 MacroBuilder &Builder) const {
Michael J. Spencera764e832010-10-21 08:22:51 +0000552 Builder.defineMacro("_WIN32");
553 }
554 void getVisualStudioDefines(const LangOptions &Opts,
555 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000556 if (Opts.CPlusPlus) {
557 if (Opts.RTTI)
558 Builder.defineMacro("_CPPRTTI");
559
560 if (Opts.Exceptions)
561 Builder.defineMacro("_CPPUNWIND");
562 }
563
564 if (!Opts.CharIsSigned)
565 Builder.defineMacro("_CHAR_UNSIGNED");
566
567 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
568 // but it works for now.
569 if (Opts.POSIXThreads)
570 Builder.defineMacro("_MT");
Michael J. Spencera764e832010-10-21 08:22:51 +0000571
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000572 if (Opts.MSCVersion != 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000573 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000574
Francois Pichet62ec1f22011-09-17 17:15:52 +0000575 if (Opts.MicrosoftExt) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000576 Builder.defineMacro("_MSC_EXTENSIONS");
577
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 }
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001040
1041 // PPC32 supports atomics up to 4 bytes.
1042 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001043 }
1044
Meador Ingec5613b22012-06-16 03:34:49 +00001045 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001046 // This is the ELF definition, and is overridden by the Darwin sub-target
Meador Ingec5613b22012-06-16 03:34:49 +00001047 return TargetInfo::PowerABIBuiltinVaList;
Eli Friedmaned855cb2008-08-21 00:13:15 +00001048 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001049};
1050} // end anonymous namespace.
1051
1052namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001053class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001054public:
Eli Friedmane4277982008-08-20 23:11:40 +00001055 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00001056 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00001057 IntMaxType = SignedLong;
1058 UIntMaxType = UnsignedLong;
1059 Int64Type = SignedLong;
Roman Divackye3d175d2012-03-13 16:53:54 +00001060
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001061 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1062 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001063 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001064 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1065 "i64:64:64-f32:32:32-f64:64:64-f128:64:64-"
1066 "v128:128:128-n32:64";
1067 } else
1068 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1069 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
1070 "v128:128:128-n32:64";
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001071
1072 // PPC64 supports atomics up to 8 bytes.
1073 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Chris Lattnerf291b102008-05-09 06:17:04 +00001074 }
Meador Ingec5613b22012-06-16 03:34:49 +00001075 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1076 return TargetInfo::CharPtrBuiltinVaList;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001077 }
Eli Friedmane4277982008-08-20 23:11:40 +00001078};
1079} // end anonymous namespace.
1080
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001081
1082namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001083class DarwinPPC32TargetInfo :
1084 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001085public:
Roman Divackyc81f2a22011-01-06 08:27:10 +00001086 DarwinPPC32TargetInfo(const std::string& triple)
1087 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001088 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001089 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001090 LongLongAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001091 SuitableAlign = 128;
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001092 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1093 "i64:32:64-f32:32:32-f64:64:64-v128:128:128-n32";
Roman Divackyc81f2a22011-01-06 08:27:10 +00001094 }
Meador Ingec5613b22012-06-16 03:34:49 +00001095 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1096 return TargetInfo::CharPtrBuiltinVaList;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001097 }
1098};
1099
1100class DarwinPPC64TargetInfo :
1101 public DarwinTargetInfo<PPC64TargetInfo> {
1102public:
1103 DarwinPPC64TargetInfo(const std::string& triple)
1104 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
1105 HasAlignMac68kSupport = true;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001106 SuitableAlign = 128;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001107 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1108 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001109 }
1110};
1111} // end anonymous namespace.
1112
Reid Spencer5f016e22007-07-11 17:01:13 +00001113namespace {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001114 static const unsigned NVPTXAddrSpaceMap[] = {
1115 1, // opencl_global
1116 3, // opencl_local
1117 4, // opencl_constant
1118 1, // cuda_device
1119 4, // cuda_constant
1120 3, // cuda_shared
1121 };
1122 class NVPTXTargetInfo : public TargetInfo {
1123 static const char * const GCCRegNames[];
Justin Holewinski2c585b92012-05-24 17:43:12 +00001124 static const Builtin::Info BuiltinInfo[];
1125 std::vector<llvm::StringRef> AvailableFeatures;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001126 public:
1127 NVPTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
1128 BigEndian = false;
1129 TLSSupported = false;
1130 LongWidth = LongAlign = 64;
1131 AddrSpaceMap = &NVPTXAddrSpaceMap;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001132 // Define available target features
1133 // These must be defined in sorted order!
Justin Holewinski9903e942012-07-11 15:34:55 +00001134 NoAsmVariants = true;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001135 }
1136 virtual void getTargetDefines(const LangOptions &Opts,
1137 MacroBuilder &Builder) const {
1138 Builder.defineMacro("__PTX__");
Justin Holewinski2c585b92012-05-24 17:43:12 +00001139 Builder.defineMacro("__NVPTX__");
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001140 }
1141 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1142 unsigned &NumRecords) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001143 Records = BuiltinInfo;
1144 NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001145 }
1146 virtual bool hasFeature(StringRef Feature) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001147 return Feature == "ptx" || Feature == "nvptx";
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001148 }
1149
1150 virtual void getGCCRegNames(const char * const *&Names,
1151 unsigned &NumNames) const;
1152 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1153 unsigned &NumAliases) const {
1154 // No aliases.
1155 Aliases = 0;
1156 NumAliases = 0;
1157 }
1158 virtual bool validateAsmConstraint(const char *&Name,
1159 TargetInfo::ConstraintInfo &info) const {
1160 // FIXME: implement
1161 return true;
1162 }
1163 virtual const char *getClobbers() const {
1164 // FIXME: Is this really right?
1165 return "";
1166 }
Meador Ingec5613b22012-06-16 03:34:49 +00001167 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001168 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00001169 return TargetInfo::CharPtrBuiltinVaList;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001170 }
1171 virtual bool setCPU(const std::string &Name) {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001172 return Name == "sm_10" || Name == "sm_13" || Name == "sm_20";
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001173 }
Justin Holewinski2c585b92012-05-24 17:43:12 +00001174 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1175 StringRef Name,
1176 bool Enabled) const;
1177 };
1178
1179 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1180#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1181#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1182 ALL_LANGUAGES },
1183#include "clang/Basic/BuiltinsNVPTX.def"
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001184 };
1185
1186 const char * const NVPTXTargetInfo::GCCRegNames[] = {
1187 "r0"
1188 };
1189
1190 void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names,
1191 unsigned &NumNames) const {
1192 Names = GCCRegNames;
1193 NumNames = llvm::array_lengthof(GCCRegNames);
1194 }
1195
Justin Holewinski2c585b92012-05-24 17:43:12 +00001196 bool NVPTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1197 StringRef Name,
1198 bool Enabled) const {
1199 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
1200 Name)) {
1201 Features[Name] = Enabled;
1202 return true;
1203 } else {
1204 return false;
1205 }
1206 }
1207
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001208 class NVPTX32TargetInfo : public NVPTXTargetInfo {
1209 public:
Justin Holewinski2c585b92012-05-24 17:43:12 +00001210 NVPTX32TargetInfo(const std::string& triple) : NVPTXTargetInfo(triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001211 PointerWidth = PointerAlign = 32;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001212 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001213 DescriptionString
1214 = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1215 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1216 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001217 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001218 };
1219
1220 class NVPTX64TargetInfo : public NVPTXTargetInfo {
1221 public:
Justin Holewinski2c585b92012-05-24 17:43:12 +00001222 NVPTX64TargetInfo(const std::string& triple) : NVPTXTargetInfo(triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001223 PointerWidth = PointerAlign = 64;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001224 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001225 DescriptionString
1226 = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1227 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1228 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001229 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001230 };
1231}
1232
1233namespace {
Eli Friedman6505a292012-10-12 23:32:00 +00001234
1235static const unsigned R600AddrSpaceMap[] = {
1236 1, // opencl_global
1237 3, // opencl_local
1238 2, // opencl_constant
1239 1, // cuda_device
1240 2, // cuda_constant
1241 3 // cuda_shared
1242};
1243
1244class R600TargetInfo : public TargetInfo {
1245public:
1246 R600TargetInfo(const std::string& triple) : TargetInfo(triple) {
1247 DescriptionString =
1248 "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16"
1249 "-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f80:32:32"
1250 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64"
1251 "-v96:128:128-v128:128:128-v192:256:256-v256:256:256"
1252 "-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1253 "-n8:16:32:64";
1254 AddrSpaceMap = &R600AddrSpaceMap;
1255 }
1256
1257 virtual const char * getClobbers() const {
1258 return "";
1259 }
1260
1261 virtual void getGCCRegNames(const char * const *&Names,
1262 unsigned &numNames) const {
1263 Names = NULL;
1264 numNames = 0;
1265 }
1266
1267 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1268 unsigned &NumAliases) const {
1269 Aliases = NULL;
1270 NumAliases = 0;
1271 }
1272
1273 virtual bool validateAsmConstraint(const char *&Name,
1274 TargetInfo::ConstraintInfo &info) const {
1275 return true;
1276 }
1277
1278 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1279 unsigned &NumRecords) const {
1280 Records = NULL;
1281 NumRecords = 0;
1282 }
1283
1284
1285 virtual void getTargetDefines(const LangOptions &Opts,
1286 MacroBuilder &Builder) const {
1287 Builder.defineMacro("__R600__");
1288 }
1289
1290 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1291 return TargetInfo::CharPtrBuiltinVaList;
1292 }
1293
1294};
1295
1296} // end anonymous namespace
1297
1298namespace {
Chris Lattner9cbeb632010-03-06 21:21:27 +00001299// MBlaze abstract base class
1300class MBlazeTargetInfo : public TargetInfo {
1301 static const char * const GCCRegNames[];
1302 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1303
1304public:
1305 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +00001306 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner9cbeb632010-03-06 21:21:27 +00001307 }
1308
1309 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1310 unsigned &NumRecords) const {
1311 // FIXME: Implement.
1312 Records = 0;
1313 NumRecords = 0;
1314 }
1315
1316 virtual void getTargetDefines(const LangOptions &Opts,
1317 MacroBuilder &Builder) const;
1318
Douglas Gregore727d212012-01-30 06:38:25 +00001319 virtual bool hasFeature(StringRef Feature) const {
1320 return Feature == "mblaze";
1321 }
1322
Meador Ingec5613b22012-06-16 03:34:49 +00001323 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1324 return TargetInfo::CharPtrBuiltinVaList;
Chris Lattner9cbeb632010-03-06 21:21:27 +00001325 }
1326 virtual const char *getTargetPrefix() const {
1327 return "mblaze";
1328 }
1329 virtual void getGCCRegNames(const char * const *&Names,
1330 unsigned &NumNames) const;
1331 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1332 unsigned &NumAliases) const;
1333 virtual bool validateAsmConstraint(const char *&Name,
1334 TargetInfo::ConstraintInfo &Info) const {
1335 switch (*Name) {
1336 default: return false;
1337 case 'O': // Zero
1338 return true;
1339 case 'b': // Base register
1340 case 'f': // Floating point register
1341 Info.setAllowsRegister();
1342 return true;
1343 }
1344 }
1345 virtual const char *getClobbers() const {
1346 return "";
1347 }
1348};
1349
1350/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1351/// #defines that are not tied to a specific subtarget.
1352void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1353 MacroBuilder &Builder) const {
1354 // Target identification.
1355 Builder.defineMacro("__microblaze__");
1356 Builder.defineMacro("_ARCH_MICROBLAZE");
1357 Builder.defineMacro("__MICROBLAZE__");
1358
1359 // Target properties.
1360 Builder.defineMacro("_BIG_ENDIAN");
1361 Builder.defineMacro("__BIG_ENDIAN__");
1362
1363 // Subtarget options.
1364 Builder.defineMacro("__REGISTER_PREFIX__", "");
1365}
1366
1367
1368const char * const MBlazeTargetInfo::GCCRegNames[] = {
1369 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1370 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1371 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1372 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1373 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1374 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1375 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1376 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1377 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1378 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1379};
1380
1381void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1382 unsigned &NumNames) const {
1383 Names = GCCRegNames;
1384 NumNames = llvm::array_lengthof(GCCRegNames);
1385}
1386
1387const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1388 { {"f0"}, "r0" },
1389 { {"f1"}, "r1" },
1390 { {"f2"}, "r2" },
1391 { {"f3"}, "r3" },
1392 { {"f4"}, "r4" },
1393 { {"f5"}, "r5" },
1394 { {"f6"}, "r6" },
1395 { {"f7"}, "r7" },
1396 { {"f8"}, "r8" },
1397 { {"f9"}, "r9" },
1398 { {"f10"}, "r10" },
1399 { {"f11"}, "r11" },
1400 { {"f12"}, "r12" },
1401 { {"f13"}, "r13" },
1402 { {"f14"}, "r14" },
1403 { {"f15"}, "r15" },
1404 { {"f16"}, "r16" },
1405 { {"f17"}, "r17" },
1406 { {"f18"}, "r18" },
1407 { {"f19"}, "r19" },
1408 { {"f20"}, "r20" },
1409 { {"f21"}, "r21" },
1410 { {"f22"}, "r22" },
1411 { {"f23"}, "r23" },
1412 { {"f24"}, "r24" },
1413 { {"f25"}, "r25" },
1414 { {"f26"}, "r26" },
1415 { {"f27"}, "r27" },
1416 { {"f28"}, "r28" },
1417 { {"f29"}, "r29" },
1418 { {"f30"}, "r30" },
1419 { {"f31"}, "r31" },
1420};
1421
1422void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1423 unsigned &NumAliases) const {
1424 Aliases = GCCRegAliases;
1425 NumAliases = llvm::array_lengthof(GCCRegAliases);
1426}
1427} // end anonymous namespace.
1428
1429namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001430// Namespace for x86 abstract base class
1431const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001432#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001433#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001434 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001435#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001436};
Eli Friedman61538a72008-05-20 14:21:01 +00001437
Nuno Lopes2550d702009-12-23 17:49:57 +00001438static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001439 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1440 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001441 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001442 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1443 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1444 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001445 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopherc5f9a012011-12-02 02:12:16 +00001446 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1447 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001448};
1449
Eric Christophercfd323d2011-06-21 00:05:20 +00001450const TargetInfo::AddlRegName AddlRegNames[] = {
1451 { { "al", "ah", "eax", "rax" }, 0 },
1452 { { "bl", "bh", "ebx", "rbx" }, 3 },
1453 { { "cl", "ch", "ecx", "rcx" }, 2 },
1454 { { "dl", "dh", "edx", "rdx" }, 1 },
1455 { { "esi", "rsi" }, 4 },
1456 { { "edi", "rdi" }, 5 },
1457 { { "esp", "rsp" }, 7 },
1458 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001459};
1460
1461// X86 target abstract base class; x86-32 and x86-64 are very close, so
1462// most of the implementation can be shared.
1463class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001464 enum X86SSEEnum {
Craig Topper05fe4b52012-01-09 09:19:09 +00001465 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2
Chris Lattner84f0ea82009-03-02 22:40:39 +00001466 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001467 enum MMX3DNowEnum {
1468 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1469 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001470
Eric Christophereea12d12010-04-02 23:50:19 +00001471 bool HasAES;
Craig Topper3c0bc152012-05-31 05:18:48 +00001472 bool HasPCLMUL;
Craig Topper31ceea02011-12-25 05:06:45 +00001473 bool HasLZCNT;
Benjamin Kramer84f30802012-07-07 09:39:18 +00001474 bool HasRDRND;
Craig Topper31ceea02011-12-25 05:06:45 +00001475 bool HasBMI;
1476 bool HasBMI2;
Craig Toppere14e08b2011-12-29 16:10:46 +00001477 bool HasPOPCNT;
Michael Liao463eb892012-11-10 05:17:46 +00001478 bool HasRTM;
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00001479 bool HasSSE4a;
Craig Topper6a511e12011-12-30 07:33:42 +00001480 bool HasFMA4;
Craig Topper2ae95072012-06-03 21:46:30 +00001481 bool HasFMA;
Craig Topperb6af69e2012-06-09 22:24:14 +00001482 bool HasXOP;
Manman Ren146e5a42012-10-11 00:59:55 +00001483 bool HasF16C;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001484
Chandler Carruth499d9722011-09-28 08:55:34 +00001485 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1486 ///
1487 /// Each enumeration represents a particular CPU supported by Clang. These
1488 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1489 enum CPUKind {
1490 CK_Generic,
1491
1492 /// \name i386
1493 /// i386-generation processors.
1494 //@{
1495 CK_i386,
1496 //@}
1497
1498 /// \name i486
1499 /// i486-generation processors.
1500 //@{
1501 CK_i486,
1502 CK_WinChipC6,
1503 CK_WinChip2,
1504 CK_C3,
1505 //@}
1506
1507 /// \name i586
1508 /// i586-generation processors, P5 microarchitecture based.
1509 //@{
1510 CK_i586,
1511 CK_Pentium,
1512 CK_PentiumMMX,
1513 //@}
1514
1515 /// \name i686
1516 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1517 //@{
1518 CK_i686,
1519 CK_PentiumPro,
1520 CK_Pentium2,
1521 CK_Pentium3,
1522 CK_Pentium3M,
1523 CK_PentiumM,
1524 CK_C3_2,
1525
1526 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1527 /// Clang however has some logic to suport this.
1528 // FIXME: Warn, deprecate, and potentially remove this.
1529 CK_Yonah,
1530 //@}
1531
1532 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001533 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001534 //@{
1535 CK_Pentium4,
1536 CK_Pentium4M,
1537 CK_Prescott,
1538 CK_Nocona,
1539 //@}
1540
1541 /// \name Core
1542 /// Core microarchitecture based processors.
1543 //@{
1544 CK_Core2,
1545
1546 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1547 /// codename which GCC no longer accepts as an option to -march, but Clang
1548 /// has some logic for recognizing it.
1549 // FIXME: Warn, deprecate, and potentially remove this.
1550 CK_Penryn,
1551 //@}
1552
1553 /// \name Atom
1554 /// Atom processors
1555 //@{
1556 CK_Atom,
1557 //@}
1558
1559 /// \name Nehalem
1560 /// Nehalem microarchitecture based processors.
1561 //@{
1562 CK_Corei7,
1563 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001564 CK_CoreAVXi,
Craig Topper2b03bb02011-12-17 19:55:21 +00001565 CK_CoreAVX2,
Chandler Carruth499d9722011-09-28 08:55:34 +00001566 //@}
1567
1568 /// \name K6
1569 /// K6 architecture processors.
1570 //@{
1571 CK_K6,
1572 CK_K6_2,
1573 CK_K6_3,
1574 //@}
1575
1576 /// \name K7
1577 /// K7 architecture processors.
1578 //@{
1579 CK_Athlon,
1580 CK_AthlonThunderbird,
1581 CK_Athlon4,
1582 CK_AthlonXP,
1583 CK_AthlonMP,
1584 //@}
1585
1586 /// \name K8
1587 /// K8 architecture processors.
1588 //@{
1589 CK_Athlon64,
1590 CK_Athlon64SSE3,
1591 CK_AthlonFX,
1592 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001593 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001594 CK_Opteron,
1595 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001596 CK_AMDFAM10,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001597 //@}
Chandler Carruth499d9722011-09-28 08:55:34 +00001598
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001599 /// \name Bobcat
1600 /// Bobcat architecture processors.
1601 //@{
1602 CK_BTVER1,
1603 //@}
1604
1605 /// \name Bulldozer
1606 /// Bulldozer architecture processors.
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001607 //@{
1608 CK_BDVER1,
1609 CK_BDVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001610 //@}
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001611
Chandler Carruth499d9722011-09-28 08:55:34 +00001612 /// This specification is deprecated and will be removed in the future.
1613 /// Users should prefer \see CK_K8.
1614 // FIXME: Warn on this when the CPU is set to it.
1615 CK_x86_64,
1616 //@}
1617
1618 /// \name Geode
1619 /// Geode processors.
1620 //@{
1621 CK_Geode
1622 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001623 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001624
Eli Friedman618234a2008-08-20 02:34:37 +00001625public:
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001626 X86TargetInfo(const std::string& triple)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001627 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Benjamin Kramer84f30802012-07-07 09:39:18 +00001628 HasAES(false), HasPCLMUL(false), HasLZCNT(false), HasRDRND(false),
Michael Liao463eb892012-11-10 05:17:46 +00001629 HasBMI(false), HasBMI2(false), HasPOPCNT(false), HasRTM(false),
1630 HasSSE4a(false), HasFMA4(false), HasFMA(false), HasXOP(false),
1631 HasF16C(false), CPU(CK_Generic) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00001632 BigEndian = false;
Eli Friedman618234a2008-08-20 02:34:37 +00001633 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001634 }
Benjamin Kramerb4066692011-12-28 15:47:06 +00001635 virtual unsigned getFloatEvalMethod() const {
1636 // X87 evaluates with 80 bits "long double" precision.
1637 return SSELevel == NoSSE ? 2 : 0;
1638 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001639 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1640 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001641 Records = BuiltinInfo;
1642 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001643 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001644 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001645 unsigned &NumNames) const {
1646 Names = GCCRegNames;
1647 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001648 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001649 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001650 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001651 Aliases = 0;
1652 NumAliases = 0;
1653 }
1654 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
Eric Christopher825d3862012-11-14 22:08:59 +00001655 unsigned &NumNames) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001656 Names = AddlRegNames;
1657 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001658 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001659 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001660 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001661 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001662 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001663 return "~{dirflag},~{fpsr},~{flags}";
1664 }
Chris Lattner33328642009-03-20 15:52:06 +00001665 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001666 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001667 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001668 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001669 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001670 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Douglas Gregore727d212012-01-30 06:38:25 +00001671 virtual bool hasFeature(StringRef Feature) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001672 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001673 virtual const char* getABI() const {
Derek Schuffbabaf312012-10-11 15:52:22 +00001674 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001675 return "avx";
Derek Schuffbabaf312012-10-11 15:52:22 +00001676 else if (getTriple().getArch() == llvm::Triple::x86 &&
1677 MMX3DNowLevel == NoMMX3DNow)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001678 return "no-mmx";
1679 return "";
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001680 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001681 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001682 CPU = llvm::StringSwitch<CPUKind>(Name)
1683 .Case("i386", CK_i386)
1684 .Case("i486", CK_i486)
1685 .Case("winchip-c6", CK_WinChipC6)
1686 .Case("winchip2", CK_WinChip2)
1687 .Case("c3", CK_C3)
1688 .Case("i586", CK_i586)
1689 .Case("pentium", CK_Pentium)
1690 .Case("pentium-mmx", CK_PentiumMMX)
1691 .Case("i686", CK_i686)
1692 .Case("pentiumpro", CK_PentiumPro)
1693 .Case("pentium2", CK_Pentium2)
1694 .Case("pentium3", CK_Pentium3)
1695 .Case("pentium3m", CK_Pentium3M)
1696 .Case("pentium-m", CK_PentiumM)
1697 .Case("c3-2", CK_C3_2)
1698 .Case("yonah", CK_Yonah)
1699 .Case("pentium4", CK_Pentium4)
1700 .Case("pentium4m", CK_Pentium4M)
1701 .Case("prescott", CK_Prescott)
1702 .Case("nocona", CK_Nocona)
1703 .Case("core2", CK_Core2)
1704 .Case("penryn", CK_Penryn)
1705 .Case("atom", CK_Atom)
1706 .Case("corei7", CK_Corei7)
1707 .Case("corei7-avx", CK_Corei7AVX)
1708 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper2b03bb02011-12-17 19:55:21 +00001709 .Case("core-avx2", CK_CoreAVX2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001710 .Case("k6", CK_K6)
1711 .Case("k6-2", CK_K6_2)
1712 .Case("k6-3", CK_K6_3)
1713 .Case("athlon", CK_Athlon)
1714 .Case("athlon-tbird", CK_AthlonThunderbird)
1715 .Case("athlon-4", CK_Athlon4)
1716 .Case("athlon-xp", CK_AthlonXP)
1717 .Case("athlon-mp", CK_AthlonMP)
1718 .Case("athlon64", CK_Athlon64)
1719 .Case("athlon64-sse3", CK_Athlon64SSE3)
1720 .Case("athlon-fx", CK_AthlonFX)
1721 .Case("k8", CK_K8)
1722 .Case("k8-sse3", CK_K8SSE3)
1723 .Case("opteron", CK_Opteron)
1724 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001725 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001726 .Case("btver1", CK_BTVER1)
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001727 .Case("bdver1", CK_BDVER1)
1728 .Case("bdver2", CK_BDVER2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001729 .Case("x86-64", CK_x86_64)
1730 .Case("geode", CK_Geode)
1731 .Default(CK_Generic);
1732
Chandler Carruth26a39142011-09-28 09:45:08 +00001733 // Perform any per-CPU checks necessary to determine if this CPU is
1734 // acceptable.
1735 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1736 // invalid without explaining *why*.
1737 switch (CPU) {
1738 case CK_Generic:
1739 // No processor selected!
1740 return false;
1741
1742 case CK_i386:
1743 case CK_i486:
1744 case CK_WinChipC6:
1745 case CK_WinChip2:
1746 case CK_C3:
1747 case CK_i586:
1748 case CK_Pentium:
1749 case CK_PentiumMMX:
1750 case CK_i686:
1751 case CK_PentiumPro:
1752 case CK_Pentium2:
1753 case CK_Pentium3:
1754 case CK_Pentium3M:
1755 case CK_PentiumM:
1756 case CK_Yonah:
1757 case CK_C3_2:
1758 case CK_Pentium4:
1759 case CK_Pentium4M:
1760 case CK_Prescott:
1761 case CK_K6:
1762 case CK_K6_2:
1763 case CK_K6_3:
1764 case CK_Athlon:
1765 case CK_AthlonThunderbird:
1766 case CK_Athlon4:
1767 case CK_AthlonXP:
1768 case CK_AthlonMP:
1769 case CK_Geode:
1770 // Only accept certain architectures when compiling in 32-bit mode.
Derek Schuffbabaf312012-10-11 15:52:22 +00001771 if (getTriple().getArch() != llvm::Triple::x86)
Chandler Carruth26a39142011-09-28 09:45:08 +00001772 return false;
1773
1774 // Fallthrough
1775 case CK_Nocona:
1776 case CK_Core2:
1777 case CK_Penryn:
1778 case CK_Atom:
1779 case CK_Corei7:
1780 case CK_Corei7AVX:
1781 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001782 case CK_CoreAVX2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001783 case CK_Athlon64:
1784 case CK_Athlon64SSE3:
1785 case CK_AthlonFX:
1786 case CK_K8:
1787 case CK_K8SSE3:
1788 case CK_Opteron:
1789 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00001790 case CK_AMDFAM10:
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001791 case CK_BTVER1:
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001792 case CK_BDVER1:
1793 case CK_BDVER2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001794 case CK_x86_64:
1795 return true;
1796 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001797 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001798 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00001799
1800 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
1801 // We accept all non-ARM calling conventions
1802 return (CC == CC_X86ThisCall ||
1803 CC == CC_X86FastCall ||
1804 CC == CC_X86StdCall ||
1805 CC == CC_C ||
1806 CC == CC_X86Pascal) ? CCCR_OK : CCCR_Warning;
1807 }
1808
1809 virtual CallingConv getDefaultCallingConv() const {
1810 return CC_C;
1811 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001812};
Chris Lattner3daed522009-03-02 22:20:04 +00001813
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001814void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001815 // FIXME: This should not be here.
1816 Features["3dnow"] = false;
1817 Features["3dnowa"] = false;
1818 Features["mmx"] = false;
1819 Features["sse"] = false;
1820 Features["sse2"] = false;
1821 Features["sse3"] = false;
1822 Features["ssse3"] = false;
1823 Features["sse41"] = false;
1824 Features["sse42"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001825 Features["sse4a"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001826 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00001827 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001828 Features["avx"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001829 Features["avx2"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001830 Features["lzcnt"] = false;
Benjamin Kramer84f30802012-07-07 09:39:18 +00001831 Features["rdrand"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001832 Features["bmi"] = false;
1833 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001834 Features["popcnt"] = false;
Michael Liao463eb892012-11-10 05:17:46 +00001835 Features["rtm"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001836 Features["fma4"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00001837 Features["fma"] = false;
Craig Topperb6af69e2012-06-09 22:24:14 +00001838 Features["xop"] = false;
Manman Ren146e5a42012-10-11 00:59:55 +00001839 Features["f16c"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001840
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001841 // FIXME: This *really* should not be here.
1842
1843 // X86_64 always has SSE2.
Derek Schuffbabaf312012-10-11 15:52:22 +00001844 if (getTriple().getArch() == llvm::Triple::x86_64)
Eli Friedman612db2a2012-11-17 01:16:19 +00001845 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001846
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001847 switch (CPU) {
1848 case CK_Generic:
1849 case CK_i386:
1850 case CK_i486:
1851 case CK_i586:
1852 case CK_Pentium:
1853 case CK_i686:
1854 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001855 break;
1856 case CK_PentiumMMX:
1857 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001858 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001859 break;
1860 case CK_Pentium3:
1861 case CK_Pentium3M:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001862 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001863 break;
1864 case CK_PentiumM:
1865 case CK_Pentium4:
1866 case CK_Pentium4M:
1867 case CK_x86_64:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001868 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001869 break;
1870 case CK_Yonah:
1871 case CK_Prescott:
1872 case CK_Nocona:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001873 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001874 break;
1875 case CK_Core2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001876 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001877 break;
1878 case CK_Penryn:
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:
Chandler Carruth49defe62011-09-28 10:36:46 +00001882 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001883 break;
1884 case CK_Corei7:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001885 setFeatureEnabled(Features, "sse4", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001886 break;
1887 case CK_Corei7AVX:
Benjamin Kramer84f30802012-07-07 09:39:18 +00001888 setFeatureEnabled(Features, "avx", true);
1889 setFeatureEnabled(Features, "aes", true);
1890 setFeatureEnabled(Features, "pclmul", true);
1891 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001892 case CK_CoreAVXi:
Craig Topperfd936302012-04-26 07:31:30 +00001893 setFeatureEnabled(Features, "avx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00001894 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00001895 setFeatureEnabled(Features, "pclmul", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00001896 setFeatureEnabled(Features, "rdrnd", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00001897 setFeatureEnabled(Features, "f16c", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001898 break;
Craig Topper2b03bb02011-12-17 19:55:21 +00001899 case CK_CoreAVX2:
Craig Topperfd936302012-04-26 07:31:30 +00001900 setFeatureEnabled(Features, "avx2", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00001901 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00001902 setFeatureEnabled(Features, "pclmul", true);
Craig Topper31ceea02011-12-25 05:06:45 +00001903 setFeatureEnabled(Features, "lzcnt", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00001904 setFeatureEnabled(Features, "rdrnd", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00001905 setFeatureEnabled(Features, "f16c", true);
Craig Topper31ceea02011-12-25 05:06:45 +00001906 setFeatureEnabled(Features, "bmi", true);
1907 setFeatureEnabled(Features, "bmi2", true);
Michael Liao463eb892012-11-10 05:17:46 +00001908 setFeatureEnabled(Features, "rtm", true);
Craig Topper2ae95072012-06-03 21:46:30 +00001909 setFeatureEnabled(Features, "fma", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00001910 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001911 case CK_K6:
1912 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001913 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001914 break;
1915 case CK_K6_2:
1916 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001917 case CK_WinChip2:
1918 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001919 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001920 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00001921 case CK_Athlon:
1922 case CK_AthlonThunderbird:
1923 case CK_Geode:
1924 setFeatureEnabled(Features, "3dnowa", true);
1925 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001926 case CK_Athlon4:
1927 case CK_AthlonXP:
1928 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001929 setFeatureEnabled(Features, "sse", true);
1930 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001931 break;
1932 case CK_K8:
1933 case CK_Opteron:
1934 case CK_Athlon64:
1935 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00001936 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001937 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001938 break;
1939 case CK_K8SSE3:
1940 case CK_OpteronSSE3:
1941 case CK_Athlon64SSE3:
Roman Divacky80b32b82011-10-30 13:47:56 +00001942 setFeatureEnabled(Features, "sse3", true);
1943 setFeatureEnabled(Features, "3dnowa", true);
1944 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00001945 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00001946 setFeatureEnabled(Features, "sse3", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00001947 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00001948 setFeatureEnabled(Features, "3dnowa", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00001949 setFeatureEnabled(Features, "lzcnt", true);
1950 setFeatureEnabled(Features, "popcnt", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001951 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001952 case CK_BTVER1:
1953 setFeatureEnabled(Features, "ssse3", true);
1954 setFeatureEnabled(Features, "sse4a", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00001955 setFeatureEnabled(Features, "lzcnt", true);
1956 setFeatureEnabled(Features, "popcnt", true);
Craig Topper90ea0362012-05-30 05:54:54 +00001957 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001958 case CK_BDVER1:
Craig Topperb6af69e2012-06-09 22:24:14 +00001959 setFeatureEnabled(Features, "xop", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00001960 setFeatureEnabled(Features, "lzcnt", 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);
Eli Friedmanfaf35382012-11-17 01:43:10 +00001963 case CK_BDVER2:
1964 setFeatureEnabled(Features, "xop", true);
1965 setFeatureEnabled(Features, "lzcnt", true);
1966 setFeatureEnabled(Features, "aes", true);
1967 setFeatureEnabled(Features, "pclmul", true);
1968 setFeatureEnabled(Features, "bmi", true);
1969 setFeatureEnabled(Features, "fma", true);
1970 setFeatureEnabled(Features, "f16c", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001971 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001972 case CK_C3_2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001973 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001974 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001975 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001976}
1977
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001978bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001979 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001980 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00001981 // FIXME: This *really* should not be here. We need some way of translating
1982 // options into llvm subtarget features.
1983 if (!Features.count(Name) &&
Benjamin Kramer84f30802012-07-07 09:39:18 +00001984 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1" &&
1985 Name != "rdrnd"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001986 return false;
1987
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001988 // FIXME: this should probably use a switch with fall through.
1989
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001990 if (Enabled) {
1991 if (Name == "mmx")
1992 Features["mmx"] = true;
1993 else if (Name == "sse")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001994 Features["mmx"] = Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001995 else if (Name == "sse2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001996 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001997 else if (Name == "sse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001998 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1999 true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002000 else if (Name == "ssse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002001 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002002 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00002003 else if (Name == "sse4" || Name == "sse4.2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002004 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002005 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2006 Features["popcnt"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00002007 else if (Name == "sse4.1")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002008 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00002009 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002010 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002011 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002012 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002013 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00002014 else if (Name == "aes")
Craig Toppera7463c32012-06-03 21:56:22 +00002015 Features["sse"] = Features["sse2"] = Features["aes"] = true;
Craig Topper3c0bc152012-05-31 05:18:48 +00002016 else if (Name == "pclmul")
Craig Toppera7463c32012-06-03 21:56:22 +00002017 Features["sse"] = Features["sse2"] = Features["pclmul"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002018 else if (Name == "avx")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002019 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2020 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002021 Features["popcnt"] = Features["avx"] = true;
Craig Topper2b03bb02011-12-17 19:55:21 +00002022 else if (Name == "avx2")
2023 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2024 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002025 Features["popcnt"] = Features["avx"] = Features["avx2"] = true;
Craig Topper2ae95072012-06-03 21:46:30 +00002026 else if (Name == "fma")
2027 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2028 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2029 Features["popcnt"] = Features["avx"] = Features["fma"] = true;
Craig Topper6a511e12011-12-30 07:33:42 +00002030 else if (Name == "fma4")
Eli Friedman612db2a2012-11-17 01:16:19 +00002031 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00002032 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper90ea0362012-05-30 05:54:54 +00002033 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
2034 Features["fma4"] = true;
Craig Topperb6af69e2012-06-09 22:24:14 +00002035 else if (Name == "xop")
Eli Friedman612db2a2012-11-17 01:16:19 +00002036 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002037 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2038 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
2039 Features["fma4"] = Features["xop"] = true;
Roman Divacky80b32b82011-10-30 13:47:56 +00002040 else if (Name == "sse4a")
Craig Topper6a511e12011-12-30 07:33:42 +00002041 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper90ea0362012-05-30 05:54:54 +00002042 Features["sse4a"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00002043 else if (Name == "lzcnt")
2044 Features["lzcnt"] = true;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002045 else if (Name == "rdrnd")
2046 Features["rdrand"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00002047 else if (Name == "bmi")
2048 Features["bmi"] = true;
2049 else if (Name == "bmi2")
2050 Features["bmi2"] = true;
Craig Toppere14e08b2011-12-29 16:10:46 +00002051 else if (Name == "popcnt")
2052 Features["popcnt"] = true;
Manman Ren146e5a42012-10-11 00:59:55 +00002053 else if (Name == "f16c")
2054 Features["f16c"] = true;
Michael Liao463eb892012-11-10 05:17:46 +00002055 else if (Name == "rtm")
2056 Features["rtm"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002057 } else {
2058 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002059 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002060 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00002061 Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00002062 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002063 Features["sse4a"] = Features["avx"] = Features["avx2"] =
2064 Features["fma"] = Features["fma4"] = Features["aes"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002065 Features["pclmul"] = Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002066 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00002067 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Craig Toppera7463c32012-06-03 21:56:22 +00002068 Features["sse41"] = Features["sse42"] = Features["sse4a"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002069 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002070 Features["fma4"] = Features["aes"] = Features["pclmul"] =
2071 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002072 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00002073 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002074 Features["sse42"] = Features["sse4a"] = Features["avx"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002075 Features["avx2"] = Features["fma"] = Features["fma4"] =
2076 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002077 else if (Name == "ssse3")
Craig Topper31380fb2012-06-03 22:23:42 +00002078 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2079 Features["avx"] = Features["avx2"] = Features["fma"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00002080 else if (Name == "sse4" || Name == "sse4.1")
Craig Topper31380fb2012-06-03 22:23:42 +00002081 Features["sse41"] = Features["sse42"] = Features["avx"] =
2082 Features["avx2"] = Features["fma"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00002083 else if (Name == "sse4.2")
Craig Topper31380fb2012-06-03 22:23:42 +00002084 Features["sse42"] = Features["avx"] = Features["avx2"] =
2085 Features["fma"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002086 else if (Name == "3dnow")
2087 Features["3dnow"] = Features["3dnowa"] = false;
2088 else if (Name == "3dnowa")
2089 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00002090 else if (Name == "aes")
2091 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00002092 else if (Name == "pclmul")
2093 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002094 else if (Name == "avx")
Craig Topper2ae95072012-06-03 21:46:30 +00002095 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002096 Features["fma4"] = Features["xop"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00002097 else if (Name == "avx2")
2098 Features["avx2"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00002099 else if (Name == "fma")
2100 Features["fma"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00002101 else if (Name == "sse4a")
Craig Topperb6af69e2012-06-09 22:24:14 +00002102 Features["sse4a"] = Features["fma4"] = Features["xop"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002103 else if (Name == "lzcnt")
2104 Features["lzcnt"] = false;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002105 else if (Name == "rdrnd")
2106 Features["rdrand"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002107 else if (Name == "bmi")
2108 Features["bmi"] = false;
2109 else if (Name == "bmi2")
2110 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00002111 else if (Name == "popcnt")
2112 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00002113 else if (Name == "fma4")
Craig Topperb6af69e2012-06-09 22:24:14 +00002114 Features["fma4"] = Features["xop"] = false;
2115 else if (Name == "xop")
2116 Features["xop"] = false;
Manman Ren146e5a42012-10-11 00:59:55 +00002117 else if (Name == "f16c")
2118 Features["f16c"] = false;
Michael Liao463eb892012-11-10 05:17:46 +00002119 else if (Name == "rtm")
2120 Features["rtm"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002121 }
2122
2123 return true;
2124}
2125
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002126/// HandleTargetOptions - Perform initialization based on the user
2127/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00002128void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002129 // Remember the maximum enabled sselevel.
2130 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
2131 // Ignore disabled features.
2132 if (Features[i][0] == '-')
2133 continue;
2134
Benjamin Kramer713575a2012-03-05 15:10:44 +00002135 StringRef Feature = StringRef(Features[i]).substr(1);
2136
2137 if (Feature == "aes") {
Eric Christophereea12d12010-04-02 23:50:19 +00002138 HasAES = true;
2139 continue;
2140 }
2141
Craig Topper3c0bc152012-05-31 05:18:48 +00002142 if (Feature == "pclmul") {
2143 HasPCLMUL = true;
2144 continue;
2145 }
2146
Benjamin Kramer713575a2012-03-05 15:10:44 +00002147 if (Feature == "lzcnt") {
Craig Topper31ceea02011-12-25 05:06:45 +00002148 HasLZCNT = true;
2149 continue;
2150 }
2151
Benjamin Kramer84f30802012-07-07 09:39:18 +00002152 if (Feature == "rdrand") {
2153 HasRDRND = true;
2154 continue;
2155 }
2156
Benjamin Kramer713575a2012-03-05 15:10:44 +00002157 if (Feature == "bmi") {
Craig Topper31ceea02011-12-25 05:06:45 +00002158 HasBMI = true;
2159 continue;
2160 }
2161
Benjamin Kramer713575a2012-03-05 15:10:44 +00002162 if (Feature == "bmi2") {
Craig Topper31ceea02011-12-25 05:06:45 +00002163 HasBMI2 = true;
2164 continue;
2165 }
2166
Benjamin Kramer713575a2012-03-05 15:10:44 +00002167 if (Feature == "popcnt") {
Craig Toppere14e08b2011-12-29 16:10:46 +00002168 HasPOPCNT = true;
2169 continue;
2170 }
2171
Michael Liao463eb892012-11-10 05:17:46 +00002172 if (Feature == "rtm") {
2173 HasRTM = true;
2174 continue;
2175 }
2176
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002177 if (Feature == "sse4a") {
2178 HasSSE4a = true;
2179 continue;
2180 }
2181
Benjamin Kramer713575a2012-03-05 15:10:44 +00002182 if (Feature == "fma4") {
Craig Topper6a511e12011-12-30 07:33:42 +00002183 HasFMA4 = true;
2184 continue;
2185 }
2186
Craig Topper2ae95072012-06-03 21:46:30 +00002187 if (Feature == "fma") {
2188 HasFMA = true;
2189 continue;
2190 }
2191
Craig Topperb6af69e2012-06-09 22:24:14 +00002192 if (Feature == "xop") {
2193 HasXOP = true;
2194 continue;
2195 }
2196
Manman Ren146e5a42012-10-11 00:59:55 +00002197 if (Feature == "f16c") {
2198 HasF16C = true;
2199 continue;
2200 }
2201
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002202 assert(Features[i][0] == '+' && "Invalid target feature!");
Benjamin Kramer713575a2012-03-05 15:10:44 +00002203 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Craig Topper05fe4b52012-01-09 09:19:09 +00002204 .Case("avx2", AVX2)
2205 .Case("avx", AVX)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002206 .Case("sse42", SSE42)
2207 .Case("sse41", SSE41)
2208 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00002209 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002210 .Case("sse2", SSE2)
2211 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002212 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002213 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002214
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002215 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer713575a2012-03-05 15:10:44 +00002216 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002217 .Case("3dnowa", AMD3DNowAthlon)
2218 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002219 .Case("mmx", MMX)
2220 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002221
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002222 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002223 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002224
2225 // Don't tell the backend if we're turning off mmx; it will end up disabling
2226 // SSE, which we don't want.
2227 std::vector<std::string>::iterator it;
2228 it = std::find(Features.begin(), Features.end(), "-mmx");
2229 if (it != Features.end())
2230 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00002231}
Chris Lattnerc0f59212009-03-02 22:27:17 +00002232
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002233/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
2234/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00002235void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002236 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002237 // Target identification.
Derek Schuffbabaf312012-10-11 15:52:22 +00002238 if (getTriple().getArch() == llvm::Triple::x86_64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002239 Builder.defineMacro("__amd64__");
2240 Builder.defineMacro("__amd64");
2241 Builder.defineMacro("__x86_64");
2242 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002243 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00002244 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00002245 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002246
Chris Lattnerc0f59212009-03-02 22:27:17 +00002247 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002248 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
2249 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002250 switch (CPU) {
2251 case CK_Generic:
2252 break;
2253 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002254 // The rest are coming from the i386 define above.
2255 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002256 break;
2257 case CK_i486:
2258 case CK_WinChipC6:
2259 case CK_WinChip2:
2260 case CK_C3:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002261 defineCPUMacros(Builder, "i486");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002262 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00002263 case CK_PentiumMMX:
2264 Builder.defineMacro("__pentium_mmx__");
2265 Builder.defineMacro("__tune_pentium_mmx__");
2266 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002267 case CK_i586:
2268 case CK_Pentium:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002269 defineCPUMacros(Builder, "i586");
2270 defineCPUMacros(Builder, "pentium");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002271 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002272 case CK_Pentium3:
2273 case CK_Pentium3M:
2274 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002275 Builder.defineMacro("__tune_pentium3__");
2276 // Fallthrough
2277 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002278 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002279 Builder.defineMacro("__tune_pentium2__");
2280 // Fallthrough
2281 case CK_PentiumPro:
2282 Builder.defineMacro("__tune_i686__");
2283 Builder.defineMacro("__tune_pentiumpro__");
2284 // Fallthrough
2285 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002286 Builder.defineMacro("__i686");
2287 Builder.defineMacro("__i686__");
2288 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
2289 Builder.defineMacro("__pentiumpro");
2290 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002291 break;
2292 case CK_Pentium4:
2293 case CK_Pentium4M:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002294 defineCPUMacros(Builder, "pentium4");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002295 break;
2296 case CK_Yonah:
2297 case CK_Prescott:
2298 case CK_Nocona:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002299 defineCPUMacros(Builder, "nocona");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002300 break;
2301 case CK_Core2:
2302 case CK_Penryn:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002303 defineCPUMacros(Builder, "core2");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002304 break;
2305 case CK_Atom:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002306 defineCPUMacros(Builder, "atom");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002307 break;
2308 case CK_Corei7:
2309 case CK_Corei7AVX:
2310 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00002311 case CK_CoreAVX2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002312 defineCPUMacros(Builder, "corei7");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002313 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002314 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002315 Builder.defineMacro("__k6_2__");
2316 Builder.defineMacro("__tune_k6_2__");
2317 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002318 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002319 if (CPU != CK_K6_2) { // In case of fallthrough
2320 // FIXME: GCC may be enabling these in cases where some other k6
2321 // architecture is specified but -m3dnow is explicitly provided. The
2322 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002323 Builder.defineMacro("__k6_3__");
2324 Builder.defineMacro("__tune_k6_3__");
2325 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00002326 // Fallthrough
2327 case CK_K6:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002328 defineCPUMacros(Builder, "k6");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002329 break;
2330 case CK_Athlon:
2331 case CK_AthlonThunderbird:
2332 case CK_Athlon4:
2333 case CK_AthlonXP:
2334 case CK_AthlonMP:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002335 defineCPUMacros(Builder, "athlon");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002336 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002337 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002338 Builder.defineMacro("__tune_athlon_sse__");
2339 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002340 break;
2341 case CK_K8:
2342 case CK_K8SSE3:
2343 case CK_x86_64:
2344 case CK_Opteron:
2345 case CK_OpteronSSE3:
2346 case CK_Athlon64:
2347 case CK_Athlon64SSE3:
2348 case CK_AthlonFX:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002349 defineCPUMacros(Builder, "k8");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002350 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002351 case CK_AMDFAM10:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002352 defineCPUMacros(Builder, "amdfam10");
Roman Divacky01c770d2011-10-30 07:48:46 +00002353 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002354 case CK_BTVER1:
2355 defineCPUMacros(Builder, "btver1");
2356 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002357 case CK_BDVER1:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002358 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002359 break;
2360 case CK_BDVER2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002361 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002362 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002363 case CK_Geode:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002364 defineCPUMacros(Builder, "geode");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002365 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002366 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00002367
Chandler Carruth88c75b02011-09-28 09:54:07 +00002368 // Target properties.
2369 Builder.defineMacro("__LITTLE_ENDIAN__");
2370 Builder.defineMacro("__REGISTER_PREFIX__", "");
2371
Chris Lattner54175442009-04-19 17:32:33 +00002372 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2373 // functions in glibc header files that use FP Stack inline asm which the
2374 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00002375 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002376
Chandler Carruth88c75b02011-09-28 09:54:07 +00002377 if (HasAES)
2378 Builder.defineMacro("__AES__");
2379
Craig Topper3c0bc152012-05-31 05:18:48 +00002380 if (HasPCLMUL)
2381 Builder.defineMacro("__PCLMUL__");
2382
Craig Topper31ceea02011-12-25 05:06:45 +00002383 if (HasLZCNT)
2384 Builder.defineMacro("__LZCNT__");
2385
Benjamin Kramer84f30802012-07-07 09:39:18 +00002386 if (HasRDRND)
2387 Builder.defineMacro("__RDRND__");
2388
Craig Topper31ceea02011-12-25 05:06:45 +00002389 if (HasBMI)
2390 Builder.defineMacro("__BMI__");
2391
2392 if (HasBMI2)
2393 Builder.defineMacro("__BMI2__");
2394
Craig Toppere14e08b2011-12-29 16:10:46 +00002395 if (HasPOPCNT)
2396 Builder.defineMacro("__POPCNT__");
2397
Michael Liao463eb892012-11-10 05:17:46 +00002398 if (HasRTM)
2399 Builder.defineMacro("__RTM__");
2400
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002401 if (HasSSE4a)
2402 Builder.defineMacro("__SSE4A__");
2403
Craig Topper6a511e12011-12-30 07:33:42 +00002404 if (HasFMA4)
2405 Builder.defineMacro("__FMA4__");
2406
Craig Topper2ae95072012-06-03 21:46:30 +00002407 if (HasFMA)
2408 Builder.defineMacro("__FMA__");
2409
Craig Topperb6af69e2012-06-09 22:24:14 +00002410 if (HasXOP)
2411 Builder.defineMacro("__XOP__");
2412
Manman Ren146e5a42012-10-11 00:59:55 +00002413 if (HasF16C)
2414 Builder.defineMacro("__F16C__");
2415
Chris Lattner84f0ea82009-03-02 22:40:39 +00002416 // Each case falls through to the previous one here.
2417 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002418 case AVX2:
2419 Builder.defineMacro("__AVX2__");
2420 case AVX:
2421 Builder.defineMacro("__AVX__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002422 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00002423 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002424 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00002425 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002426 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002427 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002428 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002429 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002430 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00002431 Builder.defineMacro("__SSE2__");
2432 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00002433 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00002434 Builder.defineMacro("__SSE__");
2435 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002436 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00002437 break;
2438 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002439
Derek Schuffbabaf312012-10-11 15:52:22 +00002440 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002441 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002442 case AVX2:
2443 case AVX:
Michael J. Spencera764e832010-10-21 08:22:51 +00002444 case SSE42:
2445 case SSE41:
2446 case SSSE3:
2447 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002448 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002449 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002450 break;
2451 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002452 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002453 break;
2454 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002455 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002456 }
2457 }
2458
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002459 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002460 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002461 case AMD3DNowAthlon:
2462 Builder.defineMacro("__3dNOW_A__");
2463 case AMD3DNow:
2464 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002465 case MMX:
2466 Builder.defineMacro("__MMX__");
2467 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002468 break;
2469 }
Chris Lattnerc0f59212009-03-02 22:27:17 +00002470}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002471
Douglas Gregore727d212012-01-30 06:38:25 +00002472bool X86TargetInfo::hasFeature(StringRef Feature) const {
2473 return llvm::StringSwitch<bool>(Feature)
2474 .Case("aes", HasAES)
2475 .Case("avx", SSELevel >= AVX)
2476 .Case("avx2", SSELevel >= AVX2)
2477 .Case("bmi", HasBMI)
2478 .Case("bmi2", HasBMI2)
Craig Topper2ae95072012-06-03 21:46:30 +00002479 .Case("fma", HasFMA)
Douglas Gregore727d212012-01-30 06:38:25 +00002480 .Case("fma4", HasFMA4)
2481 .Case("lzcnt", HasLZCNT)
Benjamin Kramer84f30802012-07-07 09:39:18 +00002482 .Case("rdrnd", HasRDRND)
Douglas Gregore727d212012-01-30 06:38:25 +00002483 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
2484 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
2485 .Case("mmx", MMX3DNowLevel >= MMX)
Craig Topper3c0bc152012-05-31 05:18:48 +00002486 .Case("pclmul", HasPCLMUL)
Douglas Gregore727d212012-01-30 06:38:25 +00002487 .Case("popcnt", HasPOPCNT)
Michael Liao463eb892012-11-10 05:17:46 +00002488 .Case("rtm", HasRTM)
Douglas Gregore727d212012-01-30 06:38:25 +00002489 .Case("sse", SSELevel >= SSE1)
2490 .Case("sse2", SSELevel >= SSE2)
2491 .Case("sse3", SSELevel >= SSE3)
2492 .Case("ssse3", SSELevel >= SSSE3)
2493 .Case("sse41", SSELevel >= SSE41)
2494 .Case("sse42", SSELevel >= SSE42)
Craig Topper3c0bc152012-05-31 05:18:48 +00002495 .Case("sse4a", HasSSE4a)
Douglas Gregore727d212012-01-30 06:38:25 +00002496 .Case("x86", true)
Derek Schuffbabaf312012-10-11 15:52:22 +00002497 .Case("x86_32", getTriple().getArch() == llvm::Triple::x86)
2498 .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64)
Craig Topperb6af69e2012-06-09 22:24:14 +00002499 .Case("xop", HasXOP)
Manman Ren146e5a42012-10-11 00:59:55 +00002500 .Case("f16c", HasF16C)
Douglas Gregore727d212012-01-30 06:38:25 +00002501 .Default(false);
2502}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002503
Eli Friedman618234a2008-08-20 02:34:37 +00002504bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002505X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002506 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002507 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00002508 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00002509 case 'Y': // first letter of a pair:
2510 switch (*(Name+1)) {
2511 default: return false;
2512 case '0': // First SSE register.
2513 case 't': // Any SSE register, when SSE2 is enabled.
2514 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2515 case 'm': // any MMX register, when inter-unit moves enabled.
2516 break; // falls through to setAllowsRegister.
2517 }
Eli Friedman618234a2008-08-20 02:34:37 +00002518 case 'a': // eax.
2519 case 'b': // ebx.
2520 case 'c': // ecx.
2521 case 'd': // edx.
2522 case 'S': // esi.
2523 case 'D': // edi.
2524 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00002525 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00002526 case 't': // top of floating point stack.
2527 case 'u': // second from top of floating point stack.
2528 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00002529 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00002530 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00002531 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00002532 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2533 case 'l': // "Index" registers: any general register that can be used as an
2534 // index in a base+index memory access.
2535 Info.setAllowsRegister();
2536 return true;
2537 case 'C': // SSE floating point constant.
2538 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002539 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002540 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002541 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002542 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00002543 return true;
2544 }
2545}
2546
Dale Johannesenf6e2c202010-10-29 23:12:32 +00002547
Eli Friedman618234a2008-08-20 02:34:37 +00002548std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00002549X86TargetInfo::convertConstraint(const char *&Constraint) const {
2550 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00002551 case 'a': return std::string("{ax}");
2552 case 'b': return std::string("{bx}");
2553 case 'c': return std::string("{cx}");
2554 case 'd': return std::string("{dx}");
2555 case 'S': return std::string("{si}");
2556 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00002557 case 'p': // address
2558 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00002559 case 't': // top of floating point stack.
2560 return std::string("{st}");
2561 case 'u': // second from top of floating point stack.
2562 return std::string("{st(1)}"); // second from top of floating point stack.
2563 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00002564 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00002565 }
2566}
Eli Friedman618234a2008-08-20 02:34:37 +00002567} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00002568
2569namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002570// X86-32 generic target
2571class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00002572public:
Eli Friedman618234a2008-08-20 02:34:37 +00002573 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
2574 DoubleAlign = LongLongAlign = 32;
2575 LongDoubleWidth = 96;
2576 LongDoubleAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00002577 SuitableAlign = 128;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002578 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2579 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00002580 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00002581 SizeType = UnsignedInt;
2582 PtrDiffType = SignedInt;
2583 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002584 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002585
2586 // Use fpret for all types.
2587 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2588 (1 << TargetInfo::Double) |
2589 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002590
2591 // x86-32 has atomics up to 8 bytes
2592 // FIXME: Check that we actually have cmpxchg8b before setting
2593 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2594 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002595 }
Meador Ingec5613b22012-06-16 03:34:49 +00002596 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2597 return TargetInfo::CharPtrBuiltinVaList;
Eli Friedman618234a2008-08-20 02:34:37 +00002598 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002599
Chris Lattner21fb98e2009-09-23 06:06:36 +00002600 int getEHDataRegisterNumber(unsigned RegNo) const {
2601 if (RegNo == 0) return 0;
2602 if (RegNo == 1) return 2;
2603 return -1;
2604 }
Bill Wendling68fd6082012-11-12 06:42:51 +00002605 virtual bool validateInputSize(StringRef Constraint,
2606 unsigned Size) const {
2607 switch (Constraint[0]) {
2608 default: break;
2609 case 'a':
2610 case 'b':
2611 case 'c':
2612 case 'd':
Bill Wendlingf634bdf2012-11-12 18:52:32 +00002613 return Size <= 32;
Bill Wendling68fd6082012-11-12 06:42:51 +00002614 }
2615
2616 return true;
2617 }
Eli Friedman618234a2008-08-20 02:34:37 +00002618};
2619} // end anonymous namespace
2620
2621namespace {
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002622class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
2623public:
2624 NetBSDI386TargetInfo(const std::string &triple) :
2625 NetBSDTargetInfo<X86_32TargetInfo>(triple) {
2626 }
2627
2628 virtual unsigned getFloatEvalMethod() const {
2629 // NetBSD defaults to "double" rounding
2630 return 1;
2631 }
2632};
2633} // end anonymous namespace
2634
2635namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002636class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2637public:
2638 OpenBSDI386TargetInfo(const std::string& triple) :
2639 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2640 SizeType = UnsignedLong;
2641 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002642 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002643 }
2644};
2645} // end anonymous namespace
2646
2647namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00002648class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
2649public:
2650 BitrigI386TargetInfo(const std::string& triple) :
2651 BitrigTargetInfo<X86_32TargetInfo>(triple) {
2652 SizeType = UnsignedLong;
2653 IntPtrType = SignedLong;
2654 PtrDiffType = SignedLong;
2655 }
2656};
2657} // end anonymous namespace
2658
2659namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002660class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002661public:
Torok Edwin5f6c1942009-06-30 17:10:35 +00002662 DarwinI386TargetInfo(const std::string& triple) :
2663 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002664 LongDoubleWidth = 128;
2665 LongDoubleAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002666 SuitableAlign = 128;
Chad Rosierf9e9af72012-07-13 23:57:43 +00002667 MaxVectorAlign = 256;
Eli Friedman1afabd92009-03-29 20:31:09 +00002668 SizeType = UnsignedLong;
2669 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002670 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2671 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002672 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002673 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002674 }
2675
Eli Friedman618234a2008-08-20 02:34:37 +00002676};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002677} // end anonymous namespace
2678
2679namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002680// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002681class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002682public:
2683 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002684 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002685 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002686 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002687 DoubleAlign = LongLongAlign = 64;
2688 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 +00002689 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002690 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002691 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002692 virtual void getTargetDefines(const LangOptions &Opts,
2693 MacroBuilder &Builder) const {
2694 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2695 }
2696};
2697} // end anonymous namespace
2698
2699namespace {
2700
2701// x86-32 Windows Visual Studio target
2702class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2703public:
2704 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2705 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002706 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002707 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2708 }
2709 virtual void getTargetDefines(const LangOptions &Opts,
2710 MacroBuilder &Builder) const {
2711 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2712 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2713 // The value of the following reflects processor type.
2714 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2715 // We lost the original triple, so we use the default.
2716 Builder.defineMacro("_M_IX86", "600");
2717 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002718};
2719} // end anonymous namespace
2720
2721namespace {
2722// x86-32 MinGW target
2723class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2724public:
2725 MinGWX86_32TargetInfo(const std::string& triple)
2726 : WindowsX86_32TargetInfo(triple) {
2727 }
2728 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002729 MacroBuilder &Builder) const {
2730 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002731 DefineStd(Builder, "WIN32", Opts);
2732 DefineStd(Builder, "WINNT", Opts);
2733 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002734 Builder.defineMacro("__MSVCRT__");
2735 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002736
2737 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2738 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002739 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002740 // Provide "as-is" __declspec.
2741 Builder.defineMacro("__declspec", "__declspec");
2742 else
2743 // Provide alias of __attribute__ like mingw32-gcc.
2744 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002745 }
2746};
2747} // end anonymous namespace
2748
2749namespace {
2750// x86-32 Cygwin target
2751class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2752public:
2753 CygwinX86_32TargetInfo(const std::string& triple)
2754 : X86_32TargetInfo(triple) {
2755 TLSSupported = false;
2756 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002757 DoubleAlign = LongLongAlign = 64;
2758 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2759 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002760 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002761 }
2762 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002763 MacroBuilder &Builder) const {
2764 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2765 Builder.defineMacro("__CYGWIN__");
2766 Builder.defineMacro("__CYGWIN32__");
2767 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00002768 if (Opts.CPlusPlus)
2769 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00002770 }
Eli Friedman29a30502008-08-21 01:40:19 +00002771};
2772} // end anonymous namespace
2773
2774namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002775// x86-32 Haiku target
2776class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2777public:
2778 HaikuX86_32TargetInfo(const std::string& triple)
2779 : X86_32TargetInfo(triple) {
2780 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00002781 IntPtrType = SignedLong;
2782 PtrDiffType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00002783 this->UserLabelPrefix = "";
Benjamin Krameref7bcea2012-11-08 12:59:15 +00002784 this->TLSSupported = false;
Eli Friedmana7e68452010-08-22 01:00:03 +00002785 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00002786 virtual void getTargetDefines(const LangOptions &Opts,
2787 MacroBuilder &Builder) const {
2788 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2789 Builder.defineMacro("__INTEL__");
2790 Builder.defineMacro("__HAIKU__");
2791 }
2792};
2793} // end anonymous namespace
2794
Douglas Gregordca52262011-07-01 22:41:14 +00002795// RTEMS Target
2796template<typename Target>
2797class RTEMSTargetInfo : public OSTargetInfo<Target> {
2798protected:
2799 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2800 MacroBuilder &Builder) const {
2801 // RTEMS defines; list based off of gcc output
2802
Douglas Gregordca52262011-07-01 22:41:14 +00002803 Builder.defineMacro("__rtems__");
2804 Builder.defineMacro("__ELF__");
2805 }
2806public:
2807 RTEMSTargetInfo(const std::string &triple)
2808 : OSTargetInfo<Target>(triple) {
2809 this->UserLabelPrefix = "";
2810
2811 llvm::Triple Triple(triple);
2812 switch (Triple.getArch()) {
2813 default:
2814 case llvm::Triple::x86:
2815 // this->MCountName = ".mcount";
2816 break;
2817 case llvm::Triple::mips:
2818 case llvm::Triple::mipsel:
2819 case llvm::Triple::ppc:
2820 case llvm::Triple::ppc64:
2821 // this->MCountName = "_mcount";
2822 break;
2823 case llvm::Triple::arm:
2824 // this->MCountName = "__mcount";
2825 break;
2826 }
2827
2828 }
2829};
2830
2831namespace {
2832// x86-32 RTEMS target
2833class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2834public:
2835 RTEMSX86_32TargetInfo(const std::string& triple)
2836 : X86_32TargetInfo(triple) {
2837 SizeType = UnsignedLong;
2838 IntPtrType = SignedLong;
2839 PtrDiffType = SignedLong;
2840 this->UserLabelPrefix = "";
2841 }
2842 virtual void getTargetDefines(const LangOptions &Opts,
2843 MacroBuilder &Builder) const {
2844 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2845 Builder.defineMacro("__INTEL__");
2846 Builder.defineMacro("__rtems__");
2847 }
2848};
2849} // end anonymous namespace
2850
Chris Lattner86ed3a32010-04-11 19:29:39 +00002851namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002852// x86-64 generic target
2853class X86_64TargetInfo : public X86TargetInfo {
2854public:
Chris Lattner33328642009-03-20 15:52:06 +00002855 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00002856 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002857 LongDoubleWidth = 128;
2858 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00002859 LargeArrayMinWidth = 128;
2860 LargeArrayAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002861 SuitableAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00002862 IntMaxType = SignedLong;
2863 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002864 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002865 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00002866
Eli Friedmaned855cb2008-08-21 00:13:15 +00002867 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2868 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002869 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002870
2871 // Use fpret only for long double.
2872 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00002873
Anders Carlssoneea64802011-10-31 16:27:11 +00002874 // Use fp2ret for _Complex long double.
2875 ComplexLongDoubleUsesFP2Ret = true;
2876
Eli Friedman2be46072011-10-14 20:59:01 +00002877 // x86-64 has atomics up to 16 bytes.
2878 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
2879 // on CPUs with cmpxchg16b
2880 MaxAtomicPromoteWidth = 128;
2881 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00002882 }
Meador Ingec5613b22012-06-16 03:34:49 +00002883 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2884 return TargetInfo::X86_64ABIBuiltinVaList;
Anders Carlsson3346ae62007-11-24 23:38:12 +00002885 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002886
Chris Lattner21fb98e2009-09-23 06:06:36 +00002887 int getEHDataRegisterNumber(unsigned RegNo) const {
2888 if (RegNo == 0) return 0;
2889 if (RegNo == 1) return 1;
2890 return -1;
2891 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00002892
2893 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
2894 return TargetInfo::checkCallingConvention(CC);
2895 }
2896
2897 virtual CallingConv getDefaultCallingConv() const {
2898 return CC_Default;
2899 }
2900
Eli Friedman618234a2008-08-20 02:34:37 +00002901};
2902} // end anonymous namespace
2903
2904namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002905// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002906class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002907public:
2908 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002909 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002910 TLSSupported = false;
2911 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00002912 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00002913 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00002914 IntMaxType = SignedLongLong;
2915 UIntMaxType = UnsignedLongLong;
2916 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00002917 SizeType = UnsignedLongLong;
2918 PtrDiffType = SignedLongLong;
2919 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00002920 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002921 }
2922 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002923 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002924 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002925 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00002926 }
Meador Ingec5613b22012-06-16 03:34:49 +00002927 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2928 return TargetInfo::CharPtrBuiltinVaList;
NAKAMURA Takumi79521992011-01-17 22:56:23 +00002929 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002930};
2931} // end anonymous namespace
2932
2933namespace {
2934// x86-64 Windows Visual Studio target
2935class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2936public:
2937 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2938 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002939 LongDoubleWidth = LongDoubleAlign = 64;
2940 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00002941 }
2942 virtual void getTargetDefines(const LangOptions &Opts,
2943 MacroBuilder &Builder) const {
2944 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
2945 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00002946 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002947 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002948 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002949};
2950} // end anonymous namespace
2951
2952namespace {
2953// x86-64 MinGW target
2954class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2955public:
2956 MinGWX86_64TargetInfo(const std::string& triple)
2957 : WindowsX86_64TargetInfo(triple) {
2958 }
2959 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002960 MacroBuilder &Builder) const {
2961 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002962 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00002963 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00002964 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00002965 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002966
2967 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2968 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002969 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002970 // Provide "as-is" __declspec.
2971 Builder.defineMacro("__declspec", "__declspec");
2972 else
2973 // Provide alias of __attribute__ like mingw32-gcc.
2974 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002975 }
2976};
2977} // end anonymous namespace
2978
2979namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002980class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2981public:
Mike Stump1eb44332009-09-09 15:08:12 +00002982 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002983 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2984 Int64Type = SignedLongLong;
Chad Rosierf9e9af72012-07-13 23:57:43 +00002985 MaxVectorAlign = 256;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002986 }
2987};
2988} // end anonymous namespace
2989
2990namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00002991class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
2992public:
Mike Stump1eb44332009-09-09 15:08:12 +00002993 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman6036ebe2009-07-05 22:31:18 +00002994 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
2995 IntMaxType = SignedLongLong;
2996 UIntMaxType = UnsignedLongLong;
2997 Int64Type = SignedLongLong;
2998 }
2999};
3000} // end anonymous namespace
3001
3002namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00003003class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
3004public:
3005 BitrigX86_64TargetInfo(const std::string& triple)
3006 : BitrigTargetInfo<X86_64TargetInfo>(triple) {
3007 IntMaxType = SignedLongLong;
3008 UIntMaxType = UnsignedLongLong;
3009 Int64Type = SignedLongLong;
3010 }
3011};
3012} // end anonymous namespace
3013
3014namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00003015class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003016 // Possible FPU choices.
3017 enum FPUMode {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003018 VFP2FPU = (1 << 0),
3019 VFP3FPU = (1 << 1),
3020 VFP4FPU = (1 << 2),
3021 NeonFPU = (1 << 3)
Daniel Dunbara91320b2009-12-21 23:28:17 +00003022 };
3023
3024 static bool FPUModeIsVFP(FPUMode Mode) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003025 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU);
Daniel Dunbara91320b2009-12-21 23:28:17 +00003026 }
3027
3028 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3029 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003030
Daniel Dunbareac7c532009-12-18 18:42:37 +00003031 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003032
Bob Wilsoncfaab002012-09-29 23:52:52 +00003033 unsigned FPU : 4;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003034
Logan Chieneae5a8202012-10-10 06:56:20 +00003035 unsigned IsAAPCS : 1;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003036 unsigned IsThumb : 1;
3037
3038 // Initialized via features.
3039 unsigned SoftFloat : 1;
3040 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003041
Chris Lattner2752c012010-03-03 19:03:45 +00003042 static const Builtin::Info BuiltinInfo[];
3043
Chris Lattner393ff042008-04-21 18:56:49 +00003044public:
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003045 ARMTargetInfo(const std::string &TripleStr)
Logan Chieneae5a8202012-10-10 06:56:20 +00003046 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s"), IsAAPCS(true)
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003047 {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003048 BigEndian = false;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003049 SizeType = UnsignedInt;
3050 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00003051 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
3052 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003053
Chris Lattner9bffb072010-04-23 16:29:58 +00003054 // {} in inline assembly are neon specifiers, not assembly variant
3055 // specifiers.
3056 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00003057
Daniel Dunbareac7c532009-12-18 18:42:37 +00003058 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00003059 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003060 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003061 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3062 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003063 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
3064 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003065 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003066 } else {
3067 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3068 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003069 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003070 }
John McCallee79a4c2010-08-21 22:46:04 +00003071
3072 // ARM targets default to using the ARM C++ ABI.
3073 CXXABI = CXXABI_ARM;
Eli Friedman2be46072011-10-14 20:59:01 +00003074
3075 // ARM has atomics up to 8 bytes
3076 // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e
3077 MaxAtomicPromoteWidth = 64;
James Molloye45b9b72012-03-12 09:14:10 +00003078
3079 // Do force alignment of members that follow zero length bitfields. If
3080 // the alignment of the zero-length bitfield is greater than the member
3081 // that follows it, `bar', `bar' will be aligned as the type of the
3082 // zero length bitfield.
3083 UseZeroLengthBitfieldAlignment = true;
Eli Friedman61538a72008-05-20 14:21:01 +00003084 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003085 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00003086 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003087 ABI = Name;
3088
Daniel Dunbara2a41612009-09-14 00:02:24 +00003089 // The defaults (above) are for AAPCS, check if we need to change them.
3090 //
3091 // FIXME: We need support for -meabi... we could just mangle it into the
3092 // name.
3093 if (Name == "apcs-gnu") {
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003094 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003095 SizeType = UnsignedLong;
3096
James Molloya6d81f92011-11-23 13:35:08 +00003097 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
3098 WCharType = SignedInt;
3099
Daniel Dunbar684de632010-04-22 16:14:54 +00003100 // Do not respect the alignment of bit-field types when laying out
3101 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
3102 UseBitFieldTypeAlignment = false;
3103
Chad Rosier61a62212011-08-04 01:21:14 +00003104 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00003105 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
3106 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00003107 ZeroLengthBitfieldBoundary = 32;
3108
Logan Chieneae5a8202012-10-10 06:56:20 +00003109 IsAAPCS = false;
3110
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003111 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003112 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3113 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003114 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 +00003115 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003116 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003117 } else {
3118 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 +00003119 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003120 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003121 }
3122
Chad Rosier9f1210c2011-07-26 07:03:04 +00003123 // FIXME: Override "preferred align" for double and long long.
David Tweedb16abb12012-10-25 13:33:01 +00003124 } else if (Name == "aapcs" || Name == "aapcs-vfp") {
Logan Chieneae5a8202012-10-10 06:56:20 +00003125 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003126 // FIXME: Enumerated types are variable width in straight AAPCS.
3127 } else if (Name == "aapcs-linux") {
Logan Chieneae5a8202012-10-10 06:56:20 +00003128 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003129 } else
3130 return false;
3131
3132 return true;
3133 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003134
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003135 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003136 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
3137 Features["vfp2"] = true;
Bob Wilsoncfaab002012-09-29 23:52:52 +00003138 else if (CPU == "cortex-a8" || CPU == "cortex-a15" ||
3139 CPU == "cortex-a9" || CPU == "cortex-a9-mp")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003140 Features["neon"] = true;
Bob Wilsoncfaab002012-09-29 23:52:52 +00003141 else if (CPU == "swift") {
3142 Features["vfp4"] = true;
3143 Features["neon"] = true;
3144 }
Daniel Dunbara91320b2009-12-21 23:28:17 +00003145 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003146
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003147 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00003148 StringRef Name,
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003149 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00003150 if (Name == "soft-float" || Name == "soft-float-abi" ||
Bob Wilsoncfaab002012-09-29 23:52:52 +00003151 Name == "vfp2" || Name == "vfp3" || Name == "vfp4" || Name == "neon" ||
3152 Name == "d16" || Name == "neonfp") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003153 Features[Name] = Enabled;
3154 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003155 return false;
3156
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003157 return true;
3158 }
3159
3160 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003161 FPU = 0;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003162 SoftFloat = SoftFloatABI = false;
3163 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
3164 if (Features[i] == "+soft-float")
3165 SoftFloat = true;
3166 else if (Features[i] == "+soft-float-abi")
3167 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003168 else if (Features[i] == "+vfp2")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003169 FPU |= VFP2FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003170 else if (Features[i] == "+vfp3")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003171 FPU |= VFP3FPU;
3172 else if (Features[i] == "+vfp4")
3173 FPU |= VFP4FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003174 else if (Features[i] == "+neon")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003175 FPU |= NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003176 }
3177
3178 // Remove front-end specific options which the backend handles differently.
3179 std::vector<std::string>::iterator it;
3180 it = std::find(Features.begin(), Features.end(), "+soft-float");
3181 if (it != Features.end())
3182 Features.erase(it);
3183 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
3184 if (it != Features.end())
3185 Features.erase(it);
3186 }
3187
Douglas Gregore727d212012-01-30 06:38:25 +00003188 virtual bool hasFeature(StringRef Feature) const {
3189 return llvm::StringSwitch<bool>(Feature)
3190 .Case("arm", true)
3191 .Case("softfloat", SoftFloat)
3192 .Case("thumb", IsThumb)
3193 .Case("neon", FPU == NeonFPU && !SoftFloat &&
3194 StringRef(getCPUDefineSuffix(CPU)).startswith("7"))
3195 .Default(false);
3196 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003197 // FIXME: Should we actually have some table instead of these switches?
Chris Lattner5f9e2722011-07-23 10:55:15 +00003198 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00003199 return llvm::StringSwitch<const char*>(Name)
3200 .Cases("arm8", "arm810", "4")
3201 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
3202 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
3203 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
3204 .Case("ep9312", "4T")
3205 .Cases("arm10tdmi", "arm1020t", "5T")
3206 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
3207 .Case("arm926ej-s", "5TEJ")
3208 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
3209 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003210 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003211 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003212 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003213 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
Silviu Baranga2df67ea2012-09-13 15:06:00 +00003214 .Cases("cortex-a8", "cortex-a9", "cortex-a15", "7A")
Bob Wilson336bfa32012-09-29 23:52:50 +00003215 .Case("cortex-a9-mp", "7F")
3216 .Case("swift", "7S")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003217 .Cases("cortex-m3", "cortex-m4", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00003218 .Case("cortex-m0", "6M")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003219 .Default(0);
3220 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003221 static const char *getCPUProfile(StringRef Name) {
3222 return llvm::StringSwitch<const char*>(Name)
3223 .Cases("cortex-a8", "cortex-a9", "A")
3224 .Cases("cortex-m3", "cortex-m4", "cortex-m0", "M")
Anton Korobeynikov8b0703d2012-09-08 08:22:13 +00003225 .Default("");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003226 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003227 virtual bool setCPU(const std::string &Name) {
3228 if (!getCPUDefineSuffix(Name))
3229 return false;
3230
3231 CPU = Name;
3232 return true;
3233 }
Chris Lattner33328642009-03-20 15:52:06 +00003234 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003235 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00003236 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00003237 Builder.defineMacro("__arm");
3238 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003239
Chris Lattnerc0f59212009-03-02 22:27:17 +00003240 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00003241 Builder.defineMacro("__ARMEL__");
3242 Builder.defineMacro("__LITTLE_ENDIAN__");
3243 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003244
Chris Lattner5f9e2722011-07-23 10:55:15 +00003245 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00003246 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003247 Builder.defineMacro("__ARM_ARCH", CPUArch.substr(0, 1));
3248 StringRef CPUProfile = getCPUProfile(CPU);
3249 if (!CPUProfile.empty())
3250 Builder.defineMacro("__ARM_ARCH_PROFILE", CPUProfile);
3251
Mike Stump437bb4b2009-04-08 02:07:04 +00003252 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003253
Daniel Dunbareac7c532009-12-18 18:42:37 +00003254 // FIXME: It's more complicated than this and we don't really support
3255 // interworking.
3256 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00003257 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003258
David Tweedb16abb12012-10-25 13:33:01 +00003259 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
Daniel Dunbar849289e2012-10-22 18:51:13 +00003260 // M-class CPUs on Darwin follow AAPCS, but not EABI.
Daniel Dunbar4d3ee9b2012-10-22 18:56:43 +00003261 if (!(getTriple().isOSDarwin() && CPUProfile == "M"))
Daniel Dunbar849289e2012-10-22 18:51:13 +00003262 Builder.defineMacro("__ARM_EABI__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003263 Builder.defineMacro("__ARM_PCS", "1");
3264
David Tweedb16abb12012-10-25 13:33:01 +00003265 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003266 Builder.defineMacro("__ARM_PCS_VFP", "1");
3267 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003268
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003269 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00003270 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003271
3272 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00003273 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003274
Bob Wilson84f95cf2011-05-13 18:56:03 +00003275 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003276 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003277 Builder.defineMacro("__THUMBEL__");
3278 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00003279 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003280 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003281 }
3282
3283 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00003284 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00003285
Bob Wilsoncfaab002012-09-29 23:52:52 +00003286 if (FPUModeIsVFP((FPUMode) FPU)) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003287 Builder.defineMacro("__VFP_FP__");
Bob Wilsoncfaab002012-09-29 23:52:52 +00003288 if (FPU & VFP2FPU)
3289 Builder.defineMacro("__ARM_VFPV2__");
3290 if (FPU & VFP3FPU)
3291 Builder.defineMacro("__ARM_VFPV3__");
3292 if (FPU & VFP4FPU)
3293 Builder.defineMacro("__ARM_VFPV4__");
3294 }
3295
Daniel Dunbara91320b2009-12-21 23:28:17 +00003296 // This only gets set when Neon instructions are actually available, unlike
3297 // the VFP define, hence the soft float and arch check. This is subtly
3298 // different from gcc, we follow the intent which was that it should be set
3299 // when Neon instructions are actually available.
Bob Wilsoncfaab002012-09-29 23:52:52 +00003300 if ((FPU & NeonFPU) && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003301 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00003302 }
3303 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3304 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00003305 Records = BuiltinInfo;
3306 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00003307 }
Bob Wilson8b30a932012-01-26 22:14:27 +00003308 virtual bool isCLZForZeroUndef() const { return false; }
Meador Ingec5613b22012-06-16 03:34:49 +00003309 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Logan Chieneae5a8202012-10-10 06:56:20 +00003310 return IsAAPCS ? AAPCSABIBuiltinVaList : TargetInfo::VoidPtrBuiltinVaList;
Chris Lattner393ff042008-04-21 18:56:49 +00003311 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003312 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003313 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003314 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003315 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003316 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00003317 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003318 switch (*Name) {
Eric Christophera0dfca12012-08-16 23:50:41 +00003319 default: break;
Nate Begemanad487f42008-04-22 05:03:19 +00003320 case 'l': // r0-r7
3321 case 'h': // r8-r15
3322 case 'w': // VFP Floating point register single precision
3323 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00003324 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00003325 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00003326 case 'Q': // A memory address that is a single base register.
3327 Info.setAllowsMemory();
3328 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00003329 case 'U': // a memory reference...
3330 switch (Name[1]) {
3331 case 'q': // ...ARMV4 ldrsb
3332 case 'v': // ...VFP load/store (reg+constant offset)
3333 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00003334 case 't': // address valid for load/store opaque types wider
Eric Christopher825d3862012-11-14 22:08:59 +00003335 // than 128-bits
Eric Christopherdda231a2011-06-17 01:40:49 +00003336 case 'n': // valid address for Neon doubleword vector load/store
3337 case 'm': // valid address for Neon element and structure load/store
3338 case 's': // valid address for non-offset loads/stores of quad-word
Eric Christopher825d3862012-11-14 22:08:59 +00003339 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00003340 Info.setAllowsMemory();
3341 Name++;
3342 return true;
3343 }
Nate Begemanad487f42008-04-22 05:03:19 +00003344 }
Chris Lattner393ff042008-04-21 18:56:49 +00003345 return false;
3346 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00003347 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00003348 std::string R;
3349 switch (*Constraint) {
3350 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00003351 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00003352 Constraint++;
3353 break;
Eric Christopher283f4472011-06-17 00:40:18 +00003354 case 'p': // 'p' should be translated to 'r' by default.
3355 R = std::string("r");
3356 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00003357 default:
3358 return std::string(1, *Constraint);
3359 }
3360 return R;
3361 }
Bill Wendling50d46ca2012-10-25 23:28:48 +00003362 virtual bool validateConstraintModifier(StringRef Constraint,
3363 const char Modifier,
3364 unsigned Size) const {
3365 // Strip off constraint modifiers.
3366 while (Constraint[0] == '=' ||
3367 Constraint[0] == '+' ||
3368 Constraint[0] == '&')
3369 Constraint = Constraint.substr(1);
3370
3371 switch (Constraint[0]) {
3372 default: break;
3373 case 'r': {
3374 switch (Modifier) {
3375 default:
3376 return Size == 32;
3377 case 'q':
3378 // A register of size 32 cannot fit a vector type.
3379 return false;
3380 }
3381 }
3382 }
3383
3384 return true;
3385 }
Chris Lattner393ff042008-04-21 18:56:49 +00003386 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00003387 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00003388 return "";
3389 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00003390
3391 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
3392 return (CC == CC_AAPCS || CC == CC_AAPCS_VFP) ? CCCR_OK : CCCR_Warning;
3393 }
Chris Lattner393ff042008-04-21 18:56:49 +00003394};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003395
3396const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003397 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003398 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003399 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
3400
3401 // Float registers
3402 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3403 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3404 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003405 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003406
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003407 // Double registers
3408 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3409 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00003410 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3411 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003412
3413 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00003414 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3415 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003416};
3417
3418void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003419 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003420 Names = GCCRegNames;
3421 NumNames = llvm::array_lengthof(GCCRegNames);
3422}
3423
3424const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003425 { { "a1" }, "r0" },
3426 { { "a2" }, "r1" },
3427 { { "a3" }, "r2" },
3428 { { "a4" }, "r3" },
3429 { { "v1" }, "r4" },
3430 { { "v2" }, "r5" },
3431 { { "v3" }, "r6" },
3432 { { "v4" }, "r7" },
3433 { { "v5" }, "r8" },
3434 { { "v6", "rfp" }, "r9" },
3435 { { "sl" }, "r10" },
3436 { { "fp" }, "r11" },
3437 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003438 { { "r13" }, "sp" },
3439 { { "r14" }, "lr" },
3440 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003441 // The S, D and Q registers overlap, but aren't really aliases; we
3442 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003443};
3444
3445void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3446 unsigned &NumAliases) const {
3447 Aliases = GCCRegAliases;
3448 NumAliases = llvm::array_lengthof(GCCRegAliases);
3449}
Chris Lattner2752c012010-03-03 19:03:45 +00003450
3451const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00003452#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00003453#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00003454 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00003455#include "clang/Basic/BuiltinsARM.def"
3456};
Chris Lattner393ff042008-04-21 18:56:49 +00003457} // end anonymous namespace.
3458
Eli Friedmana9f54962008-08-20 07:44:10 +00003459namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00003460class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003461 public DarwinTargetInfo<ARMTargetInfo> {
3462protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00003463 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00003464 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00003465 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00003466 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003467
Torok Edwin5f6c1942009-06-30 17:10:35 +00003468public:
Mike Stump1eb44332009-09-09 15:08:12 +00003469 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003470 : DarwinTargetInfo<ARMTargetInfo>(triple) {
3471 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00003472 // iOS always has 64-bit atomic instructions.
3473 // FIXME: This should be based off of the target features in ARMTargetInfo.
3474 MaxAtomicInlineWidth = 64;
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003475 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003476};
3477} // end anonymous namespace.
3478
Tony Linthicum96319392011-12-12 21:14:55 +00003479
3480namespace {
3481// Hexagon abstract base class
3482class HexagonTargetInfo : public TargetInfo {
3483 static const Builtin::Info BuiltinInfo[];
3484 static const char * const GCCRegNames[];
3485 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3486 std::string CPU;
3487public:
3488 HexagonTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003489 BigEndian = false;
Tony Linthicum96319392011-12-12 21:14:55 +00003490 DescriptionString = ("e-p:32:32:32-"
Sirish Pande5f9688b2012-05-10 20:19:54 +00003491 "i64:64:64-i32:32:32-i16:16:16-i1:32:32"
3492 "f64:64:64-f32:32:32-a0:0-n32");
Tony Linthicum96319392011-12-12 21:14:55 +00003493
3494 // {} in inline assembly are packet specifiers, not assembly variant
3495 // specifiers.
3496 NoAsmVariants = true;
3497 }
3498
3499 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3500 unsigned &NumRecords) const {
3501 Records = BuiltinInfo;
3502 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
3503 }
3504
3505 virtual bool validateAsmConstraint(const char *&Name,
3506 TargetInfo::ConstraintInfo &Info) const {
3507 return true;
3508 }
3509
3510 virtual void getTargetDefines(const LangOptions &Opts,
3511 MacroBuilder &Builder) const;
3512
Douglas Gregore727d212012-01-30 06:38:25 +00003513 virtual bool hasFeature(StringRef Feature) const {
3514 return Feature == "hexagon";
3515 }
3516
Meador Ingec5613b22012-06-16 03:34:49 +00003517 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3518 return TargetInfo::CharPtrBuiltinVaList;
Tony Linthicum96319392011-12-12 21:14:55 +00003519 }
3520 virtual void getGCCRegNames(const char * const *&Names,
3521 unsigned &NumNames) const;
3522 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3523 unsigned &NumAliases) const;
3524 virtual const char *getClobbers() const {
3525 return "";
3526 }
Sebastian Pop43115d42012-01-13 20:37:10 +00003527
3528 static const char *getHexagonCPUSuffix(StringRef Name) {
3529 return llvm::StringSwitch<const char*>(Name)
3530 .Case("hexagonv2", "2")
3531 .Case("hexagonv3", "3")
3532 .Case("hexagonv4", "4")
Sirish Pande5f9688b2012-05-10 20:19:54 +00003533 .Case("hexagonv5", "5")
Sebastian Pop43115d42012-01-13 20:37:10 +00003534 .Default(0);
3535 }
3536
Tony Linthicum96319392011-12-12 21:14:55 +00003537 virtual bool setCPU(const std::string &Name) {
Sebastian Pop43115d42012-01-13 20:37:10 +00003538 if (!getHexagonCPUSuffix(Name))
3539 return false;
3540
Tony Linthicum96319392011-12-12 21:14:55 +00003541 CPU = Name;
3542 return true;
3543 }
3544};
3545
3546void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
3547 MacroBuilder &Builder) const {
3548 Builder.defineMacro("qdsp6");
3549 Builder.defineMacro("__qdsp6", "1");
3550 Builder.defineMacro("__qdsp6__", "1");
3551
3552 Builder.defineMacro("hexagon");
3553 Builder.defineMacro("__hexagon", "1");
3554 Builder.defineMacro("__hexagon__", "1");
3555
3556 if(CPU == "hexagonv1") {
3557 Builder.defineMacro("__HEXAGON_V1__");
3558 Builder.defineMacro("__HEXAGON_ARCH__", "1");
3559 if(Opts.HexagonQdsp6Compat) {
3560 Builder.defineMacro("__QDSP6_V1__");
3561 Builder.defineMacro("__QDSP6_ARCH__", "1");
3562 }
3563 }
3564 else if(CPU == "hexagonv2") {
3565 Builder.defineMacro("__HEXAGON_V2__");
3566 Builder.defineMacro("__HEXAGON_ARCH__", "2");
3567 if(Opts.HexagonQdsp6Compat) {
3568 Builder.defineMacro("__QDSP6_V2__");
3569 Builder.defineMacro("__QDSP6_ARCH__", "2");
3570 }
3571 }
3572 else if(CPU == "hexagonv3") {
3573 Builder.defineMacro("__HEXAGON_V3__");
3574 Builder.defineMacro("__HEXAGON_ARCH__", "3");
3575 if(Opts.HexagonQdsp6Compat) {
3576 Builder.defineMacro("__QDSP6_V3__");
3577 Builder.defineMacro("__QDSP6_ARCH__", "3");
3578 }
3579 }
3580 else if(CPU == "hexagonv4") {
3581 Builder.defineMacro("__HEXAGON_V4__");
3582 Builder.defineMacro("__HEXAGON_ARCH__", "4");
3583 if(Opts.HexagonQdsp6Compat) {
3584 Builder.defineMacro("__QDSP6_V4__");
3585 Builder.defineMacro("__QDSP6_ARCH__", "4");
3586 }
3587 }
Sirish Pande5f9688b2012-05-10 20:19:54 +00003588 else if(CPU == "hexagonv5") {
3589 Builder.defineMacro("__HEXAGON_V5__");
3590 Builder.defineMacro("__HEXAGON_ARCH__", "5");
3591 if(Opts.HexagonQdsp6Compat) {
3592 Builder.defineMacro("__QDSP6_V5__");
3593 Builder.defineMacro("__QDSP6_ARCH__", "5");
3594 }
3595 }
Tony Linthicum96319392011-12-12 21:14:55 +00003596}
3597
3598const char * const HexagonTargetInfo::GCCRegNames[] = {
3599 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3600 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3601 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3602 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
3603 "p0", "p1", "p2", "p3",
3604 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
3605};
3606
3607void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
3608 unsigned &NumNames) const {
3609 Names = GCCRegNames;
3610 NumNames = llvm::array_lengthof(GCCRegNames);
3611}
3612
3613
3614const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
3615 { { "sp" }, "r29" },
3616 { { "fp" }, "r30" },
3617 { { "lr" }, "r31" },
3618 };
3619
3620void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3621 unsigned &NumAliases) const {
3622 Aliases = GCCRegAliases;
3623 NumAliases = llvm::array_lengthof(GCCRegAliases);
3624}
3625
3626
3627const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
3628#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3629#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3630 ALL_LANGUAGES },
3631#include "clang/Basic/BuiltinsHexagon.def"
3632};
3633}
3634
3635
Reid Spencer5f016e22007-07-11 17:01:13 +00003636namespace {
Eli Friedman01b86682008-08-20 07:28:14 +00003637class SparcV8TargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00003638 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3639 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003640 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00003641public:
Eli Friedman01b86682008-08-20 07:28:14 +00003642 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
3643 // FIXME: Support Sparc quad-precision long double?
Eli Friedmaned855cb2008-08-21 00:13:15 +00003644 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 +00003645 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedman01b86682008-08-20 07:28:14 +00003646 }
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003647 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00003648 StringRef Name,
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003649 bool Enabled) const {
3650 if (Name == "soft-float")
3651 Features[Name] = Enabled;
3652 else
3653 return false;
3654
3655 return true;
3656 }
3657 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
3658 SoftFloat = false;
3659 for (unsigned i = 0, e = Features.size(); i != e; ++i)
3660 if (Features[i] == "+soft-float")
3661 SoftFloat = true;
3662 }
Chris Lattner33328642009-03-20 15:52:06 +00003663 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003664 MacroBuilder &Builder) const {
3665 DefineStd(Builder, "sparc", Opts);
3666 Builder.defineMacro("__sparcv8");
3667 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003668
3669 if (SoftFloat)
3670 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00003671 }
Douglas Gregore727d212012-01-30 06:38:25 +00003672
3673 virtual bool hasFeature(StringRef Feature) const {
3674 return llvm::StringSwitch<bool>(Feature)
3675 .Case("softfloat", SoftFloat)
3676 .Case("sparc", true)
3677 .Default(false);
3678 }
3679
Gabor Greif26658672008-02-21 16:29:08 +00003680 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3681 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003682 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00003683 }
Meador Ingec5613b22012-06-16 03:34:49 +00003684 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3685 return TargetInfo::VoidPtrBuiltinVaList;
Gabor Greif26658672008-02-21 16:29:08 +00003686 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003687 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003688 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003689 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003690 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003691 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00003692 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003693 // FIXME: Implement!
3694 return false;
Gabor Greif26658672008-02-21 16:29:08 +00003695 }
3696 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00003697 // FIXME: Implement!
3698 return "";
Gabor Greif26658672008-02-21 16:29:08 +00003699 }
3700};
3701
Chris Lattnere957f532009-01-27 01:58:38 +00003702const char * const SparcV8TargetInfo::GCCRegNames[] = {
3703 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3704 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3705 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3706 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
3707};
3708
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003709void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003710 unsigned &NumNames) const {
3711 Names = GCCRegNames;
3712 NumNames = llvm::array_lengthof(GCCRegNames);
3713}
3714
3715const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003716 { { "g0" }, "r0" },
3717 { { "g1" }, "r1" },
3718 { { "g2" }, "r2" },
3719 { { "g3" }, "r3" },
3720 { { "g4" }, "r4" },
3721 { { "g5" }, "r5" },
3722 { { "g6" }, "r6" },
3723 { { "g7" }, "r7" },
3724 { { "o0" }, "r8" },
3725 { { "o1" }, "r9" },
3726 { { "o2" }, "r10" },
3727 { { "o3" }, "r11" },
3728 { { "o4" }, "r12" },
3729 { { "o5" }, "r13" },
3730 { { "o6", "sp" }, "r14" },
3731 { { "o7" }, "r15" },
3732 { { "l0" }, "r16" },
3733 { { "l1" }, "r17" },
3734 { { "l2" }, "r18" },
3735 { { "l3" }, "r19" },
3736 { { "l4" }, "r20" },
3737 { { "l5" }, "r21" },
3738 { { "l6" }, "r22" },
3739 { { "l7" }, "r23" },
3740 { { "i0" }, "r24" },
3741 { { "i1" }, "r25" },
3742 { { "i2" }, "r26" },
3743 { { "i3" }, "r27" },
3744 { { "i4" }, "r28" },
3745 { { "i5" }, "r29" },
3746 { { "i6", "fp" }, "r30" },
3747 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00003748};
3749
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003750void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003751 unsigned &NumAliases) const {
3752 Aliases = GCCRegAliases;
3753 NumAliases = llvm::array_lengthof(GCCRegAliases);
3754}
Gabor Greif26658672008-02-21 16:29:08 +00003755} // end anonymous namespace.
3756
Eli Friedman01b86682008-08-20 07:28:14 +00003757namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003758class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
3759public:
3760 AuroraUXSparcV8TargetInfo(const std::string& triple) :
3761 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
3762 SizeType = UnsignedInt;
3763 PtrDiffType = SignedInt;
3764 }
3765};
Torok Edwin5f6c1942009-06-30 17:10:35 +00003766class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00003767public:
3768 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003769 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00003770 SizeType = UnsignedInt;
3771 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00003772 }
3773};
3774} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00003775
Chris Lattner2621fd12008-05-08 05:58:21 +00003776namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003777 class MSP430TargetInfo : public TargetInfo {
3778 static const char * const GCCRegNames[];
3779 public:
3780 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003781 BigEndian = false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003782 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00003783 IntWidth = 16; IntAlign = 16;
3784 LongWidth = 32; LongLongWidth = 64;
3785 LongAlign = LongLongAlign = 16;
3786 PointerWidth = 16; PointerAlign = 16;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003787 SuitableAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003788 SizeType = UnsignedInt;
3789 IntMaxType = SignedLong;
3790 UIntMaxType = UnsignedLong;
3791 IntPtrType = SignedShort;
3792 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00003793 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00003794 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003795 }
3796 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003797 MacroBuilder &Builder) const {
3798 Builder.defineMacro("MSP430");
3799 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003800 // FIXME: defines for different 'flavours' of MCU
3801 }
3802 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3803 unsigned &NumRecords) const {
3804 // FIXME: Implement.
3805 Records = 0;
3806 NumRecords = 0;
3807 }
Douglas Gregore727d212012-01-30 06:38:25 +00003808 virtual bool hasFeature(StringRef Feature) const {
3809 return Feature == "msp430";
3810 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003811 virtual void getGCCRegNames(const char * const *&Names,
3812 unsigned &NumNames) const;
3813 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3814 unsigned &NumAliases) const {
3815 // No aliases.
3816 Aliases = 0;
3817 NumAliases = 0;
3818 }
3819 virtual bool validateAsmConstraint(const char *&Name,
3820 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00003821 // No target constraints for now.
3822 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003823 }
3824 virtual const char *getClobbers() const {
3825 // FIXME: Is this really right?
3826 return "";
3827 }
Meador Ingec5613b22012-06-16 03:34:49 +00003828 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003829 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00003830 return TargetInfo::CharPtrBuiltinVaList;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003831 }
3832 };
3833
3834 const char * const MSP430TargetInfo::GCCRegNames[] = {
3835 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3836 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3837 };
3838
3839 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
3840 unsigned &NumNames) const {
3841 Names = GCCRegNames;
3842 NumNames = llvm::array_lengthof(GCCRegNames);
3843 }
3844}
3845
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00003846namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00003847
Mike Stump1eb44332009-09-09 15:08:12 +00003848 // LLVM and Clang cannot be used directly to output native binaries for
3849 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00003850 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00003851 //
3852 // TCE uses the llvm bitcode as input and uses it for generating customized
3853 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00003854 // publicly available in http://tce.cs.tut.fi
3855
Eli Friedman209f5bb2011-10-07 19:51:42 +00003856 static const unsigned TCEOpenCLAddrSpaceMap[] = {
3857 3, // opencl_global
3858 4, // opencl_local
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00003859 5, // opencl_constant
3860 0, // cuda_device
3861 0, // cuda_constant
3862 0 // cuda_shared
Eli Friedman209f5bb2011-10-07 19:51:42 +00003863 };
3864
Eli Friedmanb63decf2009-08-19 20:47:07 +00003865 class TCETargetInfo : public TargetInfo{
3866 public:
3867 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
3868 TLSSupported = false;
3869 IntWidth = 32;
3870 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003871 PointerWidth = 32;
3872 IntAlign = 32;
3873 LongAlign = LongLongAlign = 32;
3874 PointerAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003875 SuitableAlign = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003876 SizeType = UnsignedInt;
3877 IntMaxType = SignedLong;
3878 UIntMaxType = UnsignedLong;
3879 IntPtrType = SignedInt;
3880 PtrDiffType = SignedInt;
3881 FloatWidth = 32;
3882 FloatAlign = 32;
3883 DoubleWidth = 32;
3884 DoubleAlign = 32;
3885 LongDoubleWidth = 32;
3886 LongDoubleAlign = 32;
3887 FloatFormat = &llvm::APFloat::IEEEsingle;
3888 DoubleFormat = &llvm::APFloat::IEEEsingle;
3889 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00003890 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
3891 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00003892 "f32:32:32-f64:32:32-v64:32:32-"
3893 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00003894 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003895 }
3896
3897 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003898 MacroBuilder &Builder) const {
3899 DefineStd(Builder, "tce", Opts);
3900 Builder.defineMacro("__TCE__");
3901 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00003902 }
Douglas Gregore727d212012-01-30 06:38:25 +00003903 virtual bool hasFeature(StringRef Feature) const {
3904 return Feature == "tce";
3905 }
3906
Eli Friedmanb63decf2009-08-19 20:47:07 +00003907 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3908 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00003909 virtual const char *getClobbers() const {
3910 return "";
3911 }
Meador Ingec5613b22012-06-16 03:34:49 +00003912 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3913 return TargetInfo::VoidPtrBuiltinVaList;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003914 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003915 virtual void getGCCRegNames(const char * const *&Names,
3916 unsigned &NumNames) const {}
3917 virtual bool validateAsmConstraint(const char *&Name,
3918 TargetInfo::ConstraintInfo &info) const {
3919 return true;
3920 }
3921 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3922 unsigned &NumAliases) const {}
3923 };
3924}
3925
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003926namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003927class MipsTargetInfoBase : public TargetInfo {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00003928 static const Builtin::Info BuiltinInfo[];
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003929 std::string CPU;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00003930 bool IsMips16;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003931 enum MipsFloatABI {
3932 HardFloat, SingleFloat, SoftFloat
3933 } FloatABI;
Simon Atanasyana1b62272012-07-05 20:16:22 +00003934 enum DspRevEnum {
3935 NoDSP, DSP1, DSP2
3936 } DspRev;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003937
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003938protected:
3939 std::string ABI;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003940
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003941public:
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00003942 MipsTargetInfoBase(const std::string& triple,
3943 const std::string& ABIStr,
3944 const std::string& CPUStr)
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003945 : TargetInfo(triple),
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00003946 CPU(CPUStr),
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00003947 IsMips16(false),
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003948 FloatABI(HardFloat),
Simon Atanasyana1b62272012-07-05 20:16:22 +00003949 DspRev(NoDSP),
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003950 ABI(ABIStr)
3951 {}
3952
Eric Christophered734732010-03-02 02:41:08 +00003953 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003954 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00003955 virtual bool setCPU(const std::string &Name) {
3956 CPU = Name;
3957 return true;
3958 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003959 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00003960 Features[ABI] = true;
3961 Features[CPU] = true;
3962 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003963
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00003964 virtual void getTargetDefines(const LangOptions &Opts,
3965 MacroBuilder &Builder) const {
Simon Atanasyand4935a02012-08-29 19:14:58 +00003966 DefineStd(Builder, "mips", Opts);
3967 Builder.defineMacro("_mips");
3968 Builder.defineMacro("__REGISTER_PREFIX__", "");
3969
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003970 switch (FloatABI) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003971 case HardFloat:
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00003972 Builder.defineMacro("__mips_hard_float", Twine(1));
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003973 break;
3974 case SingleFloat:
3975 Builder.defineMacro("__mips_hard_float", Twine(1));
3976 Builder.defineMacro("__mips_single_float", Twine(1));
3977 break;
3978 case SoftFloat:
3979 Builder.defineMacro("__mips_soft_float", Twine(1));
3980 break;
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00003981 }
Simon Atanasyan90913892012-04-05 19:28:31 +00003982
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00003983 if (IsMips16)
3984 Builder.defineMacro("__mips16", Twine(1));
3985
Simon Atanasyana1b62272012-07-05 20:16:22 +00003986 switch (DspRev) {
3987 default:
3988 break;
3989 case DSP1:
3990 Builder.defineMacro("__mips_dsp_rev", Twine(1));
3991 Builder.defineMacro("__mips_dsp", Twine(1));
3992 break;
3993 case DSP2:
3994 Builder.defineMacro("__mips_dsp_rev", Twine(2));
3995 Builder.defineMacro("__mips_dspr2", Twine(1));
3996 Builder.defineMacro("__mips_dsp", Twine(1));
3997 break;
3998 }
3999
Simon Atanasyan90913892012-04-05 19:28:31 +00004000 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
4001 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
4002 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
Simon Atanasyan260e5062012-08-29 15:17:29 +00004003
4004 Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
4005 Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004006 }
4007
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004008 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4009 unsigned &NumRecords) const {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004010 Records = BuiltinInfo;
4011 NumRecords = clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004012 }
Douglas Gregore727d212012-01-30 06:38:25 +00004013 virtual bool hasFeature(StringRef Feature) const {
4014 return Feature == "mips";
4015 }
Meador Ingec5613b22012-06-16 03:34:49 +00004016 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4017 return TargetInfo::VoidPtrBuiltinVaList;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004018 }
4019 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004020 unsigned &NumNames) const {
4021 static const char * const GCCRegNames[] = {
Eric Christopherd1f853d2012-03-27 19:56:11 +00004022 // CPU register names
4023 // Must match second column of GCCRegAliases
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004024 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
4025 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
4026 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004027 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",
4028 // Floating point register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004029 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
4030 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
4031 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
4032 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004033 // Hi/lo and condition register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004034 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
4035 "$fcc5","$fcc6","$fcc7"
4036 };
4037 Names = GCCRegNames;
4038 NumNames = llvm::array_lengthof(GCCRegNames);
4039 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004040 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004041 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004042 virtual bool validateAsmConstraint(const char *&Name,
4043 TargetInfo::ConstraintInfo &Info) const {
4044 switch (*Name) {
4045 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00004046 return false;
4047
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004048 case 'r': // CPU registers.
4049 case 'd': // Equivalent to "r" unless generating MIPS16 code.
4050 case 'y': // Equivalent to "r", backwards compatibility only.
4051 case 'f': // floating-point registers.
Eric Christopher0ea61642012-04-03 01:16:32 +00004052 case 'c': // $25 for indirect jumps
4053 case 'l': // lo register
4054 case 'x': // hilo register pair
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004055 Info.setAllowsRegister();
4056 return true;
4057 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004058 }
4059
4060 virtual const char *getClobbers() const {
4061 // FIXME: Implement!
4062 return "";
4063 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004064
4065 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
4066 StringRef Name,
4067 bool Enabled) const {
Simon Atanasyan8b2a5d22012-04-18 12:00:11 +00004068 if (Name == "soft-float" || Name == "single-float" ||
4069 Name == "o32" || Name == "n32" || Name == "n64" || Name == "eabi" ||
4070 Name == "mips32" || Name == "mips32r2" ||
Simon Atanasyan0b273ef2012-07-05 14:19:39 +00004071 Name == "mips64" || Name == "mips64r2" ||
Simon Atanasyand797a852012-07-05 19:23:00 +00004072 Name == "mips16" || Name == "dsp" || Name == "dspr2") {
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004073 Features[Name] = Enabled;
4074 return true;
4075 }
4076 return false;
4077 }
4078
4079 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004080 IsMips16 = false;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004081 FloatABI = HardFloat;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004082 DspRev = NoDSP;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004083
4084 for (std::vector<std::string>::iterator it = Features.begin(),
4085 ie = Features.end(); it != ie; ++it) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004086 if (*it == "+single-float")
4087 FloatABI = SingleFloat;
4088 else if (*it == "+soft-float")
4089 FloatABI = SoftFloat;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004090 else if (*it == "+mips16")
4091 IsMips16 = true;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004092 else if (*it == "+dsp")
4093 DspRev = std::max(DspRev, DSP1);
4094 else if (*it == "+dspr2")
4095 DspRev = std::max(DspRev, DSP2);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004096 }
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004097
4098 // Remove front-end specific option.
4099 std::vector<std::string>::iterator it =
4100 std::find(Features.begin(), Features.end(), "+soft-float");
4101 if (it != Features.end())
4102 Features.erase(it);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004103 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004104};
4105
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004106const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = {
4107#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4108#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4109 ALL_LANGUAGES },
4110#include "clang/Basic/BuiltinsMips.def"
4111};
4112
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004113class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004114public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004115 Mips32TargetInfoBase(const std::string& triple) :
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00004116 MipsTargetInfoBase(triple, "o32", "mips32") {
Akira Hatanaka148735e2011-11-05 01:48:34 +00004117 SizeType = UnsignedInt;
4118 PtrDiffType = SignedInt;
4119 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004120 virtual bool setABI(const std::string &Name) {
4121 if ((Name == "o32") || (Name == "eabi")) {
4122 ABI = Name;
4123 return true;
4124 } else
4125 return false;
4126 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004127 virtual void getTargetDefines(const LangOptions &Opts,
4128 MacroBuilder &Builder) const {
4129 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004130
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004131 if (ABI == "o32") {
4132 Builder.defineMacro("__mips_o32");
4133 Builder.defineMacro("_ABIO32", "1");
4134 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
4135 }
4136 else if (ABI == "eabi")
4137 Builder.defineMacro("__mips_eabi");
4138 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004139 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004140 }
4141 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4142 unsigned &NumAliases) const {
4143 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4144 { { "at" }, "$1" },
4145 { { "v0" }, "$2" },
4146 { { "v1" }, "$3" },
4147 { { "a0" }, "$4" },
4148 { { "a1" }, "$5" },
4149 { { "a2" }, "$6" },
4150 { { "a3" }, "$7" },
4151 { { "t0" }, "$8" },
4152 { { "t1" }, "$9" },
4153 { { "t2" }, "$10" },
4154 { { "t3" }, "$11" },
4155 { { "t4" }, "$12" },
4156 { { "t5" }, "$13" },
4157 { { "t6" }, "$14" },
4158 { { "t7" }, "$15" },
4159 { { "s0" }, "$16" },
4160 { { "s1" }, "$17" },
4161 { { "s2" }, "$18" },
4162 { { "s3" }, "$19" },
4163 { { "s4" }, "$20" },
4164 { { "s5" }, "$21" },
4165 { { "s6" }, "$22" },
4166 { { "s7" }, "$23" },
4167 { { "t8" }, "$24" },
4168 { { "t9" }, "$25" },
4169 { { "k0" }, "$26" },
4170 { { "k1" }, "$27" },
4171 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004172 { { "sp","$sp" }, "$29" },
4173 { { "fp","$fp" }, "$30" },
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004174 { { "ra" }, "$31" }
4175 };
4176 Aliases = GCCRegAliases;
4177 NumAliases = llvm::array_lengthof(GCCRegAliases);
4178 }
4179};
4180
4181class Mips32EBTargetInfo : public Mips32TargetInfoBase {
4182public:
4183 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
4184 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
4185 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
4186 }
4187 virtual void getTargetDefines(const LangOptions &Opts,
4188 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004189 DefineStd(Builder, "MIPSEB", Opts);
4190 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004191 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004192 }
4193};
4194
4195class Mips32ELTargetInfo : public Mips32TargetInfoBase {
4196public:
4197 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004198 BigEndian = false;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004199 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 +00004200 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004201 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004202 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004203 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004204 DefineStd(Builder, "MIPSEL", Opts);
4205 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004206 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004207 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004208};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004209
4210class Mips64TargetInfoBase : public MipsTargetInfoBase {
4211 virtual void SetDescriptionString(const std::string &Name) = 0;
4212public:
4213 Mips64TargetInfoBase(const std::string& triple) :
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00004214 MipsTargetInfoBase(triple, "n64", "mips64") {
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004215 LongWidth = LongAlign = 64;
4216 PointerWidth = PointerAlign = 64;
4217 LongDoubleWidth = LongDoubleAlign = 128;
4218 LongDoubleFormat = &llvm::APFloat::IEEEquad;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004219 SuitableAlign = 128;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004220 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004221 virtual bool setABI(const std::string &Name) {
4222 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004223
4224 if (Name != "n32" && Name != "n64")
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004225 return false;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004226
4227 ABI = Name;
4228
4229 if (Name == "n32") {
4230 LongWidth = LongAlign = 32;
4231 PointerWidth = PointerAlign = 32;
4232 }
4233
4234 return true;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004235 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004236 virtual void getTargetDefines(const LangOptions &Opts,
4237 MacroBuilder &Builder) const {
4238 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004239
Simon Atanasyan600a5132012-08-29 20:50:11 +00004240 Builder.defineMacro("__mips64");
4241 Builder.defineMacro("__mips64__");
4242
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004243 if (ABI == "n32") {
4244 Builder.defineMacro("__mips_n32");
4245 Builder.defineMacro("_ABIN32", "2");
4246 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
4247 }
4248 else if (ABI == "n64") {
4249 Builder.defineMacro("__mips_n64");
4250 Builder.defineMacro("_ABI64", "3");
4251 Builder.defineMacro("_MIPS_SIM", "_ABI64");
4252 }
4253 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004254 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004255 }
4256 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4257 unsigned &NumAliases) const {
4258 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4259 { { "at" }, "$1" },
4260 { { "v0" }, "$2" },
4261 { { "v1" }, "$3" },
4262 { { "a0" }, "$4" },
4263 { { "a1" }, "$5" },
4264 { { "a2" }, "$6" },
4265 { { "a3" }, "$7" },
4266 { { "a4" }, "$8" },
4267 { { "a5" }, "$9" },
4268 { { "a6" }, "$10" },
4269 { { "a7" }, "$11" },
4270 { { "t0" }, "$12" },
4271 { { "t1" }, "$13" },
4272 { { "t2" }, "$14" },
4273 { { "t3" }, "$15" },
4274 { { "s0" }, "$16" },
4275 { { "s1" }, "$17" },
4276 { { "s2" }, "$18" },
4277 { { "s3" }, "$19" },
4278 { { "s4" }, "$20" },
4279 { { "s5" }, "$21" },
4280 { { "s6" }, "$22" },
4281 { { "s7" }, "$23" },
4282 { { "t8" }, "$24" },
4283 { { "t9" }, "$25" },
4284 { { "k0" }, "$26" },
4285 { { "k1" }, "$27" },
4286 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004287 { { "sp","$sp" }, "$29" },
4288 { { "fp","$fp" }, "$30" },
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004289 { { "ra" }, "$31" }
4290 };
4291 Aliases = GCCRegAliases;
4292 NumAliases = llvm::array_lengthof(GCCRegAliases);
4293 }
4294};
4295
4296class Mips64EBTargetInfo : public Mips64TargetInfoBase {
4297 virtual void SetDescriptionString(const std::string &Name) {
4298 // Change DescriptionString only if ABI is n32.
4299 if (Name == "n32")
4300 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 +00004301 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
4302 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004303 }
4304public:
4305 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
4306 // Default ABI is n64.
4307 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 +00004308 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
4309 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004310 }
4311 virtual void getTargetDefines(const LangOptions &Opts,
4312 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004313 DefineStd(Builder, "MIPSEB", Opts);
4314 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004315 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004316 }
4317};
4318
4319class Mips64ELTargetInfo : public Mips64TargetInfoBase {
4320 virtual void SetDescriptionString(const std::string &Name) {
4321 // Change DescriptionString only if ABI is n32.
4322 if (Name == "n32")
4323 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 +00004324 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
4325 "-v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004326 }
4327public:
4328 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004329 // Default ABI is n64.
4330 BigEndian = false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004331 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 +00004332 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
4333 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004334 }
4335 virtual void getTargetDefines(const LangOptions &Opts,
4336 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004337 DefineStd(Builder, "MIPSEL", Opts);
4338 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004339 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004340 }
4341};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004342} // end anonymous namespace.
4343
Ivan Krasinef05abd2011-08-24 20:22:22 +00004344namespace {
4345class PNaClTargetInfo : public TargetInfo {
4346public:
4347 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004348 BigEndian = false;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004349 this->UserLabelPrefix = "";
4350 this->LongAlign = 32;
4351 this->LongWidth = 32;
4352 this->PointerAlign = 32;
4353 this->PointerWidth = 32;
4354 this->IntMaxType = TargetInfo::SignedLongLong;
4355 this->UIntMaxType = TargetInfo::UnsignedLongLong;
4356 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00004357 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00004358 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00004359 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00004360 this->SizeType = TargetInfo::UnsignedInt;
4361 this->PtrDiffType = TargetInfo::SignedInt;
4362 this->IntPtrType = TargetInfo::SignedInt;
David Meyerdd4a8892011-10-11 03:12:01 +00004363 this->RegParmMax = 2;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004364 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
4365 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
4366 }
4367
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004368 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00004369 }
4370 virtual void getArchDefines(const LangOptions &Opts,
4371 MacroBuilder &Builder) const {
4372 Builder.defineMacro("__le32__");
4373 Builder.defineMacro("__pnacl__");
4374 }
4375 virtual void getTargetDefines(const LangOptions &Opts,
4376 MacroBuilder &Builder) const {
Jan Wen Voungdde3bdb2012-03-29 00:05:59 +00004377 Builder.defineMacro("__LITTLE_ENDIAN__");
Ivan Krasinef05abd2011-08-24 20:22:22 +00004378 getArchDefines(Opts, Builder);
4379 }
Douglas Gregore727d212012-01-30 06:38:25 +00004380 virtual bool hasFeature(StringRef Feature) const {
4381 return Feature == "pnacl";
4382 }
Ivan Krasinef05abd2011-08-24 20:22:22 +00004383 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4384 unsigned &NumRecords) const {
4385 }
Meador Ingec5613b22012-06-16 03:34:49 +00004386 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4387 return TargetInfo::PNaClABIBuiltinVaList;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004388 }
4389 virtual void getGCCRegNames(const char * const *&Names,
4390 unsigned &NumNames) const;
4391 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4392 unsigned &NumAliases) const;
4393 virtual bool validateAsmConstraint(const char *&Name,
4394 TargetInfo::ConstraintInfo &Info) const {
4395 return false;
4396 }
4397
4398 virtual const char *getClobbers() const {
4399 return "";
4400 }
4401};
4402
4403void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
4404 unsigned &NumNames) const {
4405 Names = NULL;
4406 NumNames = 0;
4407}
4408
4409void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4410 unsigned &NumAliases) const {
4411 Aliases = NULL;
4412 NumAliases = 0;
4413}
4414} // end anonymous namespace.
4415
4416
Reid Spencer5f016e22007-07-11 17:01:13 +00004417//===----------------------------------------------------------------------===//
4418// Driver code
4419//===----------------------------------------------------------------------===//
4420
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004421static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004422 llvm::Triple Triple(T);
4423 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00004424
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004425 switch (Triple.getArch()) {
4426 default:
4427 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00004428
Tony Linthicum96319392011-12-12 21:14:55 +00004429 case llvm::Triple::hexagon:
4430 return new HexagonTargetInfo(T);
4431
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004432 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00004433 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004434 if (Triple.isOSDarwin())
4435 return new DarwinARMTargetInfo(T);
4436
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004437 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00004438 case llvm::Triple::Linux:
4439 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004440 case llvm::Triple::FreeBSD:
Torok Edwin5f6c1942009-06-30 17:10:35 +00004441 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004442 case llvm::Triple::NetBSD:
4443 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00004444 case llvm::Triple::OpenBSD:
4445 return new OpenBSDTargetInfo<ARMTargetInfo>(T);
Eli Friedman42f74f22012-08-08 23:57:20 +00004446 case llvm::Triple::Bitrig:
4447 return new BitrigTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00004448 case llvm::Triple::RTEMS:
4449 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Derek Schuff7da46f92012-10-11 16:55:58 +00004450 case llvm::Triple::NativeClient:
4451 return new NaClTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004452 default:
4453 return new ARMTargetInfo(T);
4454 }
Eli Friedman61538a72008-05-20 14:21:01 +00004455
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004456 case llvm::Triple::msp430:
4457 return new MSP430TargetInfo(T);
Eli Friedman61538a72008-05-20 14:21:01 +00004458
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004459 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004460 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004461 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004462 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004463 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004464 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004465 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004466 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004467 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004468 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004469 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004470 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004471 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004472
4473 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004474 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004475 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004476 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004477 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004478 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004479 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004480 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004481 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004482 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004483 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004484 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004485 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004486
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004487 case llvm::Triple::mips64:
4488 switch (os) {
4489 case llvm::Triple::Linux:
4490 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
4491 case llvm::Triple::RTEMS:
4492 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
4493 case llvm::Triple::FreeBSD:
4494 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
4495 case llvm::Triple::NetBSD:
4496 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00004497 case llvm::Triple::OpenBSD:
4498 return new OpenBSDTargetInfo<Mips64EBTargetInfo>(T);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004499 default:
4500 return new Mips64EBTargetInfo(T);
4501 }
4502
4503 case llvm::Triple::mips64el:
4504 switch (os) {
4505 case llvm::Triple::Linux:
4506 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
4507 case llvm::Triple::RTEMS:
4508 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
4509 case llvm::Triple::FreeBSD:
4510 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
4511 case llvm::Triple::NetBSD:
4512 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00004513 case llvm::Triple::OpenBSD:
4514 return new OpenBSDTargetInfo<Mips64ELTargetInfo>(T);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004515 default:
4516 return new Mips64ELTargetInfo(T);
4517 }
4518
Ivan Krasinef05abd2011-08-24 20:22:22 +00004519 case llvm::Triple::le32:
4520 switch (os) {
4521 case llvm::Triple::NativeClient:
Derek Schuff7da46f92012-10-11 16:55:58 +00004522 return new NaClTargetInfo<PNaClTargetInfo>(T);
Ivan Krasinef05abd2011-08-24 20:22:22 +00004523 default:
4524 return NULL;
4525 }
4526
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004527 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004528 if (Triple.isOSDarwin())
Roman Divackyc81f2a22011-01-06 08:27:10 +00004529 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004530 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00004531 case llvm::Triple::Linux:
4532 return new LinuxTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004533 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00004534 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004535 case llvm::Triple::NetBSD:
4536 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00004537 case llvm::Triple::OpenBSD:
4538 return new OpenBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004539 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00004540 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004541 default:
4542 return new PPC32TargetInfo(T);
4543 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004544
4545 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004546 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00004547 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004548 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00004549 case llvm::Triple::Linux:
4550 return new LinuxTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004551 case llvm::Triple::Lv2:
John Thompson3f6918a2009-11-19 17:18:50 +00004552 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004553 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00004554 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004555 case llvm::Triple::NetBSD:
4556 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
4557 default:
4558 return new PPC64TargetInfo(T);
4559 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004560
Peter Collingbourneedb66f32012-05-20 23:28:41 +00004561 case llvm::Triple::nvptx:
4562 return new NVPTX32TargetInfo(T);
4563 case llvm::Triple::nvptx64:
4564 return new NVPTX64TargetInfo(T);
4565
Chris Lattner9cbeb632010-03-06 21:21:27 +00004566 case llvm::Triple::mblaze:
4567 return new MBlazeTargetInfo(T);
4568
Eli Friedman6505a292012-10-12 23:32:00 +00004569 case llvm::Triple::r600:
4570 return new R600TargetInfo(T);
4571
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004572 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004573 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00004574 case llvm::Triple::Linux:
4575 return new LinuxTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004576 case llvm::Triple::AuroraUX:
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004577 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004578 case llvm::Triple::Solaris:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004579 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004580 case llvm::Triple::NetBSD:
4581 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00004582 case llvm::Triple::OpenBSD:
4583 return new OpenBSDTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004584 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00004585 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004586 default:
4587 return new SparcV8TargetInfo(T);
4588 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004589
Eli Friedmanb63decf2009-08-19 20:47:07 +00004590 case llvm::Triple::tce:
4591 return new TCETargetInfo(T);
4592
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004593 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004594 if (Triple.isOSDarwin())
4595 return new DarwinI386TargetInfo(T);
4596
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004597 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004598 case llvm::Triple::AuroraUX:
4599 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004600 case llvm::Triple::Linux:
4601 return new LinuxTargetInfo<X86_32TargetInfo>(T);
4602 case llvm::Triple::DragonFly:
4603 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
4604 case llvm::Triple::NetBSD:
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00004605 return new NetBSDI386TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004606 case llvm::Triple::OpenBSD:
4607 return new OpenBSDI386TargetInfo(T);
Eli Friedman42f74f22012-08-08 23:57:20 +00004608 case llvm::Triple::Bitrig:
4609 return new BitrigI386TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004610 case llvm::Triple::FreeBSD:
4611 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner38e317d2010-07-07 16:01:42 +00004612 case llvm::Triple::Minix:
4613 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004614 case llvm::Triple::Solaris:
4615 return new SolarisTargetInfo<X86_32TargetInfo>(T);
4616 case llvm::Triple::Cygwin:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004617 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004618 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004619 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004620 case llvm::Triple::Win32:
Michael J. Spencera764e832010-10-21 08:22:51 +00004621 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattner86ed3a32010-04-11 19:29:39 +00004622 case llvm::Triple::Haiku:
4623 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00004624 case llvm::Triple::RTEMS:
4625 return new RTEMSX86_32TargetInfo(T);
Derek Schuff7da46f92012-10-11 16:55:58 +00004626 case llvm::Triple::NativeClient:
4627 return new NaClTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004628 default:
4629 return new X86_32TargetInfo(T);
4630 }
4631
4632 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004633 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
4634 return new DarwinX86_64TargetInfo(T);
4635
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004636 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004637 case llvm::Triple::AuroraUX:
4638 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004639 case llvm::Triple::Linux:
4640 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner7a7ca282010-01-09 05:41:14 +00004641 case llvm::Triple::DragonFly:
4642 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004643 case llvm::Triple::NetBSD:
4644 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
4645 case llvm::Triple::OpenBSD:
4646 return new OpenBSDX86_64TargetInfo(T);
Eli Friedman42f74f22012-08-08 23:57:20 +00004647 case llvm::Triple::Bitrig:
4648 return new BitrigX86_64TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004649 case llvm::Triple::FreeBSD:
4650 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
4651 case llvm::Triple::Solaris:
4652 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00004653 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004654 return new MinGWX86_64TargetInfo(T);
4655 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004656 return new VisualStudioWindowsX86_64TargetInfo(T);
Derek Schuff7da46f92012-10-11 16:55:58 +00004657 case llvm::Triple::NativeClient:
4658 return new NaClTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004659 default:
4660 return new X86_64TargetInfo(T);
4661 }
4662 }
Reid Spencer5f016e22007-07-11 17:01:13 +00004663}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004664
4665/// CreateTargetInfo - Return the target info object for the specified target
4666/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00004667TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Douglas Gregor49a87542012-11-16 04:24:59 +00004668 TargetOptions *Opts) {
4669 llvm::Triple Triple(Opts->Triple);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004670
4671 // Construct the target
Dylan Noblesmith6f42b622012-02-05 02:12:40 +00004672 OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004673 if (!Target) {
4674 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
4675 return 0;
4676 }
Douglas Gregor9a022bb2012-10-15 16:45:32 +00004677 Target->setTargetOpts(Opts);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004678
Daniel Dunbareac7c532009-12-18 18:42:37 +00004679 // Set the target CPU if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00004680 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
4681 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
Daniel Dunbareac7c532009-12-18 18:42:37 +00004682 return 0;
4683 }
4684
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004685 // Set the target ABI if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00004686 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
4687 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004688 return 0;
4689 }
4690
Charles Davis98b7c5c2010-06-11 01:06:47 +00004691 // Set the target C++ ABI.
Douglas Gregor49a87542012-11-16 04:24:59 +00004692 if (!Opts->CXXABI.empty() && !Target->setCXXABI(Opts->CXXABI)) {
4693 Diags.Report(diag::err_target_unknown_cxxabi) << Opts->CXXABI;
Charles Davis98b7c5c2010-06-11 01:06:47 +00004694 return 0;
4695 }
4696
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004697 // Compute the default target features, we need the target to handle this
4698 // because features may have dependencies on one another.
4699 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004700 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004701
4702 // Apply the user specified deltas.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004703 // First the enables.
Douglas Gregor57016dd2012-10-16 23:40:58 +00004704 for (std::vector<std::string>::const_iterator
Douglas Gregor49a87542012-11-16 04:24:59 +00004705 it = Opts->FeaturesAsWritten.begin(),
4706 ie = Opts->FeaturesAsWritten.end();
Douglas Gregor57016dd2012-10-16 23:40:58 +00004707 it != ie; ++it) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004708 const char *Name = it->c_str();
4709
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004710 if (Name[0] != '+')
4711 continue;
4712
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004713 // Apply the feature via the target.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004714 if (!Target->setFeatureEnabled(Features, Name + 1, true)) {
4715 Diags.Report(diag::err_target_invalid_feature) << Name;
4716 return 0;
4717 }
4718 }
4719
4720 // Then the disables.
Douglas Gregor57016dd2012-10-16 23:40:58 +00004721 for (std::vector<std::string>::const_iterator
Douglas Gregor49a87542012-11-16 04:24:59 +00004722 it = Opts->FeaturesAsWritten.begin(),
4723 ie = Opts->FeaturesAsWritten.end();
Douglas Gregor57016dd2012-10-16 23:40:58 +00004724 it != ie; ++it) {
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004725 const char *Name = it->c_str();
4726
4727 if (Name[0] == '+')
4728 continue;
4729
4730 // Apply the feature via the target.
4731 if (Name[0] != '-' ||
4732 !Target->setFeatureEnabled(Features, Name + 1, false)) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004733 Diags.Report(diag::err_target_invalid_feature) << Name;
4734 return 0;
4735 }
4736 }
4737
4738 // Add the features to the compile options.
4739 //
4740 // FIXME: If we are completely confident that we have the right set, we only
4741 // need to pass the minuses.
Douglas Gregor49a87542012-11-16 04:24:59 +00004742 Opts->Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004743 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
4744 ie = Features.end(); it != ie; ++it)
Douglas Gregor49a87542012-11-16 04:24:59 +00004745 Opts->Features.push_back((it->second ? "+" : "-") + it->first().str());
4746 Target->HandleTargetFeatures(Opts->Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004747
4748 return Target.take();
4749}