blob: 51538f1a775971385e36232ecb89bb1c5786e498 [file] [log] [blame]
Chris Lattner5ba61f02006-10-14 07:39:34 +00001//===--- Targets.cpp - Implement -arch option and targets -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner5ba61f02006-10-14 07:39:34 +00007//
8//===----------------------------------------------------------------------===//
9//
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000010// This file implements construction of a TargetInfo object from a
Ted Kremenek6f6ff372007-12-12 18:05:32 +000011// target triple.
Chris Lattner5ba61f02006-10-14 07:39:34 +000012//
13//===----------------------------------------------------------------------===//
14
Chris Lattner5ba61f02006-10-14 07:39:34 +000015#include "clang/Basic/TargetInfo.h"
Daniel Dunbarb9bbd542009-11-15 06:48:46 +000016#include "clang/Basic/Builtins.h"
17#include "clang/Basic/Diagnostic.h"
Chris Lattnerc7c6dd42008-12-04 22:54:33 +000018#include "clang/Basic/LangOptions.h"
Chandler Carruth26b29a02010-01-20 06:13:02 +000019#include "clang/Basic/MacroBuilder.h"
Daniel Dunbarb9bbd542009-11-15 06:48:46 +000020#include "clang/Basic/TargetBuiltins.h"
21#include "clang/Basic/TargetOptions.h"
Eli Friedman7cef49e2008-05-20 14:27:34 +000022#include "llvm/ADT/APFloat.h"
Daniel Dunbarb9bbd542009-11-15 06:48:46 +000023#include "llvm/ADT/OwningPtr.h"
Daniel Dunbar979586e2009-11-11 09:38:56 +000024#include "llvm/ADT/STLExtras.h"
Daniel Dunbar58bc48c2009-08-19 20:04:03 +000025#include "llvm/ADT/StringRef.h"
Daniel Dunbar979586e2009-11-11 09:38:56 +000026#include "llvm/ADT/StringSwitch.h"
Chris Lattner859c37a2009-08-12 06:24:27 +000027#include "llvm/ADT/Triple.h"
Chris Lattner30ba6742009-08-10 19:03:04 +000028#include "llvm/MC/MCSectionMachO.h"
David Blaikie76bd3c82011-09-23 05:35:21 +000029#include "llvm/Support/ErrorHandling.h"
Dale Johannesen182addf2010-10-29 23:24:33 +000030#include "llvm/Type.h"
Benjamin Kramerdc2f0062010-01-09 18:20:57 +000031#include <algorithm>
Chris Lattner5ba61f02006-10-14 07:39:34 +000032using namespace clang;
33
Chris Lattner5ba61f02006-10-14 07:39:34 +000034//===----------------------------------------------------------------------===//
Chris Lattner1f5ad112006-10-14 18:32:12 +000035// Common code shared among targets.
Chris Lattner5ba61f02006-10-14 07:39:34 +000036//===----------------------------------------------------------------------===//
37
Chris Lattner1e1c0b92009-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 Lattner0e62c1c2011-07-23 10:55:15 +000041static void DefineStd(MacroBuilder &Builder, StringRef MacroName,
Chris Lattner1e1c0b92009-03-20 16:06:38 +000042 const LangOptions &Opts) {
43 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000044
Chris Lattner1e1c0b92009-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 Kramer2d6fda32010-01-09 17:55:51 +000048 Builder.defineMacro(MacroName);
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000049
Chris Lattner1e1c0b92009-03-20 16:06:38 +000050 // Define __unix.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000051 Builder.defineMacro("__" + MacroName);
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000052
Chris Lattner1e1c0b92009-03-20 16:06:38 +000053 // Define __unix__.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000054 Builder.defineMacro("__" + MacroName + "__");
Chris Lattner1e1c0b92009-03-20 16:06:38 +000055}
56
Chris Lattner09d98f52008-10-05 21:50:58 +000057//===----------------------------------------------------------------------===//
58// Defines specific to certain operating systems.
59//===----------------------------------------------------------------------===//
Chris Lattner30ba6742009-08-10 19:03:04 +000060
Torok Edwinb2b37c62009-06-30 17:10:35 +000061namespace {
Douglas Gregorc05d2a12009-07-01 15:12:53 +000062template<typename TgtInfo>
63class OSTargetInfo : public TgtInfo {
Torok Edwinb2b37c62009-06-30 17:10:35 +000064protected:
Daniel Dunbar40165182009-08-24 09:10:05 +000065 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000066 MacroBuilder &Builder) const=0;
Torok Edwinb2b37c62009-06-30 17:10:35 +000067public:
Douglas Gregorc05d2a12009-07-01 15:12:53 +000068 OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
Torok Edwinb2b37c62009-06-30 17:10:35 +000069 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000070 MacroBuilder &Builder) const {
71 TgtInfo::getTargetDefines(Opts, Builder);
72 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Torok Edwin4e054162009-06-30 17:00:25 +000073 }
Torok Edwinb2b37c62009-06-30 17:10:35 +000074
75};
Chris Lattner859c37a2009-08-12 06:24:27 +000076} // end anonymous namespace
Torok Edwin4e054162009-06-30 17:00:25 +000077
Chris Lattner30ba6742009-08-10 19:03:04 +000078
Daniel Dunbard86666f2010-01-26 01:44:04 +000079static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +000080 const llvm::Triple &Triple,
Chris Lattner0e62c1c2011-07-23 10:55:15 +000081 StringRef &PlatformName,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +000082 VersionTuple &PlatformMinVersion) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000083 Builder.defineMacro("__APPLE_CC__", "5621");
84 Builder.defineMacro("__APPLE__");
85 Builder.defineMacro("__MACH__");
86 Builder.defineMacro("OBJC_NEW_PROPERTIES");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000087
John McCall5d36a8c2011-06-16 00:03:19 +000088 if (!Opts.ObjCAutoRefCount) {
John McCall31168b02011-06-15 23:02:42 +000089 // __weak is always defined, for use in blocks and with objc pointers.
90 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000091
John McCall31168b02011-06-15 23:02:42 +000092 // Darwin defines __strong even in C mode (just to nothing).
Douglas Gregor79a91412011-09-13 17:21:33 +000093 if (Opts.getGC() != LangOptions::NonGC)
John McCall31168b02011-06-15 23:02:42 +000094 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
95 else
96 Builder.defineMacro("__strong", "");
Eric Christopher0c912c52011-07-07 22:55:26 +000097
John McCall31168b02011-06-15 23:02:42 +000098 // __unsafe_unretained is defined to nothing in non-ARC mode. We even
99 // allow this in C, since one might have block pointers in structs that
100 // are used in pure C code and in Objective-C ARC.
101 Builder.defineMacro("__unsafe_unretained", "");
John McCall31168b02011-06-15 23:02:42 +0000102 }
Eric Christopher0c912c52011-07-07 22:55:26 +0000103
Eli Friedmanfd4b1552009-06-04 23:00:29 +0000104 if (Opts.Static)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000105 Builder.defineMacro("__STATIC__");
Eli Friedmanfd4b1552009-06-04 23:00:29 +0000106 else
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000107 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000108
109 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000110 Builder.defineMacro("_REENTRANT");
Daniel Dunbar497ff132009-04-10 19:52:24 +0000111
Daniel Dunbarecf13562011-04-19 21:40:34 +0000112 // Get the platform type and version number from the triple.
Daniel Dunbar497ff132009-04-10 19:52:24 +0000113 unsigned Maj, Min, Rev;
Mike Stump11289f42009-09-09 15:08:12 +0000114
Daniel Dunbard86666f2010-01-26 01:44:04 +0000115 // If no version was given, default to to 10.4.0, for simplifying tests.
Daniel Dunbarecf13562011-04-19 21:40:34 +0000116 if (Triple.getOSName() == "darwin" || Triple.getOSName() == "osx") {
117 PlatformName = "macosx";
Daniel Dunbard86666f2010-01-26 01:44:04 +0000118 Min = Rev = 0;
119 Maj = 8;
Daniel Dunbarecf13562011-04-19 21:40:34 +0000120 } else {
121 // Otherwise, honor all three triple forms ("-darwinNNN[-iphoneos]",
122 // "-osxNNN", and "-iosNNN").
123
124 if (Triple.getOS() == llvm::Triple::Darwin) {
125 // For historical reasons that make little sense, the version passed here
126 // is the "darwin" version, which drops the 10 and offsets by 4.
127 Triple.getOSVersion(Maj, Min, Rev);
128
129 if (Triple.getEnvironmentName() == "iphoneos") {
130 PlatformName = "ios";
131 } else {
Daniel Dunbarecf13562011-04-19 21:40:34 +0000132 PlatformName = "macosx";
133 Rev = Min;
134 Min = Maj - 4;
135 Maj = 10;
136 }
Daniel Dunbarecf13562011-04-19 21:40:34 +0000137 } else {
Daniel Dunbarecf13562011-04-19 21:40:34 +0000138 Triple.getOSVersion(Maj, Min, Rev);
Daniel Dunbarfcd23892011-04-19 23:34:21 +0000139 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbarecf13562011-04-19 21:40:34 +0000140 }
141 }
Daniel Dunbard86666f2010-01-26 01:44:04 +0000142
Chad Rosierb90e4022011-07-19 20:00:06 +0000143 // If -ccc-host-triple arch-pc-win32-macho option specified, we're
Eric Christopherb081ba62011-07-29 21:20:35 +0000144 // generating code for Win32 ABI. No need to emit
Chad Rosierb90e4022011-07-19 20:00:06 +0000145 // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
146 if (PlatformName == "win32") {
147 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
148 return;
149 }
150
Daniel Dunbard86666f2010-01-26 01:44:04 +0000151 // Set the appropriate OS version define.
Daniel Dunbarecf13562011-04-19 21:40:34 +0000152 if (PlatformName == "ios") {
Daniel Dunbarbbd48222011-04-21 21:27:33 +0000153 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbard86666f2010-01-26 01:44:04 +0000154 char Str[6];
155 Str[0] = '0' + Maj;
156 Str[1] = '0' + (Min / 10);
157 Str[2] = '0' + (Min % 10);
158 Str[3] = '0' + (Rev / 10);
159 Str[4] = '0' + (Rev % 10);
160 Str[5] = '\0';
161 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
162 } else {
Daniel Dunbarbbd48222011-04-21 21:27:33 +0000163 // Note that the Driver allows versions which aren't representable in the
164 // define (because we only get a single digit for the minor and micro
165 // revision numbers). So, we limit them to the maximum representable
166 // version.
Daniel Dunbard86666f2010-01-26 01:44:04 +0000167 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
Daniel Dunbarbbd48222011-04-21 21:27:33 +0000168 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbard86666f2010-01-26 01:44:04 +0000169 char Str[5];
170 Str[0] = '0' + (Maj / 10);
171 Str[1] = '0' + (Maj % 10);
Daniel Dunbarbbd48222011-04-21 21:27:33 +0000172 Str[2] = '0' + std::min(Min, 9U);
173 Str[3] = '0' + std::min(Rev, 9U);
Daniel Dunbard86666f2010-01-26 01:44:04 +0000174 Str[4] = '\0';
175 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar497ff132009-04-10 19:52:24 +0000176 }
Daniel Dunbarecf13562011-04-19 21:40:34 +0000177
178 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman3fd920a2008-08-20 02:34:37 +0000179}
Chris Lattner5ba61f02006-10-14 07:39:34 +0000180
Chris Lattner30ba6742009-08-10 19:03:04 +0000181namespace {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000182template<typename Target>
183class DarwinTargetInfo : public OSTargetInfo<Target> {
184protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000185 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000186 MacroBuilder &Builder) const {
Eric Christopher0c912c52011-07-07 22:55:26 +0000187 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000188 this->PlatformMinVersion);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000189 }
Mike Stump11289f42009-09-09 15:08:12 +0000190
Torok Edwinb2b37c62009-06-30 17:10:35 +0000191public:
192 DarwinTargetInfo(const std::string& triple) :
193 OSTargetInfo<Target>(triple) {
Eric Christopherbf15d2b2011-07-02 00:20:22 +0000194 llvm::Triple T = llvm::Triple(triple);
195 this->TLSSupported = T.isMacOSX() && !T.isMacOSXVersionLT(10,7);
Daniel Dunbar13adc7f2011-02-21 23:12:51 +0000196 this->MCountName = "\01mcount";
Torok Edwinb2b37c62009-06-30 17:10:35 +0000197 }
198
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000199 virtual std::string isValidSectionSpecifier(StringRef SR) const {
Chris Lattner30ba6742009-08-10 19:03:04 +0000200 // Let MCSectionMachO validate this.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000201 StringRef Segment, Section;
Chris Lattner30ba6742009-08-10 19:03:04 +0000202 unsigned TAA, StubSize;
Daniel Dunbar75942372011-03-19 02:06:21 +0000203 bool HasTAA;
Chris Lattner30ba6742009-08-10 19:03:04 +0000204 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar75942372011-03-19 02:06:21 +0000205 TAA, HasTAA, StubSize);
Chris Lattner30ba6742009-08-10 19:03:04 +0000206 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000207
Anders Carlsson851318a2010-06-08 22:47:50 +0000208 virtual const char *getStaticInitSectionSpecifier() const {
209 // FIXME: We should return 0 when building kexts.
210 return "__TEXT,__StaticInit,regular,pure_instructions";
211 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000212
Torok Edwinb2b37c62009-06-30 17:10:35 +0000213};
214
Chris Lattner30ba6742009-08-10 19:03:04 +0000215
Torok Edwinb2b37c62009-06-30 17:10:35 +0000216// DragonFlyBSD Target
217template<typename Target>
218class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
219protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000220 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000221 MacroBuilder &Builder) const {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000222 // DragonFly defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000223 Builder.defineMacro("__DragonFly__");
224 Builder.defineMacro("__DragonFly_cc_version", "100001");
225 Builder.defineMacro("__ELF__");
226 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
227 Builder.defineMacro("__tune_i386__");
228 DefineStd(Builder, "unix", Opts);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000229 }
230public:
Mike Stump11289f42009-09-09 15:08:12 +0000231 DragonFlyBSDTargetInfo(const std::string &triple)
Torok Edwinb2b37c62009-06-30 17:10:35 +0000232 : OSTargetInfo<Target>(triple) {}
233};
234
235// FreeBSD Target
236template<typename Target>
237class FreeBSDTargetInfo : public OSTargetInfo<Target> {
238protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000239 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000240 MacroBuilder &Builder) const {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000241 // FreeBSD defines; list based off of gcc output
242
Benjamin Kramer80ca4072011-10-18 10:10:08 +0000243 unsigned Release = Triple.getOSMajorVersion();
244 if (Release == 0U)
245 Release = 8;
Torok Edwinb2b37c62009-06-30 17:10:35 +0000246
Benjamin Kramer80ca4072011-10-18 10:10:08 +0000247 Builder.defineMacro("__FreeBSD__", Twine(Release));
248 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000249 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
250 DefineStd(Builder, "unix", Opts);
251 Builder.defineMacro("__ELF__");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000252 }
253public:
Mike Stump11289f42009-09-09 15:08:12 +0000254 FreeBSDTargetInfo(const std::string &triple)
Duncan Sands9cb27e92009-07-08 13:55:08 +0000255 : OSTargetInfo<Target>(triple) {
256 this->UserLabelPrefix = "";
Roman Divacky178e01602011-02-10 16:52:03 +0000257
258 llvm::Triple Triple(triple);
259 switch (Triple.getArch()) {
260 default:
261 case llvm::Triple::x86:
262 case llvm::Triple::x86_64:
263 this->MCountName = ".mcount";
264 break;
265 case llvm::Triple::mips:
266 case llvm::Triple::mipsel:
267 case llvm::Triple::ppc:
268 case llvm::Triple::ppc64:
269 this->MCountName = "_mcount";
270 break;
271 case llvm::Triple::arm:
272 this->MCountName = "__mcount";
273 break;
274 }
275
Duncan Sands9cb27e92009-07-08 13:55:08 +0000276 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000277};
278
Chris Lattner3e2ee142010-07-07 16:01:42 +0000279// Minix Target
280template<typename Target>
281class MinixTargetInfo : public OSTargetInfo<Target> {
282protected:
283 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
284 MacroBuilder &Builder) const {
285 // Minix defines
286
287 Builder.defineMacro("__minix", "3");
288 Builder.defineMacro("_EM_WSIZE", "4");
289 Builder.defineMacro("_EM_PSIZE", "4");
290 Builder.defineMacro("_EM_SSIZE", "2");
291 Builder.defineMacro("_EM_LSIZE", "4");
292 Builder.defineMacro("_EM_FSIZE", "4");
293 Builder.defineMacro("_EM_DSIZE", "8");
Eli Friedman83de5132011-12-08 23:54:21 +0000294 Builder.defineMacro("__ELF__");
Chris Lattner3e2ee142010-07-07 16:01:42 +0000295 DefineStd(Builder, "unix", Opts);
296 }
297public:
298 MinixTargetInfo(const std::string &triple)
299 : OSTargetInfo<Target>(triple) {
300 this->UserLabelPrefix = "";
301 }
302};
303
Torok Edwinb2b37c62009-06-30 17:10:35 +0000304// Linux target
305template<typename Target>
306class LinuxTargetInfo : public OSTargetInfo<Target> {
307protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000308 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000309 MacroBuilder &Builder) const {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000310 // Linux defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000311 DefineStd(Builder, "unix", Opts);
312 DefineStd(Builder, "linux", Opts);
313 Builder.defineMacro("__gnu_linux__");
314 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000315 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000316 Builder.defineMacro("_REENTRANT");
Douglas Gregor3ecc6652010-04-21 05:52:38 +0000317 if (Opts.CPlusPlus)
318 Builder.defineMacro("_GNU_SOURCE");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000319 }
320public:
Mike Stump11289f42009-09-09 15:08:12 +0000321 LinuxTargetInfo(const std::string& triple)
Torok Edwinb2b37c62009-06-30 17:10:35 +0000322 : OSTargetInfo<Target>(triple) {
323 this->UserLabelPrefix = "";
Douglas Gregore6d6e512011-01-12 21:19:25 +0000324 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwinb2b37c62009-06-30 17:10:35 +0000325 }
Benjamin Kramera518b222011-10-15 17:53:33 +0000326
327 virtual const char *getStaticInitSectionSpecifier() const {
328 return ".text.startup";
329 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000330};
331
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000332// NetBSD Target
333template<typename Target>
334class NetBSDTargetInfo : public OSTargetInfo<Target> {
335protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000336 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000337 MacroBuilder &Builder) const {
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000338 // NetBSD defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000339 Builder.defineMacro("__NetBSD__");
340 Builder.defineMacro("__unix__");
341 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000342 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000343 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000344 }
345public:
Mike Stump11289f42009-09-09 15:08:12 +0000346 NetBSDTargetInfo(const std::string &triple)
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000347 : OSTargetInfo<Target>(triple) {
348 this->UserLabelPrefix = "";
349 }
350};
351
Torok Edwinb2b37c62009-06-30 17:10:35 +0000352// OpenBSD Target
353template<typename Target>
354class OpenBSDTargetInfo : public OSTargetInfo<Target> {
355protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000356 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000357 MacroBuilder &Builder) const {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000358 // OpenBSD defines; list based off of gcc output
359
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000360 Builder.defineMacro("__OpenBSD__");
361 DefineStd(Builder, "unix", Opts);
362 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000363 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000364 Builder.defineMacro("_POSIX_THREADS");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000365 }
366public:
Mike Stump11289f42009-09-09 15:08:12 +0000367 OpenBSDTargetInfo(const std::string &triple)
Eli Friedman3715d1f2011-12-15 02:15:56 +0000368 : OSTargetInfo<Target>(triple) {
369 this->UserLabelPrefix = "";
370
371 llvm::Triple Triple(triple);
372 switch (Triple.getArch()) {
373 default:
374 case llvm::Triple::x86:
375 case llvm::Triple::x86_64:
376 case llvm::Triple::arm:
377 case llvm::Triple::sparc:
378 this->MCountName = "__mcount";
379 break;
380 case llvm::Triple::mips64:
381 case llvm::Triple::mips64el:
382 case llvm::Triple::ppc:
383 case llvm::Triple::sparcv9:
384 this->MCountName = "_mcount";
385 break;
386 }
387 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000388};
389
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000390// PSP Target
391template<typename Target>
392class PSPTargetInfo : public OSTargetInfo<Target> {
393protected:
394 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000395 MacroBuilder &Builder) const {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000396 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000397 Builder.defineMacro("PSP");
398 Builder.defineMacro("_PSP");
399 Builder.defineMacro("__psp__");
400 Builder.defineMacro("__ELF__");
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000401 }
402public:
403 PSPTargetInfo(const std::string& triple)
404 : OSTargetInfo<Target>(triple) {
405 this->UserLabelPrefix = "";
406 }
407};
408
John Thompsone467e192009-11-19 17:18:50 +0000409// PS3 PPU Target
410template<typename Target>
411class PS3PPUTargetInfo : public OSTargetInfo<Target> {
412protected:
413 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000414 MacroBuilder &Builder) const {
John Thompsone467e192009-11-19 17:18:50 +0000415 // PS3 PPU defines.
John Thompson957816f2010-03-25 16:18:32 +0000416 Builder.defineMacro("__PPC__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000417 Builder.defineMacro("__PPU__");
418 Builder.defineMacro("__CELLOS_LV2__");
419 Builder.defineMacro("__ELF__");
420 Builder.defineMacro("__LP32__");
John Thompson07a61a42010-06-24 22:44:13 +0000421 Builder.defineMacro("_ARCH_PPC64");
422 Builder.defineMacro("__powerpc64__");
John Thompsone467e192009-11-19 17:18:50 +0000423 }
424public:
425 PS3PPUTargetInfo(const std::string& triple)
426 : OSTargetInfo<Target>(triple) {
427 this->UserLabelPrefix = "";
Nick Lewyckyc0a61732011-12-16 22:32:39 +0000428 this->LongWidth = this->LongAlign = 32;
429 this->PointerWidth = this->PointerAlign = 32;
John Thompson07a61a42010-06-24 22:44:13 +0000430 this->IntMaxType = TargetInfo::SignedLongLong;
431 this->UIntMaxType = TargetInfo::UnsignedLongLong;
432 this->Int64Type = TargetInfo::SignedLongLong;
John Thompson6f8dba72009-12-18 14:21:08 +0000433 this->SizeType = TargetInfo::UnsignedInt;
John Thompson07a61a42010-06-24 22:44:13 +0000434 this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Nick Lewyckyc0a61732011-12-16 22:32:39 +0000435 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompsone467e192009-11-19 17:18:50 +0000436 }
437};
438
439// FIXME: Need a real SPU target.
440// PS3 SPU Target
441template<typename Target>
442class PS3SPUTargetInfo : public OSTargetInfo<Target> {
443protected:
444 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000445 MacroBuilder &Builder) const {
John Thompsone467e192009-11-19 17:18:50 +0000446 // PS3 PPU defines.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000447 Builder.defineMacro("__SPU__");
448 Builder.defineMacro("__ELF__");
John Thompsone467e192009-11-19 17:18:50 +0000449 }
450public:
451 PS3SPUTargetInfo(const std::string& triple)
452 : OSTargetInfo<Target>(triple) {
453 this->UserLabelPrefix = "";
454 }
455};
456
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +0000457// AuroraUX target
458template<typename Target>
459class AuroraUXTargetInfo : public OSTargetInfo<Target> {
460protected:
461 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000462 MacroBuilder &Builder) const {
463 DefineStd(Builder, "sun", Opts);
464 DefineStd(Builder, "unix", Opts);
465 Builder.defineMacro("__ELF__");
466 Builder.defineMacro("__svr4__");
467 Builder.defineMacro("__SVR4");
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +0000468 }
469public:
470 AuroraUXTargetInfo(const std::string& triple)
471 : OSTargetInfo<Target>(triple) {
472 this->UserLabelPrefix = "";
473 this->WCharType = this->SignedLong;
474 // FIXME: WIntType should be SignedLong
475 }
476};
477
Torok Edwinb2b37c62009-06-30 17:10:35 +0000478// Solaris target
479template<typename Target>
480class SolarisTargetInfo : public OSTargetInfo<Target> {
481protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000482 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000483 MacroBuilder &Builder) const {
484 DefineStd(Builder, "sun", Opts);
485 DefineStd(Builder, "unix", Opts);
486 Builder.defineMacro("__ELF__");
487 Builder.defineMacro("__svr4__");
488 Builder.defineMacro("__SVR4");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000489 }
490public:
Mike Stump11289f42009-09-09 15:08:12 +0000491 SolarisTargetInfo(const std::string& triple)
Torok Edwinb2b37c62009-06-30 17:10:35 +0000492 : OSTargetInfo<Target>(triple) {
493 this->UserLabelPrefix = "";
494 this->WCharType = this->SignedLong;
495 // FIXME: WIntType should be SignedLong
496 }
497};
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000498
499// Windows target
500template<typename Target>
501class WindowsTargetInfo : public OSTargetInfo<Target> {
502protected:
503 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
504 MacroBuilder &Builder) const {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +0000505 Builder.defineMacro("_WIN32");
506 }
507 void getVisualStudioDefines(const LangOptions &Opts,
508 MacroBuilder &Builder) const {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000509 if (Opts.CPlusPlus) {
510 if (Opts.RTTI)
511 Builder.defineMacro("_CPPRTTI");
512
513 if (Opts.Exceptions)
514 Builder.defineMacro("_CPPUNWIND");
515 }
516
517 if (!Opts.CharIsSigned)
518 Builder.defineMacro("_CHAR_UNSIGNED");
519
520 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
521 // but it works for now.
522 if (Opts.POSIXThreads)
523 Builder.defineMacro("_MT");
Michael J. Spencer54bf3c32010-10-21 08:22:51 +0000524
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000525 if (Opts.MSCVersion != 0)
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000526 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000527
Francois Pichet0706d202011-09-17 17:15:52 +0000528 if (Opts.MicrosoftExt) {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000529 Builder.defineMacro("_MSC_EXTENSIONS");
530
531 if (Opts.CPlusPlus0x) {
532 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
533 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
534 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
535 }
536 }
537
538 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000539 }
540
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000541public:
542 WindowsTargetInfo(const std::string &triple)
543 : OSTargetInfo<Target>(triple) {}
544};
545
Mike Stump11289f42009-09-09 15:08:12 +0000546} // end anonymous namespace.
Torok Edwinb2b37c62009-06-30 17:10:35 +0000547
Chris Lattner09d98f52008-10-05 21:50:58 +0000548//===----------------------------------------------------------------------===//
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000549// Specific target implementations.
550//===----------------------------------------------------------------------===//
Anders Carlssona7408e72007-10-13 00:45:48 +0000551
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000552namespace {
553// PPC abstract base class
554class PPCTargetInfo : public TargetInfo {
555 static const Builtin::Info BuiltinInfo[];
556 static const char * const GCCRegNames[];
557 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000558public:
Eli Friedman9ffd4a92009-06-05 07:05:05 +0000559 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
560
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000561 virtual void getTargetBuiltins(const Builtin::Info *&Records,
562 unsigned &NumRecords) const {
Chris Lattner10a5b382007-01-29 05:24:35 +0000563 Records = BuiltinInfo;
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000564 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner10a5b382007-01-29 05:24:35 +0000565 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000566
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000567 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000568 MacroBuilder &Builder) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000569
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000570 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000571 unsigned &NumNames) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000572 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000573 unsigned &NumAliases) const;
Anders Carlsson58436352009-02-28 17:11:49 +0000574 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +0000575 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson58436352009-02-28 17:11:49 +0000576 switch (*Name) {
Anders Carlssonf511f642007-11-27 04:11:28 +0000577 default: return false;
578 case 'O': // Zero
John Thompson07a61a42010-06-24 22:44:13 +0000579 break;
Anders Carlssonf511f642007-11-27 04:11:28 +0000580 case 'b': // Base register
581 case 'f': // Floating point register
Chris Lattnerd9725f72009-04-26 07:16:29 +0000582 Info.setAllowsRegister();
John Thompson07a61a42010-06-24 22:44:13 +0000583 break;
584 // FIXME: The following are added to allow parsing.
585 // I just took a guess at what the actions should be.
586 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000587 case 'd': // Floating point register (containing 64-bit value)
John Thompson07a61a42010-06-24 22:44:13 +0000588 case 'v': // Altivec vector register
589 Info.setAllowsRegister();
590 break;
591 case 'w':
592 switch (Name[1]) {
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000593 case 'd':// VSX vector register to hold vector double data
594 case 'f':// VSX vector register to hold vector float data
595 case 's':// VSX vector register to hold scalar float data
596 case 'a':// Any VSX register
John Thompson07a61a42010-06-24 22:44:13 +0000597 break;
598 default:
599 return false;
600 }
601 Info.setAllowsRegister();
602 Name++; // Skip over 'w'.
603 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000604 case 'h': // `MQ', `CTR', or `LINK' register
605 case 'q': // `MQ' register
606 case 'c': // `CTR' register
607 case 'l': // `LINK' register
608 case 'x': // `CR' register (condition register) number 0
609 case 'y': // `CR' register (condition register)
610 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson07a61a42010-06-24 22:44:13 +0000611 Info.setAllowsRegister();
612 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000613 case 'I': // Signed 16-bit constant
John Thompson07a61a42010-06-24 22:44:13 +0000614 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000615 // (use `L' instead for SImode constants)
616 case 'K': // Unsigned 16-bit constant
617 case 'L': // Signed 16-bit constant shifted left 16 bits
618 case 'M': // Constant larger than 31
619 case 'N': // Exact power of 2
620 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson07a61a42010-06-24 22:44:13 +0000621 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000622 // register with one instruction per word
John Thompson07a61a42010-06-24 22:44:13 +0000623 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000624 // into a register using three instructions
John Thompson07a61a42010-06-24 22:44:13 +0000625 break;
626 case 'm': // Memory operand. Note that on PowerPC targets, m can
627 // include addresses that update the base register. It
628 // is therefore only safe to use `m' in an asm statement
629 // if that asm statement accesses the operand exactly once.
630 // The asm statement must also use `%U<opno>' as a
Sebastian Redldd008712010-08-17 22:42:34 +0000631 // placeholder for the "update" flag in the corresponding
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000632 // load or store instruction. For example:
John Thompson07a61a42010-06-24 22:44:13 +0000633 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000634 // is correct but:
John Thompson07a61a42010-06-24 22:44:13 +0000635 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
636 // is not. Use es rather than m if you don't want the base
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000637 // register to be updated.
638 case 'e':
John Thompsonceebdf12010-06-25 00:02:05 +0000639 if (Name[1] != 's')
640 return false;
Sebastian Redldd008712010-08-17 22:42:34 +0000641 // es: A "stable" memory operand; that is, one which does not
John Thompson07a61a42010-06-24 22:44:13 +0000642 // include any automodification of the base register. Unlike
643 // `m', this constraint can be used in asm statements that
644 // might access the operand several times, or that might not
John Thompsonceebdf12010-06-25 00:02:05 +0000645 // access it at all.
John Thompson07a61a42010-06-24 22:44:13 +0000646 Info.setAllowsMemory();
John Thompsonceebdf12010-06-25 00:02:05 +0000647 Name++; // Skip over 'e'.
John Thompson07a61a42010-06-24 22:44:13 +0000648 break;
649 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000650 // usually better to use `m' or `es' in asm statements)
John Thompson07a61a42010-06-24 22:44:13 +0000651 case 'Z': // Memory operand that is an indexed or indirect from a
652 // register (it is usually better to use `m' or `es' in
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000653 // asm statements)
John Thompson07a61a42010-06-24 22:44:13 +0000654 Info.setAllowsMemory();
655 Info.setAllowsRegister();
656 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000657 case 'R': // AIX TOC entry
John Thompson07a61a42010-06-24 22:44:13 +0000658 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000659 // register (`p' is preferable for asm statements)
660 case 'S': // Constant suitable as a 64-bit mask operand
661 case 'T': // Constant suitable as a 32-bit mask operand
662 case 'U': // System V Release 4 small data area reference
John Thompson07a61a42010-06-24 22:44:13 +0000663 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000664 // instructions
665 case 'W': // Vector constant that does not require memory
666 case 'j': // Vector constant that is all zeros.
John Thompson07a61a42010-06-24 22:44:13 +0000667 break;
668 // End FIXME.
Anders Carlssonf511f642007-11-27 04:11:28 +0000669 }
John Thompson07a61a42010-06-24 22:44:13 +0000670 return true;
Anders Carlssonf511f642007-11-27 04:11:28 +0000671 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000672 virtual const char *getClobbers() const {
673 return "";
Anders Carlssonf511f642007-11-27 04:11:28 +0000674 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000675};
Anders Carlssonf511f642007-11-27 04:11:28 +0000676
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000677const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000678#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +0000679#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000680 ALL_LANGUAGES },
Chris Lattner5abdec72009-06-14 01:05:48 +0000681#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000682};
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000683
684
Chris Lattnerecd49032009-03-02 22:27:17 +0000685/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
686/// #defines that are not tied to a specific subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000687void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000688 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +0000689 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000690 Builder.defineMacro("__ppc__");
691 Builder.defineMacro("_ARCH_PPC");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000692 Builder.defineMacro("__powerpc__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000693 Builder.defineMacro("__POWERPC__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000694 if (PointerWidth == 64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000695 Builder.defineMacro("_ARCH_PPC64");
696 Builder.defineMacro("_LP64");
697 Builder.defineMacro("__LP64__");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000698 Builder.defineMacro("__powerpc64__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000699 Builder.defineMacro("__ppc64__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000700 } else {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000701 Builder.defineMacro("__ppc__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000702 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000703
Chris Lattnerecd49032009-03-02 22:27:17 +0000704 // Target properties.
Joerg Sonnenberger870b3c52011-07-05 14:56:12 +0000705 if (getTriple().getOS() != llvm::Triple::NetBSD)
706 Builder.defineMacro("_BIG_ENDIAN");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000707 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000708
Chris Lattnerecd49032009-03-02 22:27:17 +0000709 // Subtarget options.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000710 Builder.defineMacro("__NATURAL_ALIGNMENT__");
711 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000712
Chris Lattnerecd49032009-03-02 22:27:17 +0000713 // FIXME: Should be controlled by command line option.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000714 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000715
John Thompsone467e192009-11-19 17:18:50 +0000716 if (Opts.AltiVec) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000717 Builder.defineMacro("__VEC__", "10206");
718 Builder.defineMacro("__ALTIVEC__");
John Thompsone467e192009-11-19 17:18:50 +0000719 }
Chris Lattnerecd49032009-03-02 22:27:17 +0000720}
721
Chris Lattner17df24e2008-04-21 18:56:49 +0000722
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000723const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnerf7ff53d2009-09-16 05:05:27 +0000724 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
725 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
726 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
727 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
728 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
729 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
730 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
731 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000732 "mq", "lr", "ctr", "ap",
Chris Lattnerf7ff53d2009-09-16 05:05:27 +0000733 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000734 "xer",
Chris Lattnerf7ff53d2009-09-16 05:05:27 +0000735 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
736 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
737 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
738 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000739 "vrsave", "vscr",
740 "spe_acc", "spefscr",
741 "sfp"
742};
Chris Lattner10a5b382007-01-29 05:24:35 +0000743
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000744void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000745 unsigned &NumNames) const {
746 Names = GCCRegNames;
747 NumNames = llvm::array_lengthof(GCCRegNames);
748}
Chris Lattner5ba61f02006-10-14 07:39:34 +0000749
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000750const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
751 // While some of these aliases do map to different registers
752 // they still share the same register name.
Daniel Dunbar1da76c42009-09-17 07:03:19 +0000753 { { "0" }, "r0" },
754 { { "1"}, "r1" },
755 { { "2" }, "r2" },
756 { { "3" }, "r3" },
757 { { "4" }, "r4" },
758 { { "5" }, "r5" },
759 { { "6" }, "r6" },
760 { { "7" }, "r7" },
761 { { "8" }, "r8" },
762 { { "9" }, "r9" },
763 { { "10" }, "r10" },
764 { { "11" }, "r11" },
765 { { "12" }, "r12" },
766 { { "13" }, "r13" },
767 { { "14" }, "r14" },
768 { { "15" }, "r15" },
769 { { "16" }, "r16" },
770 { { "17" }, "r17" },
771 { { "18" }, "r18" },
772 { { "19" }, "r19" },
773 { { "20" }, "r20" },
774 { { "21" }, "r21" },
775 { { "22" }, "r22" },
776 { { "23" }, "r23" },
777 { { "24" }, "r24" },
778 { { "25" }, "r25" },
779 { { "26" }, "r26" },
780 { { "27" }, "r27" },
781 { { "28" }, "r28" },
782 { { "29" }, "r29" },
783 { { "30" }, "r30" },
784 { { "31" }, "r31" },
785 { { "fr0" }, "f0" },
786 { { "fr1" }, "f1" },
787 { { "fr2" }, "f2" },
788 { { "fr3" }, "f3" },
789 { { "fr4" }, "f4" },
790 { { "fr5" }, "f5" },
791 { { "fr6" }, "f6" },
792 { { "fr7" }, "f7" },
793 { { "fr8" }, "f8" },
794 { { "fr9" }, "f9" },
Mike Stumpfaacf012009-09-17 21:15:00 +0000795 { { "fr10" }, "f10" },
Daniel Dunbar1da76c42009-09-17 07:03:19 +0000796 { { "fr11" }, "f11" },
797 { { "fr12" }, "f12" },
798 { { "fr13" }, "f13" },
799 { { "fr14" }, "f14" },
800 { { "fr15" }, "f15" },
801 { { "fr16" }, "f16" },
802 { { "fr17" }, "f17" },
803 { { "fr18" }, "f18" },
804 { { "fr19" }, "f19" },
805 { { "fr20" }, "f20" },
806 { { "fr21" }, "f21" },
807 { { "fr22" }, "f22" },
808 { { "fr23" }, "f23" },
809 { { "fr24" }, "f24" },
810 { { "fr25" }, "f25" },
811 { { "fr26" }, "f26" },
812 { { "fr27" }, "f27" },
813 { { "fr28" }, "f28" },
814 { { "fr29" }, "f29" },
815 { { "fr30" }, "f30" },
816 { { "fr31" }, "f31" },
817 { { "cc" }, "cr0" },
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000818};
819
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000820void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000821 unsigned &NumAliases) const {
822 Aliases = GCCRegAliases;
823 NumAliases = llvm::array_lengthof(GCCRegAliases);
824}
825} // end anonymous namespace.
Chris Lattner02dffbd2006-10-14 07:50:21 +0000826
Chris Lattner5ba61f02006-10-14 07:39:34 +0000827namespace {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000828class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +0000829public:
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000830 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedman873f65a2008-08-21 00:13:15 +0000831 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner5c67237f2009-11-07 18:59:41 +0000832 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000833
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +0000834 switch (getTriple().getOS()) {
835 case llvm::Triple::FreeBSD:
836 case llvm::Triple::NetBSD:
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +0000837 SizeType = UnsignedInt;
838 break;
Joerg Sonnenbergerf031fd92011-07-04 23:11:58 +0000839 default:
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +0000840 break;
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +0000841 }
Roman Divacky965b0b72011-01-06 08:27:10 +0000842 }
843
844 virtual const char *getVAListDeclaration() const {
845 // This is the ELF definition, and is overridden by the Darwin sub-target
846 return "typedef struct __va_list_tag {"
847 " unsigned char gpr;"
848 " unsigned char fpr;"
849 " unsigned short reserved;"
850 " void* overflow_arg_area;"
851 " void* reg_save_area;"
852 "} __builtin_va_list[1];";
Eli Friedman873f65a2008-08-21 00:13:15 +0000853 }
Chris Lattner5ba61f02006-10-14 07:39:34 +0000854};
855} // end anonymous namespace.
856
857namespace {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000858class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +0000859public:
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000860 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerba7a6c12008-05-09 06:17:04 +0000861 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman2857ccb2009-07-01 03:36:11 +0000862 IntMaxType = SignedLong;
863 UIntMaxType = UnsignedLong;
864 Int64Type = SignedLong;
Eli Friedman873f65a2008-08-21 00:13:15 +0000865 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner5c67237f2009-11-07 18:59:41 +0000866 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnerba7a6c12008-05-09 06:17:04 +0000867 }
Roman Divacky965b0b72011-01-06 08:27:10 +0000868 virtual const char *getVAListDeclaration() const {
869 return "typedef char* __builtin_va_list;";
870 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000871};
872} // end anonymous namespace.
873
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +0000874
875namespace {
Roman Divacky965b0b72011-01-06 08:27:10 +0000876class DarwinPPC32TargetInfo :
877 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +0000878public:
Roman Divacky965b0b72011-01-06 08:27:10 +0000879 DarwinPPC32TargetInfo(const std::string& triple)
880 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +0000881 HasAlignMac68kSupport = true;
Roman Divacky965b0b72011-01-06 08:27:10 +0000882 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
Nick Lewyckyf243e0d2011-12-21 04:25:47 +0000883 SuitableAlign = 128;
Roman Divacky965b0b72011-01-06 08:27:10 +0000884 }
885 virtual const char *getVAListDeclaration() const {
886 return "typedef char* __builtin_va_list;";
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +0000887 }
888};
889
890class DarwinPPC64TargetInfo :
891 public DarwinTargetInfo<PPC64TargetInfo> {
892public:
893 DarwinPPC64TargetInfo(const std::string& triple)
894 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
895 HasAlignMac68kSupport = true;
Nick Lewyckyf243e0d2011-12-21 04:25:47 +0000896 SuitableAlign = 128;
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +0000897 }
898};
899} // end anonymous namespace.
900
Chris Lattner5ba61f02006-10-14 07:39:34 +0000901namespace {
Justin Holewinski794c2052011-10-03 17:28:37 +0000902 static const unsigned PTXAddrSpaceMap[] = {
903 0, // opencl_global
904 4, // opencl_local
905 1 // opencl_constant
906 };
Justin Holewinski514cce82011-04-20 19:34:15 +0000907 class PTXTargetInfo : public TargetInfo {
908 static const char * const GCCRegNames[];
909 static const Builtin::Info BuiltinInfo[];
Justin Holewinski0542df52011-09-22 17:57:40 +0000910 std::vector<llvm::StringRef> AvailableFeatures;
Justin Holewinski514cce82011-04-20 19:34:15 +0000911 public:
912 PTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedman803acb32011-12-22 03:51:45 +0000913 BigEndian = false;
Justin Holewinski514cce82011-04-20 19:34:15 +0000914 TLSSupported = false;
915 LongWidth = LongAlign = 64;
Justin Holewinski794c2052011-10-03 17:28:37 +0000916 AddrSpaceMap = &PTXAddrSpaceMap;
Justin Holewinski0542df52011-09-22 17:57:40 +0000917 // Define available target features
918 // These must be defined in sorted order!
919 AvailableFeatures.push_back("compute10");
920 AvailableFeatures.push_back("compute11");
921 AvailableFeatures.push_back("compute12");
922 AvailableFeatures.push_back("compute13");
923 AvailableFeatures.push_back("compute20");
924 AvailableFeatures.push_back("double");
925 AvailableFeatures.push_back("no-fma");
926 AvailableFeatures.push_back("ptx20");
927 AvailableFeatures.push_back("ptx21");
928 AvailableFeatures.push_back("ptx22");
929 AvailableFeatures.push_back("ptx23");
930 AvailableFeatures.push_back("sm10");
931 AvailableFeatures.push_back("sm11");
932 AvailableFeatures.push_back("sm12");
933 AvailableFeatures.push_back("sm13");
934 AvailableFeatures.push_back("sm20");
935 AvailableFeatures.push_back("sm21");
936 AvailableFeatures.push_back("sm22");
937 AvailableFeatures.push_back("sm23");
Justin Holewinski514cce82011-04-20 19:34:15 +0000938 }
939 virtual void getTargetDefines(const LangOptions &Opts,
940 MacroBuilder &Builder) const {
941 Builder.defineMacro("__PTX__");
942 }
943 virtual void getTargetBuiltins(const Builtin::Info *&Records,
944 unsigned &NumRecords) const {
945 Records = BuiltinInfo;
946 NumRecords = clang::PTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
947 }
948
949 virtual void getGCCRegNames(const char * const *&Names,
950 unsigned &NumNames) const;
951 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
952 unsigned &NumAliases) const {
953 // No aliases.
954 Aliases = 0;
955 NumAliases = 0;
956 }
957 virtual bool validateAsmConstraint(const char *&Name,
958 TargetInfo::ConstraintInfo &info) const {
959 // FIXME: implement
960 return true;
961 }
962 virtual const char *getClobbers() const {
963 // FIXME: Is this really right?
964 return "";
965 }
966 virtual const char *getVAListDeclaration() const {
967 // FIXME: implement
968 return "typedef char* __builtin_va_list;";
969 }
Justin Holewinskiaa78b232011-09-15 12:13:38 +0000970
971 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
972 const std::string &Name,
973 bool Enabled) const;
Justin Holewinski514cce82011-04-20 19:34:15 +0000974 };
975
976 const Builtin::Info PTXTargetInfo::BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000977#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Justin Holewinski514cce82011-04-20 19:34:15 +0000978#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000979 ALL_LANGUAGES },
Justin Holewinski514cce82011-04-20 19:34:15 +0000980#include "clang/Basic/BuiltinsPTX.def"
981 };
982
983 const char * const PTXTargetInfo::GCCRegNames[] = {
984 "r0"
985 };
986
987 void PTXTargetInfo::getGCCRegNames(const char * const *&Names,
988 unsigned &NumNames) const {
989 Names = GCCRegNames;
990 NumNames = llvm::array_lengthof(GCCRegNames);
991 }
992
Justin Holewinskiaa78b232011-09-15 12:13:38 +0000993 bool PTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
994 const std::string &Name,
995 bool Enabled) const {
Justin Holewinski0542df52011-09-22 17:57:40 +0000996 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
997 Name)) {
998 Features[Name] = Enabled;
999 return true;
Justin Holewinskiaa78b232011-09-15 12:13:38 +00001000 } else {
Justin Holewinski0542df52011-09-22 17:57:40 +00001001 return false;
Justin Holewinskiaa78b232011-09-15 12:13:38 +00001002 }
Justin Holewinskiaa78b232011-09-15 12:13:38 +00001003 }
Justin Holewinski514cce82011-04-20 19:34:15 +00001004
1005 class PTX32TargetInfo : public PTXTargetInfo {
1006 public:
1007 PTX32TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
1008 PointerWidth = PointerAlign = 32;
1009 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
1010 DescriptionString
1011 = "e-p:32:32-i64:64:64-f64:64:64-n1:8:16:32:64";
1012 }
1013 };
1014
1015 class PTX64TargetInfo : public PTXTargetInfo {
1016 public:
1017 PTX64TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
1018 PointerWidth = PointerAlign = 64;
1019 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
1020 DescriptionString
1021 = "e-p:64:64-i64:64:64-f64:64:64-n1:8:16:32:64";
1022 }
1023 };
1024}
1025
1026namespace {
Chris Lattner5178f562010-03-06 21:21:27 +00001027// MBlaze abstract base class
1028class MBlazeTargetInfo : public TargetInfo {
1029 static const char * const GCCRegNames[];
1030 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1031
1032public:
1033 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Peck69bf1282010-12-12 20:56:47 +00001034 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner5178f562010-03-06 21:21:27 +00001035 }
1036
1037 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1038 unsigned &NumRecords) const {
1039 // FIXME: Implement.
1040 Records = 0;
1041 NumRecords = 0;
1042 }
1043
1044 virtual void getTargetDefines(const LangOptions &Opts,
1045 MacroBuilder &Builder) const;
1046
1047 virtual const char *getVAListDeclaration() const {
1048 return "typedef char* __builtin_va_list;";
1049 }
1050 virtual const char *getTargetPrefix() const {
1051 return "mblaze";
1052 }
1053 virtual void getGCCRegNames(const char * const *&Names,
1054 unsigned &NumNames) const;
1055 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1056 unsigned &NumAliases) const;
1057 virtual bool validateAsmConstraint(const char *&Name,
1058 TargetInfo::ConstraintInfo &Info) const {
1059 switch (*Name) {
1060 default: return false;
1061 case 'O': // Zero
1062 return true;
1063 case 'b': // Base register
1064 case 'f': // Floating point register
1065 Info.setAllowsRegister();
1066 return true;
1067 }
1068 }
1069 virtual const char *getClobbers() const {
1070 return "";
1071 }
1072};
1073
1074/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1075/// #defines that are not tied to a specific subtarget.
1076void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1077 MacroBuilder &Builder) const {
1078 // Target identification.
1079 Builder.defineMacro("__microblaze__");
1080 Builder.defineMacro("_ARCH_MICROBLAZE");
1081 Builder.defineMacro("__MICROBLAZE__");
1082
1083 // Target properties.
1084 Builder.defineMacro("_BIG_ENDIAN");
1085 Builder.defineMacro("__BIG_ENDIAN__");
1086
1087 // Subtarget options.
1088 Builder.defineMacro("__REGISTER_PREFIX__", "");
1089}
1090
1091
1092const char * const MBlazeTargetInfo::GCCRegNames[] = {
1093 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1094 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1095 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1096 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1097 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1098 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1099 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1100 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1101 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1102 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1103};
1104
1105void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1106 unsigned &NumNames) const {
1107 Names = GCCRegNames;
1108 NumNames = llvm::array_lengthof(GCCRegNames);
1109}
1110
1111const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1112 { {"f0"}, "r0" },
1113 { {"f1"}, "r1" },
1114 { {"f2"}, "r2" },
1115 { {"f3"}, "r3" },
1116 { {"f4"}, "r4" },
1117 { {"f5"}, "r5" },
1118 { {"f6"}, "r6" },
1119 { {"f7"}, "r7" },
1120 { {"f8"}, "r8" },
1121 { {"f9"}, "r9" },
1122 { {"f10"}, "r10" },
1123 { {"f11"}, "r11" },
1124 { {"f12"}, "r12" },
1125 { {"f13"}, "r13" },
1126 { {"f14"}, "r14" },
1127 { {"f15"}, "r15" },
1128 { {"f16"}, "r16" },
1129 { {"f17"}, "r17" },
1130 { {"f18"}, "r18" },
1131 { {"f19"}, "r19" },
1132 { {"f20"}, "r20" },
1133 { {"f21"}, "r21" },
1134 { {"f22"}, "r22" },
1135 { {"f23"}, "r23" },
1136 { {"f24"}, "r24" },
1137 { {"f25"}, "r25" },
1138 { {"f26"}, "r26" },
1139 { {"f27"}, "r27" },
1140 { {"f28"}, "r28" },
1141 { {"f29"}, "r29" },
1142 { {"f30"}, "r30" },
1143 { {"f31"}, "r31" },
1144};
1145
1146void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1147 unsigned &NumAliases) const {
1148 Aliases = GCCRegAliases;
1149 NumAliases = llvm::array_lengthof(GCCRegAliases);
1150}
1151} // end anonymous namespace.
1152
1153namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001154// Namespace for x86 abstract base class
1155const Builtin::Info BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00001156#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +00001157#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00001158 ALL_LANGUAGES },
Chris Lattner5abdec72009-06-14 01:05:48 +00001159#include "clang/Basic/BuiltinsX86.def"
Eli Friedman3fd920a2008-08-20 02:34:37 +00001160};
Eli Friedmanb5366062008-05-20 14:21:01 +00001161
Nuno Lopescfca1f02009-12-23 17:49:57 +00001162static const char* const GCCRegNames[] = {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001163 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1164 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher0c912c52011-07-07 22:55:26 +00001165 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman3fd920a2008-08-20 02:34:37 +00001166 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1167 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1168 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercdd36352011-06-21 00:05:20 +00001169 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopheraf643102011-12-02 02:12:16 +00001170 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1171 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman3fd920a2008-08-20 02:34:37 +00001172};
1173
Eric Christophercdd36352011-06-21 00:05:20 +00001174const TargetInfo::AddlRegName AddlRegNames[] = {
1175 { { "al", "ah", "eax", "rax" }, 0 },
1176 { { "bl", "bh", "ebx", "rbx" }, 3 },
1177 { { "cl", "ch", "ecx", "rcx" }, 2 },
1178 { { "dl", "dh", "edx", "rdx" }, 1 },
1179 { { "esi", "rsi" }, 4 },
1180 { { "edi", "rdi" }, 5 },
1181 { { "esp", "rsp" }, 7 },
1182 { { "ebp", "rbp" }, 6 },
Eli Friedman3fd920a2008-08-20 02:34:37 +00001183};
1184
1185// X86 target abstract base class; x86-32 and x86-64 are very close, so
1186// most of the implementation can be shared.
1187class X86TargetInfo : public TargetInfo {
Chris Lattner96e43572009-03-02 22:40:39 +00001188 enum X86SSEEnum {
Eli Friedman33465822011-07-08 23:31:17 +00001189 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
Chris Lattner96e43572009-03-02 22:40:39 +00001190 } SSELevel;
Eli Friedman33465822011-07-08 23:31:17 +00001191 enum MMX3DNowEnum {
1192 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1193 } MMX3DNowLevel;
Anders Carlssone437c682010-01-27 03:47:49 +00001194
Eric Christophere1ddaf92010-04-02 23:50:19 +00001195 bool HasAES;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001196 bool HasAVX;
Craig Topper865fff52011-12-17 19:55:21 +00001197 bool HasAVX2;
Craig Topper22967d42011-12-25 05:06:45 +00001198 bool HasLZCNT;
1199 bool HasBMI;
1200 bool HasBMI2;
Craig Topper1de83482011-12-29 16:10:46 +00001201 bool HasPOPCNT;
Craig Topperffdb46c2011-12-30 07:33:42 +00001202 bool HasFMA4;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001203
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001204 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1205 ///
1206 /// Each enumeration represents a particular CPU supported by Clang. These
1207 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1208 enum CPUKind {
1209 CK_Generic,
1210
1211 /// \name i386
1212 /// i386-generation processors.
1213 //@{
1214 CK_i386,
1215 //@}
1216
1217 /// \name i486
1218 /// i486-generation processors.
1219 //@{
1220 CK_i486,
1221 CK_WinChipC6,
1222 CK_WinChip2,
1223 CK_C3,
1224 //@}
1225
1226 /// \name i586
1227 /// i586-generation processors, P5 microarchitecture based.
1228 //@{
1229 CK_i586,
1230 CK_Pentium,
1231 CK_PentiumMMX,
1232 //@}
1233
1234 /// \name i686
1235 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1236 //@{
1237 CK_i686,
1238 CK_PentiumPro,
1239 CK_Pentium2,
1240 CK_Pentium3,
1241 CK_Pentium3M,
1242 CK_PentiumM,
1243 CK_C3_2,
1244
1245 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1246 /// Clang however has some logic to suport this.
1247 // FIXME: Warn, deprecate, and potentially remove this.
1248 CK_Yonah,
1249 //@}
1250
1251 /// \name Netburst
Chandler Carruth3270e262011-09-28 18:17:30 +00001252 /// Netburst microarchitecture based processors.
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001253 //@{
1254 CK_Pentium4,
1255 CK_Pentium4M,
1256 CK_Prescott,
1257 CK_Nocona,
1258 //@}
1259
1260 /// \name Core
1261 /// Core microarchitecture based processors.
1262 //@{
1263 CK_Core2,
1264
1265 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1266 /// codename which GCC no longer accepts as an option to -march, but Clang
1267 /// has some logic for recognizing it.
1268 // FIXME: Warn, deprecate, and potentially remove this.
1269 CK_Penryn,
1270 //@}
1271
1272 /// \name Atom
1273 /// Atom processors
1274 //@{
1275 CK_Atom,
1276 //@}
1277
1278 /// \name Nehalem
1279 /// Nehalem microarchitecture based processors.
1280 //@{
1281 CK_Corei7,
1282 CK_Corei7AVX,
Chandler Carruth212334f2011-09-28 08:55:37 +00001283 CK_CoreAVXi,
Craig Topper865fff52011-12-17 19:55:21 +00001284 CK_CoreAVX2,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001285 //@}
1286
1287 /// \name K6
1288 /// K6 architecture processors.
1289 //@{
1290 CK_K6,
1291 CK_K6_2,
1292 CK_K6_3,
1293 //@}
1294
1295 /// \name K7
1296 /// K7 architecture processors.
1297 //@{
1298 CK_Athlon,
1299 CK_AthlonThunderbird,
1300 CK_Athlon4,
1301 CK_AthlonXP,
1302 CK_AthlonMP,
1303 //@}
1304
1305 /// \name K8
1306 /// K8 architecture processors.
1307 //@{
1308 CK_Athlon64,
1309 CK_Athlon64SSE3,
1310 CK_AthlonFX,
1311 CK_K8,
Chandler Carruth212334f2011-09-28 08:55:37 +00001312 CK_K8SSE3,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001313 CK_Opteron,
1314 CK_OpteronSSE3,
Roman Divacky43eb6f82011-10-30 07:48:46 +00001315 CK_AMDFAM10,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001316
Benjamin Kramer6bd51592011-12-01 18:23:59 +00001317 /// \name K10
1318 /// K10 architecture processors.
1319 //@{
1320 CK_BDVER1,
1321 CK_BDVER2,
1322
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001323 /// This specification is deprecated and will be removed in the future.
1324 /// Users should prefer \see CK_K8.
1325 // FIXME: Warn on this when the CPU is set to it.
1326 CK_x86_64,
1327 //@}
1328
1329 /// \name Geode
1330 /// Geode processors.
1331 //@{
1332 CK_Geode
1333 //@}
Chandler Carruth212334f2011-09-28 08:55:37 +00001334 } CPU;
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001335
Eli Friedman3fd920a2008-08-20 02:34:37 +00001336public:
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001337 X86TargetInfo(const std::string& triple)
Eli Friedman33465822011-07-08 23:31:17 +00001338 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Craig Topper22967d42011-12-25 05:06:45 +00001339 HasAES(false), HasAVX(false), HasAVX2(false), HasLZCNT(false),
Craig Topperffdb46c2011-12-30 07:33:42 +00001340 HasBMI(false), HasBMI2(false), HasPOPCNT(false), HasFMA4(false),
1341 CPU(CK_Generic) {
Eli Friedman803acb32011-12-22 03:51:45 +00001342 BigEndian = false;
Eli Friedman3fd920a2008-08-20 02:34:37 +00001343 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner1f5ad112006-10-14 18:32:12 +00001344 }
Benjamin Kramercf501472011-12-28 15:47:06 +00001345 virtual unsigned getFloatEvalMethod() const {
1346 // X87 evaluates with 80 bits "long double" precision.
1347 return SSELevel == NoSSE ? 2 : 0;
1348 }
Chris Lattner10a5b382007-01-29 05:24:35 +00001349 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1350 unsigned &NumRecords) const {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001351 Records = BuiltinInfo;
1352 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner10a5b382007-01-29 05:24:35 +00001353 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001354 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman3fd920a2008-08-20 02:34:37 +00001355 unsigned &NumNames) const {
1356 Names = GCCRegNames;
1357 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson5fa3f342007-11-24 23:38:12 +00001358 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001359 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson5fa3f342007-11-24 23:38:12 +00001360 unsigned &NumAliases) const {
Eric Christophercdd36352011-06-21 00:05:20 +00001361 Aliases = 0;
1362 NumAliases = 0;
1363 }
1364 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1365 unsigned &NumNames) const {
1366 Names = AddlRegNames;
1367 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssona7408e72007-10-13 00:45:48 +00001368 }
Anders Carlsson58436352009-02-28 17:11:49 +00001369 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman3fd920a2008-08-20 02:34:37 +00001370 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00001371 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssonf511f642007-11-27 04:11:28 +00001372 virtual const char *getClobbers() const {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001373 return "~{dirflag},~{fpsr},~{flags}";
1374 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001375 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001376 MacroBuilder &Builder) const;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001377 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1378 const std::string &Name,
1379 bool Enabled) const;
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00001380 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00001381 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedman33465822011-07-08 23:31:17 +00001382 virtual const char* getABI() const {
Eli Friedmanbfd5add2011-12-02 00:11:43 +00001383 if (PointerWidth == 64 && HasAVX)
1384 return "avx";
1385 else if (PointerWidth == 32 && MMX3DNowLevel == NoMMX3DNow)
1386 return "no-mmx";
1387 return "";
Eli Friedman33465822011-07-08 23:31:17 +00001388 }
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001389 virtual bool setCPU(const std::string &Name) {
Chandler Carruth212334f2011-09-28 08:55:37 +00001390 CPU = llvm::StringSwitch<CPUKind>(Name)
1391 .Case("i386", CK_i386)
1392 .Case("i486", CK_i486)
1393 .Case("winchip-c6", CK_WinChipC6)
1394 .Case("winchip2", CK_WinChip2)
1395 .Case("c3", CK_C3)
1396 .Case("i586", CK_i586)
1397 .Case("pentium", CK_Pentium)
1398 .Case("pentium-mmx", CK_PentiumMMX)
1399 .Case("i686", CK_i686)
1400 .Case("pentiumpro", CK_PentiumPro)
1401 .Case("pentium2", CK_Pentium2)
1402 .Case("pentium3", CK_Pentium3)
1403 .Case("pentium3m", CK_Pentium3M)
1404 .Case("pentium-m", CK_PentiumM)
1405 .Case("c3-2", CK_C3_2)
1406 .Case("yonah", CK_Yonah)
1407 .Case("pentium4", CK_Pentium4)
1408 .Case("pentium4m", CK_Pentium4M)
1409 .Case("prescott", CK_Prescott)
1410 .Case("nocona", CK_Nocona)
1411 .Case("core2", CK_Core2)
1412 .Case("penryn", CK_Penryn)
1413 .Case("atom", CK_Atom)
1414 .Case("corei7", CK_Corei7)
1415 .Case("corei7-avx", CK_Corei7AVX)
1416 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper865fff52011-12-17 19:55:21 +00001417 .Case("core-avx2", CK_CoreAVX2)
Chandler Carruth212334f2011-09-28 08:55:37 +00001418 .Case("k6", CK_K6)
1419 .Case("k6-2", CK_K6_2)
1420 .Case("k6-3", CK_K6_3)
1421 .Case("athlon", CK_Athlon)
1422 .Case("athlon-tbird", CK_AthlonThunderbird)
1423 .Case("athlon-4", CK_Athlon4)
1424 .Case("athlon-xp", CK_AthlonXP)
1425 .Case("athlon-mp", CK_AthlonMP)
1426 .Case("athlon64", CK_Athlon64)
1427 .Case("athlon64-sse3", CK_Athlon64SSE3)
1428 .Case("athlon-fx", CK_AthlonFX)
1429 .Case("k8", CK_K8)
1430 .Case("k8-sse3", CK_K8SSE3)
1431 .Case("opteron", CK_Opteron)
1432 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky43eb6f82011-10-30 07:48:46 +00001433 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer6bd51592011-12-01 18:23:59 +00001434 .Case("bdver1", CK_BDVER1)
1435 .Case("bdver2", CK_BDVER2)
Chandler Carruth212334f2011-09-28 08:55:37 +00001436 .Case("x86-64", CK_x86_64)
1437 .Case("geode", CK_Geode)
1438 .Default(CK_Generic);
1439
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00001440 // Perform any per-CPU checks necessary to determine if this CPU is
1441 // acceptable.
1442 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1443 // invalid without explaining *why*.
1444 switch (CPU) {
1445 case CK_Generic:
1446 // No processor selected!
1447 return false;
1448
1449 case CK_i386:
1450 case CK_i486:
1451 case CK_WinChipC6:
1452 case CK_WinChip2:
1453 case CK_C3:
1454 case CK_i586:
1455 case CK_Pentium:
1456 case CK_PentiumMMX:
1457 case CK_i686:
1458 case CK_PentiumPro:
1459 case CK_Pentium2:
1460 case CK_Pentium3:
1461 case CK_Pentium3M:
1462 case CK_PentiumM:
1463 case CK_Yonah:
1464 case CK_C3_2:
1465 case CK_Pentium4:
1466 case CK_Pentium4M:
1467 case CK_Prescott:
1468 case CK_K6:
1469 case CK_K6_2:
1470 case CK_K6_3:
1471 case CK_Athlon:
1472 case CK_AthlonThunderbird:
1473 case CK_Athlon4:
1474 case CK_AthlonXP:
1475 case CK_AthlonMP:
1476 case CK_Geode:
1477 // Only accept certain architectures when compiling in 32-bit mode.
1478 if (PointerWidth != 32)
1479 return false;
1480
1481 // Fallthrough
1482 case CK_Nocona:
1483 case CK_Core2:
1484 case CK_Penryn:
1485 case CK_Atom:
1486 case CK_Corei7:
1487 case CK_Corei7AVX:
1488 case CK_CoreAVXi:
Craig Topper865fff52011-12-17 19:55:21 +00001489 case CK_CoreAVX2:
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00001490 case CK_Athlon64:
1491 case CK_Athlon64SSE3:
1492 case CK_AthlonFX:
1493 case CK_K8:
1494 case CK_K8SSE3:
1495 case CK_Opteron:
1496 case CK_OpteronSSE3:
Roman Divacky43eb6f82011-10-30 07:48:46 +00001497 case CK_AMDFAM10:
Benjamin Kramer6bd51592011-12-01 18:23:59 +00001498 case CK_BDVER1:
1499 case CK_BDVER2:
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00001500 case CK_x86_64:
1501 return true;
1502 }
Chandler Carruth7d8241c2011-09-28 10:49:06 +00001503 llvm_unreachable("Unhandled CPU kind");
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001504 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00001505};
Chris Lattnerc25d8a72009-03-02 22:20:04 +00001506
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00001507void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001508 // FIXME: This should not be here.
1509 Features["3dnow"] = false;
1510 Features["3dnowa"] = false;
1511 Features["mmx"] = false;
1512 Features["sse"] = false;
1513 Features["sse2"] = false;
1514 Features["sse3"] = false;
1515 Features["ssse3"] = false;
1516 Features["sse41"] = false;
1517 Features["sse42"] = false;
Roman Divackyce253d82011-10-30 13:47:56 +00001518 Features["sse4a"] = false;
Eric Christophere1ddaf92010-04-02 23:50:19 +00001519 Features["aes"] = false;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001520 Features["avx"] = false;
Craig Topper865fff52011-12-17 19:55:21 +00001521 Features["avx2"] = false;
Craig Topper22967d42011-12-25 05:06:45 +00001522 Features["lzcnt"] = false;
1523 Features["bmi"] = false;
1524 Features["bmi2"] = false;
Craig Topper1de83482011-12-29 16:10:46 +00001525 Features["popcnt"] = false;
Craig Topperffdb46c2011-12-30 07:33:42 +00001526 Features["fma4"] = false;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001527
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001528 // FIXME: This *really* should not be here.
1529
1530 // X86_64 always has SSE2.
1531 if (PointerWidth == 64)
1532 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1533
Chandler Carruth212334f2011-09-28 08:55:37 +00001534 switch (CPU) {
1535 case CK_Generic:
1536 case CK_i386:
1537 case CK_i486:
1538 case CK_i586:
1539 case CK_Pentium:
1540 case CK_i686:
1541 case CK_PentiumPro:
Chandler Carruth212334f2011-09-28 08:55:37 +00001542 break;
1543 case CK_PentiumMMX:
1544 case CK_Pentium2:
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001545 setFeatureEnabled(Features, "mmx", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001546 break;
1547 case CK_Pentium3:
1548 case CK_Pentium3M:
Eli Friedman33465822011-07-08 23:31:17 +00001549 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001550 setFeatureEnabled(Features, "sse", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001551 break;
1552 case CK_PentiumM:
1553 case CK_Pentium4:
1554 case CK_Pentium4M:
1555 case CK_x86_64:
Eli Friedman33465822011-07-08 23:31:17 +00001556 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001557 setFeatureEnabled(Features, "sse2", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001558 break;
1559 case CK_Yonah:
1560 case CK_Prescott:
1561 case CK_Nocona:
Eli Friedman33465822011-07-08 23:31:17 +00001562 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001563 setFeatureEnabled(Features, "sse3", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001564 break;
1565 case CK_Core2:
Eli Friedman33465822011-07-08 23:31:17 +00001566 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001567 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001568 break;
1569 case CK_Penryn:
Eli Friedman33465822011-07-08 23:31:17 +00001570 setFeatureEnabled(Features, "mmx", true);
Benjamin Kramer6dced3b2012-01-04 14:36:57 +00001571 setFeatureEnabled(Features, "sse4.1", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001572 break;
1573 case CK_Atom:
Eli Friedman33465822011-07-08 23:31:17 +00001574 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthcd99bad2011-09-28 10:36:46 +00001575 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001576 break;
1577 case CK_Corei7:
Eli Friedman33465822011-07-08 23:31:17 +00001578 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001579 setFeatureEnabled(Features, "sse4", true);
Eric Christophere1ddaf92010-04-02 23:50:19 +00001580 setFeatureEnabled(Features, "aes", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001581 break;
1582 case CK_Corei7AVX:
1583 case CK_CoreAVXi:
Eli Friedman33465822011-07-08 23:31:17 +00001584 setFeatureEnabled(Features, "mmx", true);
Roman Divacky27ec14f2011-04-05 20:32:44 +00001585 setFeatureEnabled(Features, "sse4", true);
1586 setFeatureEnabled(Features, "aes", true);
Bruno Cardoso Lopes34728382011-07-11 23:33:46 +00001587 //setFeatureEnabled(Features, "avx", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001588 break;
Craig Topper865fff52011-12-17 19:55:21 +00001589 case CK_CoreAVX2:
1590 setFeatureEnabled(Features, "mmx", true);
1591 setFeatureEnabled(Features, "sse4", true);
1592 setFeatureEnabled(Features, "aes", true);
Craig Topper22967d42011-12-25 05:06:45 +00001593 setFeatureEnabled(Features, "lzcnt", true);
1594 setFeatureEnabled(Features, "bmi", true);
1595 setFeatureEnabled(Features, "bmi2", true);
Craig Topper865fff52011-12-17 19:55:21 +00001596 //setFeatureEnabled(Features, "avx2", true);
1597 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00001598 case CK_K6:
1599 case CK_WinChipC6:
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001600 setFeatureEnabled(Features, "mmx", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001601 break;
1602 case CK_K6_2:
1603 case CK_K6_3:
Chandler Carruth212334f2011-09-28 08:55:37 +00001604 case CK_WinChip2:
1605 case CK_C3:
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001606 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001607 break;
Chandler Carruthcd99bad2011-09-28 10:36:46 +00001608 case CK_Athlon:
1609 case CK_AthlonThunderbird:
1610 case CK_Geode:
1611 setFeatureEnabled(Features, "3dnowa", true);
1612 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00001613 case CK_Athlon4:
1614 case CK_AthlonXP:
1615 case CK_AthlonMP:
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001616 setFeatureEnabled(Features, "sse", true);
1617 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001618 break;
1619 case CK_K8:
1620 case CK_Opteron:
1621 case CK_Athlon64:
1622 case CK_AthlonFX:
Mike Stump11289f42009-09-09 15:08:12 +00001623 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001624 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001625 break;
1626 case CK_K8SSE3:
1627 case CK_OpteronSSE3:
1628 case CK_Athlon64SSE3:
Roman Divackyce253d82011-10-30 13:47:56 +00001629 setFeatureEnabled(Features, "sse3", true);
1630 setFeatureEnabled(Features, "3dnowa", true);
1631 break;
Roman Divacky43eb6f82011-10-30 07:48:46 +00001632 case CK_AMDFAM10:
Roman Divackydacbfe42010-12-29 13:28:29 +00001633 setFeatureEnabled(Features, "sse3", true);
Roman Divackyce253d82011-10-30 13:47:56 +00001634 setFeatureEnabled(Features, "sse4a", true);
Roman Divackydacbfe42010-12-29 13:28:29 +00001635 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001636 break;
Benjamin Kramer6bd51592011-12-01 18:23:59 +00001637 case CK_BDVER1:
1638 case CK_BDVER2:
1639 setFeatureEnabled(Features, "sse4", true);
1640 setFeatureEnabled(Features, "sse4a", true);
1641 setFeatureEnabled(Features, "aes", true);
1642 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00001643 case CK_C3_2:
Eli Friedman33465822011-07-08 23:31:17 +00001644 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001645 setFeatureEnabled(Features, "sse", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001646 break;
Eli Friedman33465822011-07-08 23:31:17 +00001647 }
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001648}
1649
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001650bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump11289f42009-09-09 15:08:12 +00001651 const std::string &Name,
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001652 bool Enabled) const {
Eric Christopher399ffa52010-03-04 02:26:37 +00001653 // FIXME: This *really* should not be here. We need some way of translating
1654 // options into llvm subtarget features.
1655 if (!Features.count(Name) &&
1656 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001657 return false;
1658
Rafael Espindolaa6416a72011-11-27 20:00:43 +00001659 // FIXME: this should probably use a switch with fall through.
1660
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001661 if (Enabled) {
1662 if (Name == "mmx")
1663 Features["mmx"] = true;
1664 else if (Name == "sse")
Rafael Espindolaa6416a72011-11-27 20:00:43 +00001665 Features["mmx"] = Features["sse"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001666 else if (Name == "sse2")
Rafael Espindolaa6416a72011-11-27 20:00:43 +00001667 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001668 else if (Name == "sse3")
Rafael Espindolaa6416a72011-11-27 20:00:43 +00001669 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1670 true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001671 else if (Name == "ssse3")
Rafael Espindolaa6416a72011-11-27 20:00:43 +00001672 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001673 Features["ssse3"] = true;
Eric Christopher399ffa52010-03-04 02:26:37 +00001674 else if (Name == "sse4" || Name == "sse4.2")
Rafael Espindolaa6416a72011-11-27 20:00:43 +00001675 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper1de83482011-12-29 16:10:46 +00001676 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1677 Features["popcnt"] = true;
Eric Christopher399ffa52010-03-04 02:26:37 +00001678 else if (Name == "sse4.1")
Rafael Espindolaa6416a72011-11-27 20:00:43 +00001679 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopher399ffa52010-03-04 02:26:37 +00001680 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001681 else if (Name == "3dnow")
Eli Friedman33465822011-07-08 23:31:17 +00001682 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001683 else if (Name == "3dnowa")
Eli Friedman33465822011-07-08 23:31:17 +00001684 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophere1ddaf92010-04-02 23:50:19 +00001685 else if (Name == "aes")
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001686 Features["aes"] = true;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001687 else if (Name == "avx")
Rafael Espindolaa6416a72011-11-27 20:00:43 +00001688 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1689 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper1de83482011-12-29 16:10:46 +00001690 Features["popcnt"] = Features["avx"] = true;
Craig Topper865fff52011-12-17 19:55:21 +00001691 else if (Name == "avx2")
1692 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1693 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper1de83482011-12-29 16:10:46 +00001694 Features["popcnt"] = Features["avx"] = Features["avx2"] = true;
Craig Topperffdb46c2011-12-30 07:33:42 +00001695 else if (Name == "fma4")
1696 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1697 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1698 Features["popcnt"] = Features["avx"] = Features["fma4"] = true;
Roman Divackyce253d82011-10-30 13:47:56 +00001699 else if (Name == "sse4a")
Craig Topperffdb46c2011-12-30 07:33:42 +00001700 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1701 Features["sse4a"] = true;
Craig Topper22967d42011-12-25 05:06:45 +00001702 else if (Name == "lzcnt")
1703 Features["lzcnt"] = true;
1704 else if (Name == "bmi")
1705 Features["bmi"] = true;
1706 else if (Name == "bmi2")
1707 Features["bmi2"] = true;
Craig Topper1de83482011-12-29 16:10:46 +00001708 else if (Name == "popcnt")
1709 Features["popcnt"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001710 } else {
1711 if (Name == "mmx")
Eli Friedman33465822011-07-08 23:31:17 +00001712 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001713 else if (Name == "sse")
Mike Stump11289f42009-09-09 15:08:12 +00001714 Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topperffdb46c2011-12-30 07:33:42 +00001715 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1716 Features["sse4a"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001717 else if (Name == "sse2")
Mike Stump11289f42009-09-09 15:08:12 +00001718 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Craig Topperffdb46c2011-12-30 07:33:42 +00001719 Features["sse41"] = Features["sse42"] = Features["sse4a"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001720 else if (Name == "sse3")
Mike Stump11289f42009-09-09 15:08:12 +00001721 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Craig Topperffdb46c2011-12-30 07:33:42 +00001722 Features["sse42"] = Features["sse4a"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001723 else if (Name == "ssse3")
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001724 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Michael J. Spencera9e41172011-04-17 19:22:03 +00001725 else if (Name == "sse4" || Name == "sse4.1")
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001726 Features["sse41"] = Features["sse42"] = false;
Eric Christophercfeceff2010-03-04 02:31:44 +00001727 else if (Name == "sse4.2")
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001728 Features["sse42"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001729 else if (Name == "3dnow")
1730 Features["3dnow"] = Features["3dnowa"] = false;
1731 else if (Name == "3dnowa")
1732 Features["3dnowa"] = false;
Eric Christophere1ddaf92010-04-02 23:50:19 +00001733 else if (Name == "aes")
1734 Features["aes"] = false;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001735 else if (Name == "avx")
Craig Topperffdb46c2011-12-30 07:33:42 +00001736 Features["avx"] = Features["avx2"] = Features["fma4"] = false;
Craig Topper865fff52011-12-17 19:55:21 +00001737 else if (Name == "avx2")
1738 Features["avx2"] = false;
Roman Divackyce253d82011-10-30 13:47:56 +00001739 else if (Name == "sse4a")
1740 Features["sse4a"] = false;
Craig Topper22967d42011-12-25 05:06:45 +00001741 else if (Name == "lzcnt")
1742 Features["lzcnt"] = false;
1743 else if (Name == "bmi")
1744 Features["bmi"] = false;
1745 else if (Name == "bmi2")
1746 Features["bmi2"] = false;
Craig Topper1de83482011-12-29 16:10:46 +00001747 else if (Name == "popcnt")
1748 Features["popcnt"] = false;
Craig Topperffdb46c2011-12-30 07:33:42 +00001749 else if (Name == "fma4")
1750 Features["fma4"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001751 }
1752
1753 return true;
1754}
1755
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001756/// HandleTargetOptions - Perform initialization based on the user
1757/// configured set of features.
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00001758void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar979586e2009-11-11 09:38:56 +00001759 // Remember the maximum enabled sselevel.
1760 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1761 // Ignore disabled features.
1762 if (Features[i][0] == '-')
1763 continue;
1764
Eric Christophere1ddaf92010-04-02 23:50:19 +00001765 if (Features[i].substr(1) == "aes") {
1766 HasAES = true;
1767 continue;
1768 }
1769
Craig Topper22967d42011-12-25 05:06:45 +00001770 if (Features[i].substr(1) == "lzcnt") {
1771 HasLZCNT = true;
1772 continue;
1773 }
1774
1775 if (Features[i].substr(1) == "bmi") {
1776 HasBMI = true;
1777 continue;
1778 }
1779
1780 if (Features[i].substr(1) == "bmi2") {
1781 HasBMI2 = true;
1782 continue;
1783 }
1784
Craig Topper1de83482011-12-29 16:10:46 +00001785 if (Features[i].substr(1) == "popcnt") {
1786 HasPOPCNT = true;
1787 continue;
1788 }
1789
Craig Topperffdb46c2011-12-30 07:33:42 +00001790 if (Features[i].substr(1) == "fma4") {
1791 HasFMA4 = true;
1792 continue;
1793 }
1794
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001795 // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1796 // For now let it be enabled together with other SSE levels.
Craig Topper865fff52011-12-17 19:55:21 +00001797 if (Features[i].substr(1) == "avx2") {
Craig Topper865fff52011-12-17 19:55:21 +00001798 HasAVX2 = true;
1799 continue;
1800 }
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001801 if (Features[i].substr(1) == "avx") {
1802 HasAVX = true;
1803 continue;
1804 }
1805
Daniel Dunbar979586e2009-11-11 09:38:56 +00001806 assert(Features[i][0] == '+' && "Invalid target feature!");
1807 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1808 .Case("sse42", SSE42)
1809 .Case("sse41", SSE41)
1810 .Case("ssse3", SSSE3)
Nuno Lopes4cbc8bd2010-03-12 10:20:09 +00001811 .Case("sse3", SSE3)
Daniel Dunbar979586e2009-11-11 09:38:56 +00001812 .Case("sse2", SSE2)
1813 .Case("sse", SSE1)
Eli Friedman33465822011-07-08 23:31:17 +00001814 .Default(NoSSE);
Daniel Dunbar979586e2009-11-11 09:38:56 +00001815 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001816
Eli Friedman33465822011-07-08 23:31:17 +00001817 MMX3DNowEnum ThreeDNowLevel =
1818 llvm::StringSwitch<MMX3DNowEnum>(Features[i].substr(1))
Anders Carlssone437c682010-01-27 03:47:49 +00001819 .Case("3dnowa", AMD3DNowAthlon)
1820 .Case("3dnow", AMD3DNow)
Eli Friedman33465822011-07-08 23:31:17 +00001821 .Case("mmx", MMX)
1822 .Default(NoMMX3DNow);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001823
Eli Friedman33465822011-07-08 23:31:17 +00001824 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar979586e2009-11-11 09:38:56 +00001825 }
Eli Friedman33465822011-07-08 23:31:17 +00001826
1827 // Don't tell the backend if we're turning off mmx; it will end up disabling
1828 // SSE, which we don't want.
1829 std::vector<std::string>::iterator it;
1830 it = std::find(Features.begin(), Features.end(), "-mmx");
1831 if (it != Features.end())
1832 Features.erase(it);
Chris Lattnerc25d8a72009-03-02 22:20:04 +00001833}
Chris Lattnerecd49032009-03-02 22:27:17 +00001834
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001835/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
1836/// definitions for this particular subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001837void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001838 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +00001839 // Target identification.
1840 if (PointerWidth == 64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001841 Builder.defineMacro("_LP64");
1842 Builder.defineMacro("__LP64__");
1843 Builder.defineMacro("__amd64__");
1844 Builder.defineMacro("__amd64");
1845 Builder.defineMacro("__x86_64");
1846 Builder.defineMacro("__x86_64__");
Chris Lattnerecd49032009-03-02 22:27:17 +00001847 } else {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001848 DefineStd(Builder, "i386", Opts);
Chris Lattnerecd49032009-03-02 22:27:17 +00001849 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001850
Chris Lattnerecd49032009-03-02 22:27:17 +00001851 // Subtarget options.
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001852 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
1853 // truly should be based on -mtune options.
Chandler Carruth212334f2011-09-28 08:55:37 +00001854 switch (CPU) {
1855 case CK_Generic:
1856 break;
1857 case CK_i386:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001858 // The rest are coming from the i386 define above.
1859 Builder.defineMacro("__tune_i386__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001860 break;
1861 case CK_i486:
1862 case CK_WinChipC6:
1863 case CK_WinChip2:
1864 case CK_C3:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001865 Builder.defineMacro("__i486");
1866 Builder.defineMacro("__i486__");
1867 Builder.defineMacro("__tune_i486__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001868 break;
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00001869 case CK_PentiumMMX:
1870 Builder.defineMacro("__pentium_mmx__");
1871 Builder.defineMacro("__tune_pentium_mmx__");
1872 // Fallthrough
Chandler Carruth212334f2011-09-28 08:55:37 +00001873 case CK_i586:
1874 case CK_Pentium:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001875 Builder.defineMacro("__i586");
1876 Builder.defineMacro("__i586__");
1877 Builder.defineMacro("__tune_i586__");
1878 Builder.defineMacro("__pentium");
1879 Builder.defineMacro("__pentium__");
1880 Builder.defineMacro("__tune_pentium__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001881 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00001882 case CK_Pentium3:
1883 case CK_Pentium3M:
1884 case CK_PentiumM:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00001885 Builder.defineMacro("__tune_pentium3__");
1886 // Fallthrough
1887 case CK_Pentium2:
Chandler Carruth212334f2011-09-28 08:55:37 +00001888 case CK_C3_2:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00001889 Builder.defineMacro("__tune_pentium2__");
1890 // Fallthrough
1891 case CK_PentiumPro:
1892 Builder.defineMacro("__tune_i686__");
1893 Builder.defineMacro("__tune_pentiumpro__");
1894 // Fallthrough
1895 case CK_i686:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001896 Builder.defineMacro("__i686");
1897 Builder.defineMacro("__i686__");
1898 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
1899 Builder.defineMacro("__pentiumpro");
1900 Builder.defineMacro("__pentiumpro__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001901 break;
1902 case CK_Pentium4:
1903 case CK_Pentium4M:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001904 Builder.defineMacro("__pentium4");
1905 Builder.defineMacro("__pentium4__");
1906 Builder.defineMacro("__tune_pentium4__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001907 break;
1908 case CK_Yonah:
1909 case CK_Prescott:
1910 case CK_Nocona:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001911 Builder.defineMacro("__nocona");
1912 Builder.defineMacro("__nocona__");
1913 Builder.defineMacro("__tune_nocona__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001914 break;
1915 case CK_Core2:
1916 case CK_Penryn:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001917 Builder.defineMacro("__core2");
1918 Builder.defineMacro("__core2__");
1919 Builder.defineMacro("__tune_core2__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001920 break;
1921 case CK_Atom:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001922 Builder.defineMacro("__atom");
1923 Builder.defineMacro("__atom__");
1924 Builder.defineMacro("__tune_atom__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001925 break;
1926 case CK_Corei7:
1927 case CK_Corei7AVX:
1928 case CK_CoreAVXi:
Craig Topper865fff52011-12-17 19:55:21 +00001929 case CK_CoreAVX2:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001930 Builder.defineMacro("__corei7");
1931 Builder.defineMacro("__corei7__");
1932 Builder.defineMacro("__tune_corei7__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001933 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00001934 case CK_K6_2:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00001935 Builder.defineMacro("__k6_2__");
1936 Builder.defineMacro("__tune_k6_2__");
1937 // Fallthrough
Chandler Carruth212334f2011-09-28 08:55:37 +00001938 case CK_K6_3:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00001939 if (CPU != CK_K6_2) { // In case of fallthrough
1940 // FIXME: GCC may be enabling these in cases where some other k6
1941 // architecture is specified but -m3dnow is explicitly provided. The
1942 // exact semantics need to be determined and emulated here.
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001943 Builder.defineMacro("__k6_3__");
1944 Builder.defineMacro("__tune_k6_3__");
1945 }
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00001946 // Fallthrough
1947 case CK_K6:
1948 Builder.defineMacro("__k6");
1949 Builder.defineMacro("__k6__");
1950 Builder.defineMacro("__tune_k6__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001951 break;
1952 case CK_Athlon:
1953 case CK_AthlonThunderbird:
1954 case CK_Athlon4:
1955 case CK_AthlonXP:
1956 case CK_AthlonMP:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001957 Builder.defineMacro("__athlon");
1958 Builder.defineMacro("__athlon__");
1959 Builder.defineMacro("__tune_athlon__");
Chandler Carruth5d0feef2011-09-28 09:54:11 +00001960 if (SSELevel != NoSSE) {
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001961 Builder.defineMacro("__athlon_sse__");
Chandler Carruth5d0feef2011-09-28 09:54:11 +00001962 Builder.defineMacro("__tune_athlon_sse__");
1963 }
Chandler Carruth212334f2011-09-28 08:55:37 +00001964 break;
1965 case CK_K8:
1966 case CK_K8SSE3:
1967 case CK_x86_64:
1968 case CK_Opteron:
1969 case CK_OpteronSSE3:
1970 case CK_Athlon64:
1971 case CK_Athlon64SSE3:
1972 case CK_AthlonFX:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001973 Builder.defineMacro("__k8");
1974 Builder.defineMacro("__k8__");
1975 Builder.defineMacro("__tune_k8__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001976 break;
Roman Divacky43eb6f82011-10-30 07:48:46 +00001977 case CK_AMDFAM10:
1978 Builder.defineMacro("__amdfam10");
1979 Builder.defineMacro("__amdfam10__");
1980 Builder.defineMacro("__tune_amdfam10__");
1981 break;
Benjamin Kramer6bd51592011-12-01 18:23:59 +00001982 case CK_BDVER1:
1983 Builder.defineMacro("__bdver1");
1984 Builder.defineMacro("__bdver1__");
1985 Builder.defineMacro("__tune__bdver1__");
1986 break;
1987 case CK_BDVER2:
1988 Builder.defineMacro("__bdver2");
1989 Builder.defineMacro("__bdver2__");
1990 Builder.defineMacro("__tune__bdver2__");
1991 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00001992 case CK_Geode:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001993 Builder.defineMacro("__geode");
1994 Builder.defineMacro("__geode__");
1995 Builder.defineMacro("__tune_geode__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001996 break;
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001997 }
Chris Lattner96e43572009-03-02 22:40:39 +00001998
Chandler Carruth3f7ed952011-09-28 09:54:07 +00001999 // Target properties.
2000 Builder.defineMacro("__LITTLE_ENDIAN__");
2001 Builder.defineMacro("__REGISTER_PREFIX__", "");
2002
Chris Lattner6df41af2009-04-19 17:32:33 +00002003 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2004 // functions in glibc header files that use FP Stack inline asm which the
2005 // backend can't deal with (PR879).
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002006 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002007
Chandler Carruth3f7ed952011-09-28 09:54:07 +00002008 if (HasAES)
2009 Builder.defineMacro("__AES__");
2010
2011 if (HasAVX)
2012 Builder.defineMacro("__AVX__");
Craig Topper865fff52011-12-17 19:55:21 +00002013 if (HasAVX2)
2014 Builder.defineMacro("__AVX2__");
Chandler Carruth3f7ed952011-09-28 09:54:07 +00002015
Craig Topper22967d42011-12-25 05:06:45 +00002016 if (HasLZCNT)
2017 Builder.defineMacro("__LZCNT__");
2018
2019 if (HasBMI)
2020 Builder.defineMacro("__BMI__");
2021
2022 if (HasBMI2)
2023 Builder.defineMacro("__BMI2__");
2024
Craig Topper1de83482011-12-29 16:10:46 +00002025 if (HasPOPCNT)
2026 Builder.defineMacro("__POPCNT__");
2027
Craig Topperffdb46c2011-12-30 07:33:42 +00002028 if (HasFMA4)
2029 Builder.defineMacro("__FMA4__");
2030
Chris Lattner96e43572009-03-02 22:40:39 +00002031 // Each case falls through to the previous one here.
2032 switch (SSELevel) {
2033 case SSE42:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002034 Builder.defineMacro("__SSE4_2__");
Chris Lattner96e43572009-03-02 22:40:39 +00002035 case SSE41:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002036 Builder.defineMacro("__SSE4_1__");
Chris Lattner96e43572009-03-02 22:40:39 +00002037 case SSSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002038 Builder.defineMacro("__SSSE3__");
Chris Lattner96e43572009-03-02 22:40:39 +00002039 case SSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002040 Builder.defineMacro("__SSE3__");
Chris Lattner96e43572009-03-02 22:40:39 +00002041 case SSE2:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002042 Builder.defineMacro("__SSE2__");
2043 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner96e43572009-03-02 22:40:39 +00002044 case SSE1:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002045 Builder.defineMacro("__SSE__");
2046 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedman33465822011-07-08 23:31:17 +00002047 case NoSSE:
Chris Lattner96e43572009-03-02 22:40:39 +00002048 break;
2049 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00002050
Francois Pichet0706d202011-09-17 17:15:52 +00002051 if (Opts.MicrosoftExt && PointerWidth == 32) {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002052 switch (SSELevel) {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002053 case SSE42:
2054 case SSE41:
2055 case SSSE3:
2056 case SSE3:
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002057 case SSE2:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002058 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002059 break;
2060 case SSE1:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002061 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002062 break;
2063 default:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002064 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002065 }
2066 }
2067
Anders Carlssone437c682010-01-27 03:47:49 +00002068 // Each case falls through to the previous one here.
Eli Friedman33465822011-07-08 23:31:17 +00002069 switch (MMX3DNowLevel) {
Anders Carlssone437c682010-01-27 03:47:49 +00002070 case AMD3DNowAthlon:
2071 Builder.defineMacro("__3dNOW_A__");
2072 case AMD3DNow:
2073 Builder.defineMacro("__3dNOW__");
Eli Friedman33465822011-07-08 23:31:17 +00002074 case MMX:
2075 Builder.defineMacro("__MMX__");
2076 case NoMMX3DNow:
Anders Carlssone437c682010-01-27 03:47:49 +00002077 break;
2078 }
Chris Lattnerecd49032009-03-02 22:27:17 +00002079}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002080
2081
Eli Friedman3fd920a2008-08-20 02:34:37 +00002082bool
Anders Carlsson58436352009-02-28 17:11:49 +00002083X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +00002084 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson58436352009-02-28 17:11:49 +00002085 switch (*Name) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00002086 default: return false;
Dale Johannesen46742a42010-08-24 22:33:12 +00002087 case 'Y': // first letter of a pair:
2088 switch (*(Name+1)) {
2089 default: return false;
2090 case '0': // First SSE register.
2091 case 't': // Any SSE register, when SSE2 is enabled.
2092 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2093 case 'm': // any MMX register, when inter-unit moves enabled.
2094 break; // falls through to setAllowsRegister.
2095 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00002096 case 'a': // eax.
2097 case 'b': // ebx.
2098 case 'c': // ecx.
2099 case 'd': // edx.
2100 case 'S': // esi.
2101 case 'D': // edi.
2102 case 'A': // edx:eax.
Dale Johannesen46742a42010-08-24 22:33:12 +00002103 case 'f': // any x87 floating point stack register.
Eli Friedman3fd920a2008-08-20 02:34:37 +00002104 case 't': // top of floating point stack.
2105 case 'u': // second from top of floating point stack.
2106 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson83661ac2008-10-06 00:41:45 +00002107 case 'y': // Any MMX register.
Anders Carlsson5f7ee682008-10-06 19:17:39 +00002108 case 'x': // Any SSE register.
Eli Friedman3fd920a2008-08-20 02:34:37 +00002109 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen46742a42010-08-24 22:33:12 +00002110 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2111 case 'l': // "Index" registers: any general register that can be used as an
2112 // index in a base+index memory access.
2113 Info.setAllowsRegister();
2114 return true;
2115 case 'C': // SSE floating point constant.
2116 case 'G': // x87 floating point constant.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002117 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssona0b89212009-01-24 18:03:09 +00002118 // x86_64 instructions.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002119 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssona0b89212009-01-24 18:03:09 +00002120 // x86_64 instructions.
Eli Friedman3fd920a2008-08-20 02:34:37 +00002121 return true;
2122 }
Dale Johannesen46742a42010-08-24 22:33:12 +00002123 return false;
Eli Friedman3fd920a2008-08-20 02:34:37 +00002124}
2125
Dale Johannesen7d3dfc02010-10-29 23:12:32 +00002126
Eli Friedman3fd920a2008-08-20 02:34:37 +00002127std::string
Stuart Hastings7fdc6702011-06-07 23:45:05 +00002128X86TargetInfo::convertConstraint(const char *&Constraint) const {
2129 switch (*Constraint) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00002130 case 'a': return std::string("{ax}");
2131 case 'b': return std::string("{bx}");
2132 case 'c': return std::string("{cx}");
2133 case 'd': return std::string("{dx}");
2134 case 'S': return std::string("{si}");
2135 case 'D': return std::string("{di}");
Dale Johannesen70f564e2010-10-22 21:07:10 +00002136 case 'p': // address
2137 return std::string("im");
Eli Friedman3fd920a2008-08-20 02:34:37 +00002138 case 't': // top of floating point stack.
2139 return std::string("{st}");
2140 case 'u': // second from top of floating point stack.
2141 return std::string("{st(1)}"); // second from top of floating point stack.
2142 default:
Stuart Hastings7fdc6702011-06-07 23:45:05 +00002143 return std::string(1, *Constraint);
Eli Friedman3fd920a2008-08-20 02:34:37 +00002144 }
2145}
Eli Friedman3fd920a2008-08-20 02:34:37 +00002146} // end anonymous namespace
Chris Lattner5ba61f02006-10-14 07:39:34 +00002147
2148namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00002149// X86-32 generic target
2150class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00002151public:
Eli Friedman3fd920a2008-08-20 02:34:37 +00002152 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
2153 DoubleAlign = LongLongAlign = 32;
2154 LongDoubleWidth = 96;
2155 LongDoubleAlign = 32;
Nick Lewyckyf243e0d2011-12-21 04:25:47 +00002156 SuitableAlign = 128;
Eli Friedman873f65a2008-08-21 00:13:15 +00002157 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2158 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames4f4aa1a2011-10-11 00:52:51 +00002159 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman32ca82a2009-03-29 20:31:09 +00002160 SizeType = UnsignedInt;
2161 PtrDiffType = SignedInt;
2162 IntPtrType = SignedInt;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00002163 RegParmMax = 3;
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00002164
2165 // Use fpret for all types.
2166 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2167 (1 << TargetInfo::Double) |
2168 (1 << TargetInfo::LongDouble));
Eli Friedman4b72fdd2011-10-14 20:59:01 +00002169
2170 // x86-32 has atomics up to 8 bytes
2171 // FIXME: Check that we actually have cmpxchg8b before setting
2172 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2173 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman3fd920a2008-08-20 02:34:37 +00002174 }
2175 virtual const char *getVAListDeclaration() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002176 return "typedef char* __builtin_va_list;";
Eli Friedman3fd920a2008-08-20 02:34:37 +00002177 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002178
Chris Lattnerd545ad12009-09-23 06:06:36 +00002179 int getEHDataRegisterNumber(unsigned RegNo) const {
2180 if (RegNo == 0) return 0;
2181 if (RegNo == 1) return 2;
2182 return -1;
2183 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00002184};
2185} // end anonymous namespace
2186
2187namespace {
Joerg Sonnenberger16237142012-01-06 18:32:26 +00002188class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
2189public:
2190 NetBSDI386TargetInfo(const std::string &triple) :
2191 NetBSDTargetInfo<X86_32TargetInfo>(triple) {
2192 }
2193
2194 virtual unsigned getFloatEvalMethod() const {
2195 // NetBSD defaults to "double" rounding
2196 return 1;
2197 }
2198};
2199} // end anonymous namespace
2200
2201namespace {
Eli Friedmane3aa4542009-07-05 18:47:56 +00002202class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2203public:
2204 OpenBSDI386TargetInfo(const std::string& triple) :
2205 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2206 SizeType = UnsignedLong;
2207 IntPtrType = SignedLong;
Eli Friedman245f2292009-07-05 22:31:18 +00002208 PtrDiffType = SignedLong;
Eli Friedmane3aa4542009-07-05 18:47:56 +00002209 }
2210};
2211} // end anonymous namespace
2212
2213namespace {
Torok Edwinb2b37c62009-06-30 17:10:35 +00002214class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman3fd920a2008-08-20 02:34:37 +00002215public:
Torok Edwinb2b37c62009-06-30 17:10:35 +00002216 DarwinI386TargetInfo(const std::string& triple) :
2217 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00002218 LongDoubleWidth = 128;
2219 LongDoubleAlign = 128;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00002220 SuitableAlign = 128;
Eli Friedman32ca82a2009-03-29 20:31:09 +00002221 SizeType = UnsignedLong;
2222 IntPtrType = SignedLong;
Eli Friedman873f65a2008-08-21 00:13:15 +00002223 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2224 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames60b2b2e2011-10-10 23:44:43 +00002225 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbarbd606522010-05-27 00:35:16 +00002226 HasAlignMac68kSupport = true;
Torok Edwin4e054162009-06-30 17:00:25 +00002227 }
2228
Eli Friedman3fd920a2008-08-20 02:34:37 +00002229};
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002230} // end anonymous namespace
2231
2232namespace {
Eli Friedmanc968a6a2008-08-21 01:40:19 +00002233// x86-32 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002234class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedmanc968a6a2008-08-21 01:40:19 +00002235public:
2236 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002237 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmand88c8a12009-04-19 21:38:35 +00002238 TLSSupported = false;
Chris Lattner46be2e12009-06-24 17:12:15 +00002239 WCharType = UnsignedShort;
Eli Friedmanebb9e4d2009-06-08 21:16:17 +00002240 DoubleAlign = LongLongAlign = 64;
2241 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Anton Korobeynikovd7e4a092009-12-19 02:05:07 +00002242 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hames60b2b2e2011-10-10 23:44:43 +00002243 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedmanc968a6a2008-08-21 01:40:19 +00002244 }
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002245 virtual void getTargetDefines(const LangOptions &Opts,
2246 MacroBuilder &Builder) const {
2247 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2248 }
2249};
2250} // end anonymous namespace
2251
2252namespace {
2253
2254// x86-32 Windows Visual Studio target
2255class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2256public:
2257 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2258 : WindowsX86_32TargetInfo(triple) {
Eli Friedman015d6282011-03-22 21:25:11 +00002259 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002260 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2261 }
2262 virtual void getTargetDefines(const LangOptions &Opts,
2263 MacroBuilder &Builder) const {
2264 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2265 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2266 // The value of the following reflects processor type.
2267 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2268 // We lost the original triple, so we use the default.
2269 Builder.defineMacro("_M_IX86", "600");
2270 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002271};
2272} // end anonymous namespace
2273
2274namespace {
2275// x86-32 MinGW target
2276class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2277public:
2278 MinGWX86_32TargetInfo(const std::string& triple)
2279 : WindowsX86_32TargetInfo(triple) {
2280 }
2281 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002282 MacroBuilder &Builder) const {
2283 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002284 DefineStd(Builder, "WIN32", Opts);
2285 DefineStd(Builder, "WINNT", Opts);
2286 Builder.defineMacro("_X86_");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002287 Builder.defineMacro("__MSVCRT__");
2288 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumib2beb012011-03-15 02:32:50 +00002289
2290 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2291 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet0706d202011-09-17 17:15:52 +00002292 if (Opts.MicrosoftExt)
NAKAMURA Takumib2beb012011-03-15 02:32:50 +00002293 // Provide "as-is" __declspec.
2294 Builder.defineMacro("__declspec", "__declspec");
2295 else
2296 // Provide alias of __attribute__ like mingw32-gcc.
2297 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002298 }
2299};
2300} // end anonymous namespace
2301
2302namespace {
2303// x86-32 Cygwin target
2304class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2305public:
2306 CygwinX86_32TargetInfo(const std::string& triple)
2307 : X86_32TargetInfo(triple) {
2308 TLSSupported = false;
2309 WCharType = UnsignedShort;
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002310 DoubleAlign = LongLongAlign = 64;
2311 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2312 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hames60b2b2e2011-10-10 23:44:43 +00002313 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002314 }
2315 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002316 MacroBuilder &Builder) const {
2317 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2318 Builder.defineMacro("__CYGWIN__");
2319 Builder.defineMacro("__CYGWIN32__");
2320 DefineStd(Builder, "unix", Opts);
Douglas Gregor3ecc6652010-04-21 05:52:38 +00002321 if (Opts.CPlusPlus)
2322 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanaa27a872009-06-08 06:11:14 +00002323 }
Eli Friedmanc968a6a2008-08-21 01:40:19 +00002324};
2325} // end anonymous namespace
2326
2327namespace {
Chris Lattnerb986aba2010-04-11 19:29:39 +00002328// x86-32 Haiku target
2329class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2330public:
2331 HaikuX86_32TargetInfo(const std::string& triple)
2332 : X86_32TargetInfo(triple) {
2333 SizeType = UnsignedLong;
Chris Lattner8b290212010-04-22 17:48:00 +00002334 IntPtrType = SignedLong;
2335 PtrDiffType = SignedLong;
Rafael Espindolac55be6d2010-11-09 16:41:02 +00002336 this->UserLabelPrefix = "";
Eli Friedman04831922010-08-22 01:00:03 +00002337 }
Chris Lattnerb986aba2010-04-11 19:29:39 +00002338 virtual void getTargetDefines(const LangOptions &Opts,
2339 MacroBuilder &Builder) const {
2340 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2341 Builder.defineMacro("__INTEL__");
2342 Builder.defineMacro("__HAIKU__");
2343 }
2344};
2345} // end anonymous namespace
2346
Douglas Gregor9fabd852011-07-01 22:41:14 +00002347// RTEMS Target
2348template<typename Target>
2349class RTEMSTargetInfo : public OSTargetInfo<Target> {
2350protected:
2351 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2352 MacroBuilder &Builder) const {
2353 // RTEMS defines; list based off of gcc output
2354
Douglas Gregor9fabd852011-07-01 22:41:14 +00002355 Builder.defineMacro("__rtems__");
2356 Builder.defineMacro("__ELF__");
2357 }
2358public:
2359 RTEMSTargetInfo(const std::string &triple)
2360 : OSTargetInfo<Target>(triple) {
2361 this->UserLabelPrefix = "";
2362
2363 llvm::Triple Triple(triple);
2364 switch (Triple.getArch()) {
2365 default:
2366 case llvm::Triple::x86:
2367 // this->MCountName = ".mcount";
2368 break;
2369 case llvm::Triple::mips:
2370 case llvm::Triple::mipsel:
2371 case llvm::Triple::ppc:
2372 case llvm::Triple::ppc64:
2373 // this->MCountName = "_mcount";
2374 break;
2375 case llvm::Triple::arm:
2376 // this->MCountName = "__mcount";
2377 break;
2378 }
2379
2380 }
2381};
2382
2383namespace {
2384// x86-32 RTEMS target
2385class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2386public:
2387 RTEMSX86_32TargetInfo(const std::string& triple)
2388 : X86_32TargetInfo(triple) {
2389 SizeType = UnsignedLong;
2390 IntPtrType = SignedLong;
2391 PtrDiffType = SignedLong;
2392 this->UserLabelPrefix = "";
2393 }
2394 virtual void getTargetDefines(const LangOptions &Opts,
2395 MacroBuilder &Builder) const {
2396 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2397 Builder.defineMacro("__INTEL__");
2398 Builder.defineMacro("__rtems__");
2399 }
2400};
2401} // end anonymous namespace
2402
Chris Lattnerb986aba2010-04-11 19:29:39 +00002403namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00002404// x86-64 generic target
2405class X86_64TargetInfo : public X86TargetInfo {
2406public:
Chris Lattner4ba73aa02009-03-20 15:52:06 +00002407 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerba7a6c12008-05-09 06:17:04 +00002408 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedmanb5366062008-05-20 14:21:01 +00002409 LongDoubleWidth = 128;
2410 LongDoubleAlign = 128;
Rafael Espindolae971b9a2010-06-04 23:15:27 +00002411 LargeArrayMinWidth = 128;
2412 LargeArrayAlign = 128;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00002413 SuitableAlign = 128;
Chris Lattnerd0a79b22009-02-05 07:32:46 +00002414 IntMaxType = SignedLong;
2415 UIntMaxType = UnsignedLong;
Eli Friedman2857ccb2009-07-01 03:36:11 +00002416 Int64Type = SignedLong;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00002417 RegParmMax = 6;
Chris Lattnerd0a79b22009-02-05 07:32:46 +00002418
Eli Friedman873f65a2008-08-21 00:13:15 +00002419 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2420 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hames60b2b2e2011-10-10 23:44:43 +00002421 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00002422
2423 // Use fpret only for long double.
2424 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman4b72fdd2011-10-14 20:59:01 +00002425
Anders Carlsson2f1a6c32011-10-31 16:27:11 +00002426 // Use fp2ret for _Complex long double.
2427 ComplexLongDoubleUsesFP2Ret = true;
2428
Eli Friedman4b72fdd2011-10-14 20:59:01 +00002429 // x86-64 has atomics up to 16 bytes.
2430 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
2431 // on CPUs with cmpxchg16b
2432 MaxAtomicPromoteWidth = 128;
2433 MaxAtomicInlineWidth = 64;
Chris Lattner10a5b382007-01-29 05:24:35 +00002434 }
Anders Carlssona7408e72007-10-13 00:45:48 +00002435 virtual const char *getVAListDeclaration() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002436 return "typedef struct __va_list_tag {"
2437 " unsigned gp_offset;"
2438 " unsigned fp_offset;"
2439 " void* overflow_arg_area;"
2440 " void* reg_save_area;"
John McCall61d82582010-05-28 18:25:28 +00002441 "} __va_list_tag;"
Eli Friedmanfb36b022009-07-03 00:45:06 +00002442 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson5fa3f342007-11-24 23:38:12 +00002443 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00002444
Chris Lattnerd545ad12009-09-23 06:06:36 +00002445 int getEHDataRegisterNumber(unsigned RegNo) const {
2446 if (RegNo == 0) return 0;
2447 if (RegNo == 1) return 1;
2448 return -1;
2449 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00002450};
2451} // end anonymous namespace
2452
2453namespace {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002454// x86-64 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002455class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002456public:
2457 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002458 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002459 TLSSupported = false;
2460 WCharType = UnsignedShort;
Mike Stumpaf9afe92009-10-08 23:00:00 +00002461 LongWidth = LongAlign = 32;
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00002462 DoubleAlign = LongLongAlign = 64;
Nate Begeman6e8865a2010-07-21 02:02:56 +00002463 IntMaxType = SignedLongLong;
2464 UIntMaxType = UnsignedLongLong;
2465 Int64Type = SignedLongLong;
Cameron Esfahanieb856502010-09-15 00:28:12 +00002466 SizeType = UnsignedLongLong;
2467 PtrDiffType = SignedLongLong;
2468 IntPtrType = SignedLongLong;
NAKAMURA Takumif7c30222011-01-17 22:56:08 +00002469 this->UserLabelPrefix = "";
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002470 }
2471 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002472 MacroBuilder &Builder) const {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002473 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002474 Builder.defineMacro("_WIN64");
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002475 }
NAKAMURA Takumia2e468c2011-01-17 22:56:23 +00002476 virtual const char *getVAListDeclaration() const {
2477 return "typedef char* __builtin_va_list;";
2478 }
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002479};
2480} // end anonymous namespace
2481
2482namespace {
2483// x86-64 Windows Visual Studio target
2484class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2485public:
2486 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2487 : WindowsX86_64TargetInfo(triple) {
Eli Friedman015d6282011-03-22 21:25:11 +00002488 LongDoubleWidth = LongDoubleAlign = 64;
2489 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002490 }
2491 virtual void getTargetDefines(const LangOptions &Opts,
2492 MacroBuilder &Builder) const {
2493 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
2494 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002495 Builder.defineMacro("_M_X64");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002496 Builder.defineMacro("_M_AMD64");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002497 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002498};
2499} // end anonymous namespace
2500
2501namespace {
2502// x86-64 MinGW target
2503class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2504public:
2505 MinGWX86_64TargetInfo(const std::string& triple)
2506 : WindowsX86_64TargetInfo(triple) {
2507 }
2508 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002509 MacroBuilder &Builder) const {
2510 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002511 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002512 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi2b7eeb22011-03-08 12:06:46 +00002513 Builder.defineMacro("__MINGW32__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002514 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumib2beb012011-03-15 02:32:50 +00002515
2516 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2517 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet0706d202011-09-17 17:15:52 +00002518 if (Opts.MicrosoftExt)
NAKAMURA Takumib2beb012011-03-15 02:32:50 +00002519 // Provide "as-is" __declspec.
2520 Builder.defineMacro("__declspec", "__declspec");
2521 else
2522 // Provide alias of __attribute__ like mingw32-gcc.
2523 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002524 }
2525};
2526} // end anonymous namespace
2527
2528namespace {
Eli Friedman2857ccb2009-07-01 03:36:11 +00002529class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2530public:
Mike Stump11289f42009-09-09 15:08:12 +00002531 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman2857ccb2009-07-01 03:36:11 +00002532 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2533 Int64Type = SignedLongLong;
2534 }
2535};
2536} // end anonymous namespace
2537
2538namespace {
Eli Friedman245f2292009-07-05 22:31:18 +00002539class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
2540public:
Mike Stump11289f42009-09-09 15:08:12 +00002541 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman245f2292009-07-05 22:31:18 +00002542 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
2543 IntMaxType = SignedLongLong;
2544 UIntMaxType = UnsignedLongLong;
2545 Int64Type = SignedLongLong;
2546 }
2547};
2548} // end anonymous namespace
2549
2550namespace {
Eli Friedmanf05b7722008-08-20 07:44:10 +00002551class ARMTargetInfo : public TargetInfo {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002552 // Possible FPU choices.
2553 enum FPUMode {
2554 NoFPU,
2555 VFP2FPU,
2556 VFP3FPU,
2557 NeonFPU
2558 };
2559
2560 static bool FPUModeIsVFP(FPUMode Mode) {
2561 return Mode >= VFP2FPU && Mode <= NeonFPU;
2562 }
2563
2564 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2565 static const char * const GCCRegNames[];
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002566
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002567 std::string ABI, CPU;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002568
2569 unsigned FPU : 3;
2570
Daniel Dunbar893d4752009-12-19 04:15:38 +00002571 unsigned IsThumb : 1;
2572
2573 // Initialized via features.
2574 unsigned SoftFloat : 1;
2575 unsigned SoftFloatABI : 1;
Daniel Dunbarb4091a92009-09-14 00:35:03 +00002576
Chris Lattner5cc15e02010-03-03 19:03:45 +00002577 static const Builtin::Info BuiltinInfo[];
2578
Chris Lattner17df24e2008-04-21 18:56:49 +00002579public:
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00002580 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002581 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbarb4091a92009-09-14 00:35:03 +00002582 {
Eli Friedman803acb32011-12-22 03:51:45 +00002583 BigEndian = false;
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00002584 SizeType = UnsignedInt;
2585 PtrDiffType = SignedInt;
James Molloyc445be42011-11-23 13:35:08 +00002586 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
2587 WCharType = UnsignedInt;
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00002588
Chris Lattner1a8f3942010-04-23 16:29:58 +00002589 // {} in inline assembly are neon specifiers, not assembly variant
2590 // specifiers.
2591 NoAsmVariants = true;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002592
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002593 // FIXME: Should we just treat this as a feature?
Daniel Dunbarc454ecf2009-12-18 19:57:13 +00002594 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbar03184792009-09-22 21:44:58 +00002595 if (IsThumb) {
Sandeep Patelf87b3732011-04-04 22:58:12 +00002596 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2597 // so set preferred for small types to 32.
Daniel Dunbar03184792009-09-22 21:44:58 +00002598 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
2599 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hames60b2b2e2011-10-10 23:44:43 +00002600 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbar03184792009-09-22 21:44:58 +00002601 } else {
2602 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2603 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hames60b2b2e2011-10-10 23:44:43 +00002604 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbar03184792009-09-22 21:44:58 +00002605 }
John McCall86353412010-08-21 22:46:04 +00002606
2607 // ARM targets default to using the ARM C++ ABI.
2608 CXXABI = CXXABI_ARM;
Eli Friedman4b72fdd2011-10-14 20:59:01 +00002609
2610 // ARM has atomics up to 8 bytes
2611 // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e
2612 MaxAtomicPromoteWidth = 64;
Eli Friedmanb5366062008-05-20 14:21:01 +00002613 }
Daniel Dunbarb4091a92009-09-14 00:35:03 +00002614 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00002615 virtual bool setABI(const std::string &Name) {
Daniel Dunbarb4091a92009-09-14 00:35:03 +00002616 ABI = Name;
2617
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00002618 // The defaults (above) are for AAPCS, check if we need to change them.
2619 //
2620 // FIXME: We need support for -meabi... we could just mangle it into the
2621 // name.
2622 if (Name == "apcs-gnu") {
Nick Lewyckyf59e1292011-12-16 22:34:14 +00002623 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00002624 SizeType = UnsignedLong;
2625
James Molloyc445be42011-11-23 13:35:08 +00002626 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
2627 WCharType = SignedInt;
2628
Daniel Dunbarf8125062010-04-22 16:14:54 +00002629 // Do not respect the alignment of bit-field types when laying out
2630 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
2631 UseBitFieldTypeAlignment = false;
2632
Chad Rosier18903ee2011-08-04 01:21:14 +00002633 /// Do force alignment of members that follow zero length bitfields. If
2634 /// the alignment of the zero-length bitfield is greater than the member
2635 /// that follows it, `bar', `bar' will be aligned as the type of the
2636 /// zero length bitfield.
2637 UseZeroLengthBitfieldAlignment = true;
2638
2639 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosiera336c6f2011-08-04 17:52:43 +00002640 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
2641 /// gcc.
Chad Rosier18903ee2011-08-04 01:21:14 +00002642 ZeroLengthBitfieldBoundary = 32;
2643
Daniel Dunbar03184792009-09-22 21:44:58 +00002644 if (IsThumb) {
Sandeep Patelf87b3732011-04-04 22:58:12 +00002645 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2646 // so set preferred for small types to 32.
Daniel Dunbar03184792009-09-22 21:44:58 +00002647 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
Bob Wilson1957a2f2011-06-29 16:09:20 +00002648 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hames60b2b2e2011-10-10 23:44:43 +00002649 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbar03184792009-09-22 21:44:58 +00002650 } else {
2651 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Bob Wilsone3a15fe2011-04-04 16:53:11 +00002652 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hames60b2b2e2011-10-10 23:44:43 +00002653 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbar03184792009-09-22 21:44:58 +00002654 }
2655
Chad Rosier99ee7822011-07-26 07:03:04 +00002656 // FIXME: Override "preferred align" for double and long long.
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00002657 } else if (Name == "aapcs") {
2658 // FIXME: Enumerated types are variable width in straight AAPCS.
2659 } else if (Name == "aapcs-linux") {
Chad Rosier99ee7822011-07-26 07:03:04 +00002660 ;
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00002661 } else
2662 return false;
2663
2664 return true;
2665 }
Daniel Dunbar893d4752009-12-19 04:15:38 +00002666
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00002667 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002668 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
2669 Features["vfp2"] = true;
2670 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
2671 Features["neon"] = true;
2672 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002673
Daniel Dunbar893d4752009-12-19 04:15:38 +00002674 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2675 const std::string &Name,
2676 bool Enabled) const {
Evan Cheng491f56d2011-07-08 06:40:11 +00002677 if (Name == "soft-float" || Name == "soft-float-abi" ||
2678 Name == "vfp2" || Name == "vfp3" || Name == "neon") {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002679 Features[Name] = Enabled;
2680 } else
Daniel Dunbar893d4752009-12-19 04:15:38 +00002681 return false;
2682
Daniel Dunbar893d4752009-12-19 04:15:38 +00002683 return true;
2684 }
2685
2686 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002687 FPU = NoFPU;
Daniel Dunbar893d4752009-12-19 04:15:38 +00002688 SoftFloat = SoftFloatABI = false;
2689 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
2690 if (Features[i] == "+soft-float")
2691 SoftFloat = true;
2692 else if (Features[i] == "+soft-float-abi")
2693 SoftFloatABI = true;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002694 else if (Features[i] == "+vfp2")
2695 FPU = VFP2FPU;
2696 else if (Features[i] == "+vfp3")
2697 FPU = VFP3FPU;
2698 else if (Features[i] == "+neon")
2699 FPU = NeonFPU;
Daniel Dunbar893d4752009-12-19 04:15:38 +00002700 }
2701
2702 // Remove front-end specific options which the backend handles differently.
2703 std::vector<std::string>::iterator it;
2704 it = std::find(Features.begin(), Features.end(), "+soft-float");
2705 if (it != Features.end())
2706 Features.erase(it);
2707 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2708 if (it != Features.end())
2709 Features.erase(it);
2710 }
2711
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002712 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002713 return llvm::StringSwitch<const char*>(Name)
2714 .Cases("arm8", "arm810", "4")
2715 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2716 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2717 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2718 .Case("ep9312", "4T")
2719 .Cases("arm10tdmi", "arm1020t", "5T")
2720 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2721 .Case("arm926ej-s", "5TEJ")
2722 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2723 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002724 .Case("arm1136j-s", "6J")
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002725 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002726 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002727 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2728 .Cases("cortex-a8", "cortex-a9", "7A")
Bob Wilson44acad82011-01-06 16:57:20 +00002729 .Case("cortex-m3", "7M")
Bob Wilson87ba1d32011-03-21 21:55:25 +00002730 .Case("cortex-m0", "6M")
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002731 .Default(0);
2732 }
2733 virtual bool setCPU(const std::string &Name) {
2734 if (!getCPUDefineSuffix(Name))
2735 return false;
2736
2737 CPU = Name;
2738 return true;
2739 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +00002740 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002741 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +00002742 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002743 Builder.defineMacro("__arm");
2744 Builder.defineMacro("__arm__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002745
Chris Lattnerecd49032009-03-02 22:27:17 +00002746 // Target properties.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002747 Builder.defineMacro("__ARMEL__");
2748 Builder.defineMacro("__LITTLE_ENDIAN__");
2749 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002750
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002751 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002752 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002753
Mike Stump9d54bd72009-04-08 02:07:04 +00002754 // Subtarget options.
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00002755
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002756 // FIXME: It's more complicated than this and we don't really support
2757 // interworking.
2758 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002759 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002760
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002761 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002762 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002763
Daniel Dunbar893d4752009-12-19 04:15:38 +00002764 if (SoftFloat)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002765 Builder.defineMacro("__SOFTFP__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002766
2767 if (CPU == "xscale")
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002768 Builder.defineMacro("__XSCALE__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00002769
Bob Wilson19c1b882011-05-13 18:56:03 +00002770 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00002771 if (IsThumb) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002772 Builder.defineMacro("__THUMBEL__");
2773 Builder.defineMacro("__thumb__");
Bob Wilson19c1b882011-05-13 18:56:03 +00002774 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002775 Builder.defineMacro("__thumb2__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00002776 }
2777
2778 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002779 Builder.defineMacro("__APCS_32__");
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002780
2781 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002782 Builder.defineMacro("__VFP_FP__");
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002783
2784 // This only gets set when Neon instructions are actually available, unlike
2785 // the VFP define, hence the soft float and arch check. This is subtly
2786 // different from gcc, we follow the intent which was that it should be set
2787 // when Neon instructions are actually available.
Bob Wilson19c1b882011-05-13 18:56:03 +00002788 if (FPU == NeonFPU && !SoftFloat && IsARMv7)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002789 Builder.defineMacro("__ARM_NEON__");
Chris Lattner17df24e2008-04-21 18:56:49 +00002790 }
2791 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2792 unsigned &NumRecords) const {
Chris Lattner5cc15e02010-03-03 19:03:45 +00002793 Records = BuiltinInfo;
2794 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner17df24e2008-04-21 18:56:49 +00002795 }
2796 virtual const char *getVAListDeclaration() const {
John McCalle155a3d2011-05-09 02:19:37 +00002797 return "typedef void* __builtin_va_list;";
Chris Lattner17df24e2008-04-21 18:56:49 +00002798 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002799 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002800 unsigned &NumNames) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002801 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002802 unsigned &NumAliases) const;
Anders Carlsson58436352009-02-28 17:11:49 +00002803 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +00002804 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanf05b7722008-08-20 07:44:10 +00002805 // FIXME: Check if this is complete
Anders Carlsson58436352009-02-28 17:11:49 +00002806 switch (*Name) {
Eli Friedmanf05b7722008-08-20 07:44:10 +00002807 default:
Nate Begeman2908fa02008-04-22 05:03:19 +00002808 case 'l': // r0-r7
2809 case 'h': // r8-r15
2810 case 'w': // VFP Floating point register single precision
2811 case 'P': // VFP Floating point register double precision
Chris Lattnerd9725f72009-04-26 07:16:29 +00002812 Info.setAllowsRegister();
Nate Begeman2908fa02008-04-22 05:03:19 +00002813 return true;
Eric Christopherb081ba62011-07-29 21:20:35 +00002814 case 'Q': // A memory address that is a single base register.
2815 Info.setAllowsMemory();
2816 return true;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00002817 case 'U': // a memory reference...
2818 switch (Name[1]) {
2819 case 'q': // ...ARMV4 ldrsb
2820 case 'v': // ...VFP load/store (reg+constant offset)
2821 case 'y': // ...iWMMXt load/store
Eric Christopherd1048542011-06-17 01:40:49 +00002822 case 't': // address valid for load/store opaque types wider
2823 // than 128-bits
2824 case 'n': // valid address for Neon doubleword vector load/store
2825 case 'm': // valid address for Neon element and structure load/store
2826 case 's': // valid address for non-offset loads/stores of quad-word
2827 // values in four ARM registers
Stuart Hastings7fdc6702011-06-07 23:45:05 +00002828 Info.setAllowsMemory();
2829 Name++;
2830 return true;
2831 }
Nate Begeman2908fa02008-04-22 05:03:19 +00002832 }
Chris Lattner17df24e2008-04-21 18:56:49 +00002833 return false;
2834 }
Evan Chengd863adb2011-06-16 19:13:15 +00002835 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings7fdc6702011-06-07 23:45:05 +00002836 std::string R;
2837 switch (*Constraint) {
2838 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings5b7b11c2011-06-08 16:06:31 +00002839 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings7fdc6702011-06-07 23:45:05 +00002840 Constraint++;
2841 break;
Eric Christopher7d237c12011-06-17 00:40:18 +00002842 case 'p': // 'p' should be translated to 'r' by default.
2843 R = std::string("r");
2844 break;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00002845 default:
2846 return std::string(1, *Constraint);
2847 }
2848 return R;
2849 }
Chris Lattner17df24e2008-04-21 18:56:49 +00002850 virtual const char *getClobbers() const {
Eli Friedmanf05b7722008-08-20 07:44:10 +00002851 // FIXME: Is this really right?
Chris Lattner17df24e2008-04-21 18:56:49 +00002852 return "";
2853 }
2854};
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002855
2856const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbar9034aa32010-08-11 02:17:20 +00002857 // Integer registers
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002858 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00002859 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
2860
2861 // Float registers
2862 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2863 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2864 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00002865 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00002866
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00002867 // Double registers
2868 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
2869 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend2b2ad02010-10-28 01:05:37 +00002870 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
2871 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00002872
2873 // Quad registers
Dale Johannesend2b2ad02010-10-28 01:05:37 +00002874 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
2875 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002876};
2877
2878void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar256e1f32010-08-11 02:17:11 +00002879 unsigned &NumNames) const {
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002880 Names = GCCRegNames;
2881 NumNames = llvm::array_lengthof(GCCRegNames);
2882}
2883
2884const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002885 { { "a1" }, "r0" },
2886 { { "a2" }, "r1" },
2887 { { "a3" }, "r2" },
2888 { { "a4" }, "r3" },
2889 { { "v1" }, "r4" },
2890 { { "v2" }, "r5" },
2891 { { "v3" }, "r6" },
2892 { { "v4" }, "r7" },
2893 { { "v5" }, "r8" },
2894 { { "v6", "rfp" }, "r9" },
2895 { { "sl" }, "r10" },
2896 { { "fp" }, "r11" },
2897 { { "ip" }, "r12" },
Daniel Dunbar256e1f32010-08-11 02:17:11 +00002898 { { "r13" }, "sp" },
2899 { { "r14" }, "lr" },
2900 { { "r15" }, "pc" },
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00002901 // The S, D and Q registers overlap, but aren't really aliases; we
2902 // don't want to substitute one of these for a different-sized one.
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002903};
2904
2905void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2906 unsigned &NumAliases) const {
2907 Aliases = GCCRegAliases;
2908 NumAliases = llvm::array_lengthof(GCCRegAliases);
2909}
Chris Lattner5cc15e02010-03-03 19:03:45 +00002910
2911const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00002912#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +00002913#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00002914 ALL_LANGUAGES },
Chris Lattner5cc15e02010-03-03 19:03:45 +00002915#include "clang/Basic/BuiltinsARM.def"
2916};
Chris Lattner17df24e2008-04-21 18:56:49 +00002917} // end anonymous namespace.
2918
Eli Friedmanf05b7722008-08-20 07:44:10 +00002919namespace {
Mike Stump11289f42009-09-09 15:08:12 +00002920class DarwinARMTargetInfo :
Torok Edwinb2b37c62009-06-30 17:10:35 +00002921 public DarwinTargetInfo<ARMTargetInfo> {
2922protected:
Daniel Dunbar40165182009-08-24 09:10:05 +00002923 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002924 MacroBuilder &Builder) const {
Douglas Gregor20b2ebd2011-03-23 00:50:03 +00002925 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmand88c8a12009-04-19 21:38:35 +00002926 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00002927
Torok Edwinb2b37c62009-06-30 17:10:35 +00002928public:
Mike Stump11289f42009-09-09 15:08:12 +00002929 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar3eeeccd2010-05-27 07:00:26 +00002930 : DarwinTargetInfo<ARMTargetInfo>(triple) {
2931 HasAlignMac68kSupport = true;
Eli Friedman4b72fdd2011-10-14 20:59:01 +00002932 // iOS always has 64-bit atomic instructions.
2933 // FIXME: This should be based off of the target features in ARMTargetInfo.
2934 MaxAtomicInlineWidth = 64;
Daniel Dunbar3eeeccd2010-05-27 07:00:26 +00002935 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00002936};
2937} // end anonymous namespace.
2938
Tony Linthicum76329bf2011-12-12 21:14:55 +00002939
2940namespace {
2941// Hexagon abstract base class
2942class HexagonTargetInfo : public TargetInfo {
2943 static const Builtin::Info BuiltinInfo[];
2944 static const char * const GCCRegNames[];
2945 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2946 std::string CPU;
2947public:
2948 HexagonTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00002949 BigEndian = false;
Tony Linthicum76329bf2011-12-12 21:14:55 +00002950 DescriptionString = ("e-p:32:32:32-"
2951 "i64:64:64-i32:32:32-"
2952 "i16:16:16-i1:32:32-a:0:0");
2953
2954 // {} in inline assembly are packet specifiers, not assembly variant
2955 // specifiers.
2956 NoAsmVariants = true;
2957 }
2958
2959 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2960 unsigned &NumRecords) const {
2961 Records = BuiltinInfo;
2962 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
2963 }
2964
2965 virtual bool validateAsmConstraint(const char *&Name,
2966 TargetInfo::ConstraintInfo &Info) const {
2967 return true;
2968 }
2969
2970 virtual void getTargetDefines(const LangOptions &Opts,
2971 MacroBuilder &Builder) const;
2972
2973 virtual const char *getVAListDeclaration() const {
2974 return "typedef char* __builtin_va_list;";
2975 }
2976 virtual void getGCCRegNames(const char * const *&Names,
2977 unsigned &NumNames) const;
2978 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2979 unsigned &NumAliases) const;
2980 virtual const char *getClobbers() const {
2981 return "";
2982 }
2983 virtual bool setCPU(const std::string &Name) {
2984 CPU = Name;
2985 return true;
2986 }
2987};
2988
2989void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
2990 MacroBuilder &Builder) const {
2991 Builder.defineMacro("qdsp6");
2992 Builder.defineMacro("__qdsp6", "1");
2993 Builder.defineMacro("__qdsp6__", "1");
2994
2995 Builder.defineMacro("hexagon");
2996 Builder.defineMacro("__hexagon", "1");
2997 Builder.defineMacro("__hexagon__", "1");
2998
2999 if(CPU == "hexagonv1") {
3000 Builder.defineMacro("__HEXAGON_V1__");
3001 Builder.defineMacro("__HEXAGON_ARCH__", "1");
3002 if(Opts.HexagonQdsp6Compat) {
3003 Builder.defineMacro("__QDSP6_V1__");
3004 Builder.defineMacro("__QDSP6_ARCH__", "1");
3005 }
3006 }
3007 else if(CPU == "hexagonv2") {
3008 Builder.defineMacro("__HEXAGON_V2__");
3009 Builder.defineMacro("__HEXAGON_ARCH__", "2");
3010 if(Opts.HexagonQdsp6Compat) {
3011 Builder.defineMacro("__QDSP6_V2__");
3012 Builder.defineMacro("__QDSP6_ARCH__", "2");
3013 }
3014 }
3015 else if(CPU == "hexagonv3") {
3016 Builder.defineMacro("__HEXAGON_V3__");
3017 Builder.defineMacro("__HEXAGON_ARCH__", "3");
3018 if(Opts.HexagonQdsp6Compat) {
3019 Builder.defineMacro("__QDSP6_V3__");
3020 Builder.defineMacro("__QDSP6_ARCH__", "3");
3021 }
3022 }
3023 else if(CPU == "hexagonv4") {
3024 Builder.defineMacro("__HEXAGON_V4__");
3025 Builder.defineMacro("__HEXAGON_ARCH__", "4");
3026 if(Opts.HexagonQdsp6Compat) {
3027 Builder.defineMacro("__QDSP6_V4__");
3028 Builder.defineMacro("__QDSP6_ARCH__", "4");
3029 }
3030 }
3031}
3032
3033const char * const HexagonTargetInfo::GCCRegNames[] = {
3034 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3035 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3036 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3037 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
3038 "p0", "p1", "p2", "p3",
3039 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
3040};
3041
3042void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
3043 unsigned &NumNames) const {
3044 Names = GCCRegNames;
3045 NumNames = llvm::array_lengthof(GCCRegNames);
3046}
3047
3048
3049const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
3050 { { "sp" }, "r29" },
3051 { { "fp" }, "r30" },
3052 { { "lr" }, "r31" },
3053 };
3054
3055void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3056 unsigned &NumAliases) const {
3057 Aliases = GCCRegAliases;
3058 NumAliases = llvm::array_lengthof(GCCRegAliases);
3059}
3060
3061
3062const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
3063#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3064#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3065 ALL_LANGUAGES },
3066#include "clang/Basic/BuiltinsHexagon.def"
3067};
3068}
3069
3070
Chris Lattner5ba61f02006-10-14 07:39:34 +00003071namespace {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00003072class SparcV8TargetInfo : public TargetInfo {
Chris Lattner9b415d62009-01-27 01:58:38 +00003073 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3074 static const char * const GCCRegNames[];
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003075 bool SoftFloat;
Gabor Greif49991682008-02-21 16:29:08 +00003076public:
Eli Friedmanda8f5a92008-08-20 07:28:14 +00003077 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
3078 // FIXME: Support Sparc quad-precision long double?
Eli Friedman803acb32011-12-22 03:51:45 +00003079 BigEndian = false;
Eli Friedman873f65a2008-08-21 00:13:15 +00003080 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00003081 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedmanda8f5a92008-08-20 07:28:14 +00003082 }
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003083 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
3084 const std::string &Name,
3085 bool Enabled) const {
3086 if (Name == "soft-float")
3087 Features[Name] = Enabled;
3088 else
3089 return false;
3090
3091 return true;
3092 }
3093 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
3094 SoftFloat = false;
3095 for (unsigned i = 0, e = Features.size(); i != e; ++i)
3096 if (Features[i] == "+soft-float")
3097 SoftFloat = true;
3098 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +00003099 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003100 MacroBuilder &Builder) const {
3101 DefineStd(Builder, "sparc", Opts);
3102 Builder.defineMacro("__sparcv8");
3103 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00003104
3105 if (SoftFloat)
3106 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif49991682008-02-21 16:29:08 +00003107 }
3108 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3109 unsigned &NumRecords) const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00003110 // FIXME: Implement!
Gabor Greif49991682008-02-21 16:29:08 +00003111 }
3112 virtual const char *getVAListDeclaration() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00003113 return "typedef void* __builtin_va_list;";
Gabor Greif49991682008-02-21 16:29:08 +00003114 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003115 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattner9b415d62009-01-27 01:58:38 +00003116 unsigned &NumNames) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003117 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner9b415d62009-01-27 01:58:38 +00003118 unsigned &NumAliases) const;
Anders Carlsson58436352009-02-28 17:11:49 +00003119 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif49991682008-02-21 16:29:08 +00003120 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00003121 // FIXME: Implement!
3122 return false;
Gabor Greif49991682008-02-21 16:29:08 +00003123 }
3124 virtual const char *getClobbers() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00003125 // FIXME: Implement!
3126 return "";
Gabor Greif49991682008-02-21 16:29:08 +00003127 }
3128};
3129
Chris Lattner9b415d62009-01-27 01:58:38 +00003130const char * const SparcV8TargetInfo::GCCRegNames[] = {
3131 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3132 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3133 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3134 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
3135};
3136
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003137void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattner9b415d62009-01-27 01:58:38 +00003138 unsigned &NumNames) const {
3139 Names = GCCRegNames;
3140 NumNames = llvm::array_lengthof(GCCRegNames);
3141}
3142
3143const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003144 { { "g0" }, "r0" },
3145 { { "g1" }, "r1" },
3146 { { "g2" }, "r2" },
3147 { { "g3" }, "r3" },
3148 { { "g4" }, "r4" },
3149 { { "g5" }, "r5" },
3150 { { "g6" }, "r6" },
3151 { { "g7" }, "r7" },
3152 { { "o0" }, "r8" },
3153 { { "o1" }, "r9" },
3154 { { "o2" }, "r10" },
3155 { { "o3" }, "r11" },
3156 { { "o4" }, "r12" },
3157 { { "o5" }, "r13" },
3158 { { "o6", "sp" }, "r14" },
3159 { { "o7" }, "r15" },
3160 { { "l0" }, "r16" },
3161 { { "l1" }, "r17" },
3162 { { "l2" }, "r18" },
3163 { { "l3" }, "r19" },
3164 { { "l4" }, "r20" },
3165 { { "l5" }, "r21" },
3166 { { "l6" }, "r22" },
3167 { { "l7" }, "r23" },
3168 { { "i0" }, "r24" },
3169 { { "i1" }, "r25" },
3170 { { "i2" }, "r26" },
3171 { { "i3" }, "r27" },
3172 { { "i4" }, "r28" },
3173 { { "i5" }, "r29" },
3174 { { "i6", "fp" }, "r30" },
3175 { { "i7" }, "r31" },
Chris Lattner9b415d62009-01-27 01:58:38 +00003176};
3177
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003178void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner9b415d62009-01-27 01:58:38 +00003179 unsigned &NumAliases) const {
3180 Aliases = GCCRegAliases;
3181 NumAliases = llvm::array_lengthof(GCCRegAliases);
3182}
Gabor Greif49991682008-02-21 16:29:08 +00003183} // end anonymous namespace.
3184
Eli Friedmanda8f5a92008-08-20 07:28:14 +00003185namespace {
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +00003186class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
3187public:
3188 AuroraUXSparcV8TargetInfo(const std::string& triple) :
3189 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
3190 SizeType = UnsignedInt;
3191 PtrDiffType = SignedInt;
3192 }
3193};
Torok Edwinb2b37c62009-06-30 17:10:35 +00003194class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00003195public:
3196 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwinb2b37c62009-06-30 17:10:35 +00003197 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmand50881c2008-11-02 02:43:55 +00003198 SizeType = UnsignedInt;
3199 PtrDiffType = SignedInt;
Eli Friedmanda8f5a92008-08-20 07:28:14 +00003200 }
3201};
3202} // end anonymous namespace.
Chris Lattner5ba61f02006-10-14 07:39:34 +00003203
Chris Lattnerb781dc792008-05-08 05:58:21 +00003204namespace {
Anton Korobeynikova0f54372009-05-03 13:43:08 +00003205 class MSP430TargetInfo : public TargetInfo {
3206 static const char * const GCCRegNames[];
3207 public:
3208 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00003209 BigEndian = false;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00003210 TLSSupported = false;
Anton Korobeynikovcbc4e982010-01-30 12:55:11 +00003211 IntWidth = 16; IntAlign = 16;
3212 LongWidth = 32; LongLongWidth = 64;
3213 LongAlign = LongLongAlign = 16;
3214 PointerWidth = 16; PointerAlign = 16;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00003215 SuitableAlign = 16;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00003216 SizeType = UnsignedInt;
3217 IntMaxType = SignedLong;
3218 UIntMaxType = UnsignedLong;
3219 IntPtrType = SignedShort;
3220 PtrDiffType = SignedInt;
Edward O'Callaghan847f2a12009-11-21 00:49:54 +00003221 SigAtomicType = SignedLong;
Anton Korobeynikovd94329a2009-12-19 01:32:37 +00003222 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikova0f54372009-05-03 13:43:08 +00003223 }
3224 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003225 MacroBuilder &Builder) const {
3226 Builder.defineMacro("MSP430");
3227 Builder.defineMacro("__MSP430__");
Anton Korobeynikova0f54372009-05-03 13:43:08 +00003228 // FIXME: defines for different 'flavours' of MCU
3229 }
3230 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3231 unsigned &NumRecords) const {
3232 // FIXME: Implement.
3233 Records = 0;
3234 NumRecords = 0;
3235 }
Anton Korobeynikova0f54372009-05-03 13:43:08 +00003236 virtual void getGCCRegNames(const char * const *&Names,
3237 unsigned &NumNames) const;
3238 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3239 unsigned &NumAliases) const {
3240 // No aliases.
3241 Aliases = 0;
3242 NumAliases = 0;
3243 }
3244 virtual bool validateAsmConstraint(const char *&Name,
3245 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov051913b2009-10-15 23:17:13 +00003246 // No target constraints for now.
3247 return false;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00003248 }
3249 virtual const char *getClobbers() const {
3250 // FIXME: Is this really right?
3251 return "";
3252 }
3253 virtual const char *getVAListDeclaration() const {
3254 // FIXME: implement
Anton Korobeynikov2f910822009-05-08 18:24:57 +00003255 return "typedef char* __builtin_va_list;";
Anton Korobeynikova0f54372009-05-03 13:43:08 +00003256 }
3257 };
3258
3259 const char * const MSP430TargetInfo::GCCRegNames[] = {
3260 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3261 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3262 };
3263
3264 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
3265 unsigned &NumNames) const {
3266 Names = GCCRegNames;
3267 NumNames = llvm::array_lengthof(GCCRegNames);
3268 }
3269}
3270
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00003271namespace {
Eli Friedmana9c3d712009-08-19 20:47:07 +00003272
Mike Stump11289f42009-09-09 15:08:12 +00003273 // LLVM and Clang cannot be used directly to output native binaries for
3274 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmana9c3d712009-08-19 20:47:07 +00003275 // type and alignment information.
Mike Stump11289f42009-09-09 15:08:12 +00003276 //
3277 // TCE uses the llvm bitcode as input and uses it for generating customized
3278 // target processor and program binary. TCE co-design environment is
Eli Friedmana9c3d712009-08-19 20:47:07 +00003279 // publicly available in http://tce.cs.tut.fi
3280
Eli Friedman1f191002011-10-07 19:51:42 +00003281 static const unsigned TCEOpenCLAddrSpaceMap[] = {
3282 3, // opencl_global
3283 4, // opencl_local
3284 5 // opencl_constant
3285 };
3286
Eli Friedmana9c3d712009-08-19 20:47:07 +00003287 class TCETargetInfo : public TargetInfo{
3288 public:
3289 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
3290 TLSSupported = false;
3291 IntWidth = 32;
3292 LongWidth = LongLongWidth = 32;
Eli Friedmana9c3d712009-08-19 20:47:07 +00003293 PointerWidth = 32;
3294 IntAlign = 32;
3295 LongAlign = LongLongAlign = 32;
3296 PointerAlign = 32;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00003297 SuitableAlign = 32;
Eli Friedmana9c3d712009-08-19 20:47:07 +00003298 SizeType = UnsignedInt;
3299 IntMaxType = SignedLong;
3300 UIntMaxType = UnsignedLong;
3301 IntPtrType = SignedInt;
3302 PtrDiffType = SignedInt;
3303 FloatWidth = 32;
3304 FloatAlign = 32;
3305 DoubleWidth = 32;
3306 DoubleAlign = 32;
3307 LongDoubleWidth = 32;
3308 LongDoubleAlign = 32;
3309 FloatFormat = &llvm::APFloat::IEEEsingle;
3310 DoubleFormat = &llvm::APFloat::IEEEsingle;
3311 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner09797542010-03-04 21:07:38 +00003312 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
3313 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumidba4ed32011-02-18 08:44:38 +00003314 "f32:32:32-f64:32:32-v64:32:32-"
3315 "v128:32:32-a0:0:32-n32";
Eli Friedman1f191002011-10-07 19:51:42 +00003316 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmana9c3d712009-08-19 20:47:07 +00003317 }
3318
3319 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003320 MacroBuilder &Builder) const {
3321 DefineStd(Builder, "tce", Opts);
3322 Builder.defineMacro("__TCE__");
3323 Builder.defineMacro("__TCE_V1__");
Eli Friedmana9c3d712009-08-19 20:47:07 +00003324 }
3325 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3326 unsigned &NumRecords) const {}
Daniel Dunbar576d90d2009-08-24 09:54:37 +00003327 virtual const char *getClobbers() const {
3328 return "";
3329 }
Eli Friedmana9c3d712009-08-19 20:47:07 +00003330 virtual const char *getVAListDeclaration() const {
3331 return "typedef void* __builtin_va_list;";
3332 }
Eli Friedmana9c3d712009-08-19 20:47:07 +00003333 virtual void getGCCRegNames(const char * const *&Names,
3334 unsigned &NumNames) const {}
3335 virtual bool validateAsmConstraint(const char *&Name,
3336 TargetInfo::ConstraintInfo &info) const {
3337 return true;
3338 }
3339 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3340 unsigned &NumAliases) const {}
3341 };
3342}
3343
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003344namespace {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003345class MipsTargetInfoBase : public TargetInfo {
3346 std::string CPU;
3347protected:
3348 std::string ABI;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003349public:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003350 MipsTargetInfoBase(const std::string& triple, const std::string& ABIStr)
Akira Hatanaka8cc2e862011-11-05 01:48:34 +00003351 : TargetInfo(triple), ABI(ABIStr) {}
Eric Christopher0b26a612010-03-02 02:41:08 +00003352 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003353 virtual bool setABI(const std::string &Name) = 0;
Eric Christopher0b26a612010-03-02 02:41:08 +00003354 virtual bool setCPU(const std::string &Name) {
3355 CPU = Name;
3356 return true;
3357 }
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00003358 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christopher0b26a612010-03-02 02:41:08 +00003359 Features[ABI] = true;
3360 Features[CPU] = true;
3361 }
3362 virtual void getArchDefines(const LangOptions &Opts,
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003363 MacroBuilder &Builder) const = 0;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003364 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003365 MacroBuilder &Builder) const = 0;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003366 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3367 unsigned &NumRecords) const {
3368 // FIXME: Implement!
3369 }
3370 virtual const char *getVAListDeclaration() const {
3371 return "typedef void* __builtin_va_list;";
3372 }
3373 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003374 unsigned &NumNames) const {
3375 static const char * const GCCRegNames[] = {
3376 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
3377 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
3378 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
3379 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
3380 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
3381 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
3382 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
3383 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
3384 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
3385 "$fcc5","$fcc6","$fcc7"
3386 };
3387 Names = GCCRegNames;
3388 NumNames = llvm::array_lengthof(GCCRegNames);
3389 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003390 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003391 unsigned &NumAliases) const = 0;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003392 virtual bool validateAsmConstraint(const char *&Name,
3393 TargetInfo::ConstraintInfo &Info) const {
3394 switch (*Name) {
3395 default:
Douglas Gregor07216d12011-11-02 20:52:01 +00003396 return false;
3397
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003398 case 'r': // CPU registers.
3399 case 'd': // Equivalent to "r" unless generating MIPS16 code.
3400 case 'y': // Equivalent to "r", backwards compatibility only.
3401 case 'f': // floating-point registers.
3402 Info.setAllowsRegister();
3403 return true;
3404 }
3405 return false;
3406 }
3407
3408 virtual const char *getClobbers() const {
3409 // FIXME: Implement!
3410 return "";
3411 }
3412};
3413
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003414class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003415public:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003416 Mips32TargetInfoBase(const std::string& triple) :
Akira Hatanaka8cc2e862011-11-05 01:48:34 +00003417 MipsTargetInfoBase(triple, "o32") {
3418 SizeType = UnsignedInt;
3419 PtrDiffType = SignedInt;
3420 }
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003421 virtual bool setABI(const std::string &Name) {
3422 if ((Name == "o32") || (Name == "eabi")) {
3423 ABI = Name;
3424 return true;
3425 } else
3426 return false;
3427 }
3428 virtual void getArchDefines(const LangOptions &Opts,
3429 MacroBuilder &Builder) const {
Douglas Gregor7240a952011-11-09 15:17:16 +00003430 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
3431 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
3432 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
3433
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003434 if (ABI == "o32") {
3435 Builder.defineMacro("__mips_o32");
3436 Builder.defineMacro("_ABIO32", "1");
3437 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
3438 }
3439 else if (ABI == "eabi")
3440 Builder.defineMacro("__mips_eabi");
3441 else
David Blaikie83d382b2011-09-23 05:06:16 +00003442 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003443 }
3444 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3445 unsigned &NumAliases) const {
3446 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3447 { { "at" }, "$1" },
3448 { { "v0" }, "$2" },
3449 { { "v1" }, "$3" },
3450 { { "a0" }, "$4" },
3451 { { "a1" }, "$5" },
3452 { { "a2" }, "$6" },
3453 { { "a3" }, "$7" },
3454 { { "t0" }, "$8" },
3455 { { "t1" }, "$9" },
3456 { { "t2" }, "$10" },
3457 { { "t3" }, "$11" },
3458 { { "t4" }, "$12" },
3459 { { "t5" }, "$13" },
3460 { { "t6" }, "$14" },
3461 { { "t7" }, "$15" },
3462 { { "s0" }, "$16" },
3463 { { "s1" }, "$17" },
3464 { { "s2" }, "$18" },
3465 { { "s3" }, "$19" },
3466 { { "s4" }, "$20" },
3467 { { "s5" }, "$21" },
3468 { { "s6" }, "$22" },
3469 { { "s7" }, "$23" },
3470 { { "t8" }, "$24" },
3471 { { "t9" }, "$25" },
3472 { { "k0" }, "$26" },
3473 { { "k1" }, "$27" },
3474 { { "gp" }, "$28" },
3475 { { "sp" }, "$29" },
3476 { { "fp" }, "$30" },
3477 { { "ra" }, "$31" }
3478 };
3479 Aliases = GCCRegAliases;
3480 NumAliases = llvm::array_lengthof(GCCRegAliases);
3481 }
3482};
3483
3484class Mips32EBTargetInfo : public Mips32TargetInfoBase {
3485public:
3486 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
3487 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3488 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3489 }
3490 virtual void getTargetDefines(const LangOptions &Opts,
3491 MacroBuilder &Builder) const {
3492 DefineStd(Builder, "mips", Opts);
3493 Builder.defineMacro("_mips");
3494 DefineStd(Builder, "MIPSEB", Opts);
3495 Builder.defineMacro("_MIPSEB");
3496 Builder.defineMacro("__REGISTER_PREFIX__", "");
3497 getArchDefines(Opts, Builder);
3498 }
3499};
3500
3501class Mips32ELTargetInfo : public Mips32TargetInfoBase {
3502public:
3503 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00003504 BigEndian = false;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003505 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanakab579fe52011-06-02 00:09:17 +00003506 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003507 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003508 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003509 MacroBuilder &Builder) const {
3510 DefineStd(Builder, "mips", Opts);
3511 Builder.defineMacro("_mips");
3512 DefineStd(Builder, "MIPSEL", Opts);
3513 Builder.defineMacro("_MIPSEL");
3514 Builder.defineMacro("__REGISTER_PREFIX__", "");
3515 getArchDefines(Opts, Builder);
3516 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003517};
Akira Hatanakabef17452011-09-20 19:21:49 +00003518
3519class Mips64TargetInfoBase : public MipsTargetInfoBase {
3520 virtual void SetDescriptionString(const std::string &Name) = 0;
3521public:
3522 Mips64TargetInfoBase(const std::string& triple) :
Akira Hatanakac12a2712011-10-22 00:07:27 +00003523 MipsTargetInfoBase(triple, "n64") {
3524 LongWidth = LongAlign = 64;
3525 PointerWidth = PointerAlign = 64;
3526 LongDoubleWidth = LongDoubleAlign = 128;
3527 LongDoubleFormat = &llvm::APFloat::IEEEquad;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00003528 SuitableAlign = 128;
Akira Hatanakac12a2712011-10-22 00:07:27 +00003529 }
Akira Hatanakabef17452011-09-20 19:21:49 +00003530 virtual bool setABI(const std::string &Name) {
3531 SetDescriptionString(Name);
Akira Hatanakac12a2712011-10-22 00:07:27 +00003532
3533 if (Name != "n32" && Name != "n64")
Akira Hatanakabef17452011-09-20 19:21:49 +00003534 return false;
Akira Hatanakac12a2712011-10-22 00:07:27 +00003535
3536 ABI = Name;
3537
3538 if (Name == "n32") {
3539 LongWidth = LongAlign = 32;
3540 PointerWidth = PointerAlign = 32;
3541 }
3542
3543 return true;
Akira Hatanakabef17452011-09-20 19:21:49 +00003544 }
3545 virtual void getArchDefines(const LangOptions &Opts,
3546 MacroBuilder &Builder) const {
3547 if (ABI == "n32") {
3548 Builder.defineMacro("__mips_n32");
3549 Builder.defineMacro("_ABIN32", "2");
3550 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
3551 }
3552 else if (ABI == "n64") {
3553 Builder.defineMacro("__mips_n64");
3554 Builder.defineMacro("_ABI64", "3");
3555 Builder.defineMacro("_MIPS_SIM", "_ABI64");
3556 }
3557 else
David Blaikie83d382b2011-09-23 05:06:16 +00003558 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabef17452011-09-20 19:21:49 +00003559 }
3560 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3561 unsigned &NumAliases) const {
3562 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3563 { { "at" }, "$1" },
3564 { { "v0" }, "$2" },
3565 { { "v1" }, "$3" },
3566 { { "a0" }, "$4" },
3567 { { "a1" }, "$5" },
3568 { { "a2" }, "$6" },
3569 { { "a3" }, "$7" },
3570 { { "a4" }, "$8" },
3571 { { "a5" }, "$9" },
3572 { { "a6" }, "$10" },
3573 { { "a7" }, "$11" },
3574 { { "t0" }, "$12" },
3575 { { "t1" }, "$13" },
3576 { { "t2" }, "$14" },
3577 { { "t3" }, "$15" },
3578 { { "s0" }, "$16" },
3579 { { "s1" }, "$17" },
3580 { { "s2" }, "$18" },
3581 { { "s3" }, "$19" },
3582 { { "s4" }, "$20" },
3583 { { "s5" }, "$21" },
3584 { { "s6" }, "$22" },
3585 { { "s7" }, "$23" },
3586 { { "t8" }, "$24" },
3587 { { "t9" }, "$25" },
3588 { { "k0" }, "$26" },
3589 { { "k1" }, "$27" },
3590 { { "gp" }, "$28" },
3591 { { "sp" }, "$29" },
3592 { { "fp" }, "$30" },
3593 { { "ra" }, "$31" }
3594 };
3595 Aliases = GCCRegAliases;
3596 NumAliases = llvm::array_lengthof(GCCRegAliases);
3597 }
3598};
3599
3600class Mips64EBTargetInfo : public Mips64TargetInfoBase {
3601 virtual void SetDescriptionString(const std::string &Name) {
3602 // Change DescriptionString only if ABI is n32.
3603 if (Name == "n32")
3604 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanakac12a2712011-10-22 00:07:27 +00003605 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3606 "v64:64:64-n32";
Akira Hatanakabef17452011-09-20 19:21:49 +00003607 }
3608public:
3609 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3610 // Default ABI is n64.
3611 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanakac12a2712011-10-22 00:07:27 +00003612 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3613 "v64:64:64-n32";
Akira Hatanakabef17452011-09-20 19:21:49 +00003614 }
3615 virtual void getTargetDefines(const LangOptions &Opts,
3616 MacroBuilder &Builder) const {
3617 DefineStd(Builder, "mips", Opts);
3618 Builder.defineMacro("_mips");
3619 DefineStd(Builder, "MIPSEB", Opts);
3620 Builder.defineMacro("_MIPSEB");
3621 Builder.defineMacro("__REGISTER_PREFIX__", "");
3622 getArchDefines(Opts, Builder);
3623 }
3624};
3625
3626class Mips64ELTargetInfo : public Mips64TargetInfoBase {
3627 virtual void SetDescriptionString(const std::string &Name) {
3628 // Change DescriptionString only if ABI is n32.
3629 if (Name == "n32")
3630 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanakac12a2712011-10-22 00:07:27 +00003631 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
3632 "-v64:64:64-n32";
Akira Hatanakabef17452011-09-20 19:21:49 +00003633 }
3634public:
3635 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00003636 // Default ABI is n64.
3637 BigEndian = false;
Akira Hatanakabef17452011-09-20 19:21:49 +00003638 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanakac12a2712011-10-22 00:07:27 +00003639 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3640 "v64:64:64-n32";
Akira Hatanakabef17452011-09-20 19:21:49 +00003641 }
3642 virtual void getTargetDefines(const LangOptions &Opts,
3643 MacroBuilder &Builder) const {
3644 DefineStd(Builder, "mips", Opts);
3645 Builder.defineMacro("_mips");
3646 DefineStd(Builder, "MIPSEL", Opts);
3647 Builder.defineMacro("_MIPSEL");
3648 Builder.defineMacro("__REGISTER_PREFIX__", "");
3649 getArchDefines(Opts, Builder);
3650 }
3651};
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003652} // end anonymous namespace.
3653
Ivan Krasindd7403e2011-08-24 20:22:22 +00003654namespace {
3655class PNaClTargetInfo : public TargetInfo {
3656public:
3657 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00003658 BigEndian = false;
Ivan Krasindd7403e2011-08-24 20:22:22 +00003659 this->UserLabelPrefix = "";
3660 this->LongAlign = 32;
3661 this->LongWidth = 32;
3662 this->PointerAlign = 32;
3663 this->PointerWidth = 32;
3664 this->IntMaxType = TargetInfo::SignedLongLong;
3665 this->UIntMaxType = TargetInfo::UnsignedLongLong;
3666 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasin69a990b2011-08-29 22:39:12 +00003667 this->DoubleAlign = 64;
Ivan Krasin96a80612011-09-20 14:56:54 +00003668 this->LongDoubleWidth = 64;
Ivan Krasin69a990b2011-08-29 22:39:12 +00003669 this->LongDoubleAlign = 64;
Ivan Krasin96a80612011-09-20 14:56:54 +00003670 this->SizeType = TargetInfo::UnsignedInt;
3671 this->PtrDiffType = TargetInfo::SignedInt;
3672 this->IntPtrType = TargetInfo::SignedInt;
David Meyerbfdbb252011-10-11 03:12:01 +00003673 this->RegParmMax = 2;
Ivan Krasindd7403e2011-08-24 20:22:22 +00003674 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
3675 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
3676 }
3677
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00003678 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasindd7403e2011-08-24 20:22:22 +00003679 }
3680 virtual void getArchDefines(const LangOptions &Opts,
3681 MacroBuilder &Builder) const {
3682 Builder.defineMacro("__le32__");
3683 Builder.defineMacro("__pnacl__");
3684 }
3685 virtual void getTargetDefines(const LangOptions &Opts,
3686 MacroBuilder &Builder) const {
Ivan Krasin9b2cbdf2011-08-25 23:49:20 +00003687 DefineStd(Builder, "unix", Opts);
3688 Builder.defineMacro("__ELF__");
3689 if (Opts.POSIXThreads)
3690 Builder.defineMacro("_REENTRANT");
3691 if (Opts.CPlusPlus)
3692 Builder.defineMacro("_GNU_SOURCE");
3693
Ivan Krasindd7403e2011-08-24 20:22:22 +00003694 Builder.defineMacro("__native_client__");
3695 getArchDefines(Opts, Builder);
3696 }
3697 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3698 unsigned &NumRecords) const {
3699 }
3700 virtual const char *getVAListDeclaration() const {
Ivan Krasin96a80612011-09-20 14:56:54 +00003701 return "typedef int __builtin_va_list[4];";
Ivan Krasindd7403e2011-08-24 20:22:22 +00003702 }
3703 virtual void getGCCRegNames(const char * const *&Names,
3704 unsigned &NumNames) const;
3705 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3706 unsigned &NumAliases) const;
3707 virtual bool validateAsmConstraint(const char *&Name,
3708 TargetInfo::ConstraintInfo &Info) const {
3709 return false;
3710 }
3711
3712 virtual const char *getClobbers() const {
3713 return "";
3714 }
3715};
3716
3717void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
3718 unsigned &NumNames) const {
3719 Names = NULL;
3720 NumNames = 0;
3721}
3722
3723void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3724 unsigned &NumAliases) const {
3725 Aliases = NULL;
3726 NumAliases = 0;
3727}
3728} // end anonymous namespace.
3729
3730
Chris Lattner5ba61f02006-10-14 07:39:34 +00003731//===----------------------------------------------------------------------===//
3732// Driver code
3733//===----------------------------------------------------------------------===//
3734
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003735static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar52322032009-08-18 05:47:58 +00003736 llvm::Triple Triple(T);
3737 llvm::Triple::OSType os = Triple.getOS();
Eli Friedmanb5366062008-05-20 14:21:01 +00003738
Daniel Dunbar52322032009-08-18 05:47:58 +00003739 switch (Triple.getArch()) {
3740 default:
3741 return NULL;
Eli Friedmanb5366062008-05-20 14:21:01 +00003742
Tony Linthicum76329bf2011-12-12 21:14:55 +00003743 case llvm::Triple::hexagon:
3744 return new HexagonTargetInfo(T);
3745
Daniel Dunbar52322032009-08-18 05:47:58 +00003746 case llvm::Triple::arm:
Daniel Dunbar33a004e2009-09-11 01:14:50 +00003747 case llvm::Triple::thumb:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00003748 if (Triple.isOSDarwin())
3749 return new DarwinARMTargetInfo(T);
3750
Daniel Dunbar52322032009-08-18 05:47:58 +00003751 switch (os) {
Rafael Espindolaad8fed52010-06-10 00:46:51 +00003752 case llvm::Triple::Linux:
3753 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003754 case llvm::Triple::FreeBSD:
Torok Edwinb2b37c62009-06-30 17:10:35 +00003755 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003756 case llvm::Triple::NetBSD:
3757 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Douglas Gregor9fabd852011-07-01 22:41:14 +00003758 case llvm::Triple::RTEMS:
3759 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003760 default:
3761 return new ARMTargetInfo(T);
3762 }
Eli Friedmanb5366062008-05-20 14:21:01 +00003763
Daniel Dunbar52322032009-08-18 05:47:58 +00003764 case llvm::Triple::msp430:
3765 return new MSP430TargetInfo(T);
Eli Friedmanb5366062008-05-20 14:21:01 +00003766
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003767 case llvm::Triple::mips:
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00003768 switch (os) {
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00003769 case llvm::Triple::Linux:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003770 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00003771 case llvm::Triple::RTEMS:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003772 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00003773 case llvm::Triple::FreeBSD:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003774 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00003775 case llvm::Triple::NetBSD:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003776 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00003777 default:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003778 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00003779 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003780
3781 case llvm::Triple::mipsel:
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00003782 switch (os) {
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00003783 case llvm::Triple::Linux:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003784 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00003785 case llvm::Triple::RTEMS:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003786 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00003787 case llvm::Triple::FreeBSD:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003788 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00003789 case llvm::Triple::NetBSD:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003790 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00003791 default:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003792 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00003793 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003794
Akira Hatanakabef17452011-09-20 19:21:49 +00003795 case llvm::Triple::mips64:
3796 switch (os) {
3797 case llvm::Triple::Linux:
3798 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
3799 case llvm::Triple::RTEMS:
3800 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
3801 case llvm::Triple::FreeBSD:
3802 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
3803 case llvm::Triple::NetBSD:
3804 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
3805 default:
3806 return new Mips64EBTargetInfo(T);
3807 }
3808
3809 case llvm::Triple::mips64el:
3810 switch (os) {
3811 case llvm::Triple::Linux:
3812 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
3813 case llvm::Triple::RTEMS:
3814 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
3815 case llvm::Triple::FreeBSD:
3816 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
3817 case llvm::Triple::NetBSD:
3818 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
3819 default:
3820 return new Mips64ELTargetInfo(T);
3821 }
3822
Ivan Krasindd7403e2011-08-24 20:22:22 +00003823 case llvm::Triple::le32:
3824 switch (os) {
3825 case llvm::Triple::NativeClient:
3826 return new PNaClTargetInfo(T);
3827 default:
3828 return NULL;
3829 }
3830
Daniel Dunbar52322032009-08-18 05:47:58 +00003831 case llvm::Triple::ppc:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00003832 if (Triple.isOSDarwin())
Roman Divacky965b0b72011-01-06 08:27:10 +00003833 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003834 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00003835 case llvm::Triple::Linux:
3836 return new LinuxTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003837 case llvm::Triple::FreeBSD:
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00003838 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003839 case llvm::Triple::NetBSD:
3840 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
3841 case llvm::Triple::RTEMS:
Douglas Gregor9fabd852011-07-01 22:41:14 +00003842 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003843 default:
3844 return new PPC32TargetInfo(T);
3845 }
Daniel Dunbar52322032009-08-18 05:47:58 +00003846
3847 case llvm::Triple::ppc64:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00003848 if (Triple.isOSDarwin())
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00003849 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003850 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00003851 case llvm::Triple::Linux:
3852 return new LinuxTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003853 case llvm::Triple::Lv2:
John Thompsone467e192009-11-19 17:18:50 +00003854 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003855 case llvm::Triple::FreeBSD:
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00003856 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003857 case llvm::Triple::NetBSD:
3858 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
3859 default:
3860 return new PPC64TargetInfo(T);
3861 }
Daniel Dunbar52322032009-08-18 05:47:58 +00003862
Justin Holewinski514cce82011-04-20 19:34:15 +00003863 case llvm::Triple::ptx32:
3864 return new PTX32TargetInfo(T);
3865 case llvm::Triple::ptx64:
3866 return new PTX64TargetInfo(T);
3867
Chris Lattner5178f562010-03-06 21:21:27 +00003868 case llvm::Triple::mblaze:
3869 return new MBlazeTargetInfo(T);
3870
Daniel Dunbar52322032009-08-18 05:47:58 +00003871 case llvm::Triple::sparc:
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003872 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00003873 case llvm::Triple::Linux:
3874 return new LinuxTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003875 case llvm::Triple::AuroraUX:
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +00003876 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003877 case llvm::Triple::Solaris:
Daniel Dunbar52322032009-08-18 05:47:58 +00003878 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003879 case llvm::Triple::NetBSD:
3880 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
3881 case llvm::Triple::RTEMS:
Douglas Gregor9fabd852011-07-01 22:41:14 +00003882 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003883 default:
3884 return new SparcV8TargetInfo(T);
3885 }
Daniel Dunbar52322032009-08-18 05:47:58 +00003886
John Thompsone467e192009-11-19 17:18:50 +00003887 // FIXME: Need a real SPU target.
3888 case llvm::Triple::cellspu:
3889 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
3890
Eli Friedmana9c3d712009-08-19 20:47:07 +00003891 case llvm::Triple::tce:
3892 return new TCETargetInfo(T);
3893
Daniel Dunbar52322032009-08-18 05:47:58 +00003894 case llvm::Triple::x86:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00003895 if (Triple.isOSDarwin())
3896 return new DarwinI386TargetInfo(T);
3897
Daniel Dunbar52322032009-08-18 05:47:58 +00003898 switch (os) {
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +00003899 case llvm::Triple::AuroraUX:
3900 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003901 case llvm::Triple::Linux:
3902 return new LinuxTargetInfo<X86_32TargetInfo>(T);
3903 case llvm::Triple::DragonFly:
3904 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
3905 case llvm::Triple::NetBSD:
Joerg Sonnenberger16237142012-01-06 18:32:26 +00003906 return new NetBSDI386TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003907 case llvm::Triple::OpenBSD:
3908 return new OpenBSDI386TargetInfo(T);
3909 case llvm::Triple::FreeBSD:
3910 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner3e2ee142010-07-07 16:01:42 +00003911 case llvm::Triple::Minix:
3912 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003913 case llvm::Triple::Solaris:
3914 return new SolarisTargetInfo<X86_32TargetInfo>(T);
3915 case llvm::Triple::Cygwin:
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003916 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003917 case llvm::Triple::MinGW32:
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003918 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003919 case llvm::Triple::Win32:
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003920 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattnerb986aba2010-04-11 19:29:39 +00003921 case llvm::Triple::Haiku:
3922 return new HaikuX86_32TargetInfo(T);
Douglas Gregor9fabd852011-07-01 22:41:14 +00003923 case llvm::Triple::RTEMS:
3924 return new RTEMSX86_32TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003925 default:
3926 return new X86_32TargetInfo(T);
3927 }
3928
3929 case llvm::Triple::x86_64:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00003930 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
3931 return new DarwinX86_64TargetInfo(T);
3932
Daniel Dunbar52322032009-08-18 05:47:58 +00003933 switch (os) {
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +00003934 case llvm::Triple::AuroraUX:
3935 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003936 case llvm::Triple::Linux:
3937 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner002ba6b2010-01-09 05:41:14 +00003938 case llvm::Triple::DragonFly:
3939 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003940 case llvm::Triple::NetBSD:
3941 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
3942 case llvm::Triple::OpenBSD:
3943 return new OpenBSDX86_64TargetInfo(T);
3944 case llvm::Triple::FreeBSD:
3945 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
3946 case llvm::Triple::Solaris:
3947 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi31ea2f12011-02-17 08:51:38 +00003948 case llvm::Triple::MinGW32:
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003949 return new MinGWX86_64TargetInfo(T);
3950 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00003951 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003952 default:
3953 return new X86_64TargetInfo(T);
3954 }
3955 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00003956}
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003957
3958/// CreateTargetInfo - Return the target info object for the specified target
3959/// triple.
David Blaikie9c902b52011-09-25 23:23:43 +00003960TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00003961 TargetOptions &Opts) {
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003962 llvm::Triple Triple(Opts.Triple);
3963
3964 // Construct the target
3965 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
3966 if (!Target) {
3967 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
3968 return 0;
3969 }
3970
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003971 // Set the target CPU if specified.
3972 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
3973 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
3974 return 0;
3975 }
3976
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003977 // Set the target ABI if specified.
3978 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
3979 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
3980 return 0;
3981 }
3982
Charles Davis95a546e2010-06-11 01:06:47 +00003983 // Set the target C++ ABI.
John McCall86353412010-08-21 22:46:04 +00003984 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davis95a546e2010-06-11 01:06:47 +00003985 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
3986 return 0;
3987 }
3988
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003989 // Compute the default target features, we need the target to handle this
3990 // because features may have dependencies on one another.
3991 llvm::StringMap<bool> Features;
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00003992 Target->getDefaultFeatures(Features);
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003993
3994 // Apply the user specified deltas.
Rafael Espindolaa6416a72011-11-27 20:00:43 +00003995 // First the enables.
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003996 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
3997 ie = Opts.Features.end(); it != ie; ++it) {
3998 const char *Name = it->c_str();
3999
Rafael Espindolaa6416a72011-11-27 20:00:43 +00004000 if (Name[0] != '+')
4001 continue;
4002
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00004003 // Apply the feature via the target.
Rafael Espindolaa6416a72011-11-27 20:00:43 +00004004 if (!Target->setFeatureEnabled(Features, Name + 1, true)) {
4005 Diags.Report(diag::err_target_invalid_feature) << Name;
4006 return 0;
4007 }
4008 }
4009
4010 // Then the disables.
4011 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
4012 ie = Opts.Features.end(); it != ie; ++it) {
4013 const char *Name = it->c_str();
4014
4015 if (Name[0] == '+')
4016 continue;
4017
4018 // Apply the feature via the target.
4019 if (Name[0] != '-' ||
4020 !Target->setFeatureEnabled(Features, Name + 1, false)) {
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00004021 Diags.Report(diag::err_target_invalid_feature) << Name;
4022 return 0;
4023 }
4024 }
4025
4026 // Add the features to the compile options.
4027 //
4028 // FIXME: If we are completely confident that we have the right set, we only
4029 // need to pass the minuses.
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00004030 Opts.Features.clear();
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00004031 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
4032 ie = Features.end(); it != ie; ++it)
Chris Lattnerd386df42011-07-14 18:24:21 +00004033 Opts.Features.push_back(std::string(it->second ? "+" : "-") +
Chris Lattner2dc4b552011-07-14 18:45:41 +00004034 it->first().str());
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00004035 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00004036
4037 return Target.take();
4038}