blob: 42f5d63cc36bfa3bb4cf10ea7db4d6daf3c5a8ba [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");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000095
John McCall098df7f2011-06-16 00:03:19 +000096 if (!Opts.ObjCAutoRefCount) {
John McCallf85e1932011-06-15 23:02:42 +000097 // __weak is always defined, for use in blocks and with objc pointers.
98 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000099
John McCallf85e1932011-06-15 23:02:42 +0000100 // Darwin defines __strong even in C mode (just to nothing).
Douglas Gregore289d812011-09-13 17:21:33 +0000101 if (Opts.getGC() != LangOptions::NonGC)
John McCallf85e1932011-06-15 23:02:42 +0000102 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
103 else
104 Builder.defineMacro("__strong", "");
Eric Christopher7c9adf92011-07-07 22:55:26 +0000105
John McCallf85e1932011-06-15 23:02:42 +0000106 // __unsafe_unretained is defined to nothing in non-ARC mode. We even
107 // allow this in C, since one might have block pointers in structs that
108 // are used in pure C code and in Objective-C ARC.
109 Builder.defineMacro("__unsafe_unretained", "");
John McCallf85e1932011-06-15 23:02:42 +0000110 }
Eric Christopher7c9adf92011-07-07 22:55:26 +0000111
Eli Friedman2de4fee2009-06-04 23:00:29 +0000112 if (Opts.Static)
Benjamin Kramera9992772010-01-09 17:55:51 +0000113 Builder.defineMacro("__STATIC__");
Eli Friedman2de4fee2009-06-04 23:00:29 +0000114 else
Benjamin Kramera9992772010-01-09 17:55:51 +0000115 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000116
117 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000118 Builder.defineMacro("_REENTRANT");
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000119
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000120 // Get the platform type and version number from the triple.
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000121 unsigned Maj, Min, Rev;
Bob Wilson48b68a02012-01-31 23:52:58 +0000122 if (Triple.isMacOSX()) {
123 Triple.getMacOSXVersion(Maj, Min, Rev);
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000124 PlatformName = "macosx";
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000125 } else {
Bob Wilson48b68a02012-01-31 23:52:58 +0000126 Triple.getOSVersion(Maj, Min, Rev);
127 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000128 }
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000129
Sebastian Pop9ec60df2012-01-20 22:01:23 +0000130 // If -target arch-pc-win32-macho option specified, we're
Eric Christopher895d4222011-07-29 21:20:35 +0000131 // generating code for Win32 ABI. No need to emit
Chad Rosierd9259f32011-07-19 20:00:06 +0000132 // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
133 if (PlatformName == "win32") {
134 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
135 return;
136 }
137
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000138 // Set the appropriate OS version define.
Bob Wilson48b68a02012-01-31 23:52:58 +0000139 if (Triple.getOS() == llvm::Triple::IOS) {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000140 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000141 char Str[6];
142 Str[0] = '0' + Maj;
143 Str[1] = '0' + (Min / 10);
144 Str[2] = '0' + (Min % 10);
145 Str[3] = '0' + (Rev / 10);
146 Str[4] = '0' + (Rev % 10);
147 Str[5] = '\0';
148 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
149 } else {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000150 // Note that the Driver allows versions which aren't representable in the
151 // define (because we only get a single digit for the minor and micro
152 // revision numbers). So, we limit them to the maximum representable
153 // version.
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000154 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000155 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000156 char Str[5];
157 Str[0] = '0' + (Maj / 10);
158 Str[1] = '0' + (Maj % 10);
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000159 Str[2] = '0' + std::min(Min, 9U);
160 Str[3] = '0' + std::min(Rev, 9U);
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000161 Str[4] = '\0';
162 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000163 }
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000164
165 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman618234a2008-08-20 02:34:37 +0000166}
Reid Spencer5f016e22007-07-11 17:01:13 +0000167
Chris Lattner797c3c42009-08-10 19:03:04 +0000168namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000169template<typename Target>
170class DarwinTargetInfo : public OSTargetInfo<Target> {
171protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000172 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000173 MacroBuilder &Builder) const {
Eric Christopher7c9adf92011-07-07 22:55:26 +0000174 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000175 this->PlatformMinVersion);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000176 }
Mike Stump1eb44332009-09-09 15:08:12 +0000177
Torok Edwin5f6c1942009-06-30 17:10:35 +0000178public:
179 DarwinTargetInfo(const std::string& triple) :
180 OSTargetInfo<Target>(triple) {
Eric Christopheraa7333c2011-07-02 00:20:22 +0000181 llvm::Triple T = llvm::Triple(triple);
182 this->TLSSupported = T.isMacOSX() && !T.isMacOSXVersionLT(10,7);
Daniel Dunbare177d3b2011-02-21 23:12:51 +0000183 this->MCountName = "\01mcount";
Torok Edwin5f6c1942009-06-30 17:10:35 +0000184 }
185
Chris Lattner5f9e2722011-07-23 10:55:15 +0000186 virtual std::string isValidSectionSpecifier(StringRef SR) const {
Chris Lattner797c3c42009-08-10 19:03:04 +0000187 // Let MCSectionMachO validate this.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000188 StringRef Segment, Section;
Chris Lattner797c3c42009-08-10 19:03:04 +0000189 unsigned TAA, StubSize;
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000190 bool HasTAA;
Chris Lattner797c3c42009-08-10 19:03:04 +0000191 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000192 TAA, HasTAA, StubSize);
Chris Lattner797c3c42009-08-10 19:03:04 +0000193 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000194
Anders Carlsson18af3682010-06-08 22:47:50 +0000195 virtual const char *getStaticInitSectionSpecifier() const {
196 // FIXME: We should return 0 when building kexts.
197 return "__TEXT,__StaticInit,regular,pure_instructions";
198 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000199
John McCall41887602012-01-29 01:20:30 +0000200 /// Darwin does not support protected visibility. Darwin's "default"
201 /// is very similar to ELF's "protected"; Darwin requires a "weak"
202 /// attribute on declarations that can be dynamically replaced.
203 virtual bool hasProtectedVisibility() const {
204 return false;
205 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000206};
207
Chris Lattner797c3c42009-08-10 19:03:04 +0000208
Torok Edwin5f6c1942009-06-30 17:10:35 +0000209// DragonFlyBSD Target
210template<typename Target>
211class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
212protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000213 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000214 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000215 // DragonFly defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000216 Builder.defineMacro("__DragonFly__");
217 Builder.defineMacro("__DragonFly_cc_version", "100001");
218 Builder.defineMacro("__ELF__");
219 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
220 Builder.defineMacro("__tune_i386__");
221 DefineStd(Builder, "unix", Opts);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000222 }
223public:
Mike Stump1eb44332009-09-09 15:08:12 +0000224 DragonFlyBSDTargetInfo(const std::string &triple)
Eli Friedmanb089c4d2012-02-10 23:02:29 +0000225 : OSTargetInfo<Target>(triple) {
226 this->UserLabelPrefix = "";
227
228 llvm::Triple Triple(triple);
229 switch (Triple.getArch()) {
230 default:
231 case llvm::Triple::x86:
232 case llvm::Triple::x86_64:
233 this->MCountName = ".mcount";
234 break;
235 }
236 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000237};
238
239// FreeBSD Target
240template<typename Target>
241class FreeBSDTargetInfo : public OSTargetInfo<Target> {
242protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000243 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000244 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000245 // FreeBSD defines; list based off of gcc output
246
Benjamin Kramer474202f2011-10-18 10:10:08 +0000247 unsigned Release = Triple.getOSMajorVersion();
248 if (Release == 0U)
249 Release = 8;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000250
Benjamin Kramer474202f2011-10-18 10:10:08 +0000251 Builder.defineMacro("__FreeBSD__", Twine(Release));
252 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramera9992772010-01-09 17:55:51 +0000253 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
254 DefineStd(Builder, "unix", Opts);
255 Builder.defineMacro("__ELF__");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000256 }
257public:
Mike Stump1eb44332009-09-09 15:08:12 +0000258 FreeBSDTargetInfo(const std::string &triple)
Duncan Sands1e90faf2009-07-08 13:55:08 +0000259 : OSTargetInfo<Target>(triple) {
260 this->UserLabelPrefix = "";
Roman Divackybe4c8702011-02-10 16:52:03 +0000261
262 llvm::Triple Triple(triple);
263 switch (Triple.getArch()) {
264 default:
265 case llvm::Triple::x86:
266 case llvm::Triple::x86_64:
267 this->MCountName = ".mcount";
268 break;
269 case llvm::Triple::mips:
270 case llvm::Triple::mipsel:
271 case llvm::Triple::ppc:
272 case llvm::Triple::ppc64:
273 this->MCountName = "_mcount";
274 break;
275 case llvm::Triple::arm:
276 this->MCountName = "__mcount";
277 break;
278 }
279
Duncan Sands1e90faf2009-07-08 13:55:08 +0000280 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000281};
282
Chris Lattner38e317d2010-07-07 16:01:42 +0000283// Minix Target
284template<typename Target>
285class MinixTargetInfo : public OSTargetInfo<Target> {
286protected:
287 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
288 MacroBuilder &Builder) const {
289 // Minix defines
290
291 Builder.defineMacro("__minix", "3");
292 Builder.defineMacro("_EM_WSIZE", "4");
293 Builder.defineMacro("_EM_PSIZE", "4");
294 Builder.defineMacro("_EM_SSIZE", "2");
295 Builder.defineMacro("_EM_LSIZE", "4");
296 Builder.defineMacro("_EM_FSIZE", "4");
297 Builder.defineMacro("_EM_DSIZE", "8");
Eli Friedman6d402dc2011-12-08 23:54:21 +0000298 Builder.defineMacro("__ELF__");
Chris Lattner38e317d2010-07-07 16:01:42 +0000299 DefineStd(Builder, "unix", Opts);
300 }
301public:
302 MinixTargetInfo(const std::string &triple)
303 : OSTargetInfo<Target>(triple) {
304 this->UserLabelPrefix = "";
305 }
306};
307
Torok Edwin5f6c1942009-06-30 17:10:35 +0000308// Linux target
309template<typename Target>
310class LinuxTargetInfo : public OSTargetInfo<Target> {
311protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000312 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000313 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000314 // Linux defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000315 DefineStd(Builder, "unix", Opts);
316 DefineStd(Builder, "linux", Opts);
317 Builder.defineMacro("__gnu_linux__");
318 Builder.defineMacro("__ELF__");
Evgeniy Stepanov32064032012-04-26 12:08:09 +0000319 if (Triple.getEnvironment() == llvm::Triple::ANDROIDEABI)
320 Builder.defineMacro("__ANDROID__", "1");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000321 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000322 Builder.defineMacro("_REENTRANT");
Douglas Gregor2b003fd2010-04-21 05:52:38 +0000323 if (Opts.CPlusPlus)
324 Builder.defineMacro("_GNU_SOURCE");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000325 }
326public:
Mike Stump1eb44332009-09-09 15:08:12 +0000327 LinuxTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000328 : OSTargetInfo<Target>(triple) {
329 this->UserLabelPrefix = "";
Douglas Gregor12e84642011-01-12 21:19:25 +0000330 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000331 }
Benjamin Kramer86d18c52011-10-15 17:53:33 +0000332
333 virtual const char *getStaticInitSectionSpecifier() const {
334 return ".text.startup";
335 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000336};
337
Chris Lattnerb62bb282009-07-13 20:29:08 +0000338// NetBSD Target
339template<typename Target>
340class NetBSDTargetInfo : public OSTargetInfo<Target> {
341protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000342 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000343 MacroBuilder &Builder) const {
Chris Lattnerb62bb282009-07-13 20:29:08 +0000344 // NetBSD defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000345 Builder.defineMacro("__NetBSD__");
346 Builder.defineMacro("__unix__");
347 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000348 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000349 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerb62bb282009-07-13 20:29:08 +0000350 }
351public:
Mike Stump1eb44332009-09-09 15:08:12 +0000352 NetBSDTargetInfo(const std::string &triple)
Chris Lattnerb62bb282009-07-13 20:29:08 +0000353 : OSTargetInfo<Target>(triple) {
354 this->UserLabelPrefix = "";
355 }
356};
357
Torok Edwin5f6c1942009-06-30 17:10:35 +0000358// OpenBSD Target
359template<typename Target>
360class OpenBSDTargetInfo : public OSTargetInfo<Target> {
361protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000362 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000363 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000364 // OpenBSD defines; list based off of gcc output
365
Benjamin Kramera9992772010-01-09 17:55:51 +0000366 Builder.defineMacro("__OpenBSD__");
367 DefineStd(Builder, "unix", Opts);
368 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000369 if (Opts.POSIXThreads)
Chris Lattner4ddcf3b2012-04-25 06:12:24 +0000370 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000371 }
372public:
Mike Stump1eb44332009-09-09 15:08:12 +0000373 OpenBSDTargetInfo(const std::string &triple)
Eli Friedman62d829a2011-12-15 02:15:56 +0000374 : OSTargetInfo<Target>(triple) {
375 this->UserLabelPrefix = "";
376
377 llvm::Triple Triple(triple);
378 switch (Triple.getArch()) {
379 default:
380 case llvm::Triple::x86:
381 case llvm::Triple::x86_64:
382 case llvm::Triple::arm:
383 case llvm::Triple::sparc:
384 this->MCountName = "__mcount";
385 break;
386 case llvm::Triple::mips64:
387 case llvm::Triple::mips64el:
388 case llvm::Triple::ppc:
389 case llvm::Triple::sparcv9:
390 this->MCountName = "_mcount";
391 break;
392 }
393 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000394};
395
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000396// PSP Target
397template<typename Target>
398class PSPTargetInfo : public OSTargetInfo<Target> {
399protected:
400 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000401 MacroBuilder &Builder) const {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000402 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramera9992772010-01-09 17:55:51 +0000403 Builder.defineMacro("PSP");
404 Builder.defineMacro("_PSP");
405 Builder.defineMacro("__psp__");
406 Builder.defineMacro("__ELF__");
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000407 }
408public:
409 PSPTargetInfo(const std::string& triple)
410 : OSTargetInfo<Target>(triple) {
411 this->UserLabelPrefix = "";
412 }
413};
414
John Thompson3f6918a2009-11-19 17:18:50 +0000415// PS3 PPU Target
416template<typename Target>
417class PS3PPUTargetInfo : public OSTargetInfo<Target> {
418protected:
419 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000420 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000421 // PS3 PPU defines.
John Thompsonfb457972010-03-25 16:18:32 +0000422 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000423 Builder.defineMacro("__PPU__");
424 Builder.defineMacro("__CELLOS_LV2__");
425 Builder.defineMacro("__ELF__");
426 Builder.defineMacro("__LP32__");
John Thompson8e6065a2010-06-24 22:44:13 +0000427 Builder.defineMacro("_ARCH_PPC64");
428 Builder.defineMacro("__powerpc64__");
John Thompson3f6918a2009-11-19 17:18:50 +0000429 }
430public:
431 PS3PPUTargetInfo(const std::string& triple)
432 : OSTargetInfo<Target>(triple) {
433 this->UserLabelPrefix = "";
Nick Lewycky99520702011-12-16 22:32:39 +0000434 this->LongWidth = this->LongAlign = 32;
435 this->PointerWidth = this->PointerAlign = 32;
John Thompson8e6065a2010-06-24 22:44:13 +0000436 this->IntMaxType = TargetInfo::SignedLongLong;
437 this->UIntMaxType = TargetInfo::UnsignedLongLong;
438 this->Int64Type = TargetInfo::SignedLongLong;
John Thompsonec387af2009-12-18 14:21:08 +0000439 this->SizeType = TargetInfo::UnsignedInt;
John Thompson8e6065a2010-06-24 22:44:13 +0000440 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 +0000441 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompson3f6918a2009-11-19 17:18:50 +0000442 }
443};
444
445// FIXME: Need a real SPU target.
446// PS3 SPU Target
447template<typename Target>
448class PS3SPUTargetInfo : public OSTargetInfo<Target> {
449protected:
450 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000451 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000452 // PS3 PPU defines.
Benjamin Kramera9992772010-01-09 17:55:51 +0000453 Builder.defineMacro("__SPU__");
454 Builder.defineMacro("__ELF__");
John Thompson3f6918a2009-11-19 17:18:50 +0000455 }
456public:
457 PS3SPUTargetInfo(const std::string& triple)
458 : OSTargetInfo<Target>(triple) {
459 this->UserLabelPrefix = "";
460 }
461};
462
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000463// AuroraUX target
464template<typename Target>
465class AuroraUXTargetInfo : public OSTargetInfo<Target> {
466protected:
467 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000468 MacroBuilder &Builder) const {
469 DefineStd(Builder, "sun", Opts);
470 DefineStd(Builder, "unix", Opts);
471 Builder.defineMacro("__ELF__");
472 Builder.defineMacro("__svr4__");
473 Builder.defineMacro("__SVR4");
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000474 }
475public:
476 AuroraUXTargetInfo(const std::string& triple)
477 : OSTargetInfo<Target>(triple) {
478 this->UserLabelPrefix = "";
479 this->WCharType = this->SignedLong;
480 // FIXME: WIntType should be SignedLong
481 }
482};
483
Torok Edwin5f6c1942009-06-30 17:10:35 +0000484// Solaris target
485template<typename Target>
486class SolarisTargetInfo : public OSTargetInfo<Target> {
487protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000488 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000489 MacroBuilder &Builder) const {
490 DefineStd(Builder, "sun", Opts);
491 DefineStd(Builder, "unix", Opts);
492 Builder.defineMacro("__ELF__");
493 Builder.defineMacro("__svr4__");
494 Builder.defineMacro("__SVR4");
David Chisnall165329c2012-02-28 17:10:04 +0000495 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
496 // newer, but to 500 for everything else. feature_test.h has a check to
497 // ensure that you are not using C99 with an old version of X/Open or C89
498 // with a new version.
499 if (Opts.C99 || Opts.C11)
500 Builder.defineMacro("_XOPEN_SOURCE", "600");
501 else
502 Builder.defineMacro("_XOPEN_SOURCE", "500");
David Chisnallb4f0bd62012-03-02 10:49:52 +0000503 if (Opts.CPlusPlus)
David Chisnall165329c2012-02-28 17:10:04 +0000504 Builder.defineMacro("__C99FEATURES__");
David Chisnall48fad492012-02-17 18:35:11 +0000505 Builder.defineMacro("_LARGEFILE_SOURCE");
506 Builder.defineMacro("_LARGEFILE64_SOURCE");
507 Builder.defineMacro("__EXTENSIONS__");
David Chisnall165329c2012-02-28 17:10:04 +0000508 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000509 }
510public:
Mike Stump1eb44332009-09-09 15:08:12 +0000511 SolarisTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000512 : OSTargetInfo<Target>(triple) {
513 this->UserLabelPrefix = "";
David Chisnallfb027842012-03-28 18:04:14 +0000514 this->WCharType = this->SignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000515 // FIXME: WIntType should be SignedLong
516 }
517};
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000518
519// Windows target
520template<typename Target>
521class WindowsTargetInfo : public OSTargetInfo<Target> {
522protected:
523 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
524 MacroBuilder &Builder) const {
Michael J. Spencera764e832010-10-21 08:22:51 +0000525 Builder.defineMacro("_WIN32");
526 }
527 void getVisualStudioDefines(const LangOptions &Opts,
528 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000529 if (Opts.CPlusPlus) {
530 if (Opts.RTTI)
531 Builder.defineMacro("_CPPRTTI");
532
533 if (Opts.Exceptions)
534 Builder.defineMacro("_CPPUNWIND");
535 }
536
537 if (!Opts.CharIsSigned)
538 Builder.defineMacro("_CHAR_UNSIGNED");
539
540 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
541 // but it works for now.
542 if (Opts.POSIXThreads)
543 Builder.defineMacro("_MT");
Michael J. Spencera764e832010-10-21 08:22:51 +0000544
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000545 if (Opts.MSCVersion != 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000546 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000547
Francois Pichet62ec1f22011-09-17 17:15:52 +0000548 if (Opts.MicrosoftExt) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000549 Builder.defineMacro("_MSC_EXTENSIONS");
550
551 if (Opts.CPlusPlus0x) {
552 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
553 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
554 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
555 }
556 }
557
558 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000559 }
560
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000561public:
562 WindowsTargetInfo(const std::string &triple)
563 : OSTargetInfo<Target>(triple) {}
564};
565
Mike Stump1eb44332009-09-09 15:08:12 +0000566} // end anonymous namespace.
Torok Edwin5f6c1942009-06-30 17:10:35 +0000567
Chris Lattnerd29b6302008-10-05 21:50:58 +0000568//===----------------------------------------------------------------------===//
Eli Friedmane4277982008-08-20 23:11:40 +0000569// Specific target implementations.
570//===----------------------------------------------------------------------===//
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +0000571
Eli Friedmane4277982008-08-20 23:11:40 +0000572namespace {
573// PPC abstract base class
574class PPCTargetInfo : public TargetInfo {
575 static const Builtin::Info BuiltinInfo[];
576 static const char * const GCCRegNames[];
577 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Hal Finkel02a84272012-06-11 22:35:19 +0000578 std::string CPU;
Eli Friedmane4277982008-08-20 23:11:40 +0000579public:
Nico Weber6e1d2ea2012-01-31 02:07:33 +0000580 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {
581 LongDoubleWidth = LongDoubleAlign = 128;
582 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
583 }
Eli Friedman15b91762009-06-05 07:05:05 +0000584
Hal Finkel39d5fa12012-07-03 16:51:04 +0000585 /// \brief Flags for architecture specific defines.
586 typedef enum {
587 ArchDefineNone = 0,
588 ArchDefineName = 1 << 0, // <name> is substituted for arch name.
589 ArchDefinePpcgr = 1 << 1,
590 ArchDefinePpcsq = 1 << 2,
591 ArchDefine440 = 1 << 3,
592 ArchDefine603 = 1 << 4,
593 ArchDefine604 = 1 << 5,
594 ArchDefinePwr4 = 1 << 6,
595 ArchDefinePwr6 = 1 << 7
596 } ArchDefineTypes;
597
Hal Finkel02a84272012-06-11 22:35:19 +0000598 virtual bool setCPU(const std::string &Name) {
599 bool CPUKnown = llvm::StringSwitch<bool>(Name)
600 .Case("generic", true)
601 .Case("440", true)
602 .Case("450", true)
603 .Case("601", true)
604 .Case("602", true)
605 .Case("603", true)
606 .Case("603e", true)
607 .Case("603ev", true)
608 .Case("604", true)
609 .Case("604e", true)
610 .Case("620", true)
611 .Case("g3", true)
612 .Case("7400", true)
613 .Case("g4", true)
614 .Case("7450", true)
615 .Case("g4+", true)
616 .Case("750", true)
617 .Case("970", true)
618 .Case("g5", true)
619 .Case("a2", true)
620 .Case("pwr6", true)
621 .Case("pwr7", true)
622 .Case("ppc", true)
623 .Case("ppc64", true)
624 .Default(false);
625
626 if (CPUKnown)
627 CPU = Name;
628
629 return CPUKnown;
630 }
631
Eli Friedmane4277982008-08-20 23:11:40 +0000632 virtual void getTargetBuiltins(const Builtin::Info *&Records,
633 unsigned &NumRecords) const {
Reid Spencer5f016e22007-07-11 17:01:13 +0000634 Records = BuiltinInfo;
Eli Friedmane4277982008-08-20 23:11:40 +0000635 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +0000636 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000637
Bob Wilson9f1c49c2012-01-28 18:02:29 +0000638 virtual bool isCLZForZeroUndef() const { return false; }
639
Chris Lattner33328642009-03-20 15:52:06 +0000640 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000641 MacroBuilder &Builder) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000642
Douglas Gregore727d212012-01-30 06:38:25 +0000643 virtual bool hasFeature(StringRef Feature) const;
644
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000645 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000646 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000647 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000648 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000649 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +0000650 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000651 switch (*Name) {
Anders Carlssond04c6e22007-11-27 04:11:28 +0000652 default: return false;
653 case 'O': // Zero
John Thompson8e6065a2010-06-24 22:44:13 +0000654 break;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000655 case 'b': // Base register
656 case 'f': // Floating point register
Chris Lattner44def072009-04-26 07:16:29 +0000657 Info.setAllowsRegister();
John Thompson8e6065a2010-06-24 22:44:13 +0000658 break;
659 // FIXME: The following are added to allow parsing.
660 // I just took a guess at what the actions should be.
661 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer20249a12010-10-21 03:16:25 +0000662 case 'd': // Floating point register (containing 64-bit value)
John Thompson8e6065a2010-06-24 22:44:13 +0000663 case 'v': // Altivec vector register
664 Info.setAllowsRegister();
665 break;
666 case 'w':
667 switch (Name[1]) {
Michael J. Spencer20249a12010-10-21 03:16:25 +0000668 case 'd':// VSX vector register to hold vector double data
669 case 'f':// VSX vector register to hold vector float data
670 case 's':// VSX vector register to hold scalar float data
671 case 'a':// Any VSX register
John Thompson8e6065a2010-06-24 22:44:13 +0000672 break;
673 default:
674 return false;
675 }
676 Info.setAllowsRegister();
677 Name++; // Skip over 'w'.
678 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000679 case 'h': // `MQ', `CTR', or `LINK' register
680 case 'q': // `MQ' register
681 case 'c': // `CTR' register
682 case 'l': // `LINK' register
683 case 'x': // `CR' register (condition register) number 0
684 case 'y': // `CR' register (condition register)
685 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson8e6065a2010-06-24 22:44:13 +0000686 Info.setAllowsRegister();
687 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000688 case 'I': // Signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000689 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer20249a12010-10-21 03:16:25 +0000690 // (use `L' instead for SImode constants)
691 case 'K': // Unsigned 16-bit constant
692 case 'L': // Signed 16-bit constant shifted left 16 bits
693 case 'M': // Constant larger than 31
694 case 'N': // Exact power of 2
695 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000696 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000697 // register with one instruction per word
John Thompson8e6065a2010-06-24 22:44:13 +0000698 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer20249a12010-10-21 03:16:25 +0000699 // into a register using three instructions
John Thompson8e6065a2010-06-24 22:44:13 +0000700 break;
701 case 'm': // Memory operand. Note that on PowerPC targets, m can
702 // include addresses that update the base register. It
703 // is therefore only safe to use `m' in an asm statement
704 // if that asm statement accesses the operand exactly once.
705 // The asm statement must also use `%U<opno>' as a
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000706 // placeholder for the "update" flag in the corresponding
Michael J. Spencer20249a12010-10-21 03:16:25 +0000707 // load or store instruction. For example:
John Thompson8e6065a2010-06-24 22:44:13 +0000708 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000709 // is correct but:
John Thompson8e6065a2010-06-24 22:44:13 +0000710 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
711 // is not. Use es rather than m if you don't want the base
Michael J. Spencer20249a12010-10-21 03:16:25 +0000712 // register to be updated.
713 case 'e':
John Thompson56b6eca2010-06-25 00:02:05 +0000714 if (Name[1] != 's')
715 return false;
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000716 // es: A "stable" memory operand; that is, one which does not
John Thompson8e6065a2010-06-24 22:44:13 +0000717 // include any automodification of the base register. Unlike
718 // `m', this constraint can be used in asm statements that
719 // might access the operand several times, or that might not
John Thompson56b6eca2010-06-25 00:02:05 +0000720 // access it at all.
John Thompson8e6065a2010-06-24 22:44:13 +0000721 Info.setAllowsMemory();
John Thompson56b6eca2010-06-25 00:02:05 +0000722 Name++; // Skip over 'e'.
John Thompson8e6065a2010-06-24 22:44:13 +0000723 break;
724 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer20249a12010-10-21 03:16:25 +0000725 // usually better to use `m' or `es' in asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000726 case 'Z': // Memory operand that is an indexed or indirect from a
727 // register (it is usually better to use `m' or `es' in
Michael J. Spencer20249a12010-10-21 03:16:25 +0000728 // asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000729 Info.setAllowsMemory();
730 Info.setAllowsRegister();
731 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000732 case 'R': // AIX TOC entry
John Thompson8e6065a2010-06-24 22:44:13 +0000733 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000734 // register (`p' is preferable for asm statements)
735 case 'S': // Constant suitable as a 64-bit mask operand
736 case 'T': // Constant suitable as a 32-bit mask operand
737 case 'U': // System V Release 4 small data area reference
John Thompson8e6065a2010-06-24 22:44:13 +0000738 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000739 // instructions
740 case 'W': // Vector constant that does not require memory
741 case 'j': // Vector constant that is all zeros.
John Thompson8e6065a2010-06-24 22:44:13 +0000742 break;
743 // End FIXME.
Anders Carlssond04c6e22007-11-27 04:11:28 +0000744 }
John Thompson8e6065a2010-06-24 22:44:13 +0000745 return true;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000746 }
Eli Friedmane4277982008-08-20 23:11:40 +0000747 virtual const char *getClobbers() const {
748 return "";
Anders Carlssond04c6e22007-11-27 04:11:28 +0000749 }
Eli Friedmane4277982008-08-20 23:11:40 +0000750};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000751
Eli Friedmane4277982008-08-20 23:11:40 +0000752const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000753#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000754#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000755 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000756#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000757};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000758
759
Chris Lattnerc0f59212009-03-02 22:27:17 +0000760/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
761/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000762void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000763 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000764 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000765 Builder.defineMacro("__ppc__");
766 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000767 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000768 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000769 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000770 Builder.defineMacro("_ARCH_PPC64");
771 Builder.defineMacro("_LP64");
772 Builder.defineMacro("__LP64__");
Chris Lattnere03ae302010-02-16 18:14:57 +0000773 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000774 Builder.defineMacro("__ppc64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000775 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +0000776 Builder.defineMacro("__ppc__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000777 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000778
Chris Lattnerc0f59212009-03-02 22:27:17 +0000779 // Target properties.
Joerg Sonnenberger7cd1de52011-07-05 14:56:12 +0000780 if (getTriple().getOS() != llvm::Triple::NetBSD)
781 Builder.defineMacro("_BIG_ENDIAN");
Benjamin Kramera9992772010-01-09 17:55:51 +0000782 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000783
Chris Lattnerc0f59212009-03-02 22:27:17 +0000784 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000785 Builder.defineMacro("__NATURAL_ALIGNMENT__");
786 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000787
Chris Lattnerc0f59212009-03-02 22:27:17 +0000788 // FIXME: Should be controlled by command line option.
Benjamin Kramera9992772010-01-09 17:55:51 +0000789 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000790
John Thompson3f6918a2009-11-19 17:18:50 +0000791 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000792 Builder.defineMacro("__VEC__", "10206");
793 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000794 }
Hal Finkel02a84272012-06-11 22:35:19 +0000795
796 // CPU identification.
Hal Finkel39d5fa12012-07-03 16:51:04 +0000797 ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
798 .Case("440", ArchDefineName)
799 .Case("450", ArchDefineName | ArchDefine440)
800 .Case("601", ArchDefineName)
801 .Case("602", ArchDefineName | ArchDefinePpcgr)
802 .Case("603", ArchDefineName | ArchDefinePpcgr)
803 .Case("603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
804 .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
805 .Case("604", ArchDefineName | ArchDefinePpcgr)
806 .Case("604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
807 .Case("620", ArchDefineName | ArchDefinePpcgr)
808 .Case("7400", ArchDefineName | ArchDefinePpcgr)
809 .Case("7450", ArchDefineName | ArchDefinePpcgr)
810 .Case("750", ArchDefineName | ArchDefinePpcgr)
811 .Case("970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
812 | ArchDefinePpcsq)
813 .Case("pwr6", ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq)
814 .Case("pwr7", ArchDefineName | ArchDefinePwr6 | ArchDefinePpcgr
815 | ArchDefinePpcsq)
816 .Default(ArchDefineNone);
817
818 if (defs & ArchDefineName)
819 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
820 if (defs & ArchDefinePpcgr)
821 Builder.defineMacro("_ARCH_PPCGR");
822 if (defs & ArchDefinePpcsq)
823 Builder.defineMacro("_ARCH_PPCSQ");
824 if (defs & ArchDefine440)
Hal Finkel02a84272012-06-11 22:35:19 +0000825 Builder.defineMacro("_ARCH_440");
Hal Finkel39d5fa12012-07-03 16:51:04 +0000826 if (defs & ArchDefine603)
827 Builder.defineMacro("_ARCH_603");
828 if (defs & ArchDefine604)
829 Builder.defineMacro("_ARCH_604");
830 if (defs & (ArchDefinePwr4 | ArchDefinePwr6))
831 Builder.defineMacro("_ARCH_PWR4");
832 if (defs & ArchDefinePwr6) {
833 Builder.defineMacro("_ARCH_PWR5");
Hal Finkel02a84272012-06-11 22:35:19 +0000834 Builder.defineMacro("_ARCH_PWR6");
Hal Finkel02a84272012-06-11 22:35:19 +0000835 }
Chris Lattnerc0f59212009-03-02 22:27:17 +0000836}
837
Douglas Gregore727d212012-01-30 06:38:25 +0000838bool PPCTargetInfo::hasFeature(StringRef Feature) const {
839 return Feature == "powerpc";
840}
Chris Lattner393ff042008-04-21 18:56:49 +0000841
Douglas Gregore727d212012-01-30 06:38:25 +0000842
Eli Friedmane4277982008-08-20 23:11:40 +0000843const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +0000844 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
845 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
846 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
847 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
848 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
849 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
850 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
851 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +0000852 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000853 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +0000854 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000855 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
856 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
857 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
858 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +0000859 "vrsave", "vscr",
860 "spe_acc", "spefscr",
861 "sfp"
862};
Reid Spencer5f016e22007-07-11 17:01:13 +0000863
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000864void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000865 unsigned &NumNames) const {
866 Names = GCCRegNames;
867 NumNames = llvm::array_lengthof(GCCRegNames);
868}
Reid Spencer5f016e22007-07-11 17:01:13 +0000869
Eli Friedmane4277982008-08-20 23:11:40 +0000870const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
871 // While some of these aliases do map to different registers
872 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000873 { { "0" }, "r0" },
874 { { "1"}, "r1" },
875 { { "2" }, "r2" },
876 { { "3" }, "r3" },
877 { { "4" }, "r4" },
878 { { "5" }, "r5" },
879 { { "6" }, "r6" },
880 { { "7" }, "r7" },
881 { { "8" }, "r8" },
882 { { "9" }, "r9" },
883 { { "10" }, "r10" },
884 { { "11" }, "r11" },
885 { { "12" }, "r12" },
886 { { "13" }, "r13" },
887 { { "14" }, "r14" },
888 { { "15" }, "r15" },
889 { { "16" }, "r16" },
890 { { "17" }, "r17" },
891 { { "18" }, "r18" },
892 { { "19" }, "r19" },
893 { { "20" }, "r20" },
894 { { "21" }, "r21" },
895 { { "22" }, "r22" },
896 { { "23" }, "r23" },
897 { { "24" }, "r24" },
898 { { "25" }, "r25" },
899 { { "26" }, "r26" },
900 { { "27" }, "r27" },
901 { { "28" }, "r28" },
902 { { "29" }, "r29" },
903 { { "30" }, "r30" },
904 { { "31" }, "r31" },
905 { { "fr0" }, "f0" },
906 { { "fr1" }, "f1" },
907 { { "fr2" }, "f2" },
908 { { "fr3" }, "f3" },
909 { { "fr4" }, "f4" },
910 { { "fr5" }, "f5" },
911 { { "fr6" }, "f6" },
912 { { "fr7" }, "f7" },
913 { { "fr8" }, "f8" },
914 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +0000915 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000916 { { "fr11" }, "f11" },
917 { { "fr12" }, "f12" },
918 { { "fr13" }, "f13" },
919 { { "fr14" }, "f14" },
920 { { "fr15" }, "f15" },
921 { { "fr16" }, "f16" },
922 { { "fr17" }, "f17" },
923 { { "fr18" }, "f18" },
924 { { "fr19" }, "f19" },
925 { { "fr20" }, "f20" },
926 { { "fr21" }, "f21" },
927 { { "fr22" }, "f22" },
928 { { "fr23" }, "f23" },
929 { { "fr24" }, "f24" },
930 { { "fr25" }, "f25" },
931 { { "fr26" }, "f26" },
932 { { "fr27" }, "f27" },
933 { { "fr28" }, "f28" },
934 { { "fr29" }, "f29" },
935 { { "fr30" }, "f30" },
936 { { "fr31" }, "f31" },
937 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +0000938};
939
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000940void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000941 unsigned &NumAliases) const {
942 Aliases = GCCRegAliases;
943 NumAliases = llvm::array_lengthof(GCCRegAliases);
944}
945} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +0000946
947namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000948class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000949public:
Chris Lattnere03ae302010-02-16 18:14:57 +0000950 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +0000951 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 +0000952 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +0000953
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000954 switch (getTriple().getOS()) {
Nico Weber6e1d2ea2012-01-31 02:07:33 +0000955 case llvm::Triple::Linux:
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000956 case llvm::Triple::FreeBSD:
957 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000958 SizeType = UnsignedInt;
Hal Finkel178a9b82012-03-02 20:54:36 +0000959 PtrDiffType = SignedInt;
960 IntPtrType = SignedInt;
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000961 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +0000962 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000963 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000964 }
Roman Divackye3d175d2012-03-13 16:53:54 +0000965
Roman Divackyefe9c0d2012-03-13 19:20:17 +0000966 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
967 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +0000968 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divackyefe9c0d2012-03-13 19:20:17 +0000969 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000970 }
971
Meador Ingec5613b22012-06-16 03:34:49 +0000972 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Roman Divackyc81f2a22011-01-06 08:27:10 +0000973 // This is the ELF definition, and is overridden by the Darwin sub-target
Meador Ingec5613b22012-06-16 03:34:49 +0000974 return TargetInfo::PowerABIBuiltinVaList;
Eli Friedmaned855cb2008-08-21 00:13:15 +0000975 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000976};
977} // end anonymous namespace.
978
979namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000980class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000981public:
Eli Friedmane4277982008-08-20 23:11:40 +0000982 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +0000983 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +0000984 IntMaxType = SignedLong;
985 UIntMaxType = UnsignedLong;
986 Int64Type = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +0000987 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner1932e122009-11-07 18:59:41 +0000988 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Roman Divackye3d175d2012-03-13 16:53:54 +0000989
Roman Divackyefe9c0d2012-03-13 19:20:17 +0000990 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
991 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +0000992 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divackyefe9c0d2012-03-13 19:20:17 +0000993 }
Chris Lattnerf291b102008-05-09 06:17:04 +0000994 }
Meador Ingec5613b22012-06-16 03:34:49 +0000995 virtual BuiltinVaListKind getBuiltinVaListKind() const {
996 return TargetInfo::CharPtrBuiltinVaList;
Roman Divackyc81f2a22011-01-06 08:27:10 +0000997 }
Eli Friedmane4277982008-08-20 23:11:40 +0000998};
999} // end anonymous namespace.
1000
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001001
1002namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001003class DarwinPPC32TargetInfo :
1004 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001005public:
Roman Divackyc81f2a22011-01-06 08:27:10 +00001006 DarwinPPC32TargetInfo(const std::string& triple)
1007 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001008 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001009 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001010 LongLongAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001011 SuitableAlign = 128;
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001012 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1013 "i64:32:64-f32:32:32-f64:64:64-v128:128:128-n32";
Roman Divackyc81f2a22011-01-06 08:27:10 +00001014 }
Meador Ingec5613b22012-06-16 03:34:49 +00001015 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1016 return TargetInfo::CharPtrBuiltinVaList;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001017 }
1018};
1019
1020class DarwinPPC64TargetInfo :
1021 public DarwinTargetInfo<PPC64TargetInfo> {
1022public:
1023 DarwinPPC64TargetInfo(const std::string& triple)
1024 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
1025 HasAlignMac68kSupport = true;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001026 SuitableAlign = 128;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001027 }
1028};
1029} // end anonymous namespace.
1030
Reid Spencer5f016e22007-07-11 17:01:13 +00001031namespace {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001032 static const unsigned NVPTXAddrSpaceMap[] = {
1033 1, // opencl_global
1034 3, // opencl_local
1035 4, // opencl_constant
1036 1, // cuda_device
1037 4, // cuda_constant
1038 3, // cuda_shared
1039 };
1040 class NVPTXTargetInfo : public TargetInfo {
1041 static const char * const GCCRegNames[];
Justin Holewinski2c585b92012-05-24 17:43:12 +00001042 static const Builtin::Info BuiltinInfo[];
1043 std::vector<llvm::StringRef> AvailableFeatures;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001044 public:
1045 NVPTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
1046 BigEndian = false;
1047 TLSSupported = false;
1048 LongWidth = LongAlign = 64;
1049 AddrSpaceMap = &NVPTXAddrSpaceMap;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001050 // Define available target features
1051 // These must be defined in sorted order!
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001052 }
1053 virtual void getTargetDefines(const LangOptions &Opts,
1054 MacroBuilder &Builder) const {
1055 Builder.defineMacro("__PTX__");
Justin Holewinski2c585b92012-05-24 17:43:12 +00001056 Builder.defineMacro("__NVPTX__");
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001057 }
1058 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1059 unsigned &NumRecords) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001060 Records = BuiltinInfo;
1061 NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001062 }
1063 virtual bool hasFeature(StringRef Feature) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001064 return Feature == "ptx" || Feature == "nvptx";
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001065 }
1066
1067 virtual void getGCCRegNames(const char * const *&Names,
1068 unsigned &NumNames) const;
1069 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1070 unsigned &NumAliases) const {
1071 // No aliases.
1072 Aliases = 0;
1073 NumAliases = 0;
1074 }
1075 virtual bool validateAsmConstraint(const char *&Name,
1076 TargetInfo::ConstraintInfo &info) const {
1077 // FIXME: implement
1078 return true;
1079 }
1080 virtual const char *getClobbers() const {
1081 // FIXME: Is this really right?
1082 return "";
1083 }
Meador Ingec5613b22012-06-16 03:34:49 +00001084 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001085 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00001086 return TargetInfo::CharPtrBuiltinVaList;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001087 }
1088 virtual bool setCPU(const std::string &Name) {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001089 return Name == "sm_10" || Name == "sm_13" || Name == "sm_20";
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001090 }
Justin Holewinski2c585b92012-05-24 17:43:12 +00001091 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1092 StringRef Name,
1093 bool Enabled) const;
1094 };
1095
1096 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1097#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1098#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1099 ALL_LANGUAGES },
1100#include "clang/Basic/BuiltinsNVPTX.def"
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001101 };
1102
1103 const char * const NVPTXTargetInfo::GCCRegNames[] = {
1104 "r0"
1105 };
1106
1107 void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names,
1108 unsigned &NumNames) const {
1109 Names = GCCRegNames;
1110 NumNames = llvm::array_lengthof(GCCRegNames);
1111 }
1112
Justin Holewinski2c585b92012-05-24 17:43:12 +00001113 bool NVPTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1114 StringRef Name,
1115 bool Enabled) const {
1116 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
1117 Name)) {
1118 Features[Name] = Enabled;
1119 return true;
1120 } else {
1121 return false;
1122 }
1123 }
1124
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001125 class NVPTX32TargetInfo : public NVPTXTargetInfo {
1126 public:
Justin Holewinski2c585b92012-05-24 17:43:12 +00001127 NVPTX32TargetInfo(const std::string& triple) : NVPTXTargetInfo(triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001128 PointerWidth = PointerAlign = 32;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001129 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001130 DescriptionString
1131 = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1132 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1133 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001134 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001135 };
1136
1137 class NVPTX64TargetInfo : public NVPTXTargetInfo {
1138 public:
Justin Holewinski2c585b92012-05-24 17:43:12 +00001139 NVPTX64TargetInfo(const std::string& triple) : NVPTXTargetInfo(triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001140 PointerWidth = PointerAlign = 64;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001141 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001142 DescriptionString
1143 = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1144 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1145 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001146 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001147 };
1148}
1149
1150namespace {
Chris Lattner9cbeb632010-03-06 21:21:27 +00001151// MBlaze abstract base class
1152class MBlazeTargetInfo : public TargetInfo {
1153 static const char * const GCCRegNames[];
1154 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1155
1156public:
1157 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +00001158 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner9cbeb632010-03-06 21:21:27 +00001159 }
1160
1161 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1162 unsigned &NumRecords) const {
1163 // FIXME: Implement.
1164 Records = 0;
1165 NumRecords = 0;
1166 }
1167
1168 virtual void getTargetDefines(const LangOptions &Opts,
1169 MacroBuilder &Builder) const;
1170
Douglas Gregore727d212012-01-30 06:38:25 +00001171 virtual bool hasFeature(StringRef Feature) const {
1172 return Feature == "mblaze";
1173 }
1174
Meador Ingec5613b22012-06-16 03:34:49 +00001175 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1176 return TargetInfo::CharPtrBuiltinVaList;
Chris Lattner9cbeb632010-03-06 21:21:27 +00001177 }
1178 virtual const char *getTargetPrefix() const {
1179 return "mblaze";
1180 }
1181 virtual void getGCCRegNames(const char * const *&Names,
1182 unsigned &NumNames) const;
1183 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1184 unsigned &NumAliases) const;
1185 virtual bool validateAsmConstraint(const char *&Name,
1186 TargetInfo::ConstraintInfo &Info) const {
1187 switch (*Name) {
1188 default: return false;
1189 case 'O': // Zero
1190 return true;
1191 case 'b': // Base register
1192 case 'f': // Floating point register
1193 Info.setAllowsRegister();
1194 return true;
1195 }
1196 }
1197 virtual const char *getClobbers() const {
1198 return "";
1199 }
1200};
1201
1202/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1203/// #defines that are not tied to a specific subtarget.
1204void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1205 MacroBuilder &Builder) const {
1206 // Target identification.
1207 Builder.defineMacro("__microblaze__");
1208 Builder.defineMacro("_ARCH_MICROBLAZE");
1209 Builder.defineMacro("__MICROBLAZE__");
1210
1211 // Target properties.
1212 Builder.defineMacro("_BIG_ENDIAN");
1213 Builder.defineMacro("__BIG_ENDIAN__");
1214
1215 // Subtarget options.
1216 Builder.defineMacro("__REGISTER_PREFIX__", "");
1217}
1218
1219
1220const char * const MBlazeTargetInfo::GCCRegNames[] = {
1221 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1222 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1223 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1224 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1225 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1226 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1227 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1228 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1229 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1230 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1231};
1232
1233void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1234 unsigned &NumNames) const {
1235 Names = GCCRegNames;
1236 NumNames = llvm::array_lengthof(GCCRegNames);
1237}
1238
1239const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1240 { {"f0"}, "r0" },
1241 { {"f1"}, "r1" },
1242 { {"f2"}, "r2" },
1243 { {"f3"}, "r3" },
1244 { {"f4"}, "r4" },
1245 { {"f5"}, "r5" },
1246 { {"f6"}, "r6" },
1247 { {"f7"}, "r7" },
1248 { {"f8"}, "r8" },
1249 { {"f9"}, "r9" },
1250 { {"f10"}, "r10" },
1251 { {"f11"}, "r11" },
1252 { {"f12"}, "r12" },
1253 { {"f13"}, "r13" },
1254 { {"f14"}, "r14" },
1255 { {"f15"}, "r15" },
1256 { {"f16"}, "r16" },
1257 { {"f17"}, "r17" },
1258 { {"f18"}, "r18" },
1259 { {"f19"}, "r19" },
1260 { {"f20"}, "r20" },
1261 { {"f21"}, "r21" },
1262 { {"f22"}, "r22" },
1263 { {"f23"}, "r23" },
1264 { {"f24"}, "r24" },
1265 { {"f25"}, "r25" },
1266 { {"f26"}, "r26" },
1267 { {"f27"}, "r27" },
1268 { {"f28"}, "r28" },
1269 { {"f29"}, "r29" },
1270 { {"f30"}, "r30" },
1271 { {"f31"}, "r31" },
1272};
1273
1274void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1275 unsigned &NumAliases) const {
1276 Aliases = GCCRegAliases;
1277 NumAliases = llvm::array_lengthof(GCCRegAliases);
1278}
1279} // end anonymous namespace.
1280
1281namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001282// Namespace for x86 abstract base class
1283const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001284#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001285#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001286 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001287#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001288};
Eli Friedman61538a72008-05-20 14:21:01 +00001289
Nuno Lopes2550d702009-12-23 17:49:57 +00001290static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001291 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1292 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001293 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001294 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1295 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1296 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001297 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopherc5f9a012011-12-02 02:12:16 +00001298 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1299 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001300};
1301
Eric Christophercfd323d2011-06-21 00:05:20 +00001302const TargetInfo::AddlRegName AddlRegNames[] = {
1303 { { "al", "ah", "eax", "rax" }, 0 },
1304 { { "bl", "bh", "ebx", "rbx" }, 3 },
1305 { { "cl", "ch", "ecx", "rcx" }, 2 },
1306 { { "dl", "dh", "edx", "rdx" }, 1 },
1307 { { "esi", "rsi" }, 4 },
1308 { { "edi", "rdi" }, 5 },
1309 { { "esp", "rsp" }, 7 },
1310 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001311};
1312
1313// X86 target abstract base class; x86-32 and x86-64 are very close, so
1314// most of the implementation can be shared.
1315class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001316 enum X86SSEEnum {
Craig Topper05fe4b52012-01-09 09:19:09 +00001317 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2
Chris Lattner84f0ea82009-03-02 22:40:39 +00001318 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001319 enum MMX3DNowEnum {
1320 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1321 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001322
Eric Christophereea12d12010-04-02 23:50:19 +00001323 bool HasAES;
Craig Topper3c0bc152012-05-31 05:18:48 +00001324 bool HasPCLMUL;
Craig Topper31ceea02011-12-25 05:06:45 +00001325 bool HasLZCNT;
1326 bool HasBMI;
1327 bool HasBMI2;
Craig Toppere14e08b2011-12-29 16:10:46 +00001328 bool HasPOPCNT;
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00001329 bool HasSSE4a;
Craig Topper6a511e12011-12-30 07:33:42 +00001330 bool HasFMA4;
Craig Topper2ae95072012-06-03 21:46:30 +00001331 bool HasFMA;
Craig Topperb6af69e2012-06-09 22:24:14 +00001332 bool HasXOP;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001333
Chandler Carruth499d9722011-09-28 08:55:34 +00001334 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1335 ///
1336 /// Each enumeration represents a particular CPU supported by Clang. These
1337 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1338 enum CPUKind {
1339 CK_Generic,
1340
1341 /// \name i386
1342 /// i386-generation processors.
1343 //@{
1344 CK_i386,
1345 //@}
1346
1347 /// \name i486
1348 /// i486-generation processors.
1349 //@{
1350 CK_i486,
1351 CK_WinChipC6,
1352 CK_WinChip2,
1353 CK_C3,
1354 //@}
1355
1356 /// \name i586
1357 /// i586-generation processors, P5 microarchitecture based.
1358 //@{
1359 CK_i586,
1360 CK_Pentium,
1361 CK_PentiumMMX,
1362 //@}
1363
1364 /// \name i686
1365 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1366 //@{
1367 CK_i686,
1368 CK_PentiumPro,
1369 CK_Pentium2,
1370 CK_Pentium3,
1371 CK_Pentium3M,
1372 CK_PentiumM,
1373 CK_C3_2,
1374
1375 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1376 /// Clang however has some logic to suport this.
1377 // FIXME: Warn, deprecate, and potentially remove this.
1378 CK_Yonah,
1379 //@}
1380
1381 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001382 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001383 //@{
1384 CK_Pentium4,
1385 CK_Pentium4M,
1386 CK_Prescott,
1387 CK_Nocona,
1388 //@}
1389
1390 /// \name Core
1391 /// Core microarchitecture based processors.
1392 //@{
1393 CK_Core2,
1394
1395 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1396 /// codename which GCC no longer accepts as an option to -march, but Clang
1397 /// has some logic for recognizing it.
1398 // FIXME: Warn, deprecate, and potentially remove this.
1399 CK_Penryn,
1400 //@}
1401
1402 /// \name Atom
1403 /// Atom processors
1404 //@{
1405 CK_Atom,
1406 //@}
1407
1408 /// \name Nehalem
1409 /// Nehalem microarchitecture based processors.
1410 //@{
1411 CK_Corei7,
1412 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001413 CK_CoreAVXi,
Craig Topper2b03bb02011-12-17 19:55:21 +00001414 CK_CoreAVX2,
Chandler Carruth499d9722011-09-28 08:55:34 +00001415 //@}
1416
1417 /// \name K6
1418 /// K6 architecture processors.
1419 //@{
1420 CK_K6,
1421 CK_K6_2,
1422 CK_K6_3,
1423 //@}
1424
1425 /// \name K7
1426 /// K7 architecture processors.
1427 //@{
1428 CK_Athlon,
1429 CK_AthlonThunderbird,
1430 CK_Athlon4,
1431 CK_AthlonXP,
1432 CK_AthlonMP,
1433 //@}
1434
1435 /// \name K8
1436 /// K8 architecture processors.
1437 //@{
1438 CK_Athlon64,
1439 CK_Athlon64SSE3,
1440 CK_AthlonFX,
1441 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001442 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001443 CK_Opteron,
1444 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001445 CK_AMDFAM10,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001446 //@}
Chandler Carruth499d9722011-09-28 08:55:34 +00001447
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001448 /// \name Bobcat
1449 /// Bobcat architecture processors.
1450 //@{
1451 CK_BTVER1,
1452 //@}
1453
1454 /// \name Bulldozer
1455 /// Bulldozer architecture processors.
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001456 //@{
1457 CK_BDVER1,
1458 CK_BDVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001459 //@}
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001460
Chandler Carruth499d9722011-09-28 08:55:34 +00001461 /// This specification is deprecated and will be removed in the future.
1462 /// Users should prefer \see CK_K8.
1463 // FIXME: Warn on this when the CPU is set to it.
1464 CK_x86_64,
1465 //@}
1466
1467 /// \name Geode
1468 /// Geode processors.
1469 //@{
1470 CK_Geode
1471 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001472 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001473
Eli Friedman618234a2008-08-20 02:34:37 +00001474public:
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001475 X86TargetInfo(const std::string& triple)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001476 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Craig Topper3c0bc152012-05-31 05:18:48 +00001477 HasAES(false), HasPCLMUL(false), HasLZCNT(false), HasBMI(false),
1478 HasBMI2(false), HasPOPCNT(false), HasSSE4a(false), HasFMA4(false),
Craig Topperb6af69e2012-06-09 22:24:14 +00001479 HasFMA(false), HasXOP(false), CPU(CK_Generic) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00001480 BigEndian = false;
Eli Friedman618234a2008-08-20 02:34:37 +00001481 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001482 }
Benjamin Kramerb4066692011-12-28 15:47:06 +00001483 virtual unsigned getFloatEvalMethod() const {
1484 // X87 evaluates with 80 bits "long double" precision.
1485 return SSELevel == NoSSE ? 2 : 0;
1486 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001487 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1488 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001489 Records = BuiltinInfo;
1490 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001491 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001492 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001493 unsigned &NumNames) const {
1494 Names = GCCRegNames;
1495 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001496 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001497 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001498 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001499 Aliases = 0;
1500 NumAliases = 0;
1501 }
1502 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1503 unsigned &NumNames) const {
1504 Names = AddlRegNames;
1505 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001506 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001507 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001508 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001509 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001510 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001511 return "~{dirflag},~{fpsr},~{flags}";
1512 }
Chris Lattner33328642009-03-20 15:52:06 +00001513 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001514 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001515 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001516 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001517 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001518 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Douglas Gregore727d212012-01-30 06:38:25 +00001519 virtual bool hasFeature(StringRef Feature) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001520 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001521 virtual const char* getABI() const {
Craig Topper05fe4b52012-01-09 09:19:09 +00001522 if (PointerWidth == 64 && SSELevel >= AVX)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001523 return "avx";
1524 else if (PointerWidth == 32 && MMX3DNowLevel == NoMMX3DNow)
1525 return "no-mmx";
1526 return "";
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001527 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001528 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001529 CPU = llvm::StringSwitch<CPUKind>(Name)
1530 .Case("i386", CK_i386)
1531 .Case("i486", CK_i486)
1532 .Case("winchip-c6", CK_WinChipC6)
1533 .Case("winchip2", CK_WinChip2)
1534 .Case("c3", CK_C3)
1535 .Case("i586", CK_i586)
1536 .Case("pentium", CK_Pentium)
1537 .Case("pentium-mmx", CK_PentiumMMX)
1538 .Case("i686", CK_i686)
1539 .Case("pentiumpro", CK_PentiumPro)
1540 .Case("pentium2", CK_Pentium2)
1541 .Case("pentium3", CK_Pentium3)
1542 .Case("pentium3m", CK_Pentium3M)
1543 .Case("pentium-m", CK_PentiumM)
1544 .Case("c3-2", CK_C3_2)
1545 .Case("yonah", CK_Yonah)
1546 .Case("pentium4", CK_Pentium4)
1547 .Case("pentium4m", CK_Pentium4M)
1548 .Case("prescott", CK_Prescott)
1549 .Case("nocona", CK_Nocona)
1550 .Case("core2", CK_Core2)
1551 .Case("penryn", CK_Penryn)
1552 .Case("atom", CK_Atom)
1553 .Case("corei7", CK_Corei7)
1554 .Case("corei7-avx", CK_Corei7AVX)
1555 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper2b03bb02011-12-17 19:55:21 +00001556 .Case("core-avx2", CK_CoreAVX2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001557 .Case("k6", CK_K6)
1558 .Case("k6-2", CK_K6_2)
1559 .Case("k6-3", CK_K6_3)
1560 .Case("athlon", CK_Athlon)
1561 .Case("athlon-tbird", CK_AthlonThunderbird)
1562 .Case("athlon-4", CK_Athlon4)
1563 .Case("athlon-xp", CK_AthlonXP)
1564 .Case("athlon-mp", CK_AthlonMP)
1565 .Case("athlon64", CK_Athlon64)
1566 .Case("athlon64-sse3", CK_Athlon64SSE3)
1567 .Case("athlon-fx", CK_AthlonFX)
1568 .Case("k8", CK_K8)
1569 .Case("k8-sse3", CK_K8SSE3)
1570 .Case("opteron", CK_Opteron)
1571 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001572 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001573 .Case("btver1", CK_BTVER1)
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001574 .Case("bdver1", CK_BDVER1)
1575 .Case("bdver2", CK_BDVER2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001576 .Case("x86-64", CK_x86_64)
1577 .Case("geode", CK_Geode)
1578 .Default(CK_Generic);
1579
Chandler Carruth26a39142011-09-28 09:45:08 +00001580 // Perform any per-CPU checks necessary to determine if this CPU is
1581 // acceptable.
1582 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1583 // invalid without explaining *why*.
1584 switch (CPU) {
1585 case CK_Generic:
1586 // No processor selected!
1587 return false;
1588
1589 case CK_i386:
1590 case CK_i486:
1591 case CK_WinChipC6:
1592 case CK_WinChip2:
1593 case CK_C3:
1594 case CK_i586:
1595 case CK_Pentium:
1596 case CK_PentiumMMX:
1597 case CK_i686:
1598 case CK_PentiumPro:
1599 case CK_Pentium2:
1600 case CK_Pentium3:
1601 case CK_Pentium3M:
1602 case CK_PentiumM:
1603 case CK_Yonah:
1604 case CK_C3_2:
1605 case CK_Pentium4:
1606 case CK_Pentium4M:
1607 case CK_Prescott:
1608 case CK_K6:
1609 case CK_K6_2:
1610 case CK_K6_3:
1611 case CK_Athlon:
1612 case CK_AthlonThunderbird:
1613 case CK_Athlon4:
1614 case CK_AthlonXP:
1615 case CK_AthlonMP:
1616 case CK_Geode:
1617 // Only accept certain architectures when compiling in 32-bit mode.
1618 if (PointerWidth != 32)
1619 return false;
1620
1621 // Fallthrough
1622 case CK_Nocona:
1623 case CK_Core2:
1624 case CK_Penryn:
1625 case CK_Atom:
1626 case CK_Corei7:
1627 case CK_Corei7AVX:
1628 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001629 case CK_CoreAVX2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001630 case CK_Athlon64:
1631 case CK_Athlon64SSE3:
1632 case CK_AthlonFX:
1633 case CK_K8:
1634 case CK_K8SSE3:
1635 case CK_Opteron:
1636 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00001637 case CK_AMDFAM10:
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001638 case CK_BTVER1:
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001639 case CK_BDVER1:
1640 case CK_BDVER2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001641 case CK_x86_64:
1642 return true;
1643 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001644 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001645 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001646};
Chris Lattner3daed522009-03-02 22:20:04 +00001647
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001648void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001649 // FIXME: This should not be here.
1650 Features["3dnow"] = false;
1651 Features["3dnowa"] = false;
1652 Features["mmx"] = false;
1653 Features["sse"] = false;
1654 Features["sse2"] = false;
1655 Features["sse3"] = false;
1656 Features["ssse3"] = false;
1657 Features["sse41"] = false;
1658 Features["sse42"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001659 Features["sse4a"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001660 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00001661 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001662 Features["avx"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001663 Features["avx2"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001664 Features["lzcnt"] = false;
1665 Features["bmi"] = false;
1666 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001667 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001668 Features["fma4"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00001669 Features["fma"] = false;
Craig Topperb6af69e2012-06-09 22:24:14 +00001670 Features["xop"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001671
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001672 // FIXME: This *really* should not be here.
1673
1674 // X86_64 always has SSE2.
1675 if (PointerWidth == 64)
1676 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1677
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001678 switch (CPU) {
1679 case CK_Generic:
1680 case CK_i386:
1681 case CK_i486:
1682 case CK_i586:
1683 case CK_Pentium:
1684 case CK_i686:
1685 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001686 break;
1687 case CK_PentiumMMX:
1688 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001689 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001690 break;
1691 case CK_Pentium3:
1692 case CK_Pentium3M:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001693 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001694 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001695 break;
1696 case CK_PentiumM:
1697 case CK_Pentium4:
1698 case CK_Pentium4M:
1699 case CK_x86_64:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001700 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001701 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001702 break;
1703 case CK_Yonah:
1704 case CK_Prescott:
1705 case CK_Nocona:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001706 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001707 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001708 break;
1709 case CK_Core2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001710 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001711 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001712 break;
1713 case CK_Penryn:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001714 setFeatureEnabled(Features, "mmx", true);
Benjamin Kramerb3453a82012-01-04 14:36:57 +00001715 setFeatureEnabled(Features, "sse4.1", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001716 break;
1717 case CK_Atom:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001718 setFeatureEnabled(Features, "mmx", true);
Chandler Carruth49defe62011-09-28 10:36:46 +00001719 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001720 break;
1721 case CK_Corei7:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001722 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001723 setFeatureEnabled(Features, "sse4", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001724 break;
1725 case CK_Corei7AVX:
1726 case CK_CoreAVXi:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001727 setFeatureEnabled(Features, "mmx", true);
Craig Topperfd936302012-04-26 07:31:30 +00001728 setFeatureEnabled(Features, "avx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00001729 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00001730 setFeatureEnabled(Features, "pclmul", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001731 break;
Craig Topper2b03bb02011-12-17 19:55:21 +00001732 case CK_CoreAVX2:
1733 setFeatureEnabled(Features, "mmx", true);
Craig Topperfd936302012-04-26 07:31:30 +00001734 setFeatureEnabled(Features, "avx2", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00001735 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00001736 setFeatureEnabled(Features, "pclmul", true);
Craig Topper31ceea02011-12-25 05:06:45 +00001737 setFeatureEnabled(Features, "lzcnt", true);
1738 setFeatureEnabled(Features, "bmi", true);
1739 setFeatureEnabled(Features, "bmi2", true);
Craig Topper2ae95072012-06-03 21:46:30 +00001740 setFeatureEnabled(Features, "fma", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00001741 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001742 case CK_K6:
1743 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001744 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001745 break;
1746 case CK_K6_2:
1747 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001748 case CK_WinChip2:
1749 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001750 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001751 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00001752 case CK_Athlon:
1753 case CK_AthlonThunderbird:
1754 case CK_Geode:
1755 setFeatureEnabled(Features, "3dnowa", true);
1756 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001757 case CK_Athlon4:
1758 case CK_AthlonXP:
1759 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001760 setFeatureEnabled(Features, "sse", true);
1761 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001762 break;
1763 case CK_K8:
1764 case CK_Opteron:
1765 case CK_Athlon64:
1766 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00001767 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001768 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001769 break;
1770 case CK_K8SSE3:
1771 case CK_OpteronSSE3:
1772 case CK_Athlon64SSE3:
Roman Divacky80b32b82011-10-30 13:47:56 +00001773 setFeatureEnabled(Features, "sse3", true);
1774 setFeatureEnabled(Features, "3dnowa", true);
1775 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00001776 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00001777 setFeatureEnabled(Features, "sse3", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00001778 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00001779 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001780 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001781 case CK_BTVER1:
1782 setFeatureEnabled(Features, "ssse3", true);
1783 setFeatureEnabled(Features, "sse4a", true);
Craig Topper90ea0362012-05-30 05:54:54 +00001784 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001785 case CK_BDVER1:
1786 case CK_BDVER2:
Craig Topper70d9b162012-05-01 07:18:03 +00001787 setFeatureEnabled(Features, "avx", true);
Craig Topperb6af69e2012-06-09 22:24:14 +00001788 setFeatureEnabled(Features, "xop", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001789 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00001790 setFeatureEnabled(Features, "pclmul", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001791 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001792 case CK_C3_2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001793 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001794 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001795 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001796 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001797}
1798
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001799bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001800 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001801 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00001802 // FIXME: This *really* should not be here. We need some way of translating
1803 // options into llvm subtarget features.
1804 if (!Features.count(Name) &&
1805 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001806 return false;
1807
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001808 // FIXME: this should probably use a switch with fall through.
1809
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001810 if (Enabled) {
1811 if (Name == "mmx")
1812 Features["mmx"] = true;
1813 else if (Name == "sse")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001814 Features["mmx"] = Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001815 else if (Name == "sse2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001816 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001817 else if (Name == "sse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001818 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1819 true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001820 else if (Name == "ssse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001821 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001822 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001823 else if (Name == "sse4" || Name == "sse4.2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001824 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001825 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1826 Features["popcnt"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001827 else if (Name == "sse4.1")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001828 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00001829 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001830 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001831 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001832 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001833 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00001834 else if (Name == "aes")
Craig Toppera7463c32012-06-03 21:56:22 +00001835 Features["sse"] = Features["sse2"] = Features["aes"] = true;
Craig Topper3c0bc152012-05-31 05:18:48 +00001836 else if (Name == "pclmul")
Craig Toppera7463c32012-06-03 21:56:22 +00001837 Features["sse"] = Features["sse2"] = Features["pclmul"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001838 else if (Name == "avx")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001839 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1840 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001841 Features["popcnt"] = Features["avx"] = true;
Craig Topper2b03bb02011-12-17 19:55:21 +00001842 else if (Name == "avx2")
1843 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1844 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001845 Features["popcnt"] = Features["avx"] = Features["avx2"] = true;
Craig Topper2ae95072012-06-03 21:46:30 +00001846 else if (Name == "fma")
1847 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1848 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1849 Features["popcnt"] = Features["avx"] = Features["fma"] = true;
Craig Topper6a511e12011-12-30 07:33:42 +00001850 else if (Name == "fma4")
1851 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1852 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper90ea0362012-05-30 05:54:54 +00001853 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
1854 Features["fma4"] = true;
Craig Topperb6af69e2012-06-09 22:24:14 +00001855 else if (Name == "xop")
1856 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1857 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1858 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
1859 Features["fma4"] = Features["xop"] = true;
Roman Divacky80b32b82011-10-30 13:47:56 +00001860 else if (Name == "sse4a")
Craig Topper6a511e12011-12-30 07:33:42 +00001861 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper90ea0362012-05-30 05:54:54 +00001862 Features["sse4a"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00001863 else if (Name == "lzcnt")
1864 Features["lzcnt"] = true;
1865 else if (Name == "bmi")
1866 Features["bmi"] = true;
1867 else if (Name == "bmi2")
1868 Features["bmi2"] = true;
Craig Toppere14e08b2011-12-29 16:10:46 +00001869 else if (Name == "popcnt")
1870 Features["popcnt"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001871 } else {
1872 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001873 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001874 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00001875 Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00001876 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper31380fb2012-06-03 22:23:42 +00001877 Features["sse4a"] = Features["avx"] = Features["avx2"] =
1878 Features["fma"] = Features["fma4"] = Features["aes"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00001879 Features["pclmul"] = Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001880 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00001881 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Craig Toppera7463c32012-06-03 21:56:22 +00001882 Features["sse41"] = Features["sse42"] = Features["sse4a"] =
Craig Topper31380fb2012-06-03 22:23:42 +00001883 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00001884 Features["fma4"] = Features["aes"] = Features["pclmul"] =
1885 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001886 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00001887 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Craig Topper31380fb2012-06-03 22:23:42 +00001888 Features["sse42"] = Features["sse4a"] = Features["avx"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00001889 Features["avx2"] = Features["fma"] = Features["fma4"] =
1890 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001891 else if (Name == "ssse3")
Craig Topper31380fb2012-06-03 22:23:42 +00001892 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1893 Features["avx"] = Features["avx2"] = Features["fma"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00001894 else if (Name == "sse4" || Name == "sse4.1")
Craig Topper31380fb2012-06-03 22:23:42 +00001895 Features["sse41"] = Features["sse42"] = Features["avx"] =
1896 Features["avx2"] = Features["fma"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00001897 else if (Name == "sse4.2")
Craig Topper31380fb2012-06-03 22:23:42 +00001898 Features["sse42"] = Features["avx"] = Features["avx2"] =
1899 Features["fma"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001900 else if (Name == "3dnow")
1901 Features["3dnow"] = Features["3dnowa"] = false;
1902 else if (Name == "3dnowa")
1903 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001904 else if (Name == "aes")
1905 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00001906 else if (Name == "pclmul")
1907 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001908 else if (Name == "avx")
Craig Topper2ae95072012-06-03 21:46:30 +00001909 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00001910 Features["fma4"] = Features["xop"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001911 else if (Name == "avx2")
1912 Features["avx2"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00001913 else if (Name == "fma")
1914 Features["fma"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001915 else if (Name == "sse4a")
Craig Topperb6af69e2012-06-09 22:24:14 +00001916 Features["sse4a"] = Features["fma4"] = Features["xop"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001917 else if (Name == "lzcnt")
1918 Features["lzcnt"] = false;
1919 else if (Name == "bmi")
1920 Features["bmi"] = false;
1921 else if (Name == "bmi2")
1922 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001923 else if (Name == "popcnt")
1924 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001925 else if (Name == "fma4")
Craig Topperb6af69e2012-06-09 22:24:14 +00001926 Features["fma4"] = Features["xop"] = false;
1927 else if (Name == "xop")
1928 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001929 }
1930
1931 return true;
1932}
1933
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001934/// HandleTargetOptions - Perform initialization based on the user
1935/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001936void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001937 // Remember the maximum enabled sselevel.
1938 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1939 // Ignore disabled features.
1940 if (Features[i][0] == '-')
1941 continue;
1942
Benjamin Kramer713575a2012-03-05 15:10:44 +00001943 StringRef Feature = StringRef(Features[i]).substr(1);
1944
1945 if (Feature == "aes") {
Eric Christophereea12d12010-04-02 23:50:19 +00001946 HasAES = true;
1947 continue;
1948 }
1949
Craig Topper3c0bc152012-05-31 05:18:48 +00001950 if (Feature == "pclmul") {
1951 HasPCLMUL = true;
1952 continue;
1953 }
1954
Benjamin Kramer713575a2012-03-05 15:10:44 +00001955 if (Feature == "lzcnt") {
Craig Topper31ceea02011-12-25 05:06:45 +00001956 HasLZCNT = true;
1957 continue;
1958 }
1959
Benjamin Kramer713575a2012-03-05 15:10:44 +00001960 if (Feature == "bmi") {
Craig Topper31ceea02011-12-25 05:06:45 +00001961 HasBMI = true;
1962 continue;
1963 }
1964
Benjamin Kramer713575a2012-03-05 15:10:44 +00001965 if (Feature == "bmi2") {
Craig Topper31ceea02011-12-25 05:06:45 +00001966 HasBMI2 = true;
1967 continue;
1968 }
1969
Benjamin Kramer713575a2012-03-05 15:10:44 +00001970 if (Feature == "popcnt") {
Craig Toppere14e08b2011-12-29 16:10:46 +00001971 HasPOPCNT = true;
1972 continue;
1973 }
1974
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00001975 if (Feature == "sse4a") {
1976 HasSSE4a = true;
1977 continue;
1978 }
1979
Benjamin Kramer713575a2012-03-05 15:10:44 +00001980 if (Feature == "fma4") {
Craig Topper6a511e12011-12-30 07:33:42 +00001981 HasFMA4 = true;
1982 continue;
1983 }
1984
Craig Topper2ae95072012-06-03 21:46:30 +00001985 if (Feature == "fma") {
1986 HasFMA = true;
1987 continue;
1988 }
1989
Craig Topperb6af69e2012-06-09 22:24:14 +00001990 if (Feature == "xop") {
1991 HasXOP = true;
1992 continue;
1993 }
1994
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001995 assert(Features[i][0] == '+' && "Invalid target feature!");
Benjamin Kramer713575a2012-03-05 15:10:44 +00001996 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Craig Topper05fe4b52012-01-09 09:19:09 +00001997 .Case("avx2", AVX2)
1998 .Case("avx", AVX)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001999 .Case("sse42", SSE42)
2000 .Case("sse41", SSE41)
2001 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00002002 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002003 .Case("sse2", SSE2)
2004 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002005 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002006 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002007
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002008 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer713575a2012-03-05 15:10:44 +00002009 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002010 .Case("3dnowa", AMD3DNowAthlon)
2011 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002012 .Case("mmx", MMX)
2013 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002014
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002015 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002016 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002017
2018 // Don't tell the backend if we're turning off mmx; it will end up disabling
2019 // SSE, which we don't want.
2020 std::vector<std::string>::iterator it;
2021 it = std::find(Features.begin(), Features.end(), "-mmx");
2022 if (it != Features.end())
2023 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00002024}
Chris Lattnerc0f59212009-03-02 22:27:17 +00002025
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002026/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
2027/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00002028void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002029 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002030 // Target identification.
2031 if (PointerWidth == 64) {
Aaron Ballmanc0765a02012-03-14 20:50:57 +00002032 if (getLongWidth() == 64) {
2033 Builder.defineMacro("_LP64");
2034 Builder.defineMacro("__LP64__");
2035 }
Benjamin Kramera9992772010-01-09 17:55:51 +00002036 Builder.defineMacro("__amd64__");
2037 Builder.defineMacro("__amd64");
2038 Builder.defineMacro("__x86_64");
2039 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002040 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00002041 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00002042 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002043
Chris Lattnerc0f59212009-03-02 22:27:17 +00002044 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002045 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
2046 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002047 switch (CPU) {
2048 case CK_Generic:
2049 break;
2050 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002051 // The rest are coming from the i386 define above.
2052 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002053 break;
2054 case CK_i486:
2055 case CK_WinChipC6:
2056 case CK_WinChip2:
2057 case CK_C3:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002058 defineCPUMacros(Builder, "i486");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002059 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00002060 case CK_PentiumMMX:
2061 Builder.defineMacro("__pentium_mmx__");
2062 Builder.defineMacro("__tune_pentium_mmx__");
2063 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002064 case CK_i586:
2065 case CK_Pentium:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002066 defineCPUMacros(Builder, "i586");
2067 defineCPUMacros(Builder, "pentium");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002068 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002069 case CK_Pentium3:
2070 case CK_Pentium3M:
2071 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002072 Builder.defineMacro("__tune_pentium3__");
2073 // Fallthrough
2074 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002075 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002076 Builder.defineMacro("__tune_pentium2__");
2077 // Fallthrough
2078 case CK_PentiumPro:
2079 Builder.defineMacro("__tune_i686__");
2080 Builder.defineMacro("__tune_pentiumpro__");
2081 // Fallthrough
2082 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002083 Builder.defineMacro("__i686");
2084 Builder.defineMacro("__i686__");
2085 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
2086 Builder.defineMacro("__pentiumpro");
2087 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002088 break;
2089 case CK_Pentium4:
2090 case CK_Pentium4M:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002091 defineCPUMacros(Builder, "pentium4");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002092 break;
2093 case CK_Yonah:
2094 case CK_Prescott:
2095 case CK_Nocona:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002096 defineCPUMacros(Builder, "nocona");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002097 break;
2098 case CK_Core2:
2099 case CK_Penryn:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002100 defineCPUMacros(Builder, "core2");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002101 break;
2102 case CK_Atom:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002103 defineCPUMacros(Builder, "atom");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002104 break;
2105 case CK_Corei7:
2106 case CK_Corei7AVX:
2107 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00002108 case CK_CoreAVX2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002109 defineCPUMacros(Builder, "corei7");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002110 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002111 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002112 Builder.defineMacro("__k6_2__");
2113 Builder.defineMacro("__tune_k6_2__");
2114 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002115 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002116 if (CPU != CK_K6_2) { // In case of fallthrough
2117 // FIXME: GCC may be enabling these in cases where some other k6
2118 // architecture is specified but -m3dnow is explicitly provided. The
2119 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002120 Builder.defineMacro("__k6_3__");
2121 Builder.defineMacro("__tune_k6_3__");
2122 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00002123 // Fallthrough
2124 case CK_K6:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002125 defineCPUMacros(Builder, "k6");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002126 break;
2127 case CK_Athlon:
2128 case CK_AthlonThunderbird:
2129 case CK_Athlon4:
2130 case CK_AthlonXP:
2131 case CK_AthlonMP:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002132 defineCPUMacros(Builder, "athlon");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002133 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002134 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002135 Builder.defineMacro("__tune_athlon_sse__");
2136 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002137 break;
2138 case CK_K8:
2139 case CK_K8SSE3:
2140 case CK_x86_64:
2141 case CK_Opteron:
2142 case CK_OpteronSSE3:
2143 case CK_Athlon64:
2144 case CK_Athlon64SSE3:
2145 case CK_AthlonFX:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002146 defineCPUMacros(Builder, "k8");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002147 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002148 case CK_AMDFAM10:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002149 defineCPUMacros(Builder, "amdfam10");
Roman Divacky01c770d2011-10-30 07:48:46 +00002150 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002151 case CK_BTVER1:
2152 defineCPUMacros(Builder, "btver1");
2153 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002154 case CK_BDVER1:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002155 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002156 break;
2157 case CK_BDVER2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002158 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002159 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002160 case CK_Geode:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002161 defineCPUMacros(Builder, "geode");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002162 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002163 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00002164
Chandler Carruth88c75b02011-09-28 09:54:07 +00002165 // Target properties.
2166 Builder.defineMacro("__LITTLE_ENDIAN__");
2167 Builder.defineMacro("__REGISTER_PREFIX__", "");
2168
Chris Lattner54175442009-04-19 17:32:33 +00002169 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2170 // functions in glibc header files that use FP Stack inline asm which the
2171 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00002172 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002173
Chandler Carruth88c75b02011-09-28 09:54:07 +00002174 if (HasAES)
2175 Builder.defineMacro("__AES__");
2176
Craig Topper3c0bc152012-05-31 05:18:48 +00002177 if (HasPCLMUL)
2178 Builder.defineMacro("__PCLMUL__");
2179
Craig Topper31ceea02011-12-25 05:06:45 +00002180 if (HasLZCNT)
2181 Builder.defineMacro("__LZCNT__");
2182
2183 if (HasBMI)
2184 Builder.defineMacro("__BMI__");
2185
2186 if (HasBMI2)
2187 Builder.defineMacro("__BMI2__");
2188
Craig Toppere14e08b2011-12-29 16:10:46 +00002189 if (HasPOPCNT)
2190 Builder.defineMacro("__POPCNT__");
2191
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002192 if (HasSSE4a)
2193 Builder.defineMacro("__SSE4A__");
2194
Craig Topper6a511e12011-12-30 07:33:42 +00002195 if (HasFMA4)
2196 Builder.defineMacro("__FMA4__");
2197
Craig Topper2ae95072012-06-03 21:46:30 +00002198 if (HasFMA)
2199 Builder.defineMacro("__FMA__");
2200
Craig Topperb6af69e2012-06-09 22:24:14 +00002201 if (HasXOP)
2202 Builder.defineMacro("__XOP__");
2203
Chris Lattner84f0ea82009-03-02 22:40:39 +00002204 // Each case falls through to the previous one here.
2205 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002206 case AVX2:
2207 Builder.defineMacro("__AVX2__");
2208 case AVX:
2209 Builder.defineMacro("__AVX__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002210 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00002211 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002212 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00002213 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002214 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002215 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002216 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002217 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002218 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00002219 Builder.defineMacro("__SSE2__");
2220 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00002221 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00002222 Builder.defineMacro("__SSE__");
2223 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002224 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00002225 break;
2226 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002227
Francois Pichet62ec1f22011-09-17 17:15:52 +00002228 if (Opts.MicrosoftExt && PointerWidth == 32) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002229 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002230 case AVX2:
2231 case AVX:
Michael J. Spencera764e832010-10-21 08:22:51 +00002232 case SSE42:
2233 case SSE41:
2234 case SSSE3:
2235 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002236 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002237 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002238 break;
2239 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002240 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002241 break;
2242 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002243 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002244 }
2245 }
2246
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002247 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002248 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002249 case AMD3DNowAthlon:
2250 Builder.defineMacro("__3dNOW_A__");
2251 case AMD3DNow:
2252 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002253 case MMX:
2254 Builder.defineMacro("__MMX__");
2255 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002256 break;
2257 }
Chris Lattnerc0f59212009-03-02 22:27:17 +00002258}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002259
Douglas Gregore727d212012-01-30 06:38:25 +00002260bool X86TargetInfo::hasFeature(StringRef Feature) const {
2261 return llvm::StringSwitch<bool>(Feature)
2262 .Case("aes", HasAES)
2263 .Case("avx", SSELevel >= AVX)
2264 .Case("avx2", SSELevel >= AVX2)
2265 .Case("bmi", HasBMI)
2266 .Case("bmi2", HasBMI2)
Craig Topper2ae95072012-06-03 21:46:30 +00002267 .Case("fma", HasFMA)
Douglas Gregore727d212012-01-30 06:38:25 +00002268 .Case("fma4", HasFMA4)
2269 .Case("lzcnt", HasLZCNT)
2270 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
2271 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
2272 .Case("mmx", MMX3DNowLevel >= MMX)
Craig Topper3c0bc152012-05-31 05:18:48 +00002273 .Case("pclmul", HasPCLMUL)
Douglas Gregore727d212012-01-30 06:38:25 +00002274 .Case("popcnt", HasPOPCNT)
2275 .Case("sse", SSELevel >= SSE1)
2276 .Case("sse2", SSELevel >= SSE2)
2277 .Case("sse3", SSELevel >= SSE3)
2278 .Case("ssse3", SSELevel >= SSSE3)
2279 .Case("sse41", SSELevel >= SSE41)
2280 .Case("sse42", SSELevel >= SSE42)
Craig Topper3c0bc152012-05-31 05:18:48 +00002281 .Case("sse4a", HasSSE4a)
Douglas Gregore727d212012-01-30 06:38:25 +00002282 .Case("x86", true)
2283 .Case("x86_32", PointerWidth == 32)
2284 .Case("x86_64", PointerWidth == 64)
Craig Topperb6af69e2012-06-09 22:24:14 +00002285 .Case("xop", HasXOP)
Douglas Gregore727d212012-01-30 06:38:25 +00002286 .Default(false);
2287}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002288
Eli Friedman618234a2008-08-20 02:34:37 +00002289bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002290X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002291 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002292 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00002293 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00002294 case 'Y': // first letter of a pair:
2295 switch (*(Name+1)) {
2296 default: return false;
2297 case '0': // First SSE register.
2298 case 't': // Any SSE register, when SSE2 is enabled.
2299 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2300 case 'm': // any MMX register, when inter-unit moves enabled.
2301 break; // falls through to setAllowsRegister.
2302 }
Eli Friedman618234a2008-08-20 02:34:37 +00002303 case 'a': // eax.
2304 case 'b': // ebx.
2305 case 'c': // ecx.
2306 case 'd': // edx.
2307 case 'S': // esi.
2308 case 'D': // edi.
2309 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00002310 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00002311 case 't': // top of floating point stack.
2312 case 'u': // second from top of floating point stack.
2313 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00002314 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00002315 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00002316 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00002317 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2318 case 'l': // "Index" registers: any general register that can be used as an
2319 // index in a base+index memory access.
2320 Info.setAllowsRegister();
2321 return true;
2322 case 'C': // SSE floating point constant.
2323 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002324 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002325 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002326 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002327 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00002328 return true;
2329 }
2330}
2331
Dale Johannesenf6e2c202010-10-29 23:12:32 +00002332
Eli Friedman618234a2008-08-20 02:34:37 +00002333std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00002334X86TargetInfo::convertConstraint(const char *&Constraint) const {
2335 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00002336 case 'a': return std::string("{ax}");
2337 case 'b': return std::string("{bx}");
2338 case 'c': return std::string("{cx}");
2339 case 'd': return std::string("{dx}");
2340 case 'S': return std::string("{si}");
2341 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00002342 case 'p': // address
2343 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00002344 case 't': // top of floating point stack.
2345 return std::string("{st}");
2346 case 'u': // second from top of floating point stack.
2347 return std::string("{st(1)}"); // second from top of floating point stack.
2348 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00002349 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00002350 }
2351}
Eli Friedman618234a2008-08-20 02:34:37 +00002352} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00002353
2354namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002355// X86-32 generic target
2356class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00002357public:
Eli Friedman618234a2008-08-20 02:34:37 +00002358 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
2359 DoubleAlign = LongLongAlign = 32;
2360 LongDoubleWidth = 96;
2361 LongDoubleAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00002362 SuitableAlign = 128;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002363 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2364 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00002365 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00002366 SizeType = UnsignedInt;
2367 PtrDiffType = SignedInt;
2368 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002369 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002370
2371 // Use fpret for all types.
2372 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2373 (1 << TargetInfo::Double) |
2374 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002375
2376 // x86-32 has atomics up to 8 bytes
2377 // FIXME: Check that we actually have cmpxchg8b before setting
2378 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2379 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002380 }
Meador Ingec5613b22012-06-16 03:34:49 +00002381 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2382 return TargetInfo::CharPtrBuiltinVaList;
Eli Friedman618234a2008-08-20 02:34:37 +00002383 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002384
Chris Lattner21fb98e2009-09-23 06:06:36 +00002385 int getEHDataRegisterNumber(unsigned RegNo) const {
2386 if (RegNo == 0) return 0;
2387 if (RegNo == 1) return 2;
2388 return -1;
2389 }
Eli Friedman618234a2008-08-20 02:34:37 +00002390};
2391} // end anonymous namespace
2392
2393namespace {
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002394class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
2395public:
2396 NetBSDI386TargetInfo(const std::string &triple) :
2397 NetBSDTargetInfo<X86_32TargetInfo>(triple) {
2398 }
2399
2400 virtual unsigned getFloatEvalMethod() const {
2401 // NetBSD defaults to "double" rounding
2402 return 1;
2403 }
2404};
2405} // end anonymous namespace
2406
2407namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002408class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2409public:
2410 OpenBSDI386TargetInfo(const std::string& triple) :
2411 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2412 SizeType = UnsignedLong;
2413 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002414 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002415 }
2416};
2417} // end anonymous namespace
2418
2419namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002420class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002421public:
Torok Edwin5f6c1942009-06-30 17:10:35 +00002422 DarwinI386TargetInfo(const std::string& triple) :
2423 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002424 LongDoubleWidth = 128;
2425 LongDoubleAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002426 SuitableAlign = 128;
Eli Friedman1afabd92009-03-29 20:31:09 +00002427 SizeType = UnsignedLong;
2428 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002429 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2430 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002431 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002432 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002433 }
2434
Eli Friedman618234a2008-08-20 02:34:37 +00002435};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002436} // end anonymous namespace
2437
2438namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002439// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002440class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002441public:
2442 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002443 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002444 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002445 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002446 DoubleAlign = LongLongAlign = 64;
2447 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 +00002448 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002449 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002450 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002451 virtual void getTargetDefines(const LangOptions &Opts,
2452 MacroBuilder &Builder) const {
2453 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2454 }
2455};
2456} // end anonymous namespace
2457
2458namespace {
2459
2460// x86-32 Windows Visual Studio target
2461class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2462public:
2463 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2464 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002465 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002466 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2467 }
2468 virtual void getTargetDefines(const LangOptions &Opts,
2469 MacroBuilder &Builder) const {
2470 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2471 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2472 // The value of the following reflects processor type.
2473 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2474 // We lost the original triple, so we use the default.
2475 Builder.defineMacro("_M_IX86", "600");
2476 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002477};
2478} // end anonymous namespace
2479
2480namespace {
2481// x86-32 MinGW target
2482class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2483public:
2484 MinGWX86_32TargetInfo(const std::string& triple)
2485 : WindowsX86_32TargetInfo(triple) {
2486 }
2487 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002488 MacroBuilder &Builder) const {
2489 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002490 DefineStd(Builder, "WIN32", Opts);
2491 DefineStd(Builder, "WINNT", Opts);
2492 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002493 Builder.defineMacro("__MSVCRT__");
2494 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002495
2496 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2497 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002498 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002499 // Provide "as-is" __declspec.
2500 Builder.defineMacro("__declspec", "__declspec");
2501 else
2502 // Provide alias of __attribute__ like mingw32-gcc.
2503 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002504 }
2505};
2506} // end anonymous namespace
2507
2508namespace {
2509// x86-32 Cygwin target
2510class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2511public:
2512 CygwinX86_32TargetInfo(const std::string& triple)
2513 : X86_32TargetInfo(triple) {
2514 TLSSupported = false;
2515 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002516 DoubleAlign = LongLongAlign = 64;
2517 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2518 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002519 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002520 }
2521 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002522 MacroBuilder &Builder) const {
2523 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2524 Builder.defineMacro("__CYGWIN__");
2525 Builder.defineMacro("__CYGWIN32__");
2526 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00002527 if (Opts.CPlusPlus)
2528 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00002529 }
Eli Friedman29a30502008-08-21 01:40:19 +00002530};
2531} // end anonymous namespace
2532
2533namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002534// x86-32 Haiku target
2535class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2536public:
2537 HaikuX86_32TargetInfo(const std::string& triple)
2538 : X86_32TargetInfo(triple) {
2539 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00002540 IntPtrType = SignedLong;
2541 PtrDiffType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00002542 this->UserLabelPrefix = "";
Eli Friedmana7e68452010-08-22 01:00:03 +00002543 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00002544 virtual void getTargetDefines(const LangOptions &Opts,
2545 MacroBuilder &Builder) const {
2546 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2547 Builder.defineMacro("__INTEL__");
2548 Builder.defineMacro("__HAIKU__");
2549 }
2550};
2551} // end anonymous namespace
2552
Douglas Gregordca52262011-07-01 22:41:14 +00002553// RTEMS Target
2554template<typename Target>
2555class RTEMSTargetInfo : public OSTargetInfo<Target> {
2556protected:
2557 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2558 MacroBuilder &Builder) const {
2559 // RTEMS defines; list based off of gcc output
2560
Douglas Gregordca52262011-07-01 22:41:14 +00002561 Builder.defineMacro("__rtems__");
2562 Builder.defineMacro("__ELF__");
2563 }
2564public:
2565 RTEMSTargetInfo(const std::string &triple)
2566 : OSTargetInfo<Target>(triple) {
2567 this->UserLabelPrefix = "";
2568
2569 llvm::Triple Triple(triple);
2570 switch (Triple.getArch()) {
2571 default:
2572 case llvm::Triple::x86:
2573 // this->MCountName = ".mcount";
2574 break;
2575 case llvm::Triple::mips:
2576 case llvm::Triple::mipsel:
2577 case llvm::Triple::ppc:
2578 case llvm::Triple::ppc64:
2579 // this->MCountName = "_mcount";
2580 break;
2581 case llvm::Triple::arm:
2582 // this->MCountName = "__mcount";
2583 break;
2584 }
2585
2586 }
2587};
2588
2589namespace {
2590// x86-32 RTEMS target
2591class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2592public:
2593 RTEMSX86_32TargetInfo(const std::string& triple)
2594 : X86_32TargetInfo(triple) {
2595 SizeType = UnsignedLong;
2596 IntPtrType = SignedLong;
2597 PtrDiffType = SignedLong;
2598 this->UserLabelPrefix = "";
2599 }
2600 virtual void getTargetDefines(const LangOptions &Opts,
2601 MacroBuilder &Builder) const {
2602 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2603 Builder.defineMacro("__INTEL__");
2604 Builder.defineMacro("__rtems__");
2605 }
2606};
2607} // end anonymous namespace
2608
Chris Lattner86ed3a32010-04-11 19:29:39 +00002609namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002610// x86-64 generic target
2611class X86_64TargetInfo : public X86TargetInfo {
2612public:
Chris Lattner33328642009-03-20 15:52:06 +00002613 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00002614 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002615 LongDoubleWidth = 128;
2616 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00002617 LargeArrayMinWidth = 128;
2618 LargeArrayAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002619 SuitableAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00002620 IntMaxType = SignedLong;
2621 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002622 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002623 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00002624
Eli Friedmaned855cb2008-08-21 00:13:15 +00002625 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2626 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002627 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002628
2629 // Use fpret only for long double.
2630 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00002631
Anders Carlssoneea64802011-10-31 16:27:11 +00002632 // Use fp2ret for _Complex long double.
2633 ComplexLongDoubleUsesFP2Ret = true;
2634
Eli Friedman2be46072011-10-14 20:59:01 +00002635 // x86-64 has atomics up to 16 bytes.
2636 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
2637 // on CPUs with cmpxchg16b
2638 MaxAtomicPromoteWidth = 128;
2639 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00002640 }
Meador Ingec5613b22012-06-16 03:34:49 +00002641 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2642 return TargetInfo::X86_64ABIBuiltinVaList;
Anders Carlsson3346ae62007-11-24 23:38:12 +00002643 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002644
Chris Lattner21fb98e2009-09-23 06:06:36 +00002645 int getEHDataRegisterNumber(unsigned RegNo) const {
2646 if (RegNo == 0) return 0;
2647 if (RegNo == 1) return 1;
2648 return -1;
2649 }
Eli Friedman618234a2008-08-20 02:34:37 +00002650};
2651} // end anonymous namespace
2652
2653namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002654// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002655class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002656public:
2657 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002658 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002659 TLSSupported = false;
2660 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00002661 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00002662 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00002663 IntMaxType = SignedLongLong;
2664 UIntMaxType = UnsignedLongLong;
2665 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00002666 SizeType = UnsignedLongLong;
2667 PtrDiffType = SignedLongLong;
2668 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00002669 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002670 }
2671 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002672 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002673 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002674 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00002675 }
Meador Ingec5613b22012-06-16 03:34:49 +00002676 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2677 return TargetInfo::CharPtrBuiltinVaList;
NAKAMURA Takumi79521992011-01-17 22:56:23 +00002678 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002679};
2680} // end anonymous namespace
2681
2682namespace {
2683// x86-64 Windows Visual Studio target
2684class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2685public:
2686 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2687 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002688 LongDoubleWidth = LongDoubleAlign = 64;
2689 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00002690 }
2691 virtual void getTargetDefines(const LangOptions &Opts,
2692 MacroBuilder &Builder) const {
2693 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
2694 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00002695 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002696 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002697 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002698};
2699} // end anonymous namespace
2700
2701namespace {
2702// x86-64 MinGW target
2703class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2704public:
2705 MinGWX86_64TargetInfo(const std::string& triple)
2706 : WindowsX86_64TargetInfo(triple) {
2707 }
2708 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002709 MacroBuilder &Builder) const {
2710 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002711 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00002712 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00002713 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00002714 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002715
2716 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2717 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002718 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002719 // Provide "as-is" __declspec.
2720 Builder.defineMacro("__declspec", "__declspec");
2721 else
2722 // Provide alias of __attribute__ like mingw32-gcc.
2723 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002724 }
2725};
2726} // end anonymous namespace
2727
2728namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002729class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2730public:
Mike Stump1eb44332009-09-09 15:08:12 +00002731 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002732 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2733 Int64Type = SignedLongLong;
2734 }
2735};
2736} // end anonymous namespace
2737
2738namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00002739class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
2740public:
Mike Stump1eb44332009-09-09 15:08:12 +00002741 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman6036ebe2009-07-05 22:31:18 +00002742 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
2743 IntMaxType = SignedLongLong;
2744 UIntMaxType = UnsignedLongLong;
2745 Int64Type = SignedLongLong;
2746 }
2747};
2748} // end anonymous namespace
2749
2750namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00002751class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002752 // Possible FPU choices.
2753 enum FPUMode {
2754 NoFPU,
2755 VFP2FPU,
2756 VFP3FPU,
2757 NeonFPU
2758 };
2759
2760 static bool FPUModeIsVFP(FPUMode Mode) {
2761 return Mode >= VFP2FPU && Mode <= NeonFPU;
2762 }
2763
2764 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2765 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002766
Daniel Dunbareac7c532009-12-18 18:42:37 +00002767 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002768
2769 unsigned FPU : 3;
2770
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002771 unsigned IsThumb : 1;
2772
2773 // Initialized via features.
2774 unsigned SoftFloat : 1;
2775 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002776
Chris Lattner2752c012010-03-03 19:03:45 +00002777 static const Builtin::Info BuiltinInfo[];
2778
Chris Lattner393ff042008-04-21 18:56:49 +00002779public:
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002780 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbareac7c532009-12-18 18:42:37 +00002781 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002782 {
Eli Friedmane6a24e82011-12-22 03:51:45 +00002783 BigEndian = false;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002784 SizeType = UnsignedInt;
2785 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00002786 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
2787 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002788
Chris Lattner9bffb072010-04-23 16:29:58 +00002789 // {} in inline assembly are neon specifiers, not assembly variant
2790 // specifiers.
2791 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00002792
Daniel Dunbareac7c532009-12-18 18:42:37 +00002793 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00002794 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002795 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002796 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2797 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002798 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
2799 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002800 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002801 } else {
2802 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2803 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002804 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002805 }
John McCallee79a4c2010-08-21 22:46:04 +00002806
2807 // ARM targets default to using the ARM C++ ABI.
2808 CXXABI = CXXABI_ARM;
Eli Friedman2be46072011-10-14 20:59:01 +00002809
2810 // ARM has atomics up to 8 bytes
2811 // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e
2812 MaxAtomicPromoteWidth = 64;
James Molloye45b9b72012-03-12 09:14:10 +00002813
2814 // Do force alignment of members that follow zero length bitfields. If
2815 // the alignment of the zero-length bitfield is greater than the member
2816 // that follows it, `bar', `bar' will be aligned as the type of the
2817 // zero length bitfield.
2818 UseZeroLengthBitfieldAlignment = true;
Eli Friedman61538a72008-05-20 14:21:01 +00002819 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002820 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00002821 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002822 ABI = Name;
2823
Daniel Dunbara2a41612009-09-14 00:02:24 +00002824 // The defaults (above) are for AAPCS, check if we need to change them.
2825 //
2826 // FIXME: We need support for -meabi... we could just mangle it into the
2827 // name.
2828 if (Name == "apcs-gnu") {
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002829 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002830 SizeType = UnsignedLong;
2831
James Molloya6d81f92011-11-23 13:35:08 +00002832 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
2833 WCharType = SignedInt;
2834
Daniel Dunbar684de632010-04-22 16:14:54 +00002835 // Do not respect the alignment of bit-field types when laying out
2836 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
2837 UseBitFieldTypeAlignment = false;
2838
Chad Rosier61a62212011-08-04 01:21:14 +00002839 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00002840 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
2841 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00002842 ZeroLengthBitfieldBoundary = 32;
2843
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002844 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002845 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2846 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002847 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 +00002848 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002849 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002850 } else {
2851 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 +00002852 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002853 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002854 }
2855
Chad Rosier9f1210c2011-07-26 07:03:04 +00002856 // FIXME: Override "preferred align" for double and long long.
Daniel Dunbara2a41612009-09-14 00:02:24 +00002857 } else if (Name == "aapcs") {
2858 // FIXME: Enumerated types are variable width in straight AAPCS.
2859 } else if (Name == "aapcs-linux") {
Chad Rosier9f1210c2011-07-26 07:03:04 +00002860 ;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002861 } else
2862 return false;
2863
2864 return true;
2865 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002866
Chandler Carruthc3a2e652011-09-28 05:56:05 +00002867 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002868 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
2869 Features["vfp2"] = true;
2870 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
2871 Features["neon"] = true;
2872 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002873
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002874 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00002875 StringRef Name,
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002876 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00002877 if (Name == "soft-float" || Name == "soft-float-abi" ||
Chad Rosier7a938fa2012-04-04 20:39:32 +00002878 Name == "vfp2" || Name == "vfp3" || Name == "neon" || Name == "d16" ||
2879 Name == "neonfp") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002880 Features[Name] = Enabled;
2881 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002882 return false;
2883
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002884 return true;
2885 }
2886
2887 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002888 FPU = NoFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002889 SoftFloat = SoftFloatABI = false;
2890 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
2891 if (Features[i] == "+soft-float")
2892 SoftFloat = true;
2893 else if (Features[i] == "+soft-float-abi")
2894 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002895 else if (Features[i] == "+vfp2")
2896 FPU = VFP2FPU;
2897 else if (Features[i] == "+vfp3")
2898 FPU = VFP3FPU;
2899 else if (Features[i] == "+neon")
2900 FPU = NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002901 }
2902
2903 // Remove front-end specific options which the backend handles differently.
2904 std::vector<std::string>::iterator it;
2905 it = std::find(Features.begin(), Features.end(), "+soft-float");
2906 if (it != Features.end())
2907 Features.erase(it);
2908 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2909 if (it != Features.end())
2910 Features.erase(it);
2911 }
2912
Douglas Gregore727d212012-01-30 06:38:25 +00002913 virtual bool hasFeature(StringRef Feature) const {
2914 return llvm::StringSwitch<bool>(Feature)
2915 .Case("arm", true)
2916 .Case("softfloat", SoftFloat)
2917 .Case("thumb", IsThumb)
2918 .Case("neon", FPU == NeonFPU && !SoftFloat &&
2919 StringRef(getCPUDefineSuffix(CPU)).startswith("7"))
2920 .Default(false);
2921 }
Chris Lattner5f9e2722011-07-23 10:55:15 +00002922 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00002923 return llvm::StringSwitch<const char*>(Name)
2924 .Cases("arm8", "arm810", "4")
2925 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2926 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2927 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2928 .Case("ep9312", "4T")
2929 .Cases("arm10tdmi", "arm1020t", "5T")
2930 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2931 .Case("arm926ej-s", "5TEJ")
2932 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2933 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002934 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002935 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002936 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002937 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2938 .Cases("cortex-a8", "cortex-a9", "7A")
Bob Wilson06f45632011-01-06 16:57:20 +00002939 .Case("cortex-m3", "7M")
Jim Grosbach69033132012-03-29 19:53:34 +00002940 .Case("cortex-m4", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00002941 .Case("cortex-m0", "6M")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002942 .Default(0);
2943 }
2944 virtual bool setCPU(const std::string &Name) {
2945 if (!getCPUDefineSuffix(Name))
2946 return false;
2947
2948 CPU = Name;
2949 return true;
2950 }
Chris Lattner33328642009-03-20 15:52:06 +00002951 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002952 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002953 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00002954 Builder.defineMacro("__arm");
2955 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002956
Chris Lattnerc0f59212009-03-02 22:27:17 +00002957 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00002958 Builder.defineMacro("__ARMEL__");
2959 Builder.defineMacro("__LITTLE_ENDIAN__");
2960 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002961
Chris Lattner5f9e2722011-07-23 10:55:15 +00002962 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00002963 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002964
Mike Stump437bb4b2009-04-08 02:07:04 +00002965 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002966
Daniel Dunbareac7c532009-12-18 18:42:37 +00002967 // FIXME: It's more complicated than this and we don't really support
2968 // interworking.
2969 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00002970 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002971
Daniel Dunbareac7c532009-12-18 18:42:37 +00002972 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramera9992772010-01-09 17:55:51 +00002973 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002974
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002975 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00002976 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002977
2978 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00002979 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002980
Bob Wilson84f95cf2011-05-13 18:56:03 +00002981 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002982 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002983 Builder.defineMacro("__THUMBEL__");
2984 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00002985 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002986 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002987 }
2988
2989 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00002990 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002991
2992 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramera9992772010-01-09 17:55:51 +00002993 Builder.defineMacro("__VFP_FP__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002994
2995 // This only gets set when Neon instructions are actually available, unlike
2996 // the VFP define, hence the soft float and arch check. This is subtly
2997 // different from gcc, we follow the intent which was that it should be set
2998 // when Neon instructions are actually available.
Bob Wilson84f95cf2011-05-13 18:56:03 +00002999 if (FPU == NeonFPU && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003000 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00003001 }
3002 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3003 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00003004 Records = BuiltinInfo;
3005 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00003006 }
Bob Wilson8b30a932012-01-26 22:14:27 +00003007 virtual bool isCLZForZeroUndef() const { return false; }
Meador Ingec5613b22012-06-16 03:34:49 +00003008 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3009 return TargetInfo::VoidPtrBuiltinVaList;
Chris Lattner393ff042008-04-21 18:56:49 +00003010 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003011 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003012 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003013 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003014 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003015 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00003016 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmana9f54962008-08-20 07:44:10 +00003017 // FIXME: Check if this is complete
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003018 switch (*Name) {
Eli Friedmana9f54962008-08-20 07:44:10 +00003019 default:
Nate Begemanad487f42008-04-22 05:03:19 +00003020 case 'l': // r0-r7
3021 case 'h': // r8-r15
3022 case 'w': // VFP Floating point register single precision
3023 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00003024 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00003025 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00003026 case 'Q': // A memory address that is a single base register.
3027 Info.setAllowsMemory();
3028 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00003029 case 'U': // a memory reference...
3030 switch (Name[1]) {
3031 case 'q': // ...ARMV4 ldrsb
3032 case 'v': // ...VFP load/store (reg+constant offset)
3033 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00003034 case 't': // address valid for load/store opaque types wider
3035 // than 128-bits
3036 case 'n': // valid address for Neon doubleword vector load/store
3037 case 'm': // valid address for Neon element and structure load/store
3038 case 's': // valid address for non-offset loads/stores of quad-word
3039 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00003040 Info.setAllowsMemory();
3041 Name++;
3042 return true;
3043 }
Nate Begemanad487f42008-04-22 05:03:19 +00003044 }
Chris Lattner393ff042008-04-21 18:56:49 +00003045 return false;
3046 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00003047 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00003048 std::string R;
3049 switch (*Constraint) {
3050 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00003051 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00003052 Constraint++;
3053 break;
Eric Christopher283f4472011-06-17 00:40:18 +00003054 case 'p': // 'p' should be translated to 'r' by default.
3055 R = std::string("r");
3056 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00003057 default:
3058 return std::string(1, *Constraint);
3059 }
3060 return R;
3061 }
Chris Lattner393ff042008-04-21 18:56:49 +00003062 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00003063 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00003064 return "";
3065 }
3066};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003067
3068const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003069 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003070 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003071 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
3072
3073 // Float registers
3074 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3075 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3076 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003077 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003078
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003079 // Double registers
3080 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3081 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00003082 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3083 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003084
3085 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00003086 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3087 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003088};
3089
3090void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003091 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003092 Names = GCCRegNames;
3093 NumNames = llvm::array_lengthof(GCCRegNames);
3094}
3095
3096const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003097 { { "a1" }, "r0" },
3098 { { "a2" }, "r1" },
3099 { { "a3" }, "r2" },
3100 { { "a4" }, "r3" },
3101 { { "v1" }, "r4" },
3102 { { "v2" }, "r5" },
3103 { { "v3" }, "r6" },
3104 { { "v4" }, "r7" },
3105 { { "v5" }, "r8" },
3106 { { "v6", "rfp" }, "r9" },
3107 { { "sl" }, "r10" },
3108 { { "fp" }, "r11" },
3109 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003110 { { "r13" }, "sp" },
3111 { { "r14" }, "lr" },
3112 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003113 // The S, D and Q registers overlap, but aren't really aliases; we
3114 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003115};
3116
3117void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3118 unsigned &NumAliases) const {
3119 Aliases = GCCRegAliases;
3120 NumAliases = llvm::array_lengthof(GCCRegAliases);
3121}
Chris Lattner2752c012010-03-03 19:03:45 +00003122
3123const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00003124#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00003125#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00003126 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00003127#include "clang/Basic/BuiltinsARM.def"
3128};
Chris Lattner393ff042008-04-21 18:56:49 +00003129} // end anonymous namespace.
3130
Eli Friedmana9f54962008-08-20 07:44:10 +00003131namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00003132class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003133 public DarwinTargetInfo<ARMTargetInfo> {
3134protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00003135 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00003136 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00003137 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00003138 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003139
Torok Edwin5f6c1942009-06-30 17:10:35 +00003140public:
Mike Stump1eb44332009-09-09 15:08:12 +00003141 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003142 : DarwinTargetInfo<ARMTargetInfo>(triple) {
3143 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00003144 // iOS always has 64-bit atomic instructions.
3145 // FIXME: This should be based off of the target features in ARMTargetInfo.
3146 MaxAtomicInlineWidth = 64;
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003147 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003148};
3149} // end anonymous namespace.
3150
Tony Linthicum96319392011-12-12 21:14:55 +00003151
3152namespace {
3153// Hexagon abstract base class
3154class HexagonTargetInfo : public TargetInfo {
3155 static const Builtin::Info BuiltinInfo[];
3156 static const char * const GCCRegNames[];
3157 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3158 std::string CPU;
3159public:
3160 HexagonTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003161 BigEndian = false;
Tony Linthicum96319392011-12-12 21:14:55 +00003162 DescriptionString = ("e-p:32:32:32-"
Sirish Pande5f9688b2012-05-10 20:19:54 +00003163 "i64:64:64-i32:32:32-i16:16:16-i1:32:32"
3164 "f64:64:64-f32:32:32-a0:0-n32");
Tony Linthicum96319392011-12-12 21:14:55 +00003165
3166 // {} in inline assembly are packet specifiers, not assembly variant
3167 // specifiers.
3168 NoAsmVariants = true;
3169 }
3170
3171 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3172 unsigned &NumRecords) const {
3173 Records = BuiltinInfo;
3174 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
3175 }
3176
3177 virtual bool validateAsmConstraint(const char *&Name,
3178 TargetInfo::ConstraintInfo &Info) const {
3179 return true;
3180 }
3181
3182 virtual void getTargetDefines(const LangOptions &Opts,
3183 MacroBuilder &Builder) const;
3184
Douglas Gregore727d212012-01-30 06:38:25 +00003185 virtual bool hasFeature(StringRef Feature) const {
3186 return Feature == "hexagon";
3187 }
3188
Meador Ingec5613b22012-06-16 03:34:49 +00003189 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3190 return TargetInfo::CharPtrBuiltinVaList;
Tony Linthicum96319392011-12-12 21:14:55 +00003191 }
3192 virtual void getGCCRegNames(const char * const *&Names,
3193 unsigned &NumNames) const;
3194 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3195 unsigned &NumAliases) const;
3196 virtual const char *getClobbers() const {
3197 return "";
3198 }
Sebastian Pop43115d42012-01-13 20:37:10 +00003199
3200 static const char *getHexagonCPUSuffix(StringRef Name) {
3201 return llvm::StringSwitch<const char*>(Name)
3202 .Case("hexagonv2", "2")
3203 .Case("hexagonv3", "3")
3204 .Case("hexagonv4", "4")
Sirish Pande5f9688b2012-05-10 20:19:54 +00003205 .Case("hexagonv5", "5")
Sebastian Pop43115d42012-01-13 20:37:10 +00003206 .Default(0);
3207 }
3208
Tony Linthicum96319392011-12-12 21:14:55 +00003209 virtual bool setCPU(const std::string &Name) {
Sebastian Pop43115d42012-01-13 20:37:10 +00003210 if (!getHexagonCPUSuffix(Name))
3211 return false;
3212
Tony Linthicum96319392011-12-12 21:14:55 +00003213 CPU = Name;
3214 return true;
3215 }
3216};
3217
3218void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
3219 MacroBuilder &Builder) const {
3220 Builder.defineMacro("qdsp6");
3221 Builder.defineMacro("__qdsp6", "1");
3222 Builder.defineMacro("__qdsp6__", "1");
3223
3224 Builder.defineMacro("hexagon");
3225 Builder.defineMacro("__hexagon", "1");
3226 Builder.defineMacro("__hexagon__", "1");
3227
3228 if(CPU == "hexagonv1") {
3229 Builder.defineMacro("__HEXAGON_V1__");
3230 Builder.defineMacro("__HEXAGON_ARCH__", "1");
3231 if(Opts.HexagonQdsp6Compat) {
3232 Builder.defineMacro("__QDSP6_V1__");
3233 Builder.defineMacro("__QDSP6_ARCH__", "1");
3234 }
3235 }
3236 else if(CPU == "hexagonv2") {
3237 Builder.defineMacro("__HEXAGON_V2__");
3238 Builder.defineMacro("__HEXAGON_ARCH__", "2");
3239 if(Opts.HexagonQdsp6Compat) {
3240 Builder.defineMacro("__QDSP6_V2__");
3241 Builder.defineMacro("__QDSP6_ARCH__", "2");
3242 }
3243 }
3244 else if(CPU == "hexagonv3") {
3245 Builder.defineMacro("__HEXAGON_V3__");
3246 Builder.defineMacro("__HEXAGON_ARCH__", "3");
3247 if(Opts.HexagonQdsp6Compat) {
3248 Builder.defineMacro("__QDSP6_V3__");
3249 Builder.defineMacro("__QDSP6_ARCH__", "3");
3250 }
3251 }
3252 else if(CPU == "hexagonv4") {
3253 Builder.defineMacro("__HEXAGON_V4__");
3254 Builder.defineMacro("__HEXAGON_ARCH__", "4");
3255 if(Opts.HexagonQdsp6Compat) {
3256 Builder.defineMacro("__QDSP6_V4__");
3257 Builder.defineMacro("__QDSP6_ARCH__", "4");
3258 }
3259 }
Sirish Pande5f9688b2012-05-10 20:19:54 +00003260 else if(CPU == "hexagonv5") {
3261 Builder.defineMacro("__HEXAGON_V5__");
3262 Builder.defineMacro("__HEXAGON_ARCH__", "5");
3263 if(Opts.HexagonQdsp6Compat) {
3264 Builder.defineMacro("__QDSP6_V5__");
3265 Builder.defineMacro("__QDSP6_ARCH__", "5");
3266 }
3267 }
Tony Linthicum96319392011-12-12 21:14:55 +00003268}
3269
3270const char * const HexagonTargetInfo::GCCRegNames[] = {
3271 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3272 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3273 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3274 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
3275 "p0", "p1", "p2", "p3",
3276 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
3277};
3278
3279void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
3280 unsigned &NumNames) const {
3281 Names = GCCRegNames;
3282 NumNames = llvm::array_lengthof(GCCRegNames);
3283}
3284
3285
3286const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
3287 { { "sp" }, "r29" },
3288 { { "fp" }, "r30" },
3289 { { "lr" }, "r31" },
3290 };
3291
3292void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3293 unsigned &NumAliases) const {
3294 Aliases = GCCRegAliases;
3295 NumAliases = llvm::array_lengthof(GCCRegAliases);
3296}
3297
3298
3299const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
3300#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3301#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3302 ALL_LANGUAGES },
3303#include "clang/Basic/BuiltinsHexagon.def"
3304};
3305}
3306
3307
Reid Spencer5f016e22007-07-11 17:01:13 +00003308namespace {
Eli Friedman01b86682008-08-20 07:28:14 +00003309class SparcV8TargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00003310 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3311 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003312 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00003313public:
Eli Friedman01b86682008-08-20 07:28:14 +00003314 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
3315 // FIXME: Support Sparc quad-precision long double?
Eli Friedmaned855cb2008-08-21 00:13:15 +00003316 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 +00003317 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedman01b86682008-08-20 07:28:14 +00003318 }
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003319 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00003320 StringRef Name,
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003321 bool Enabled) const {
3322 if (Name == "soft-float")
3323 Features[Name] = Enabled;
3324 else
3325 return false;
3326
3327 return true;
3328 }
3329 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
3330 SoftFloat = false;
3331 for (unsigned i = 0, e = Features.size(); i != e; ++i)
3332 if (Features[i] == "+soft-float")
3333 SoftFloat = true;
3334 }
Chris Lattner33328642009-03-20 15:52:06 +00003335 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003336 MacroBuilder &Builder) const {
3337 DefineStd(Builder, "sparc", Opts);
3338 Builder.defineMacro("__sparcv8");
3339 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003340
3341 if (SoftFloat)
3342 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00003343 }
Douglas Gregore727d212012-01-30 06:38:25 +00003344
3345 virtual bool hasFeature(StringRef Feature) const {
3346 return llvm::StringSwitch<bool>(Feature)
3347 .Case("softfloat", SoftFloat)
3348 .Case("sparc", true)
3349 .Default(false);
3350 }
3351
Gabor Greif26658672008-02-21 16:29:08 +00003352 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3353 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003354 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00003355 }
Meador Ingec5613b22012-06-16 03:34:49 +00003356 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3357 return TargetInfo::VoidPtrBuiltinVaList;
Gabor Greif26658672008-02-21 16:29:08 +00003358 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003359 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003360 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003361 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003362 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003363 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00003364 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003365 // FIXME: Implement!
3366 return false;
Gabor Greif26658672008-02-21 16:29:08 +00003367 }
3368 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00003369 // FIXME: Implement!
3370 return "";
Gabor Greif26658672008-02-21 16:29:08 +00003371 }
3372};
3373
Chris Lattnere957f532009-01-27 01:58:38 +00003374const char * const SparcV8TargetInfo::GCCRegNames[] = {
3375 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3376 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3377 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3378 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
3379};
3380
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003381void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003382 unsigned &NumNames) const {
3383 Names = GCCRegNames;
3384 NumNames = llvm::array_lengthof(GCCRegNames);
3385}
3386
3387const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003388 { { "g0" }, "r0" },
3389 { { "g1" }, "r1" },
3390 { { "g2" }, "r2" },
3391 { { "g3" }, "r3" },
3392 { { "g4" }, "r4" },
3393 { { "g5" }, "r5" },
3394 { { "g6" }, "r6" },
3395 { { "g7" }, "r7" },
3396 { { "o0" }, "r8" },
3397 { { "o1" }, "r9" },
3398 { { "o2" }, "r10" },
3399 { { "o3" }, "r11" },
3400 { { "o4" }, "r12" },
3401 { { "o5" }, "r13" },
3402 { { "o6", "sp" }, "r14" },
3403 { { "o7" }, "r15" },
3404 { { "l0" }, "r16" },
3405 { { "l1" }, "r17" },
3406 { { "l2" }, "r18" },
3407 { { "l3" }, "r19" },
3408 { { "l4" }, "r20" },
3409 { { "l5" }, "r21" },
3410 { { "l6" }, "r22" },
3411 { { "l7" }, "r23" },
3412 { { "i0" }, "r24" },
3413 { { "i1" }, "r25" },
3414 { { "i2" }, "r26" },
3415 { { "i3" }, "r27" },
3416 { { "i4" }, "r28" },
3417 { { "i5" }, "r29" },
3418 { { "i6", "fp" }, "r30" },
3419 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00003420};
3421
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003422void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003423 unsigned &NumAliases) const {
3424 Aliases = GCCRegAliases;
3425 NumAliases = llvm::array_lengthof(GCCRegAliases);
3426}
Gabor Greif26658672008-02-21 16:29:08 +00003427} // end anonymous namespace.
3428
Eli Friedman01b86682008-08-20 07:28:14 +00003429namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003430class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
3431public:
3432 AuroraUXSparcV8TargetInfo(const std::string& triple) :
3433 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
3434 SizeType = UnsignedInt;
3435 PtrDiffType = SignedInt;
3436 }
3437};
Torok Edwin5f6c1942009-06-30 17:10:35 +00003438class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00003439public:
3440 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003441 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00003442 SizeType = UnsignedInt;
3443 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00003444 }
3445};
3446} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00003447
Chris Lattner2621fd12008-05-08 05:58:21 +00003448namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003449 class MSP430TargetInfo : public TargetInfo {
3450 static const char * const GCCRegNames[];
3451 public:
3452 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003453 BigEndian = false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003454 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00003455 IntWidth = 16; IntAlign = 16;
3456 LongWidth = 32; LongLongWidth = 64;
3457 LongAlign = LongLongAlign = 16;
3458 PointerWidth = 16; PointerAlign = 16;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003459 SuitableAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003460 SizeType = UnsignedInt;
3461 IntMaxType = SignedLong;
3462 UIntMaxType = UnsignedLong;
3463 IntPtrType = SignedShort;
3464 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00003465 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00003466 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003467 }
3468 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003469 MacroBuilder &Builder) const {
3470 Builder.defineMacro("MSP430");
3471 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003472 // FIXME: defines for different 'flavours' of MCU
3473 }
3474 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3475 unsigned &NumRecords) const {
3476 // FIXME: Implement.
3477 Records = 0;
3478 NumRecords = 0;
3479 }
Douglas Gregore727d212012-01-30 06:38:25 +00003480 virtual bool hasFeature(StringRef Feature) const {
3481 return Feature == "msp430";
3482 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003483 virtual void getGCCRegNames(const char * const *&Names,
3484 unsigned &NumNames) const;
3485 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3486 unsigned &NumAliases) const {
3487 // No aliases.
3488 Aliases = 0;
3489 NumAliases = 0;
3490 }
3491 virtual bool validateAsmConstraint(const char *&Name,
3492 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00003493 // No target constraints for now.
3494 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003495 }
3496 virtual const char *getClobbers() const {
3497 // FIXME: Is this really right?
3498 return "";
3499 }
Meador Ingec5613b22012-06-16 03:34:49 +00003500 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003501 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00003502 return TargetInfo::CharPtrBuiltinVaList;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003503 }
3504 };
3505
3506 const char * const MSP430TargetInfo::GCCRegNames[] = {
3507 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3508 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3509 };
3510
3511 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
3512 unsigned &NumNames) const {
3513 Names = GCCRegNames;
3514 NumNames = llvm::array_lengthof(GCCRegNames);
3515 }
3516}
3517
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00003518namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00003519
Mike Stump1eb44332009-09-09 15:08:12 +00003520 // LLVM and Clang cannot be used directly to output native binaries for
3521 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00003522 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00003523 //
3524 // TCE uses the llvm bitcode as input and uses it for generating customized
3525 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00003526 // publicly available in http://tce.cs.tut.fi
3527
Eli Friedman209f5bb2011-10-07 19:51:42 +00003528 static const unsigned TCEOpenCLAddrSpaceMap[] = {
3529 3, // opencl_global
3530 4, // opencl_local
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00003531 5, // opencl_constant
3532 0, // cuda_device
3533 0, // cuda_constant
3534 0 // cuda_shared
Eli Friedman209f5bb2011-10-07 19:51:42 +00003535 };
3536
Eli Friedmanb63decf2009-08-19 20:47:07 +00003537 class TCETargetInfo : public TargetInfo{
3538 public:
3539 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
3540 TLSSupported = false;
3541 IntWidth = 32;
3542 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003543 PointerWidth = 32;
3544 IntAlign = 32;
3545 LongAlign = LongLongAlign = 32;
3546 PointerAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003547 SuitableAlign = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003548 SizeType = UnsignedInt;
3549 IntMaxType = SignedLong;
3550 UIntMaxType = UnsignedLong;
3551 IntPtrType = SignedInt;
3552 PtrDiffType = SignedInt;
3553 FloatWidth = 32;
3554 FloatAlign = 32;
3555 DoubleWidth = 32;
3556 DoubleAlign = 32;
3557 LongDoubleWidth = 32;
3558 LongDoubleAlign = 32;
3559 FloatFormat = &llvm::APFloat::IEEEsingle;
3560 DoubleFormat = &llvm::APFloat::IEEEsingle;
3561 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00003562 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
3563 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00003564 "f32:32:32-f64:32:32-v64:32:32-"
3565 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00003566 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003567 }
3568
3569 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003570 MacroBuilder &Builder) const {
3571 DefineStd(Builder, "tce", Opts);
3572 Builder.defineMacro("__TCE__");
3573 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00003574 }
Douglas Gregore727d212012-01-30 06:38:25 +00003575 virtual bool hasFeature(StringRef Feature) const {
3576 return Feature == "tce";
3577 }
3578
Eli Friedmanb63decf2009-08-19 20:47:07 +00003579 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3580 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00003581 virtual const char *getClobbers() const {
3582 return "";
3583 }
Meador Ingec5613b22012-06-16 03:34:49 +00003584 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3585 return TargetInfo::VoidPtrBuiltinVaList;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003586 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003587 virtual void getGCCRegNames(const char * const *&Names,
3588 unsigned &NumNames) const {}
3589 virtual bool validateAsmConstraint(const char *&Name,
3590 TargetInfo::ConstraintInfo &info) const {
3591 return true;
3592 }
3593 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3594 unsigned &NumAliases) const {}
3595 };
3596}
3597
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003598namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003599class MipsTargetInfoBase : public TargetInfo {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00003600 static const Builtin::Info BuiltinInfo[];
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003601 std::string CPU;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00003602 bool IsMips16;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003603 enum MipsFloatABI {
3604 HardFloat, SingleFloat, SoftFloat
3605 } FloatABI;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003606
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003607protected:
3608 std::string ABI;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003609
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003610public:
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00003611 MipsTargetInfoBase(const std::string& triple,
3612 const std::string& ABIStr,
3613 const std::string& CPUStr)
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003614 : TargetInfo(triple),
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00003615 CPU(CPUStr),
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00003616 IsMips16(false),
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003617 FloatABI(HardFloat),
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003618 ABI(ABIStr)
3619 {}
3620
Eric Christophered734732010-03-02 02:41:08 +00003621 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003622 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00003623 virtual bool setCPU(const std::string &Name) {
3624 CPU = Name;
3625 return true;
3626 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003627 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00003628 Features[ABI] = true;
3629 Features[CPU] = true;
3630 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003631
Eric Christophered734732010-03-02 02:41:08 +00003632 virtual void getArchDefines(const LangOptions &Opts,
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003633 MacroBuilder &Builder) const {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003634 switch (FloatABI) {
3635 default:
3636 case HardFloat:
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00003637 Builder.defineMacro("__mips_hard_float", Twine(1));
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003638 break;
3639 case SingleFloat:
3640 Builder.defineMacro("__mips_hard_float", Twine(1));
3641 Builder.defineMacro("__mips_single_float", Twine(1));
3642 break;
3643 case SoftFloat:
3644 Builder.defineMacro("__mips_soft_float", Twine(1));
3645 break;
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00003646 }
Simon Atanasyan90913892012-04-05 19:28:31 +00003647
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00003648 if (IsMips16)
3649 Builder.defineMacro("__mips16", Twine(1));
3650
Simon Atanasyan90913892012-04-05 19:28:31 +00003651 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
3652 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
3653 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003654 }
3655
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003656 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003657 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003658 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3659 unsigned &NumRecords) const {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00003660 Records = BuiltinInfo;
3661 NumRecords = clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003662 }
Douglas Gregore727d212012-01-30 06:38:25 +00003663 virtual bool hasFeature(StringRef Feature) const {
3664 return Feature == "mips";
3665 }
Meador Ingec5613b22012-06-16 03:34:49 +00003666 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3667 return TargetInfo::VoidPtrBuiltinVaList;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003668 }
3669 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003670 unsigned &NumNames) const {
3671 static const char * const GCCRegNames[] = {
Eric Christopherd1f853d2012-03-27 19:56:11 +00003672 // CPU register names
3673 // Must match second column of GCCRegAliases
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003674 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
3675 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
3676 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
Eric Christopherd1f853d2012-03-27 19:56:11 +00003677 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",
3678 // Floating point register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003679 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
3680 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
3681 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
3682 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
Eric Christopherd1f853d2012-03-27 19:56:11 +00003683 // Hi/lo and condition register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003684 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
3685 "$fcc5","$fcc6","$fcc7"
3686 };
3687 Names = GCCRegNames;
3688 NumNames = llvm::array_lengthof(GCCRegNames);
3689 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003690 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003691 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003692 virtual bool validateAsmConstraint(const char *&Name,
3693 TargetInfo::ConstraintInfo &Info) const {
3694 switch (*Name) {
3695 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00003696 return false;
3697
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003698 case 'r': // CPU registers.
3699 case 'd': // Equivalent to "r" unless generating MIPS16 code.
3700 case 'y': // Equivalent to "r", backwards compatibility only.
3701 case 'f': // floating-point registers.
Eric Christopher0ea61642012-04-03 01:16:32 +00003702 case 'c': // $25 for indirect jumps
3703 case 'l': // lo register
3704 case 'x': // hilo register pair
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003705 Info.setAllowsRegister();
3706 return true;
3707 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003708 }
3709
3710 virtual const char *getClobbers() const {
3711 // FIXME: Implement!
3712 return "";
3713 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003714
3715 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
3716 StringRef Name,
3717 bool Enabled) const {
Simon Atanasyan8b2a5d22012-04-18 12:00:11 +00003718 if (Name == "soft-float" || Name == "single-float" ||
3719 Name == "o32" || Name == "n32" || Name == "n64" || Name == "eabi" ||
3720 Name == "mips32" || Name == "mips32r2" ||
Simon Atanasyan0b273ef2012-07-05 14:19:39 +00003721 Name == "mips64" || Name == "mips64r2" ||
Simon Atanasyand797a852012-07-05 19:23:00 +00003722 Name == "mips16" || Name == "dsp" || Name == "dspr2") {
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003723 Features[Name] = Enabled;
3724 return true;
3725 }
3726 return false;
3727 }
3728
3729 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00003730 IsMips16 = false;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003731 FloatABI = HardFloat;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003732
3733 for (std::vector<std::string>::iterator it = Features.begin(),
3734 ie = Features.end(); it != ie; ++it) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003735 if (*it == "+single-float")
3736 FloatABI = SingleFloat;
3737 else if (*it == "+soft-float")
3738 FloatABI = SoftFloat;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00003739 else if (*it == "+mips16")
3740 IsMips16 = true;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003741 }
Simon Atanasyanbbd99162012-07-05 15:32:46 +00003742
3743 // Remove front-end specific option.
3744 std::vector<std::string>::iterator it =
3745 std::find(Features.begin(), Features.end(), "+soft-float");
3746 if (it != Features.end())
3747 Features.erase(it);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003748 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003749};
3750
Simon Atanasyanfbf70052012-06-28 18:23:16 +00003751const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = {
3752#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3753#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3754 ALL_LANGUAGES },
3755#include "clang/Basic/BuiltinsMips.def"
3756};
3757
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003758class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003759public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003760 Mips32TargetInfoBase(const std::string& triple) :
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00003761 MipsTargetInfoBase(triple, "o32", "mips32") {
Akira Hatanaka148735e2011-11-05 01:48:34 +00003762 SizeType = UnsignedInt;
3763 PtrDiffType = SignedInt;
3764 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003765 virtual bool setABI(const std::string &Name) {
3766 if ((Name == "o32") || (Name == "eabi")) {
3767 ABI = Name;
3768 return true;
3769 } else
3770 return false;
3771 }
3772 virtual void getArchDefines(const LangOptions &Opts,
3773 MacroBuilder &Builder) const {
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003774 MipsTargetInfoBase::getArchDefines(Opts, Builder);
3775
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003776 if (ABI == "o32") {
3777 Builder.defineMacro("__mips_o32");
3778 Builder.defineMacro("_ABIO32", "1");
3779 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
3780 }
3781 else if (ABI == "eabi")
3782 Builder.defineMacro("__mips_eabi");
3783 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003784 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003785 }
3786 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3787 unsigned &NumAliases) const {
3788 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3789 { { "at" }, "$1" },
3790 { { "v0" }, "$2" },
3791 { { "v1" }, "$3" },
3792 { { "a0" }, "$4" },
3793 { { "a1" }, "$5" },
3794 { { "a2" }, "$6" },
3795 { { "a3" }, "$7" },
3796 { { "t0" }, "$8" },
3797 { { "t1" }, "$9" },
3798 { { "t2" }, "$10" },
3799 { { "t3" }, "$11" },
3800 { { "t4" }, "$12" },
3801 { { "t5" }, "$13" },
3802 { { "t6" }, "$14" },
3803 { { "t7" }, "$15" },
3804 { { "s0" }, "$16" },
3805 { { "s1" }, "$17" },
3806 { { "s2" }, "$18" },
3807 { { "s3" }, "$19" },
3808 { { "s4" }, "$20" },
3809 { { "s5" }, "$21" },
3810 { { "s6" }, "$22" },
3811 { { "s7" }, "$23" },
3812 { { "t8" }, "$24" },
3813 { { "t9" }, "$25" },
3814 { { "k0" }, "$26" },
3815 { { "k1" }, "$27" },
3816 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00003817 { { "sp","$sp" }, "$29" },
3818 { { "fp","$fp" }, "$30" },
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003819 { { "ra" }, "$31" }
3820 };
3821 Aliases = GCCRegAliases;
3822 NumAliases = llvm::array_lengthof(GCCRegAliases);
3823 }
3824};
3825
3826class Mips32EBTargetInfo : public Mips32TargetInfoBase {
3827public:
3828 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
3829 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3830 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3831 }
3832 virtual void getTargetDefines(const LangOptions &Opts,
3833 MacroBuilder &Builder) const {
3834 DefineStd(Builder, "mips", Opts);
3835 Builder.defineMacro("_mips");
3836 DefineStd(Builder, "MIPSEB", Opts);
3837 Builder.defineMacro("_MIPSEB");
3838 Builder.defineMacro("__REGISTER_PREFIX__", "");
3839 getArchDefines(Opts, Builder);
3840 }
3841};
3842
3843class Mips32ELTargetInfo : public Mips32TargetInfoBase {
3844public:
3845 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003846 BigEndian = false;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003847 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 +00003848 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003849 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003850 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003851 MacroBuilder &Builder) const {
3852 DefineStd(Builder, "mips", Opts);
3853 Builder.defineMacro("_mips");
3854 DefineStd(Builder, "MIPSEL", Opts);
3855 Builder.defineMacro("_MIPSEL");
3856 Builder.defineMacro("__REGISTER_PREFIX__", "");
3857 getArchDefines(Opts, Builder);
3858 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003859};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003860
3861class Mips64TargetInfoBase : public MipsTargetInfoBase {
3862 virtual void SetDescriptionString(const std::string &Name) = 0;
3863public:
3864 Mips64TargetInfoBase(const std::string& triple) :
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00003865 MipsTargetInfoBase(triple, "n64", "mips64") {
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003866 LongWidth = LongAlign = 64;
3867 PointerWidth = PointerAlign = 64;
3868 LongDoubleWidth = LongDoubleAlign = 128;
3869 LongDoubleFormat = &llvm::APFloat::IEEEquad;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003870 SuitableAlign = 128;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003871 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003872 virtual bool setABI(const std::string &Name) {
3873 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003874
3875 if (Name != "n32" && Name != "n64")
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003876 return false;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003877
3878 ABI = Name;
3879
3880 if (Name == "n32") {
3881 LongWidth = LongAlign = 32;
3882 PointerWidth = PointerAlign = 32;
3883 }
3884
3885 return true;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003886 }
3887 virtual void getArchDefines(const LangOptions &Opts,
3888 MacroBuilder &Builder) const {
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003889 MipsTargetInfoBase::getArchDefines(Opts, Builder);
3890
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003891 if (ABI == "n32") {
3892 Builder.defineMacro("__mips_n32");
3893 Builder.defineMacro("_ABIN32", "2");
3894 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
3895 }
3896 else if (ABI == "n64") {
3897 Builder.defineMacro("__mips_n64");
3898 Builder.defineMacro("_ABI64", "3");
3899 Builder.defineMacro("_MIPS_SIM", "_ABI64");
3900 }
3901 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003902 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003903 }
3904 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3905 unsigned &NumAliases) const {
3906 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3907 { { "at" }, "$1" },
3908 { { "v0" }, "$2" },
3909 { { "v1" }, "$3" },
3910 { { "a0" }, "$4" },
3911 { { "a1" }, "$5" },
3912 { { "a2" }, "$6" },
3913 { { "a3" }, "$7" },
3914 { { "a4" }, "$8" },
3915 { { "a5" }, "$9" },
3916 { { "a6" }, "$10" },
3917 { { "a7" }, "$11" },
3918 { { "t0" }, "$12" },
3919 { { "t1" }, "$13" },
3920 { { "t2" }, "$14" },
3921 { { "t3" }, "$15" },
3922 { { "s0" }, "$16" },
3923 { { "s1" }, "$17" },
3924 { { "s2" }, "$18" },
3925 { { "s3" }, "$19" },
3926 { { "s4" }, "$20" },
3927 { { "s5" }, "$21" },
3928 { { "s6" }, "$22" },
3929 { { "s7" }, "$23" },
3930 { { "t8" }, "$24" },
3931 { { "t9" }, "$25" },
3932 { { "k0" }, "$26" },
3933 { { "k1" }, "$27" },
3934 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00003935 { { "sp","$sp" }, "$29" },
3936 { { "fp","$fp" }, "$30" },
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003937 { { "ra" }, "$31" }
3938 };
3939 Aliases = GCCRegAliases;
3940 NumAliases = llvm::array_lengthof(GCCRegAliases);
3941 }
3942};
3943
3944class Mips64EBTargetInfo : public Mips64TargetInfoBase {
3945 virtual void SetDescriptionString(const std::string &Name) {
3946 // Change DescriptionString only if ABI is n32.
3947 if (Name == "n32")
3948 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 +00003949 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3950 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003951 }
3952public:
3953 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3954 // Default ABI is n64.
3955 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 +00003956 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3957 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003958 }
3959 virtual void getTargetDefines(const LangOptions &Opts,
3960 MacroBuilder &Builder) const {
3961 DefineStd(Builder, "mips", Opts);
3962 Builder.defineMacro("_mips");
3963 DefineStd(Builder, "MIPSEB", Opts);
3964 Builder.defineMacro("_MIPSEB");
3965 Builder.defineMacro("__REGISTER_PREFIX__", "");
3966 getArchDefines(Opts, Builder);
3967 }
3968};
3969
3970class Mips64ELTargetInfo : public Mips64TargetInfoBase {
3971 virtual void SetDescriptionString(const std::string &Name) {
3972 // Change DescriptionString only if ABI is n32.
3973 if (Name == "n32")
3974 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 +00003975 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
3976 "-v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003977 }
3978public:
3979 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003980 // Default ABI is n64.
3981 BigEndian = false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003982 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 +00003983 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3984 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003985 }
3986 virtual void getTargetDefines(const LangOptions &Opts,
3987 MacroBuilder &Builder) const {
3988 DefineStd(Builder, "mips", Opts);
3989 Builder.defineMacro("_mips");
3990 DefineStd(Builder, "MIPSEL", Opts);
3991 Builder.defineMacro("_MIPSEL");
3992 Builder.defineMacro("__REGISTER_PREFIX__", "");
3993 getArchDefines(Opts, Builder);
3994 }
3995};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003996} // end anonymous namespace.
3997
Ivan Krasinef05abd2011-08-24 20:22:22 +00003998namespace {
3999class PNaClTargetInfo : public TargetInfo {
4000public:
4001 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004002 BigEndian = false;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004003 this->UserLabelPrefix = "";
4004 this->LongAlign = 32;
4005 this->LongWidth = 32;
4006 this->PointerAlign = 32;
4007 this->PointerWidth = 32;
4008 this->IntMaxType = TargetInfo::SignedLongLong;
4009 this->UIntMaxType = TargetInfo::UnsignedLongLong;
4010 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00004011 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00004012 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00004013 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00004014 this->SizeType = TargetInfo::UnsignedInt;
4015 this->PtrDiffType = TargetInfo::SignedInt;
4016 this->IntPtrType = TargetInfo::SignedInt;
David Meyerdd4a8892011-10-11 03:12:01 +00004017 this->RegParmMax = 2;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004018 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
4019 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
4020 }
4021
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004022 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00004023 }
4024 virtual void getArchDefines(const LangOptions &Opts,
4025 MacroBuilder &Builder) const {
4026 Builder.defineMacro("__le32__");
4027 Builder.defineMacro("__pnacl__");
4028 }
4029 virtual void getTargetDefines(const LangOptions &Opts,
4030 MacroBuilder &Builder) const {
Ivan Krasin089ee112011-08-25 23:49:20 +00004031 DefineStd(Builder, "unix", Opts);
4032 Builder.defineMacro("__ELF__");
4033 if (Opts.POSIXThreads)
4034 Builder.defineMacro("_REENTRANT");
4035 if (Opts.CPlusPlus)
4036 Builder.defineMacro("_GNU_SOURCE");
4037
Jan Wen Voungdde3bdb2012-03-29 00:05:59 +00004038 Builder.defineMacro("__LITTLE_ENDIAN__");
Ivan Krasinef05abd2011-08-24 20:22:22 +00004039 Builder.defineMacro("__native_client__");
4040 getArchDefines(Opts, Builder);
4041 }
Douglas Gregore727d212012-01-30 06:38:25 +00004042 virtual bool hasFeature(StringRef Feature) const {
4043 return Feature == "pnacl";
4044 }
Ivan Krasinef05abd2011-08-24 20:22:22 +00004045 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4046 unsigned &NumRecords) const {
4047 }
Meador Ingec5613b22012-06-16 03:34:49 +00004048 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4049 return TargetInfo::PNaClABIBuiltinVaList;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004050 }
4051 virtual void getGCCRegNames(const char * const *&Names,
4052 unsigned &NumNames) const;
4053 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4054 unsigned &NumAliases) const;
4055 virtual bool validateAsmConstraint(const char *&Name,
4056 TargetInfo::ConstraintInfo &Info) const {
4057 return false;
4058 }
4059
4060 virtual const char *getClobbers() const {
4061 return "";
4062 }
4063};
4064
4065void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
4066 unsigned &NumNames) const {
4067 Names = NULL;
4068 NumNames = 0;
4069}
4070
4071void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4072 unsigned &NumAliases) const {
4073 Aliases = NULL;
4074 NumAliases = 0;
4075}
4076} // end anonymous namespace.
4077
4078
Reid Spencer5f016e22007-07-11 17:01:13 +00004079//===----------------------------------------------------------------------===//
4080// Driver code
4081//===----------------------------------------------------------------------===//
4082
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004083static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004084 llvm::Triple Triple(T);
4085 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00004086
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004087 switch (Triple.getArch()) {
4088 default:
4089 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00004090
Tony Linthicum96319392011-12-12 21:14:55 +00004091 case llvm::Triple::hexagon:
4092 return new HexagonTargetInfo(T);
4093
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004094 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00004095 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004096 if (Triple.isOSDarwin())
4097 return new DarwinARMTargetInfo(T);
4098
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004099 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00004100 case llvm::Triple::Linux:
4101 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004102 case llvm::Triple::FreeBSD:
Torok Edwin5f6c1942009-06-30 17:10:35 +00004103 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004104 case llvm::Triple::NetBSD:
4105 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00004106 case llvm::Triple::RTEMS:
4107 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004108 default:
4109 return new ARMTargetInfo(T);
4110 }
Eli Friedman61538a72008-05-20 14:21:01 +00004111
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004112 case llvm::Triple::msp430:
4113 return new MSP430TargetInfo(T);
Eli Friedman61538a72008-05-20 14:21:01 +00004114
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004115 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004116 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004117 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004118 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004119 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004120 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004121 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004122 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004123 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004124 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004125 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004126 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004127 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004128
4129 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004130 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004131 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004132 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004133 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004134 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004135 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004136 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004137 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004138 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004139 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004140 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004141 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004142
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004143 case llvm::Triple::mips64:
4144 switch (os) {
4145 case llvm::Triple::Linux:
4146 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
4147 case llvm::Triple::RTEMS:
4148 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
4149 case llvm::Triple::FreeBSD:
4150 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
4151 case llvm::Triple::NetBSD:
4152 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
4153 default:
4154 return new Mips64EBTargetInfo(T);
4155 }
4156
4157 case llvm::Triple::mips64el:
4158 switch (os) {
4159 case llvm::Triple::Linux:
4160 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
4161 case llvm::Triple::RTEMS:
4162 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
4163 case llvm::Triple::FreeBSD:
4164 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
4165 case llvm::Triple::NetBSD:
4166 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
4167 default:
4168 return new Mips64ELTargetInfo(T);
4169 }
4170
Ivan Krasinef05abd2011-08-24 20:22:22 +00004171 case llvm::Triple::le32:
4172 switch (os) {
4173 case llvm::Triple::NativeClient:
4174 return new PNaClTargetInfo(T);
4175 default:
4176 return NULL;
4177 }
4178
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004179 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004180 if (Triple.isOSDarwin())
Roman Divackyc81f2a22011-01-06 08:27:10 +00004181 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004182 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00004183 case llvm::Triple::Linux:
4184 return new LinuxTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004185 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00004186 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004187 case llvm::Triple::NetBSD:
4188 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
4189 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00004190 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004191 default:
4192 return new PPC32TargetInfo(T);
4193 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004194
4195 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004196 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00004197 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004198 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00004199 case llvm::Triple::Linux:
4200 return new LinuxTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004201 case llvm::Triple::Lv2:
John Thompson3f6918a2009-11-19 17:18:50 +00004202 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004203 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00004204 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004205 case llvm::Triple::NetBSD:
4206 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
4207 default:
4208 return new PPC64TargetInfo(T);
4209 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004210
Peter Collingbourneedb66f32012-05-20 23:28:41 +00004211 case llvm::Triple::nvptx:
4212 return new NVPTX32TargetInfo(T);
4213 case llvm::Triple::nvptx64:
4214 return new NVPTX64TargetInfo(T);
4215
Chris Lattner9cbeb632010-03-06 21:21:27 +00004216 case llvm::Triple::mblaze:
4217 return new MBlazeTargetInfo(T);
4218
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004219 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004220 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00004221 case llvm::Triple::Linux:
4222 return new LinuxTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004223 case llvm::Triple::AuroraUX:
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004224 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004225 case llvm::Triple::Solaris:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004226 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004227 case llvm::Triple::NetBSD:
4228 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
4229 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00004230 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004231 default:
4232 return new SparcV8TargetInfo(T);
4233 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004234
John Thompson3f6918a2009-11-19 17:18:50 +00004235 // FIXME: Need a real SPU target.
4236 case llvm::Triple::cellspu:
4237 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
4238
Eli Friedmanb63decf2009-08-19 20:47:07 +00004239 case llvm::Triple::tce:
4240 return new TCETargetInfo(T);
4241
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004242 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004243 if (Triple.isOSDarwin())
4244 return new DarwinI386TargetInfo(T);
4245
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004246 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004247 case llvm::Triple::AuroraUX:
4248 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004249 case llvm::Triple::Linux:
4250 return new LinuxTargetInfo<X86_32TargetInfo>(T);
4251 case llvm::Triple::DragonFly:
4252 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
4253 case llvm::Triple::NetBSD:
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00004254 return new NetBSDI386TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004255 case llvm::Triple::OpenBSD:
4256 return new OpenBSDI386TargetInfo(T);
4257 case llvm::Triple::FreeBSD:
4258 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner38e317d2010-07-07 16:01:42 +00004259 case llvm::Triple::Minix:
4260 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004261 case llvm::Triple::Solaris:
4262 return new SolarisTargetInfo<X86_32TargetInfo>(T);
4263 case llvm::Triple::Cygwin:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004264 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004265 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004266 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004267 case llvm::Triple::Win32:
Michael J. Spencera764e832010-10-21 08:22:51 +00004268 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattner86ed3a32010-04-11 19:29:39 +00004269 case llvm::Triple::Haiku:
4270 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00004271 case llvm::Triple::RTEMS:
4272 return new RTEMSX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004273 default:
4274 return new X86_32TargetInfo(T);
4275 }
4276
4277 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004278 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
4279 return new DarwinX86_64TargetInfo(T);
4280
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004281 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004282 case llvm::Triple::AuroraUX:
4283 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004284 case llvm::Triple::Linux:
4285 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner7a7ca282010-01-09 05:41:14 +00004286 case llvm::Triple::DragonFly:
4287 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004288 case llvm::Triple::NetBSD:
4289 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
4290 case llvm::Triple::OpenBSD:
4291 return new OpenBSDX86_64TargetInfo(T);
4292 case llvm::Triple::FreeBSD:
4293 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
4294 case llvm::Triple::Solaris:
4295 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00004296 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004297 return new MinGWX86_64TargetInfo(T);
4298 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004299 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004300 default:
4301 return new X86_64TargetInfo(T);
4302 }
4303 }
Reid Spencer5f016e22007-07-11 17:01:13 +00004304}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004305
4306/// CreateTargetInfo - Return the target info object for the specified target
4307/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00004308TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004309 TargetOptions &Opts) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004310 llvm::Triple Triple(Opts.Triple);
4311
4312 // Construct the target
Dylan Noblesmith6f42b622012-02-05 02:12:40 +00004313 OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004314 if (!Target) {
4315 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
4316 return 0;
4317 }
4318
Daniel Dunbareac7c532009-12-18 18:42:37 +00004319 // Set the target CPU if specified.
4320 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
4321 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
4322 return 0;
4323 }
4324
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004325 // Set the target ABI if specified.
4326 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
4327 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
4328 return 0;
4329 }
4330
Charles Davis98b7c5c2010-06-11 01:06:47 +00004331 // Set the target C++ ABI.
John McCallee79a4c2010-08-21 22:46:04 +00004332 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davis98b7c5c2010-06-11 01:06:47 +00004333 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
4334 return 0;
4335 }
4336
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004337 // Compute the default target features, we need the target to handle this
4338 // because features may have dependencies on one another.
4339 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004340 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004341
4342 // Apply the user specified deltas.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004343 // First the enables.
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004344 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
4345 ie = Opts.Features.end(); it != ie; ++it) {
4346 const char *Name = it->c_str();
4347
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004348 if (Name[0] != '+')
4349 continue;
4350
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004351 // Apply the feature via the target.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004352 if (!Target->setFeatureEnabled(Features, Name + 1, true)) {
4353 Diags.Report(diag::err_target_invalid_feature) << Name;
4354 return 0;
4355 }
4356 }
4357
4358 // Then the disables.
4359 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
4360 ie = Opts.Features.end(); it != ie; ++it) {
4361 const char *Name = it->c_str();
4362
4363 if (Name[0] == '+')
4364 continue;
4365
4366 // Apply the feature via the target.
4367 if (Name[0] != '-' ||
4368 !Target->setFeatureEnabled(Features, Name + 1, false)) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004369 Diags.Report(diag::err_target_invalid_feature) << Name;
4370 return 0;
4371 }
4372 }
4373
4374 // Add the features to the compile options.
4375 //
4376 // FIXME: If we are completely confident that we have the right set, we only
4377 // need to pass the minuses.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004378 Opts.Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004379 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
4380 ie = Features.end(); it != ie; ++it)
Benjamin Kramer713575a2012-03-05 15:10:44 +00004381 Opts.Features.push_back((it->second ? "+" : "-") + it->first().str());
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004382 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004383
4384 return Target.take();
4385}