blob: 3ae21d4c327133f81e94b0b04e7682da971afacd [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", "");
Eric Christopher0c912c52011-07-07 22:55:26 +0000102
John McCall31168b02011-06-15 23:02:42 +0000103 // The Objective-C bridged cast keywords are defined to nothing in non-ARC
104 // mode; then they become normal, C-style casts.
105 Builder.defineMacro("__bridge", "");
106 Builder.defineMacro("__bridge_transfer", "");
107 Builder.defineMacro("__bridge_retained", "");
John McCall0c329252011-06-17 21:23:37 +0000108 Builder.defineMacro("__bridge_retain", "");
John McCall31168b02011-06-15 23:02:42 +0000109 }
Eric Christopher0c912c52011-07-07 22:55:26 +0000110
Eli Friedmanfd4b1552009-06-04 23:00:29 +0000111 if (Opts.Static)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000112 Builder.defineMacro("__STATIC__");
Eli Friedmanfd4b1552009-06-04 23:00:29 +0000113 else
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000114 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000115
116 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000117 Builder.defineMacro("_REENTRANT");
Daniel Dunbar497ff132009-04-10 19:52:24 +0000118
Daniel Dunbarecf13562011-04-19 21:40:34 +0000119 // Get the platform type and version number from the triple.
Daniel Dunbar497ff132009-04-10 19:52:24 +0000120 unsigned Maj, Min, Rev;
Mike Stump11289f42009-09-09 15:08:12 +0000121
Daniel Dunbard86666f2010-01-26 01:44:04 +0000122 // If no version was given, default to to 10.4.0, for simplifying tests.
Daniel Dunbarecf13562011-04-19 21:40:34 +0000123 if (Triple.getOSName() == "darwin" || Triple.getOSName() == "osx") {
124 PlatformName = "macosx";
Daniel Dunbard86666f2010-01-26 01:44:04 +0000125 Min = Rev = 0;
126 Maj = 8;
Daniel Dunbarecf13562011-04-19 21:40:34 +0000127 } else {
128 // Otherwise, honor all three triple forms ("-darwinNNN[-iphoneos]",
129 // "-osxNNN", and "-iosNNN").
130
131 if (Triple.getOS() == llvm::Triple::Darwin) {
132 // For historical reasons that make little sense, the version passed here
133 // is the "darwin" version, which drops the 10 and offsets by 4.
134 Triple.getOSVersion(Maj, Min, Rev);
135
136 if (Triple.getEnvironmentName() == "iphoneos") {
137 PlatformName = "ios";
138 } else {
Daniel Dunbarecf13562011-04-19 21:40:34 +0000139 PlatformName = "macosx";
140 Rev = Min;
141 Min = Maj - 4;
142 Maj = 10;
143 }
Daniel Dunbarecf13562011-04-19 21:40:34 +0000144 } else {
Daniel Dunbarecf13562011-04-19 21:40:34 +0000145 Triple.getOSVersion(Maj, Min, Rev);
Daniel Dunbarfcd23892011-04-19 23:34:21 +0000146 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbarecf13562011-04-19 21:40:34 +0000147 }
148 }
Daniel Dunbard86666f2010-01-26 01:44:04 +0000149
Chad Rosierb90e4022011-07-19 20:00:06 +0000150 // If -ccc-host-triple arch-pc-win32-macho option specified, we're
Eric Christopherb081ba62011-07-29 21:20:35 +0000151 // generating code for Win32 ABI. No need to emit
Chad Rosierb90e4022011-07-19 20:00:06 +0000152 // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
153 if (PlatformName == "win32") {
154 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
155 return;
156 }
157
Daniel Dunbard86666f2010-01-26 01:44:04 +0000158 // Set the appropriate OS version define.
Daniel Dunbarecf13562011-04-19 21:40:34 +0000159 if (PlatformName == "ios") {
Daniel Dunbarbbd48222011-04-21 21:27:33 +0000160 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbard86666f2010-01-26 01:44:04 +0000161 char Str[6];
162 Str[0] = '0' + Maj;
163 Str[1] = '0' + (Min / 10);
164 Str[2] = '0' + (Min % 10);
165 Str[3] = '0' + (Rev / 10);
166 Str[4] = '0' + (Rev % 10);
167 Str[5] = '\0';
168 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
169 } else {
Daniel Dunbarbbd48222011-04-21 21:27:33 +0000170 // Note that the Driver allows versions which aren't representable in the
171 // define (because we only get a single digit for the minor and micro
172 // revision numbers). So, we limit them to the maximum representable
173 // version.
Daniel Dunbard86666f2010-01-26 01:44:04 +0000174 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
Daniel Dunbarbbd48222011-04-21 21:27:33 +0000175 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbard86666f2010-01-26 01:44:04 +0000176 char Str[5];
177 Str[0] = '0' + (Maj / 10);
178 Str[1] = '0' + (Maj % 10);
Daniel Dunbarbbd48222011-04-21 21:27:33 +0000179 Str[2] = '0' + std::min(Min, 9U);
180 Str[3] = '0' + std::min(Rev, 9U);
Daniel Dunbard86666f2010-01-26 01:44:04 +0000181 Str[4] = '\0';
182 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar497ff132009-04-10 19:52:24 +0000183 }
Daniel Dunbarecf13562011-04-19 21:40:34 +0000184
185 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman3fd920a2008-08-20 02:34:37 +0000186}
Chris Lattner5ba61f02006-10-14 07:39:34 +0000187
Chris Lattner30ba6742009-08-10 19:03:04 +0000188namespace {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000189template<typename Target>
190class DarwinTargetInfo : public OSTargetInfo<Target> {
191protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000192 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000193 MacroBuilder &Builder) const {
Eric Christopher0c912c52011-07-07 22:55:26 +0000194 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000195 this->PlatformMinVersion);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000196 }
Mike Stump11289f42009-09-09 15:08:12 +0000197
Torok Edwinb2b37c62009-06-30 17:10:35 +0000198public:
199 DarwinTargetInfo(const std::string& triple) :
200 OSTargetInfo<Target>(triple) {
Eric Christopherbf15d2b2011-07-02 00:20:22 +0000201 llvm::Triple T = llvm::Triple(triple);
202 this->TLSSupported = T.isMacOSX() && !T.isMacOSXVersionLT(10,7);
Daniel Dunbar13adc7f2011-02-21 23:12:51 +0000203 this->MCountName = "\01mcount";
Torok Edwinb2b37c62009-06-30 17:10:35 +0000204 }
205
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000206 virtual std::string isValidSectionSpecifier(StringRef SR) const {
Chris Lattner30ba6742009-08-10 19:03:04 +0000207 // Let MCSectionMachO validate this.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000208 StringRef Segment, Section;
Chris Lattner30ba6742009-08-10 19:03:04 +0000209 unsigned TAA, StubSize;
Daniel Dunbar75942372011-03-19 02:06:21 +0000210 bool HasTAA;
Chris Lattner30ba6742009-08-10 19:03:04 +0000211 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar75942372011-03-19 02:06:21 +0000212 TAA, HasTAA, StubSize);
Chris Lattner30ba6742009-08-10 19:03:04 +0000213 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000214
Anders Carlsson851318a2010-06-08 22:47:50 +0000215 virtual const char *getStaticInitSectionSpecifier() const {
216 // FIXME: We should return 0 when building kexts.
217 return "__TEXT,__StaticInit,regular,pure_instructions";
218 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000219
Torok Edwinb2b37c62009-06-30 17:10:35 +0000220};
221
Chris Lattner30ba6742009-08-10 19:03:04 +0000222
Torok Edwinb2b37c62009-06-30 17:10:35 +0000223// DragonFlyBSD Target
224template<typename Target>
225class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
226protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000227 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000228 MacroBuilder &Builder) const {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000229 // DragonFly defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000230 Builder.defineMacro("__DragonFly__");
231 Builder.defineMacro("__DragonFly_cc_version", "100001");
232 Builder.defineMacro("__ELF__");
233 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
234 Builder.defineMacro("__tune_i386__");
235 DefineStd(Builder, "unix", Opts);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000236 }
237public:
Mike Stump11289f42009-09-09 15:08:12 +0000238 DragonFlyBSDTargetInfo(const std::string &triple)
Torok Edwinb2b37c62009-06-30 17:10:35 +0000239 : OSTargetInfo<Target>(triple) {}
240};
241
242// FreeBSD Target
243template<typename Target>
244class FreeBSDTargetInfo : public OSTargetInfo<Target> {
245protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000246 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000247 MacroBuilder &Builder) const {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000248 // FreeBSD defines; list based off of gcc output
249
Daniel Dunbar40165182009-08-24 09:10:05 +0000250 // FIXME: Move version number handling to llvm::Triple.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000251 StringRef Release = Triple.getOSName().substr(strlen("freebsd"), 1);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000252
Benjamin Kramer31a68e72010-01-30 19:55:01 +0000253 Builder.defineMacro("__FreeBSD__", Release);
254 Builder.defineMacro("__FreeBSD_cc_version", Release + "00001");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000255 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
256 DefineStd(Builder, "unix", Opts);
257 Builder.defineMacro("__ELF__");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000258 }
259public:
Mike Stump11289f42009-09-09 15:08:12 +0000260 FreeBSDTargetInfo(const std::string &triple)
Duncan Sands9cb27e92009-07-08 13:55:08 +0000261 : OSTargetInfo<Target>(triple) {
262 this->UserLabelPrefix = "";
Roman Divacky178e01602011-02-10 16:52:03 +0000263
264 llvm::Triple Triple(triple);
265 switch (Triple.getArch()) {
266 default:
267 case llvm::Triple::x86:
268 case llvm::Triple::x86_64:
269 this->MCountName = ".mcount";
270 break;
271 case llvm::Triple::mips:
272 case llvm::Triple::mipsel:
273 case llvm::Triple::ppc:
274 case llvm::Triple::ppc64:
275 this->MCountName = "_mcount";
276 break;
277 case llvm::Triple::arm:
278 this->MCountName = "__mcount";
279 break;
280 }
281
Duncan Sands9cb27e92009-07-08 13:55:08 +0000282 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000283};
284
Chris Lattner3e2ee142010-07-07 16:01:42 +0000285// Minix Target
286template<typename Target>
287class MinixTargetInfo : public OSTargetInfo<Target> {
288protected:
289 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
290 MacroBuilder &Builder) const {
291 // Minix defines
292
293 Builder.defineMacro("__minix", "3");
294 Builder.defineMacro("_EM_WSIZE", "4");
295 Builder.defineMacro("_EM_PSIZE", "4");
296 Builder.defineMacro("_EM_SSIZE", "2");
297 Builder.defineMacro("_EM_LSIZE", "4");
298 Builder.defineMacro("_EM_FSIZE", "4");
299 Builder.defineMacro("_EM_DSIZE", "8");
300 DefineStd(Builder, "unix", Opts);
301 }
302public:
303 MinixTargetInfo(const std::string &triple)
304 : OSTargetInfo<Target>(triple) {
305 this->UserLabelPrefix = "";
306 }
307};
308
Torok Edwinb2b37c62009-06-30 17:10:35 +0000309// Linux target
310template<typename Target>
311class LinuxTargetInfo : public OSTargetInfo<Target> {
312protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000313 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000314 MacroBuilder &Builder) const {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000315 // Linux defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000316 DefineStd(Builder, "unix", Opts);
317 DefineStd(Builder, "linux", Opts);
318 Builder.defineMacro("__gnu_linux__");
319 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000320 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000321 Builder.defineMacro("_REENTRANT");
Douglas Gregor3ecc6652010-04-21 05:52:38 +0000322 if (Opts.CPlusPlus)
323 Builder.defineMacro("_GNU_SOURCE");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000324 }
325public:
Mike Stump11289f42009-09-09 15:08:12 +0000326 LinuxTargetInfo(const std::string& triple)
Torok Edwinb2b37c62009-06-30 17:10:35 +0000327 : OSTargetInfo<Target>(triple) {
328 this->UserLabelPrefix = "";
Douglas Gregore6d6e512011-01-12 21:19:25 +0000329 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwinb2b37c62009-06-30 17:10:35 +0000330 }
331};
332
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000333// NetBSD Target
334template<typename Target>
335class NetBSDTargetInfo : public OSTargetInfo<Target> {
336protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000337 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000338 MacroBuilder &Builder) const {
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000339 // NetBSD defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000340 Builder.defineMacro("__NetBSD__");
341 Builder.defineMacro("__unix__");
342 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000343 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000344 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000345 }
346public:
Mike Stump11289f42009-09-09 15:08:12 +0000347 NetBSDTargetInfo(const std::string &triple)
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000348 : OSTargetInfo<Target>(triple) {
349 this->UserLabelPrefix = "";
350 }
351};
352
Torok Edwinb2b37c62009-06-30 17:10:35 +0000353// OpenBSD Target
354template<typename Target>
355class OpenBSDTargetInfo : public OSTargetInfo<Target> {
356protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000357 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000358 MacroBuilder &Builder) const {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000359 // OpenBSD defines; list based off of gcc output
360
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000361 Builder.defineMacro("__OpenBSD__");
362 DefineStd(Builder, "unix", Opts);
363 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000364 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000365 Builder.defineMacro("_POSIX_THREADS");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000366 }
367public:
Mike Stump11289f42009-09-09 15:08:12 +0000368 OpenBSDTargetInfo(const std::string &triple)
Torok Edwinb2b37c62009-06-30 17:10:35 +0000369 : OSTargetInfo<Target>(triple) {}
370};
371
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000372// PSP Target
373template<typename Target>
374class PSPTargetInfo : public OSTargetInfo<Target> {
375protected:
376 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000377 MacroBuilder &Builder) const {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000378 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000379 Builder.defineMacro("PSP");
380 Builder.defineMacro("_PSP");
381 Builder.defineMacro("__psp__");
382 Builder.defineMacro("__ELF__");
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000383 }
384public:
385 PSPTargetInfo(const std::string& triple)
386 : OSTargetInfo<Target>(triple) {
387 this->UserLabelPrefix = "";
388 }
389};
390
John Thompsone467e192009-11-19 17:18:50 +0000391// PS3 PPU Target
392template<typename Target>
393class PS3PPUTargetInfo : public OSTargetInfo<Target> {
394protected:
395 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000396 MacroBuilder &Builder) const {
John Thompsone467e192009-11-19 17:18:50 +0000397 // PS3 PPU defines.
John Thompson957816f2010-03-25 16:18:32 +0000398 Builder.defineMacro("__PPC__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000399 Builder.defineMacro("__PPU__");
400 Builder.defineMacro("__CELLOS_LV2__");
401 Builder.defineMacro("__ELF__");
402 Builder.defineMacro("__LP32__");
John Thompson07a61a42010-06-24 22:44:13 +0000403 Builder.defineMacro("_ARCH_PPC64");
404 Builder.defineMacro("__powerpc64__");
John Thompsone467e192009-11-19 17:18:50 +0000405 }
406public:
407 PS3PPUTargetInfo(const std::string& triple)
408 : OSTargetInfo<Target>(triple) {
409 this->UserLabelPrefix = "";
John Thompson6f8dba72009-12-18 14:21:08 +0000410 this->LongWidth = this->LongAlign = this->PointerWidth = this->PointerAlign = 32;
John Thompson07a61a42010-06-24 22:44:13 +0000411 this->IntMaxType = TargetInfo::SignedLongLong;
412 this->UIntMaxType = TargetInfo::UnsignedLongLong;
413 this->Int64Type = TargetInfo::SignedLongLong;
John Thompson6f8dba72009-12-18 14:21:08 +0000414 this->SizeType = TargetInfo::UnsignedInt;
John Thompson07a61a42010-06-24 22:44:13 +0000415 this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
416 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompsone467e192009-11-19 17:18:50 +0000417 }
418};
419
420// FIXME: Need a real SPU target.
421// PS3 SPU Target
422template<typename Target>
423class PS3SPUTargetInfo : public OSTargetInfo<Target> {
424protected:
425 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000426 MacroBuilder &Builder) const {
John Thompsone467e192009-11-19 17:18:50 +0000427 // PS3 PPU defines.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000428 Builder.defineMacro("__SPU__");
429 Builder.defineMacro("__ELF__");
John Thompsone467e192009-11-19 17:18:50 +0000430 }
431public:
432 PS3SPUTargetInfo(const std::string& triple)
433 : OSTargetInfo<Target>(triple) {
434 this->UserLabelPrefix = "";
435 }
436};
437
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +0000438// AuroraUX target
439template<typename Target>
440class AuroraUXTargetInfo : public OSTargetInfo<Target> {
441protected:
442 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000443 MacroBuilder &Builder) const {
444 DefineStd(Builder, "sun", Opts);
445 DefineStd(Builder, "unix", Opts);
446 Builder.defineMacro("__ELF__");
447 Builder.defineMacro("__svr4__");
448 Builder.defineMacro("__SVR4");
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +0000449 }
450public:
451 AuroraUXTargetInfo(const std::string& triple)
452 : OSTargetInfo<Target>(triple) {
453 this->UserLabelPrefix = "";
454 this->WCharType = this->SignedLong;
455 // FIXME: WIntType should be SignedLong
456 }
457};
458
Torok Edwinb2b37c62009-06-30 17:10:35 +0000459// Solaris target
460template<typename Target>
461class SolarisTargetInfo : public OSTargetInfo<Target> {
462protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000463 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000464 MacroBuilder &Builder) const {
465 DefineStd(Builder, "sun", Opts);
466 DefineStd(Builder, "unix", Opts);
467 Builder.defineMacro("__ELF__");
468 Builder.defineMacro("__svr4__");
469 Builder.defineMacro("__SVR4");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000470 }
471public:
Mike Stump11289f42009-09-09 15:08:12 +0000472 SolarisTargetInfo(const std::string& triple)
Torok Edwinb2b37c62009-06-30 17:10:35 +0000473 : OSTargetInfo<Target>(triple) {
474 this->UserLabelPrefix = "";
475 this->WCharType = this->SignedLong;
476 // FIXME: WIntType should be SignedLong
477 }
478};
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000479
480// Windows target
481template<typename Target>
482class WindowsTargetInfo : public OSTargetInfo<Target> {
483protected:
484 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
485 MacroBuilder &Builder) const {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +0000486 Builder.defineMacro("_WIN32");
487 }
488 void getVisualStudioDefines(const LangOptions &Opts,
489 MacroBuilder &Builder) const {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000490 if (Opts.CPlusPlus) {
491 if (Opts.RTTI)
492 Builder.defineMacro("_CPPRTTI");
493
494 if (Opts.Exceptions)
495 Builder.defineMacro("_CPPUNWIND");
496 }
497
498 if (!Opts.CharIsSigned)
499 Builder.defineMacro("_CHAR_UNSIGNED");
500
501 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
502 // but it works for now.
503 if (Opts.POSIXThreads)
504 Builder.defineMacro("_MT");
Michael J. Spencer54bf3c32010-10-21 08:22:51 +0000505
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000506 if (Opts.MSCVersion != 0)
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000507 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000508
Francois Pichet0706d202011-09-17 17:15:52 +0000509 if (Opts.MicrosoftExt) {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000510 Builder.defineMacro("_MSC_EXTENSIONS");
511
512 if (Opts.CPlusPlus0x) {
513 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
514 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
515 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
516 }
517 }
518
519 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000520 }
521
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000522public:
523 WindowsTargetInfo(const std::string &triple)
524 : OSTargetInfo<Target>(triple) {}
525};
526
Mike Stump11289f42009-09-09 15:08:12 +0000527} // end anonymous namespace.
Torok Edwinb2b37c62009-06-30 17:10:35 +0000528
Chris Lattner09d98f52008-10-05 21:50:58 +0000529//===----------------------------------------------------------------------===//
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000530// Specific target implementations.
531//===----------------------------------------------------------------------===//
Anders Carlssona7408e72007-10-13 00:45:48 +0000532
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000533namespace {
534// PPC abstract base class
535class PPCTargetInfo : public TargetInfo {
536 static const Builtin::Info BuiltinInfo[];
537 static const char * const GCCRegNames[];
538 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000539public:
Eli Friedman9ffd4a92009-06-05 07:05:05 +0000540 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
541
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000542 virtual void getTargetBuiltins(const Builtin::Info *&Records,
543 unsigned &NumRecords) const {
Chris Lattner10a5b382007-01-29 05:24:35 +0000544 Records = BuiltinInfo;
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000545 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner10a5b382007-01-29 05:24:35 +0000546 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000547
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000548 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000549 MacroBuilder &Builder) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000550
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000551 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000552 unsigned &NumNames) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000553 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000554 unsigned &NumAliases) const;
Anders Carlsson58436352009-02-28 17:11:49 +0000555 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +0000556 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson58436352009-02-28 17:11:49 +0000557 switch (*Name) {
Anders Carlssonf511f642007-11-27 04:11:28 +0000558 default: return false;
559 case 'O': // Zero
John Thompson07a61a42010-06-24 22:44:13 +0000560 break;
Anders Carlssonf511f642007-11-27 04:11:28 +0000561 case 'b': // Base register
562 case 'f': // Floating point register
Chris Lattnerd9725f72009-04-26 07:16:29 +0000563 Info.setAllowsRegister();
John Thompson07a61a42010-06-24 22:44:13 +0000564 break;
565 // FIXME: The following are added to allow parsing.
566 // I just took a guess at what the actions should be.
567 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000568 case 'd': // Floating point register (containing 64-bit value)
John Thompson07a61a42010-06-24 22:44:13 +0000569 case 'v': // Altivec vector register
570 Info.setAllowsRegister();
571 break;
572 case 'w':
573 switch (Name[1]) {
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000574 case 'd':// VSX vector register to hold vector double data
575 case 'f':// VSX vector register to hold vector float data
576 case 's':// VSX vector register to hold scalar float data
577 case 'a':// Any VSX register
John Thompson07a61a42010-06-24 22:44:13 +0000578 break;
579 default:
580 return false;
581 }
582 Info.setAllowsRegister();
583 Name++; // Skip over 'w'.
584 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000585 case 'h': // `MQ', `CTR', or `LINK' register
586 case 'q': // `MQ' register
587 case 'c': // `CTR' register
588 case 'l': // `LINK' register
589 case 'x': // `CR' register (condition register) number 0
590 case 'y': // `CR' register (condition register)
591 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson07a61a42010-06-24 22:44:13 +0000592 Info.setAllowsRegister();
593 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000594 case 'I': // Signed 16-bit constant
John Thompson07a61a42010-06-24 22:44:13 +0000595 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000596 // (use `L' instead for SImode constants)
597 case 'K': // Unsigned 16-bit constant
598 case 'L': // Signed 16-bit constant shifted left 16 bits
599 case 'M': // Constant larger than 31
600 case 'N': // Exact power of 2
601 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson07a61a42010-06-24 22:44:13 +0000602 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000603 // register with one instruction per word
John Thompson07a61a42010-06-24 22:44:13 +0000604 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000605 // into a register using three instructions
John Thompson07a61a42010-06-24 22:44:13 +0000606 break;
607 case 'm': // Memory operand. Note that on PowerPC targets, m can
608 // include addresses that update the base register. It
609 // is therefore only safe to use `m' in an asm statement
610 // if that asm statement accesses the operand exactly once.
611 // The asm statement must also use `%U<opno>' as a
Sebastian Redldd008712010-08-17 22:42:34 +0000612 // placeholder for the "update" flag in the corresponding
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000613 // load or store instruction. For example:
John Thompson07a61a42010-06-24 22:44:13 +0000614 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000615 // is correct but:
John Thompson07a61a42010-06-24 22:44:13 +0000616 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
617 // is not. Use es rather than m if you don't want the base
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000618 // register to be updated.
619 case 'e':
John Thompsonceebdf12010-06-25 00:02:05 +0000620 if (Name[1] != 's')
621 return false;
Sebastian Redldd008712010-08-17 22:42:34 +0000622 // es: A "stable" memory operand; that is, one which does not
John Thompson07a61a42010-06-24 22:44:13 +0000623 // include any automodification of the base register. Unlike
624 // `m', this constraint can be used in asm statements that
625 // might access the operand several times, or that might not
John Thompsonceebdf12010-06-25 00:02:05 +0000626 // access it at all.
John Thompson07a61a42010-06-24 22:44:13 +0000627 Info.setAllowsMemory();
John Thompsonceebdf12010-06-25 00:02:05 +0000628 Name++; // Skip over 'e'.
John Thompson07a61a42010-06-24 22:44:13 +0000629 break;
630 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000631 // usually better to use `m' or `es' in asm statements)
John Thompson07a61a42010-06-24 22:44:13 +0000632 case 'Z': // Memory operand that is an indexed or indirect from a
633 // register (it is usually better to use `m' or `es' in
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000634 // asm statements)
John Thompson07a61a42010-06-24 22:44:13 +0000635 Info.setAllowsMemory();
636 Info.setAllowsRegister();
637 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000638 case 'R': // AIX TOC entry
John Thompson07a61a42010-06-24 22:44:13 +0000639 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000640 // register (`p' is preferable for asm statements)
641 case 'S': // Constant suitable as a 64-bit mask operand
642 case 'T': // Constant suitable as a 32-bit mask operand
643 case 'U': // System V Release 4 small data area reference
John Thompson07a61a42010-06-24 22:44:13 +0000644 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000645 // instructions
646 case 'W': // Vector constant that does not require memory
647 case 'j': // Vector constant that is all zeros.
John Thompson07a61a42010-06-24 22:44:13 +0000648 break;
649 // End FIXME.
Anders Carlssonf511f642007-11-27 04:11:28 +0000650 }
John Thompson07a61a42010-06-24 22:44:13 +0000651 return true;
Anders Carlssonf511f642007-11-27 04:11:28 +0000652 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000653 virtual const char *getClobbers() const {
654 return "";
Anders Carlssonf511f642007-11-27 04:11:28 +0000655 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000656};
Anders Carlssonf511f642007-11-27 04:11:28 +0000657
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000658const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000659#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +0000660#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000661 ALL_LANGUAGES },
Chris Lattner5abdec72009-06-14 01:05:48 +0000662#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000663};
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000664
665
Chris Lattnerecd49032009-03-02 22:27:17 +0000666/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
667/// #defines that are not tied to a specific subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000668void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000669 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +0000670 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000671 Builder.defineMacro("__ppc__");
672 Builder.defineMacro("_ARCH_PPC");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000673 Builder.defineMacro("__powerpc__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000674 Builder.defineMacro("__POWERPC__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000675 if (PointerWidth == 64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000676 Builder.defineMacro("_ARCH_PPC64");
677 Builder.defineMacro("_LP64");
678 Builder.defineMacro("__LP64__");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000679 Builder.defineMacro("__powerpc64__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000680 Builder.defineMacro("__ppc64__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000681 } else {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000682 Builder.defineMacro("__ppc__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000683 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000684
Chris Lattnerecd49032009-03-02 22:27:17 +0000685 // Target properties.
Joerg Sonnenberger870b3c52011-07-05 14:56:12 +0000686 if (getTriple().getOS() != llvm::Triple::NetBSD)
687 Builder.defineMacro("_BIG_ENDIAN");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000688 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000689
Chris Lattnerecd49032009-03-02 22:27:17 +0000690 // Subtarget options.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000691 Builder.defineMacro("__NATURAL_ALIGNMENT__");
692 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000693
Chris Lattnerecd49032009-03-02 22:27:17 +0000694 // FIXME: Should be controlled by command line option.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000695 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000696
John Thompsone467e192009-11-19 17:18:50 +0000697 if (Opts.AltiVec) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000698 Builder.defineMacro("__VEC__", "10206");
699 Builder.defineMacro("__ALTIVEC__");
John Thompsone467e192009-11-19 17:18:50 +0000700 }
Chris Lattnerecd49032009-03-02 22:27:17 +0000701}
702
Chris Lattner17df24e2008-04-21 18:56:49 +0000703
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000704const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnerf7ff53d2009-09-16 05:05:27 +0000705 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
706 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
707 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
708 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
709 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
710 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
711 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
712 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000713 "mq", "lr", "ctr", "ap",
Chris Lattnerf7ff53d2009-09-16 05:05:27 +0000714 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000715 "xer",
Chris Lattnerf7ff53d2009-09-16 05:05:27 +0000716 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
717 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
718 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
719 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000720 "vrsave", "vscr",
721 "spe_acc", "spefscr",
722 "sfp"
723};
Chris Lattner10a5b382007-01-29 05:24:35 +0000724
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000725void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000726 unsigned &NumNames) const {
727 Names = GCCRegNames;
728 NumNames = llvm::array_lengthof(GCCRegNames);
729}
Chris Lattner5ba61f02006-10-14 07:39:34 +0000730
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000731const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
732 // While some of these aliases do map to different registers
733 // they still share the same register name.
Daniel Dunbar1da76c42009-09-17 07:03:19 +0000734 { { "0" }, "r0" },
735 { { "1"}, "r1" },
736 { { "2" }, "r2" },
737 { { "3" }, "r3" },
738 { { "4" }, "r4" },
739 { { "5" }, "r5" },
740 { { "6" }, "r6" },
741 { { "7" }, "r7" },
742 { { "8" }, "r8" },
743 { { "9" }, "r9" },
744 { { "10" }, "r10" },
745 { { "11" }, "r11" },
746 { { "12" }, "r12" },
747 { { "13" }, "r13" },
748 { { "14" }, "r14" },
749 { { "15" }, "r15" },
750 { { "16" }, "r16" },
751 { { "17" }, "r17" },
752 { { "18" }, "r18" },
753 { { "19" }, "r19" },
754 { { "20" }, "r20" },
755 { { "21" }, "r21" },
756 { { "22" }, "r22" },
757 { { "23" }, "r23" },
758 { { "24" }, "r24" },
759 { { "25" }, "r25" },
760 { { "26" }, "r26" },
761 { { "27" }, "r27" },
762 { { "28" }, "r28" },
763 { { "29" }, "r29" },
764 { { "30" }, "r30" },
765 { { "31" }, "r31" },
766 { { "fr0" }, "f0" },
767 { { "fr1" }, "f1" },
768 { { "fr2" }, "f2" },
769 { { "fr3" }, "f3" },
770 { { "fr4" }, "f4" },
771 { { "fr5" }, "f5" },
772 { { "fr6" }, "f6" },
773 { { "fr7" }, "f7" },
774 { { "fr8" }, "f8" },
775 { { "fr9" }, "f9" },
Mike Stumpfaacf012009-09-17 21:15:00 +0000776 { { "fr10" }, "f10" },
Daniel Dunbar1da76c42009-09-17 07:03:19 +0000777 { { "fr11" }, "f11" },
778 { { "fr12" }, "f12" },
779 { { "fr13" }, "f13" },
780 { { "fr14" }, "f14" },
781 { { "fr15" }, "f15" },
782 { { "fr16" }, "f16" },
783 { { "fr17" }, "f17" },
784 { { "fr18" }, "f18" },
785 { { "fr19" }, "f19" },
786 { { "fr20" }, "f20" },
787 { { "fr21" }, "f21" },
788 { { "fr22" }, "f22" },
789 { { "fr23" }, "f23" },
790 { { "fr24" }, "f24" },
791 { { "fr25" }, "f25" },
792 { { "fr26" }, "f26" },
793 { { "fr27" }, "f27" },
794 { { "fr28" }, "f28" },
795 { { "fr29" }, "f29" },
796 { { "fr30" }, "f30" },
797 { { "fr31" }, "f31" },
798 { { "cc" }, "cr0" },
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000799};
800
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000801void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000802 unsigned &NumAliases) const {
803 Aliases = GCCRegAliases;
804 NumAliases = llvm::array_lengthof(GCCRegAliases);
805}
806} // end anonymous namespace.
Chris Lattner02dffbd2006-10-14 07:50:21 +0000807
Chris Lattner5ba61f02006-10-14 07:39:34 +0000808namespace {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000809class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +0000810public:
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000811 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedman873f65a2008-08-21 00:13:15 +0000812 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 +0000813 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000814
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +0000815 switch (getTriple().getOS()) {
816 case llvm::Triple::FreeBSD:
817 case llvm::Triple::NetBSD:
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +0000818 SizeType = UnsignedInt;
819 break;
Joerg Sonnenbergerf031fd92011-07-04 23:11:58 +0000820 default:
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +0000821 break;
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +0000822 }
Roman Divacky965b0b72011-01-06 08:27:10 +0000823 }
824
825 virtual const char *getVAListDeclaration() const {
826 // This is the ELF definition, and is overridden by the Darwin sub-target
827 return "typedef struct __va_list_tag {"
828 " unsigned char gpr;"
829 " unsigned char fpr;"
830 " unsigned short reserved;"
831 " void* overflow_arg_area;"
832 " void* reg_save_area;"
833 "} __builtin_va_list[1];";
Eli Friedman873f65a2008-08-21 00:13:15 +0000834 }
Chris Lattner5ba61f02006-10-14 07:39:34 +0000835};
836} // end anonymous namespace.
837
838namespace {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000839class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +0000840public:
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000841 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerba7a6c12008-05-09 06:17:04 +0000842 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman2857ccb2009-07-01 03:36:11 +0000843 IntMaxType = SignedLong;
844 UIntMaxType = UnsignedLong;
845 Int64Type = SignedLong;
Eli Friedman873f65a2008-08-21 00:13:15 +0000846 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 +0000847 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnerba7a6c12008-05-09 06:17:04 +0000848 }
Roman Divacky965b0b72011-01-06 08:27:10 +0000849 virtual const char *getVAListDeclaration() const {
850 return "typedef char* __builtin_va_list;";
851 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000852};
853} // end anonymous namespace.
854
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +0000855
856namespace {
Roman Divacky965b0b72011-01-06 08:27:10 +0000857class DarwinPPC32TargetInfo :
858 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +0000859public:
Roman Divacky965b0b72011-01-06 08:27:10 +0000860 DarwinPPC32TargetInfo(const std::string& triple)
861 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +0000862 HasAlignMac68kSupport = true;
Roman Divacky965b0b72011-01-06 08:27:10 +0000863 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
864 }
865 virtual const char *getVAListDeclaration() const {
866 return "typedef char* __builtin_va_list;";
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +0000867 }
868};
869
870class DarwinPPC64TargetInfo :
871 public DarwinTargetInfo<PPC64TargetInfo> {
872public:
873 DarwinPPC64TargetInfo(const std::string& triple)
874 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
875 HasAlignMac68kSupport = true;
876 }
877};
878} // end anonymous namespace.
879
Chris Lattner5ba61f02006-10-14 07:39:34 +0000880namespace {
Justin Holewinski514cce82011-04-20 19:34:15 +0000881 class PTXTargetInfo : public TargetInfo {
882 static const char * const GCCRegNames[];
883 static const Builtin::Info BuiltinInfo[];
Justin Holewinski0542df52011-09-22 17:57:40 +0000884 std::vector<llvm::StringRef> AvailableFeatures;
Justin Holewinski514cce82011-04-20 19:34:15 +0000885 public:
886 PTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
887 TLSSupported = false;
888 LongWidth = LongAlign = 64;
Justin Holewinski0542df52011-09-22 17:57:40 +0000889 // Define available target features
890 // These must be defined in sorted order!
891 AvailableFeatures.push_back("compute10");
892 AvailableFeatures.push_back("compute11");
893 AvailableFeatures.push_back("compute12");
894 AvailableFeatures.push_back("compute13");
895 AvailableFeatures.push_back("compute20");
896 AvailableFeatures.push_back("double");
897 AvailableFeatures.push_back("no-fma");
898 AvailableFeatures.push_back("ptx20");
899 AvailableFeatures.push_back("ptx21");
900 AvailableFeatures.push_back("ptx22");
901 AvailableFeatures.push_back("ptx23");
902 AvailableFeatures.push_back("sm10");
903 AvailableFeatures.push_back("sm11");
904 AvailableFeatures.push_back("sm12");
905 AvailableFeatures.push_back("sm13");
906 AvailableFeatures.push_back("sm20");
907 AvailableFeatures.push_back("sm21");
908 AvailableFeatures.push_back("sm22");
909 AvailableFeatures.push_back("sm23");
Justin Holewinski514cce82011-04-20 19:34:15 +0000910 }
911 virtual void getTargetDefines(const LangOptions &Opts,
912 MacroBuilder &Builder) const {
913 Builder.defineMacro("__PTX__");
914 }
915 virtual void getTargetBuiltins(const Builtin::Info *&Records,
916 unsigned &NumRecords) const {
917 Records = BuiltinInfo;
918 NumRecords = clang::PTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
919 }
920
921 virtual void getGCCRegNames(const char * const *&Names,
922 unsigned &NumNames) const;
923 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
924 unsigned &NumAliases) const {
925 // No aliases.
926 Aliases = 0;
927 NumAliases = 0;
928 }
929 virtual bool validateAsmConstraint(const char *&Name,
930 TargetInfo::ConstraintInfo &info) const {
931 // FIXME: implement
932 return true;
933 }
934 virtual const char *getClobbers() const {
935 // FIXME: Is this really right?
936 return "";
937 }
938 virtual const char *getVAListDeclaration() const {
939 // FIXME: implement
940 return "typedef char* __builtin_va_list;";
941 }
Justin Holewinskiaa78b232011-09-15 12:13:38 +0000942
943 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
944 const std::string &Name,
945 bool Enabled) const;
Justin Holewinski514cce82011-04-20 19:34:15 +0000946 };
947
948 const Builtin::Info PTXTargetInfo::BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000949#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Justin Holewinski514cce82011-04-20 19:34:15 +0000950#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000951 ALL_LANGUAGES },
Justin Holewinski514cce82011-04-20 19:34:15 +0000952#include "clang/Basic/BuiltinsPTX.def"
953 };
954
955 const char * const PTXTargetInfo::GCCRegNames[] = {
956 "r0"
957 };
958
959 void PTXTargetInfo::getGCCRegNames(const char * const *&Names,
960 unsigned &NumNames) const {
961 Names = GCCRegNames;
962 NumNames = llvm::array_lengthof(GCCRegNames);
963 }
964
Justin Holewinskiaa78b232011-09-15 12:13:38 +0000965 bool PTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
966 const std::string &Name,
967 bool Enabled) const {
Justin Holewinski0542df52011-09-22 17:57:40 +0000968 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
969 Name)) {
970 Features[Name] = Enabled;
971 return true;
Justin Holewinskiaa78b232011-09-15 12:13:38 +0000972 } else {
Justin Holewinski0542df52011-09-22 17:57:40 +0000973 return false;
Justin Holewinskiaa78b232011-09-15 12:13:38 +0000974 }
Justin Holewinskiaa78b232011-09-15 12:13:38 +0000975 }
Justin Holewinski514cce82011-04-20 19:34:15 +0000976
977 class PTX32TargetInfo : public PTXTargetInfo {
978 public:
979 PTX32TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
980 PointerWidth = PointerAlign = 32;
981 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
982 DescriptionString
983 = "e-p:32:32-i64:64:64-f64:64:64-n1:8:16:32:64";
984 }
985 };
986
987 class PTX64TargetInfo : public PTXTargetInfo {
988 public:
989 PTX64TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
990 PointerWidth = PointerAlign = 64;
991 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
992 DescriptionString
993 = "e-p:64:64-i64:64:64-f64:64:64-n1:8:16:32:64";
994 }
995 };
996}
997
998namespace {
Chris Lattner5178f562010-03-06 21:21:27 +0000999// MBlaze abstract base class
1000class MBlazeTargetInfo : public TargetInfo {
1001 static const char * const GCCRegNames[];
1002 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1003
1004public:
1005 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Peck69bf1282010-12-12 20:56:47 +00001006 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner5178f562010-03-06 21:21:27 +00001007 }
1008
1009 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1010 unsigned &NumRecords) const {
1011 // FIXME: Implement.
1012 Records = 0;
1013 NumRecords = 0;
1014 }
1015
1016 virtual void getTargetDefines(const LangOptions &Opts,
1017 MacroBuilder &Builder) const;
1018
1019 virtual const char *getVAListDeclaration() const {
1020 return "typedef char* __builtin_va_list;";
1021 }
1022 virtual const char *getTargetPrefix() const {
1023 return "mblaze";
1024 }
1025 virtual void getGCCRegNames(const char * const *&Names,
1026 unsigned &NumNames) const;
1027 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1028 unsigned &NumAliases) const;
1029 virtual bool validateAsmConstraint(const char *&Name,
1030 TargetInfo::ConstraintInfo &Info) const {
1031 switch (*Name) {
1032 default: return false;
1033 case 'O': // Zero
1034 return true;
1035 case 'b': // Base register
1036 case 'f': // Floating point register
1037 Info.setAllowsRegister();
1038 return true;
1039 }
1040 }
1041 virtual const char *getClobbers() const {
1042 return "";
1043 }
1044};
1045
1046/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1047/// #defines that are not tied to a specific subtarget.
1048void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1049 MacroBuilder &Builder) const {
1050 // Target identification.
1051 Builder.defineMacro("__microblaze__");
1052 Builder.defineMacro("_ARCH_MICROBLAZE");
1053 Builder.defineMacro("__MICROBLAZE__");
1054
1055 // Target properties.
1056 Builder.defineMacro("_BIG_ENDIAN");
1057 Builder.defineMacro("__BIG_ENDIAN__");
1058
1059 // Subtarget options.
1060 Builder.defineMacro("__REGISTER_PREFIX__", "");
1061}
1062
1063
1064const char * const MBlazeTargetInfo::GCCRegNames[] = {
1065 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1066 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1067 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1068 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1069 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1070 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1071 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1072 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1073 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1074 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1075};
1076
1077void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1078 unsigned &NumNames) const {
1079 Names = GCCRegNames;
1080 NumNames = llvm::array_lengthof(GCCRegNames);
1081}
1082
1083const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1084 { {"f0"}, "r0" },
1085 { {"f1"}, "r1" },
1086 { {"f2"}, "r2" },
1087 { {"f3"}, "r3" },
1088 { {"f4"}, "r4" },
1089 { {"f5"}, "r5" },
1090 { {"f6"}, "r6" },
1091 { {"f7"}, "r7" },
1092 { {"f8"}, "r8" },
1093 { {"f9"}, "r9" },
1094 { {"f10"}, "r10" },
1095 { {"f11"}, "r11" },
1096 { {"f12"}, "r12" },
1097 { {"f13"}, "r13" },
1098 { {"f14"}, "r14" },
1099 { {"f15"}, "r15" },
1100 { {"f16"}, "r16" },
1101 { {"f17"}, "r17" },
1102 { {"f18"}, "r18" },
1103 { {"f19"}, "r19" },
1104 { {"f20"}, "r20" },
1105 { {"f21"}, "r21" },
1106 { {"f22"}, "r22" },
1107 { {"f23"}, "r23" },
1108 { {"f24"}, "r24" },
1109 { {"f25"}, "r25" },
1110 { {"f26"}, "r26" },
1111 { {"f27"}, "r27" },
1112 { {"f28"}, "r28" },
1113 { {"f29"}, "r29" },
1114 { {"f30"}, "r30" },
1115 { {"f31"}, "r31" },
1116};
1117
1118void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1119 unsigned &NumAliases) const {
1120 Aliases = GCCRegAliases;
1121 NumAliases = llvm::array_lengthof(GCCRegAliases);
1122}
1123} // end anonymous namespace.
1124
1125namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001126// Namespace for x86 abstract base class
1127const Builtin::Info BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00001128#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +00001129#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00001130 ALL_LANGUAGES },
Chris Lattner5abdec72009-06-14 01:05:48 +00001131#include "clang/Basic/BuiltinsX86.def"
Eli Friedman3fd920a2008-08-20 02:34:37 +00001132};
Eli Friedmanb5366062008-05-20 14:21:01 +00001133
Nuno Lopescfca1f02009-12-23 17:49:57 +00001134static const char* const GCCRegNames[] = {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001135 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1136 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher0c912c52011-07-07 22:55:26 +00001137 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman3fd920a2008-08-20 02:34:37 +00001138 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1139 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1140 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercdd36352011-06-21 00:05:20 +00001141 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eli Friedman3fd920a2008-08-20 02:34:37 +00001142};
1143
Eric Christophercdd36352011-06-21 00:05:20 +00001144const TargetInfo::AddlRegName AddlRegNames[] = {
1145 { { "al", "ah", "eax", "rax" }, 0 },
1146 { { "bl", "bh", "ebx", "rbx" }, 3 },
1147 { { "cl", "ch", "ecx", "rcx" }, 2 },
1148 { { "dl", "dh", "edx", "rdx" }, 1 },
1149 { { "esi", "rsi" }, 4 },
1150 { { "edi", "rdi" }, 5 },
1151 { { "esp", "rsp" }, 7 },
1152 { { "ebp", "rbp" }, 6 },
Eli Friedman3fd920a2008-08-20 02:34:37 +00001153};
1154
1155// X86 target abstract base class; x86-32 and x86-64 are very close, so
1156// most of the implementation can be shared.
1157class X86TargetInfo : public TargetInfo {
Chris Lattner96e43572009-03-02 22:40:39 +00001158 enum X86SSEEnum {
Eli Friedman33465822011-07-08 23:31:17 +00001159 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
Chris Lattner96e43572009-03-02 22:40:39 +00001160 } SSELevel;
Eli Friedman33465822011-07-08 23:31:17 +00001161 enum MMX3DNowEnum {
1162 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1163 } MMX3DNowLevel;
Anders Carlssone437c682010-01-27 03:47:49 +00001164
Eric Christophere1ddaf92010-04-02 23:50:19 +00001165 bool HasAES;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001166 bool HasAVX;
1167
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001168 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1169 ///
1170 /// Each enumeration represents a particular CPU supported by Clang. These
1171 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1172 enum CPUKind {
1173 CK_Generic,
1174
1175 /// \name i386
1176 /// i386-generation processors.
1177 //@{
1178 CK_i386,
1179 //@}
1180
1181 /// \name i486
1182 /// i486-generation processors.
1183 //@{
1184 CK_i486,
1185 CK_WinChipC6,
1186 CK_WinChip2,
1187 CK_C3,
1188 //@}
1189
1190 /// \name i586
1191 /// i586-generation processors, P5 microarchitecture based.
1192 //@{
1193 CK_i586,
1194 CK_Pentium,
1195 CK_PentiumMMX,
1196 //@}
1197
1198 /// \name i686
1199 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1200 //@{
1201 CK_i686,
1202 CK_PentiumPro,
1203 CK_Pentium2,
1204 CK_Pentium3,
1205 CK_Pentium3M,
1206 CK_PentiumM,
1207 CK_C3_2,
1208
1209 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1210 /// Clang however has some logic to suport this.
1211 // FIXME: Warn, deprecate, and potentially remove this.
1212 CK_Yonah,
1213 //@}
1214
1215 /// \name Netburst
1216 /// Netburt microarchitecture based processors.
1217 //@{
1218 CK_Pentium4,
1219 CK_Pentium4M,
1220 CK_Prescott,
1221 CK_Nocona,
1222 //@}
1223
1224 /// \name Core
1225 /// Core microarchitecture based processors.
1226 //@{
1227 CK_Core2,
1228
1229 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1230 /// codename which GCC no longer accepts as an option to -march, but Clang
1231 /// has some logic for recognizing it.
1232 // FIXME: Warn, deprecate, and potentially remove this.
1233 CK_Penryn,
1234 //@}
1235
1236 /// \name Atom
1237 /// Atom processors
1238 //@{
1239 CK_Atom,
1240 //@}
1241
1242 /// \name Nehalem
1243 /// Nehalem microarchitecture based processors.
1244 //@{
1245 CK_Corei7,
1246 CK_Corei7AVX,
Chandler Carruth212334f2011-09-28 08:55:37 +00001247 CK_CoreAVXi,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001248 //@}
1249
1250 /// \name K6
1251 /// K6 architecture processors.
1252 //@{
1253 CK_K6,
1254 CK_K6_2,
1255 CK_K6_3,
1256 //@}
1257
1258 /// \name K7
1259 /// K7 architecture processors.
1260 //@{
1261 CK_Athlon,
1262 CK_AthlonThunderbird,
1263 CK_Athlon4,
1264 CK_AthlonXP,
1265 CK_AthlonMP,
1266 //@}
1267
1268 /// \name K8
1269 /// K8 architecture processors.
1270 //@{
1271 CK_Athlon64,
1272 CK_Athlon64SSE3,
1273 CK_AthlonFX,
1274 CK_K8,
Chandler Carruth212334f2011-09-28 08:55:37 +00001275 CK_K8SSE3,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001276 CK_Opteron,
1277 CK_OpteronSSE3,
1278
1279 /// This specification is deprecated and will be removed in the future.
1280 /// Users should prefer \see CK_K8.
1281 // FIXME: Warn on this when the CPU is set to it.
1282 CK_x86_64,
1283 //@}
1284
1285 /// \name Geode
1286 /// Geode processors.
1287 //@{
1288 CK_Geode
1289 //@}
Chandler Carruth212334f2011-09-28 08:55:37 +00001290 } CPU;
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001291
Eli Friedman3fd920a2008-08-20 02:34:37 +00001292public:
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001293 X86TargetInfo(const std::string& triple)
Eli Friedman33465822011-07-08 23:31:17 +00001294 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Chandler Carruth212334f2011-09-28 08:55:37 +00001295 HasAES(false), HasAVX(false), CPU(CK_Generic) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001296 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner1f5ad112006-10-14 18:32:12 +00001297 }
Chris Lattner10a5b382007-01-29 05:24:35 +00001298 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1299 unsigned &NumRecords) const {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001300 Records = BuiltinInfo;
1301 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner10a5b382007-01-29 05:24:35 +00001302 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001303 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman3fd920a2008-08-20 02:34:37 +00001304 unsigned &NumNames) const {
1305 Names = GCCRegNames;
1306 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson5fa3f342007-11-24 23:38:12 +00001307 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001308 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson5fa3f342007-11-24 23:38:12 +00001309 unsigned &NumAliases) const {
Eric Christophercdd36352011-06-21 00:05:20 +00001310 Aliases = 0;
1311 NumAliases = 0;
1312 }
1313 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1314 unsigned &NumNames) const {
1315 Names = AddlRegNames;
1316 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssona7408e72007-10-13 00:45:48 +00001317 }
Anders Carlsson58436352009-02-28 17:11:49 +00001318 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman3fd920a2008-08-20 02:34:37 +00001319 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00001320 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssonf511f642007-11-27 04:11:28 +00001321 virtual const char *getClobbers() const {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001322 return "~{dirflag},~{fpsr},~{flags}";
1323 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001324 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001325 MacroBuilder &Builder) const;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001326 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1327 const std::string &Name,
1328 bool Enabled) const;
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00001329 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00001330 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedman33465822011-07-08 23:31:17 +00001331 virtual const char* getABI() const {
1332 return MMX3DNowLevel == NoMMX3DNow ? "no-mmx" : "";
1333 }
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001334 virtual bool setCPU(const std::string &Name) {
Chandler Carruth212334f2011-09-28 08:55:37 +00001335 CPU = llvm::StringSwitch<CPUKind>(Name)
1336 .Case("i386", CK_i386)
1337 .Case("i486", CK_i486)
1338 .Case("winchip-c6", CK_WinChipC6)
1339 .Case("winchip2", CK_WinChip2)
1340 .Case("c3", CK_C3)
1341 .Case("i586", CK_i586)
1342 .Case("pentium", CK_Pentium)
1343 .Case("pentium-mmx", CK_PentiumMMX)
1344 .Case("i686", CK_i686)
1345 .Case("pentiumpro", CK_PentiumPro)
1346 .Case("pentium2", CK_Pentium2)
1347 .Case("pentium3", CK_Pentium3)
1348 .Case("pentium3m", CK_Pentium3M)
1349 .Case("pentium-m", CK_PentiumM)
1350 .Case("c3-2", CK_C3_2)
1351 .Case("yonah", CK_Yonah)
1352 .Case("pentium4", CK_Pentium4)
1353 .Case("pentium4m", CK_Pentium4M)
1354 .Case("prescott", CK_Prescott)
1355 .Case("nocona", CK_Nocona)
1356 .Case("core2", CK_Core2)
1357 .Case("penryn", CK_Penryn)
1358 .Case("atom", CK_Atom)
1359 .Case("corei7", CK_Corei7)
1360 .Case("corei7-avx", CK_Corei7AVX)
1361 .Case("core-avx-i", CK_CoreAVXi)
1362 .Case("k6", CK_K6)
1363 .Case("k6-2", CK_K6_2)
1364 .Case("k6-3", CK_K6_3)
1365 .Case("athlon", CK_Athlon)
1366 .Case("athlon-tbird", CK_AthlonThunderbird)
1367 .Case("athlon-4", CK_Athlon4)
1368 .Case("athlon-xp", CK_AthlonXP)
1369 .Case("athlon-mp", CK_AthlonMP)
1370 .Case("athlon64", CK_Athlon64)
1371 .Case("athlon64-sse3", CK_Athlon64SSE3)
1372 .Case("athlon-fx", CK_AthlonFX)
1373 .Case("k8", CK_K8)
1374 .Case("k8-sse3", CK_K8SSE3)
1375 .Case("opteron", CK_Opteron)
1376 .Case("opteron-sse3", CK_OpteronSSE3)
1377 .Case("x86-64", CK_x86_64)
1378 .Case("geode", CK_Geode)
1379 .Default(CK_Generic);
1380
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00001381 // Perform any per-CPU checks necessary to determine if this CPU is
1382 // acceptable.
1383 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1384 // invalid without explaining *why*.
1385 switch (CPU) {
1386 case CK_Generic:
1387 // No processor selected!
1388 return false;
1389
1390 case CK_i386:
1391 case CK_i486:
1392 case CK_WinChipC6:
1393 case CK_WinChip2:
1394 case CK_C3:
1395 case CK_i586:
1396 case CK_Pentium:
1397 case CK_PentiumMMX:
1398 case CK_i686:
1399 case CK_PentiumPro:
1400 case CK_Pentium2:
1401 case CK_Pentium3:
1402 case CK_Pentium3M:
1403 case CK_PentiumM:
1404 case CK_Yonah:
1405 case CK_C3_2:
1406 case CK_Pentium4:
1407 case CK_Pentium4M:
1408 case CK_Prescott:
1409 case CK_K6:
1410 case CK_K6_2:
1411 case CK_K6_3:
1412 case CK_Athlon:
1413 case CK_AthlonThunderbird:
1414 case CK_Athlon4:
1415 case CK_AthlonXP:
1416 case CK_AthlonMP:
1417 case CK_Geode:
1418 // Only accept certain architectures when compiling in 32-bit mode.
1419 if (PointerWidth != 32)
1420 return false;
1421
1422 // Fallthrough
1423 case CK_Nocona:
1424 case CK_Core2:
1425 case CK_Penryn:
1426 case CK_Atom:
1427 case CK_Corei7:
1428 case CK_Corei7AVX:
1429 case CK_CoreAVXi:
1430 case CK_Athlon64:
1431 case CK_Athlon64SSE3:
1432 case CK_AthlonFX:
1433 case CK_K8:
1434 case CK_K8SSE3:
1435 case CK_Opteron:
1436 case CK_OpteronSSE3:
1437 case CK_x86_64:
1438 return true;
1439 }
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001440 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00001441};
Chris Lattnerc25d8a72009-03-02 22:20:04 +00001442
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00001443void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001444 // FIXME: This should not be here.
1445 Features["3dnow"] = false;
1446 Features["3dnowa"] = false;
1447 Features["mmx"] = false;
1448 Features["sse"] = false;
1449 Features["sse2"] = false;
1450 Features["sse3"] = false;
1451 Features["ssse3"] = false;
1452 Features["sse41"] = false;
1453 Features["sse42"] = false;
Eric Christophere1ddaf92010-04-02 23:50:19 +00001454 Features["aes"] = false;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001455 Features["avx"] = false;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001456
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001457 // LLVM does not currently recognize this.
1458 // Features["sse4a"] = false;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001459
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001460 // FIXME: This *really* should not be here.
1461
1462 // X86_64 always has SSE2.
1463 if (PointerWidth == 64)
1464 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1465
Chandler Carruth212334f2011-09-28 08:55:37 +00001466 switch (CPU) {
1467 case CK_Generic:
1468 case CK_i386:
1469 case CK_i486:
1470 case CK_i586:
1471 case CK_Pentium:
1472 case CK_i686:
1473 case CK_PentiumPro:
Chandler Carruth212334f2011-09-28 08:55:37 +00001474 break;
1475 case CK_PentiumMMX:
1476 case CK_Pentium2:
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001477 setFeatureEnabled(Features, "mmx", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001478 break;
1479 case CK_Pentium3:
1480 case CK_Pentium3M:
Eli Friedman33465822011-07-08 23:31:17 +00001481 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001482 setFeatureEnabled(Features, "sse", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001483 break;
1484 case CK_PentiumM:
1485 case CK_Pentium4:
1486 case CK_Pentium4M:
1487 case CK_x86_64:
Eli Friedman33465822011-07-08 23:31:17 +00001488 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001489 setFeatureEnabled(Features, "sse2", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001490 break;
1491 case CK_Yonah:
1492 case CK_Prescott:
1493 case CK_Nocona:
Eli Friedman33465822011-07-08 23:31:17 +00001494 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001495 setFeatureEnabled(Features, "sse3", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001496 break;
1497 case CK_Core2:
Eli Friedman33465822011-07-08 23:31:17 +00001498 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001499 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001500 break;
1501 case CK_Penryn:
Eli Friedman33465822011-07-08 23:31:17 +00001502 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001503 setFeatureEnabled(Features, "sse4", true);
1504 Features["sse42"] = false;
Chandler Carruth212334f2011-09-28 08:55:37 +00001505 break;
1506 case CK_Atom:
Eli Friedman33465822011-07-08 23:31:17 +00001507 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthcd99bad2011-09-28 10:36:46 +00001508 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001509 break;
1510 case CK_Corei7:
Eli Friedman33465822011-07-08 23:31:17 +00001511 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001512 setFeatureEnabled(Features, "sse4", true);
Eric Christophere1ddaf92010-04-02 23:50:19 +00001513 setFeatureEnabled(Features, "aes", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001514 break;
1515 case CK_Corei7AVX:
1516 case CK_CoreAVXi:
Eli Friedman33465822011-07-08 23:31:17 +00001517 setFeatureEnabled(Features, "mmx", true);
Roman Divacky27ec14f2011-04-05 20:32:44 +00001518 setFeatureEnabled(Features, "sse4", true);
1519 setFeatureEnabled(Features, "aes", true);
Bruno Cardoso Lopes34728382011-07-11 23:33:46 +00001520 //setFeatureEnabled(Features, "avx", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001521 break;
1522 case CK_K6:
1523 case CK_WinChipC6:
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001524 setFeatureEnabled(Features, "mmx", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001525 break;
1526 case CK_K6_2:
1527 case CK_K6_3:
Chandler Carruth212334f2011-09-28 08:55:37 +00001528 case CK_WinChip2:
1529 case CK_C3:
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001530 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001531 break;
Chandler Carruthcd99bad2011-09-28 10:36:46 +00001532 case CK_Athlon:
1533 case CK_AthlonThunderbird:
1534 case CK_Geode:
1535 setFeatureEnabled(Features, "3dnowa", true);
1536 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00001537 case CK_Athlon4:
1538 case CK_AthlonXP:
1539 case CK_AthlonMP:
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001540 setFeatureEnabled(Features, "sse", true);
1541 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001542 break;
1543 case CK_K8:
1544 case CK_Opteron:
1545 case CK_Athlon64:
1546 case CK_AthlonFX:
Mike Stump11289f42009-09-09 15:08:12 +00001547 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001548 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001549 break;
1550 case CK_K8SSE3:
1551 case CK_OpteronSSE3:
1552 case CK_Athlon64SSE3:
Roman Divackydacbfe42010-12-29 13:28:29 +00001553 setFeatureEnabled(Features, "sse3", true);
1554 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001555 break;
1556 case CK_C3_2:
Eli Friedman33465822011-07-08 23:31:17 +00001557 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001558 setFeatureEnabled(Features, "sse", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00001559 break;
Eli Friedman33465822011-07-08 23:31:17 +00001560 }
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001561}
1562
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001563bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump11289f42009-09-09 15:08:12 +00001564 const std::string &Name,
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001565 bool Enabled) const {
Eric Christopher399ffa52010-03-04 02:26:37 +00001566 // FIXME: This *really* should not be here. We need some way of translating
1567 // options into llvm subtarget features.
1568 if (!Features.count(Name) &&
1569 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001570 return false;
1571
1572 if (Enabled) {
1573 if (Name == "mmx")
1574 Features["mmx"] = true;
1575 else if (Name == "sse")
Eli Friedman33465822011-07-08 23:31:17 +00001576 Features["sse"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001577 else if (Name == "sse2")
Eli Friedman33465822011-07-08 23:31:17 +00001578 Features["sse"] = Features["sse2"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001579 else if (Name == "sse3")
Eli Friedman33465822011-07-08 23:31:17 +00001580 Features["sse"] = Features["sse2"] = Features["sse3"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001581 else if (Name == "ssse3")
Eli Friedman33465822011-07-08 23:31:17 +00001582 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001583 Features["ssse3"] = true;
Eric Christopher399ffa52010-03-04 02:26:37 +00001584 else if (Name == "sse4" || Name == "sse4.2")
Eli Friedman33465822011-07-08 23:31:17 +00001585 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001586 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Eric Christopher399ffa52010-03-04 02:26:37 +00001587 else if (Name == "sse4.1")
Eli Friedman33465822011-07-08 23:31:17 +00001588 Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopher399ffa52010-03-04 02:26:37 +00001589 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001590 else if (Name == "3dnow")
Eli Friedman33465822011-07-08 23:31:17 +00001591 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001592 else if (Name == "3dnowa")
Eli Friedman33465822011-07-08 23:31:17 +00001593 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophere1ddaf92010-04-02 23:50:19 +00001594 else if (Name == "aes")
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001595 Features["aes"] = true;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001596 else if (Name == "avx")
Bruno Cardoso Lopesbf9246d2011-08-18 00:07:03 +00001597 Features["avx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1598 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001599 } else {
1600 if (Name == "mmx")
Eli Friedman33465822011-07-08 23:31:17 +00001601 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001602 else if (Name == "sse")
Mike Stump11289f42009-09-09 15:08:12 +00001603 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001604 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001605 else if (Name == "sse2")
Mike Stump11289f42009-09-09 15:08:12 +00001606 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001607 Features["sse41"] = Features["sse42"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001608 else if (Name == "sse3")
Mike Stump11289f42009-09-09 15:08:12 +00001609 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001610 Features["sse42"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001611 else if (Name == "ssse3")
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001612 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Michael J. Spencera9e41172011-04-17 19:22:03 +00001613 else if (Name == "sse4" || Name == "sse4.1")
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001614 Features["sse41"] = Features["sse42"] = false;
Eric Christophercfeceff2010-03-04 02:31:44 +00001615 else if (Name == "sse4.2")
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001616 Features["sse42"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001617 else if (Name == "3dnow")
1618 Features["3dnow"] = Features["3dnowa"] = false;
1619 else if (Name == "3dnowa")
1620 Features["3dnowa"] = false;
Eric Christophere1ddaf92010-04-02 23:50:19 +00001621 else if (Name == "aes")
1622 Features["aes"] = false;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001623 else if (Name == "avx")
1624 Features["avx"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001625 }
1626
1627 return true;
1628}
1629
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001630/// HandleTargetOptions - Perform initialization based on the user
1631/// configured set of features.
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00001632void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar979586e2009-11-11 09:38:56 +00001633 // Remember the maximum enabled sselevel.
1634 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1635 // Ignore disabled features.
1636 if (Features[i][0] == '-')
1637 continue;
1638
Eric Christophere1ddaf92010-04-02 23:50:19 +00001639 if (Features[i].substr(1) == "aes") {
1640 HasAES = true;
1641 continue;
1642 }
1643
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001644 // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1645 // For now let it be enabled together with other SSE levels.
1646 if (Features[i].substr(1) == "avx") {
1647 HasAVX = true;
1648 continue;
1649 }
1650
Daniel Dunbar979586e2009-11-11 09:38:56 +00001651 assert(Features[i][0] == '+' && "Invalid target feature!");
1652 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1653 .Case("sse42", SSE42)
1654 .Case("sse41", SSE41)
1655 .Case("ssse3", SSSE3)
Nuno Lopes4cbc8bd2010-03-12 10:20:09 +00001656 .Case("sse3", SSE3)
Daniel Dunbar979586e2009-11-11 09:38:56 +00001657 .Case("sse2", SSE2)
1658 .Case("sse", SSE1)
Eli Friedman33465822011-07-08 23:31:17 +00001659 .Default(NoSSE);
Daniel Dunbar979586e2009-11-11 09:38:56 +00001660 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001661
Eli Friedman33465822011-07-08 23:31:17 +00001662 MMX3DNowEnum ThreeDNowLevel =
1663 llvm::StringSwitch<MMX3DNowEnum>(Features[i].substr(1))
Anders Carlssone437c682010-01-27 03:47:49 +00001664 .Case("3dnowa", AMD3DNowAthlon)
1665 .Case("3dnow", AMD3DNow)
Eli Friedman33465822011-07-08 23:31:17 +00001666 .Case("mmx", MMX)
1667 .Default(NoMMX3DNow);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001668
Eli Friedman33465822011-07-08 23:31:17 +00001669 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar979586e2009-11-11 09:38:56 +00001670 }
Eli Friedman33465822011-07-08 23:31:17 +00001671
1672 // Don't tell the backend if we're turning off mmx; it will end up disabling
1673 // SSE, which we don't want.
1674 std::vector<std::string>::iterator it;
1675 it = std::find(Features.begin(), Features.end(), "-mmx");
1676 if (it != Features.end())
1677 Features.erase(it);
Chris Lattnerc25d8a72009-03-02 22:20:04 +00001678}
Chris Lattnerecd49032009-03-02 22:27:17 +00001679
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001680/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
1681/// definitions for this particular subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001682void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001683 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +00001684 // Target identification.
1685 if (PointerWidth == 64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001686 Builder.defineMacro("_LP64");
1687 Builder.defineMacro("__LP64__");
1688 Builder.defineMacro("__amd64__");
1689 Builder.defineMacro("__amd64");
1690 Builder.defineMacro("__x86_64");
1691 Builder.defineMacro("__x86_64__");
Chris Lattnerecd49032009-03-02 22:27:17 +00001692 } else {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001693 DefineStd(Builder, "i386", Opts);
Chris Lattnerecd49032009-03-02 22:27:17 +00001694 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001695
Chris Lattnerecd49032009-03-02 22:27:17 +00001696 // Subtarget options.
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001697 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
1698 // truly should be based on -mtune options.
Chandler Carruth212334f2011-09-28 08:55:37 +00001699 switch (CPU) {
1700 case CK_Generic:
1701 break;
1702 case CK_i386:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001703 // The rest are coming from the i386 define above.
1704 Builder.defineMacro("__tune_i386__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001705 break;
1706 case CK_i486:
1707 case CK_WinChipC6:
1708 case CK_WinChip2:
1709 case CK_C3:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001710 Builder.defineMacro("__i486");
1711 Builder.defineMacro("__i486__");
1712 Builder.defineMacro("__tune_i486__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001713 break;
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00001714 case CK_PentiumMMX:
1715 Builder.defineMacro("__pentium_mmx__");
1716 Builder.defineMacro("__tune_pentium_mmx__");
1717 // Fallthrough
Chandler Carruth212334f2011-09-28 08:55:37 +00001718 case CK_i586:
1719 case CK_Pentium:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001720 Builder.defineMacro("__i586");
1721 Builder.defineMacro("__i586__");
1722 Builder.defineMacro("__tune_i586__");
1723 Builder.defineMacro("__pentium");
1724 Builder.defineMacro("__pentium__");
1725 Builder.defineMacro("__tune_pentium__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001726 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00001727 case CK_Pentium3:
1728 case CK_Pentium3M:
1729 case CK_PentiumM:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00001730 Builder.defineMacro("__tune_pentium3__");
1731 // Fallthrough
1732 case CK_Pentium2:
Chandler Carruth212334f2011-09-28 08:55:37 +00001733 case CK_C3_2:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00001734 Builder.defineMacro("__tune_pentium2__");
1735 // Fallthrough
1736 case CK_PentiumPro:
1737 Builder.defineMacro("__tune_i686__");
1738 Builder.defineMacro("__tune_pentiumpro__");
1739 // Fallthrough
1740 case CK_i686:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001741 Builder.defineMacro("__i686");
1742 Builder.defineMacro("__i686__");
1743 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
1744 Builder.defineMacro("__pentiumpro");
1745 Builder.defineMacro("__pentiumpro__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001746 break;
1747 case CK_Pentium4:
1748 case CK_Pentium4M:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001749 Builder.defineMacro("__pentium4");
1750 Builder.defineMacro("__pentium4__");
1751 Builder.defineMacro("__tune_pentium4__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001752 break;
1753 case CK_Yonah:
1754 case CK_Prescott:
1755 case CK_Nocona:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001756 Builder.defineMacro("__nocona");
1757 Builder.defineMacro("__nocona__");
1758 Builder.defineMacro("__tune_nocona__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001759 break;
1760 case CK_Core2:
1761 case CK_Penryn:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001762 Builder.defineMacro("__core2");
1763 Builder.defineMacro("__core2__");
1764 Builder.defineMacro("__tune_core2__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001765 break;
1766 case CK_Atom:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001767 Builder.defineMacro("__atom");
1768 Builder.defineMacro("__atom__");
1769 Builder.defineMacro("__tune_atom__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001770 break;
1771 case CK_Corei7:
1772 case CK_Corei7AVX:
1773 case CK_CoreAVXi:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001774 Builder.defineMacro("__corei7");
1775 Builder.defineMacro("__corei7__");
1776 Builder.defineMacro("__tune_corei7__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001777 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00001778 case CK_K6_2:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00001779 Builder.defineMacro("__k6_2__");
1780 Builder.defineMacro("__tune_k6_2__");
1781 // Fallthrough
Chandler Carruth212334f2011-09-28 08:55:37 +00001782 case CK_K6_3:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00001783 if (CPU != CK_K6_2) { // In case of fallthrough
1784 // FIXME: GCC may be enabling these in cases where some other k6
1785 // architecture is specified but -m3dnow is explicitly provided. The
1786 // exact semantics need to be determined and emulated here.
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001787 Builder.defineMacro("__k6_3__");
1788 Builder.defineMacro("__tune_k6_3__");
1789 }
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00001790 // Fallthrough
1791 case CK_K6:
1792 Builder.defineMacro("__k6");
1793 Builder.defineMacro("__k6__");
1794 Builder.defineMacro("__tune_k6__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001795 break;
1796 case CK_Athlon:
1797 case CK_AthlonThunderbird:
1798 case CK_Athlon4:
1799 case CK_AthlonXP:
1800 case CK_AthlonMP:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001801 Builder.defineMacro("__athlon");
1802 Builder.defineMacro("__athlon__");
1803 Builder.defineMacro("__tune_athlon__");
Chandler Carruth5d0feef2011-09-28 09:54:11 +00001804 if (SSELevel != NoSSE) {
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001805 Builder.defineMacro("__athlon_sse__");
Chandler Carruth5d0feef2011-09-28 09:54:11 +00001806 Builder.defineMacro("__tune_athlon_sse__");
1807 }
Chandler Carruth212334f2011-09-28 08:55:37 +00001808 break;
1809 case CK_K8:
1810 case CK_K8SSE3:
1811 case CK_x86_64:
1812 case CK_Opteron:
1813 case CK_OpteronSSE3:
1814 case CK_Athlon64:
1815 case CK_Athlon64SSE3:
1816 case CK_AthlonFX:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001817 Builder.defineMacro("__k8");
1818 Builder.defineMacro("__k8__");
1819 Builder.defineMacro("__tune_k8__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001820 break;
1821 case CK_Geode:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001822 Builder.defineMacro("__geode");
1823 Builder.defineMacro("__geode__");
1824 Builder.defineMacro("__tune_geode__");
Chandler Carruth212334f2011-09-28 08:55:37 +00001825 break;
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00001826 }
Chris Lattner96e43572009-03-02 22:40:39 +00001827
Chandler Carruth3f7ed952011-09-28 09:54:07 +00001828 // Target properties.
1829 Builder.defineMacro("__LITTLE_ENDIAN__");
1830 Builder.defineMacro("__REGISTER_PREFIX__", "");
1831
Chris Lattner6df41af2009-04-19 17:32:33 +00001832 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1833 // functions in glibc header files that use FP Stack inline asm which the
1834 // backend can't deal with (PR879).
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001835 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001836
Chandler Carruth3f7ed952011-09-28 09:54:07 +00001837 if (HasAES)
1838 Builder.defineMacro("__AES__");
1839
1840 if (HasAVX)
1841 Builder.defineMacro("__AVX__");
1842
Chris Lattner96e43572009-03-02 22:40:39 +00001843 // Each case falls through to the previous one here.
1844 switch (SSELevel) {
1845 case SSE42:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001846 Builder.defineMacro("__SSE4_2__");
Chris Lattner96e43572009-03-02 22:40:39 +00001847 case SSE41:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001848 Builder.defineMacro("__SSE4_1__");
Chris Lattner96e43572009-03-02 22:40:39 +00001849 case SSSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001850 Builder.defineMacro("__SSSE3__");
Chris Lattner96e43572009-03-02 22:40:39 +00001851 case SSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001852 Builder.defineMacro("__SSE3__");
Chris Lattner96e43572009-03-02 22:40:39 +00001853 case SSE2:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001854 Builder.defineMacro("__SSE2__");
1855 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner96e43572009-03-02 22:40:39 +00001856 case SSE1:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001857 Builder.defineMacro("__SSE__");
1858 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedman33465822011-07-08 23:31:17 +00001859 case NoSSE:
Chris Lattner96e43572009-03-02 22:40:39 +00001860 break;
1861 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00001862
Francois Pichet0706d202011-09-17 17:15:52 +00001863 if (Opts.MicrosoftExt && PointerWidth == 32) {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001864 switch (SSELevel) {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00001865 case SSE42:
1866 case SSE41:
1867 case SSSE3:
1868 case SSE3:
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001869 case SSE2:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001870 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001871 break;
1872 case SSE1:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001873 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001874 break;
1875 default:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001876 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001877 }
1878 }
1879
Anders Carlssone437c682010-01-27 03:47:49 +00001880 // Each case falls through to the previous one here.
Eli Friedman33465822011-07-08 23:31:17 +00001881 switch (MMX3DNowLevel) {
Anders Carlssone437c682010-01-27 03:47:49 +00001882 case AMD3DNowAthlon:
1883 Builder.defineMacro("__3dNOW_A__");
1884 case AMD3DNow:
1885 Builder.defineMacro("__3dNOW__");
Eli Friedman33465822011-07-08 23:31:17 +00001886 case MMX:
1887 Builder.defineMacro("__MMX__");
1888 case NoMMX3DNow:
Anders Carlssone437c682010-01-27 03:47:49 +00001889 break;
1890 }
Chris Lattnerecd49032009-03-02 22:27:17 +00001891}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001892
1893
Eli Friedman3fd920a2008-08-20 02:34:37 +00001894bool
Anders Carlsson58436352009-02-28 17:11:49 +00001895X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +00001896 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson58436352009-02-28 17:11:49 +00001897 switch (*Name) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001898 default: return false;
Dale Johannesen46742a42010-08-24 22:33:12 +00001899 case 'Y': // first letter of a pair:
1900 switch (*(Name+1)) {
1901 default: return false;
1902 case '0': // First SSE register.
1903 case 't': // Any SSE register, when SSE2 is enabled.
1904 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
1905 case 'm': // any MMX register, when inter-unit moves enabled.
1906 break; // falls through to setAllowsRegister.
1907 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00001908 case 'a': // eax.
1909 case 'b': // ebx.
1910 case 'c': // ecx.
1911 case 'd': // edx.
1912 case 'S': // esi.
1913 case 'D': // edi.
1914 case 'A': // edx:eax.
Dale Johannesen46742a42010-08-24 22:33:12 +00001915 case 'f': // any x87 floating point stack register.
Eli Friedman3fd920a2008-08-20 02:34:37 +00001916 case 't': // top of floating point stack.
1917 case 'u': // second from top of floating point stack.
1918 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson83661ac2008-10-06 00:41:45 +00001919 case 'y': // Any MMX register.
Anders Carlsson5f7ee682008-10-06 19:17:39 +00001920 case 'x': // Any SSE register.
Eli Friedman3fd920a2008-08-20 02:34:37 +00001921 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen46742a42010-08-24 22:33:12 +00001922 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
1923 case 'l': // "Index" registers: any general register that can be used as an
1924 // index in a base+index memory access.
1925 Info.setAllowsRegister();
1926 return true;
1927 case 'C': // SSE floating point constant.
1928 case 'G': // x87 floating point constant.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001929 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssona0b89212009-01-24 18:03:09 +00001930 // x86_64 instructions.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001931 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssona0b89212009-01-24 18:03:09 +00001932 // x86_64 instructions.
Eli Friedman3fd920a2008-08-20 02:34:37 +00001933 return true;
1934 }
Dale Johannesen46742a42010-08-24 22:33:12 +00001935 return false;
Eli Friedman3fd920a2008-08-20 02:34:37 +00001936}
1937
Dale Johannesen7d3dfc02010-10-29 23:12:32 +00001938
Eli Friedman3fd920a2008-08-20 02:34:37 +00001939std::string
Stuart Hastings7fdc6702011-06-07 23:45:05 +00001940X86TargetInfo::convertConstraint(const char *&Constraint) const {
1941 switch (*Constraint) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001942 case 'a': return std::string("{ax}");
1943 case 'b': return std::string("{bx}");
1944 case 'c': return std::string("{cx}");
1945 case 'd': return std::string("{dx}");
1946 case 'S': return std::string("{si}");
1947 case 'D': return std::string("{di}");
Dale Johannesen70f564e2010-10-22 21:07:10 +00001948 case 'p': // address
1949 return std::string("im");
Eli Friedman3fd920a2008-08-20 02:34:37 +00001950 case 't': // top of floating point stack.
1951 return std::string("{st}");
1952 case 'u': // second from top of floating point stack.
1953 return std::string("{st(1)}"); // second from top of floating point stack.
1954 default:
Stuart Hastings7fdc6702011-06-07 23:45:05 +00001955 return std::string(1, *Constraint);
Eli Friedman3fd920a2008-08-20 02:34:37 +00001956 }
1957}
Eli Friedman3fd920a2008-08-20 02:34:37 +00001958} // end anonymous namespace
Chris Lattner5ba61f02006-10-14 07:39:34 +00001959
1960namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001961// X86-32 generic target
1962class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00001963public:
Eli Friedman3fd920a2008-08-20 02:34:37 +00001964 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1965 DoubleAlign = LongLongAlign = 32;
1966 LongDoubleWidth = 96;
1967 LongDoubleAlign = 32;
Eli Friedman873f65a2008-08-21 00:13:15 +00001968 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1969 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00001970 "a0:0:64-f80:32:32-n8:16:32";
Eli Friedman32ca82a2009-03-29 20:31:09 +00001971 SizeType = UnsignedInt;
1972 PtrDiffType = SignedInt;
1973 IntPtrType = SignedInt;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00001974 RegParmMax = 3;
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00001975
1976 // Use fpret for all types.
1977 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
1978 (1 << TargetInfo::Double) |
1979 (1 << TargetInfo::LongDouble));
Eli Friedman3fd920a2008-08-20 02:34:37 +00001980 }
1981 virtual const char *getVAListDeclaration() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001982 return "typedef char* __builtin_va_list;";
Eli Friedman3fd920a2008-08-20 02:34:37 +00001983 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001984
Chris Lattnerd545ad12009-09-23 06:06:36 +00001985 int getEHDataRegisterNumber(unsigned RegNo) const {
1986 if (RegNo == 0) return 0;
1987 if (RegNo == 1) return 2;
1988 return -1;
1989 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00001990};
1991} // end anonymous namespace
1992
1993namespace {
Eli Friedmane3aa4542009-07-05 18:47:56 +00001994class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
1995public:
1996 OpenBSDI386TargetInfo(const std::string& triple) :
1997 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
1998 SizeType = UnsignedLong;
1999 IntPtrType = SignedLong;
Eli Friedman245f2292009-07-05 22:31:18 +00002000 PtrDiffType = SignedLong;
Eli Friedmane3aa4542009-07-05 18:47:56 +00002001 }
2002};
2003} // end anonymous namespace
2004
2005namespace {
Torok Edwinb2b37c62009-06-30 17:10:35 +00002006class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman3fd920a2008-08-20 02:34:37 +00002007public:
Torok Edwinb2b37c62009-06-30 17:10:35 +00002008 DarwinI386TargetInfo(const std::string& triple) :
2009 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00002010 LongDoubleWidth = 128;
2011 LongDoubleAlign = 128;
Eli Friedman32ca82a2009-03-29 20:31:09 +00002012 SizeType = UnsignedLong;
2013 IntPtrType = SignedLong;
Eli Friedman873f65a2008-08-21 00:13:15 +00002014 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2015 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00002016 "a0:0:64-f80:128:128-n8:16:32";
Daniel Dunbarbd606522010-05-27 00:35:16 +00002017 HasAlignMac68kSupport = true;
Torok Edwin4e054162009-06-30 17:00:25 +00002018 }
2019
Eli Friedman3fd920a2008-08-20 02:34:37 +00002020};
Daniel Dunbar10de9e62009-06-29 20:52:51 +00002021} // end anonymous namespace
2022
2023namespace {
Eli Friedmanc968a6a2008-08-21 01:40:19 +00002024// x86-32 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002025class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedmanc968a6a2008-08-21 01:40:19 +00002026public:
2027 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002028 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmand88c8a12009-04-19 21:38:35 +00002029 TLSSupported = false;
Chris Lattner46be2e12009-06-24 17:12:15 +00002030 WCharType = UnsignedShort;
Eli Friedmanebb9e4d2009-06-08 21:16:17 +00002031 DoubleAlign = LongLongAlign = 64;
2032 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 +00002033 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
2034 "v128:128:128-a0:0:64-f80:32:32-n8:16:32";
Eli Friedmanc968a6a2008-08-21 01:40:19 +00002035 }
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002036 virtual void getTargetDefines(const LangOptions &Opts,
2037 MacroBuilder &Builder) const {
2038 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2039 }
2040};
2041} // end anonymous namespace
2042
2043namespace {
2044
2045// x86-32 Windows Visual Studio target
2046class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2047public:
2048 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2049 : WindowsX86_32TargetInfo(triple) {
Eli Friedman015d6282011-03-22 21:25:11 +00002050 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002051 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2052 }
2053 virtual void getTargetDefines(const LangOptions &Opts,
2054 MacroBuilder &Builder) const {
2055 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2056 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2057 // The value of the following reflects processor type.
2058 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2059 // We lost the original triple, so we use the default.
2060 Builder.defineMacro("_M_IX86", "600");
2061 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002062};
2063} // end anonymous namespace
2064
2065namespace {
2066// x86-32 MinGW target
2067class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2068public:
2069 MinGWX86_32TargetInfo(const std::string& triple)
2070 : WindowsX86_32TargetInfo(triple) {
2071 }
2072 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002073 MacroBuilder &Builder) const {
2074 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002075 DefineStd(Builder, "WIN32", Opts);
2076 DefineStd(Builder, "WINNT", Opts);
2077 Builder.defineMacro("_X86_");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002078 Builder.defineMacro("__MSVCRT__");
2079 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumib2beb012011-03-15 02:32:50 +00002080
2081 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2082 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet0706d202011-09-17 17:15:52 +00002083 if (Opts.MicrosoftExt)
NAKAMURA Takumib2beb012011-03-15 02:32:50 +00002084 // Provide "as-is" __declspec.
2085 Builder.defineMacro("__declspec", "__declspec");
2086 else
2087 // Provide alias of __attribute__ like mingw32-gcc.
2088 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002089 }
2090};
2091} // end anonymous namespace
2092
2093namespace {
2094// x86-32 Cygwin target
2095class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2096public:
2097 CygwinX86_32TargetInfo(const std::string& triple)
2098 : X86_32TargetInfo(triple) {
2099 TLSSupported = false;
2100 WCharType = UnsignedShort;
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002101 DoubleAlign = LongLongAlign = 64;
2102 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2103 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00002104 "a0:0:64-f80:32:32-n8:16:32";
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002105 }
2106 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002107 MacroBuilder &Builder) const {
2108 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2109 Builder.defineMacro("__CYGWIN__");
2110 Builder.defineMacro("__CYGWIN32__");
2111 DefineStd(Builder, "unix", Opts);
Douglas Gregor3ecc6652010-04-21 05:52:38 +00002112 if (Opts.CPlusPlus)
2113 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanaa27a872009-06-08 06:11:14 +00002114 }
Eli Friedmanc968a6a2008-08-21 01:40:19 +00002115};
2116} // end anonymous namespace
2117
2118namespace {
Chris Lattnerb986aba2010-04-11 19:29:39 +00002119// x86-32 Haiku target
2120class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2121public:
2122 HaikuX86_32TargetInfo(const std::string& triple)
2123 : X86_32TargetInfo(triple) {
2124 SizeType = UnsignedLong;
Chris Lattner8b290212010-04-22 17:48:00 +00002125 IntPtrType = SignedLong;
2126 PtrDiffType = SignedLong;
Rafael Espindolac55be6d2010-11-09 16:41:02 +00002127 this->UserLabelPrefix = "";
Eli Friedman04831922010-08-22 01:00:03 +00002128 }
Chris Lattnerb986aba2010-04-11 19:29:39 +00002129 virtual void getTargetDefines(const LangOptions &Opts,
2130 MacroBuilder &Builder) const {
2131 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2132 Builder.defineMacro("__INTEL__");
2133 Builder.defineMacro("__HAIKU__");
2134 }
2135};
2136} // end anonymous namespace
2137
Douglas Gregor9fabd852011-07-01 22:41:14 +00002138// RTEMS Target
2139template<typename Target>
2140class RTEMSTargetInfo : public OSTargetInfo<Target> {
2141protected:
2142 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2143 MacroBuilder &Builder) const {
2144 // RTEMS defines; list based off of gcc output
2145
Douglas Gregor9fabd852011-07-01 22:41:14 +00002146 Builder.defineMacro("__rtems__");
2147 Builder.defineMacro("__ELF__");
2148 }
2149public:
2150 RTEMSTargetInfo(const std::string &triple)
2151 : OSTargetInfo<Target>(triple) {
2152 this->UserLabelPrefix = "";
2153
2154 llvm::Triple Triple(triple);
2155 switch (Triple.getArch()) {
2156 default:
2157 case llvm::Triple::x86:
2158 // this->MCountName = ".mcount";
2159 break;
2160 case llvm::Triple::mips:
2161 case llvm::Triple::mipsel:
2162 case llvm::Triple::ppc:
2163 case llvm::Triple::ppc64:
2164 // this->MCountName = "_mcount";
2165 break;
2166 case llvm::Triple::arm:
2167 // this->MCountName = "__mcount";
2168 break;
2169 }
2170
2171 }
2172};
2173
2174namespace {
2175// x86-32 RTEMS target
2176class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2177public:
2178 RTEMSX86_32TargetInfo(const std::string& triple)
2179 : X86_32TargetInfo(triple) {
2180 SizeType = UnsignedLong;
2181 IntPtrType = SignedLong;
2182 PtrDiffType = SignedLong;
2183 this->UserLabelPrefix = "";
2184 }
2185 virtual void getTargetDefines(const LangOptions &Opts,
2186 MacroBuilder &Builder) const {
2187 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2188 Builder.defineMacro("__INTEL__");
2189 Builder.defineMacro("__rtems__");
2190 }
2191};
2192} // end anonymous namespace
2193
Chris Lattnerb986aba2010-04-11 19:29:39 +00002194namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00002195// x86-64 generic target
2196class X86_64TargetInfo : public X86TargetInfo {
2197public:
Chris Lattner4ba73aa02009-03-20 15:52:06 +00002198 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerba7a6c12008-05-09 06:17:04 +00002199 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedmanb5366062008-05-20 14:21:01 +00002200 LongDoubleWidth = 128;
2201 LongDoubleAlign = 128;
Rafael Espindolae971b9a2010-06-04 23:15:27 +00002202 LargeArrayMinWidth = 128;
2203 LargeArrayAlign = 128;
Chris Lattnerd0a79b22009-02-05 07:32:46 +00002204 IntMaxType = SignedLong;
2205 UIntMaxType = UnsignedLong;
Eli Friedman2857ccb2009-07-01 03:36:11 +00002206 Int64Type = SignedLong;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00002207 RegParmMax = 6;
Chris Lattnerd0a79b22009-02-05 07:32:46 +00002208
Eli Friedman873f65a2008-08-21 00:13:15 +00002209 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2210 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00002211 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64";
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00002212
2213 // Use fpret only for long double.
2214 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Chris Lattner10a5b382007-01-29 05:24:35 +00002215 }
Anders Carlssona7408e72007-10-13 00:45:48 +00002216 virtual const char *getVAListDeclaration() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002217 return "typedef struct __va_list_tag {"
2218 " unsigned gp_offset;"
2219 " unsigned fp_offset;"
2220 " void* overflow_arg_area;"
2221 " void* reg_save_area;"
John McCall61d82582010-05-28 18:25:28 +00002222 "} __va_list_tag;"
Eli Friedmanfb36b022009-07-03 00:45:06 +00002223 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson5fa3f342007-11-24 23:38:12 +00002224 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00002225
Chris Lattnerd545ad12009-09-23 06:06:36 +00002226 int getEHDataRegisterNumber(unsigned RegNo) const {
2227 if (RegNo == 0) return 0;
2228 if (RegNo == 1) return 1;
2229 return -1;
2230 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00002231};
2232} // end anonymous namespace
2233
2234namespace {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002235// x86-64 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002236class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002237public:
2238 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002239 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002240 TLSSupported = false;
2241 WCharType = UnsignedShort;
Mike Stumpaf9afe92009-10-08 23:00:00 +00002242 LongWidth = LongAlign = 32;
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00002243 DoubleAlign = LongLongAlign = 64;
Nate Begeman6e8865a2010-07-21 02:02:56 +00002244 IntMaxType = SignedLongLong;
2245 UIntMaxType = UnsignedLongLong;
2246 Int64Type = SignedLongLong;
Cameron Esfahanieb856502010-09-15 00:28:12 +00002247 SizeType = UnsignedLongLong;
2248 PtrDiffType = SignedLongLong;
2249 IntPtrType = SignedLongLong;
NAKAMURA Takumif7c30222011-01-17 22:56:08 +00002250 this->UserLabelPrefix = "";
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002251 }
2252 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002253 MacroBuilder &Builder) const {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002254 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002255 Builder.defineMacro("_WIN64");
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002256 }
NAKAMURA Takumia2e468c2011-01-17 22:56:23 +00002257 virtual const char *getVAListDeclaration() const {
2258 return "typedef char* __builtin_va_list;";
2259 }
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002260};
2261} // end anonymous namespace
2262
2263namespace {
2264// x86-64 Windows Visual Studio target
2265class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2266public:
2267 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2268 : WindowsX86_64TargetInfo(triple) {
Eli Friedman015d6282011-03-22 21:25:11 +00002269 LongDoubleWidth = LongDoubleAlign = 64;
2270 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002271 }
2272 virtual void getTargetDefines(const LangOptions &Opts,
2273 MacroBuilder &Builder) const {
2274 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
2275 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002276 Builder.defineMacro("_M_X64");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002277 Builder.defineMacro("_M_AMD64");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002278 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002279};
2280} // end anonymous namespace
2281
2282namespace {
2283// x86-64 MinGW target
2284class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2285public:
2286 MinGWX86_64TargetInfo(const std::string& triple)
2287 : WindowsX86_64TargetInfo(triple) {
2288 }
2289 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002290 MacroBuilder &Builder) const {
2291 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002292 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002293 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi2b7eeb22011-03-08 12:06:46 +00002294 Builder.defineMacro("__MINGW32__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002295 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumib2beb012011-03-15 02:32:50 +00002296
2297 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2298 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet0706d202011-09-17 17:15:52 +00002299 if (Opts.MicrosoftExt)
NAKAMURA Takumib2beb012011-03-15 02:32:50 +00002300 // Provide "as-is" __declspec.
2301 Builder.defineMacro("__declspec", "__declspec");
2302 else
2303 // Provide alias of __attribute__ like mingw32-gcc.
2304 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002305 }
2306};
2307} // end anonymous namespace
2308
2309namespace {
Eli Friedman2857ccb2009-07-01 03:36:11 +00002310class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2311public:
Mike Stump11289f42009-09-09 15:08:12 +00002312 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman2857ccb2009-07-01 03:36:11 +00002313 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2314 Int64Type = SignedLongLong;
2315 }
2316};
2317} // end anonymous namespace
2318
2319namespace {
Eli Friedman245f2292009-07-05 22:31:18 +00002320class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
2321public:
Mike Stump11289f42009-09-09 15:08:12 +00002322 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman245f2292009-07-05 22:31:18 +00002323 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
2324 IntMaxType = SignedLongLong;
2325 UIntMaxType = UnsignedLongLong;
2326 Int64Type = SignedLongLong;
2327 }
2328};
2329} // end anonymous namespace
2330
2331namespace {
Eli Friedmanf05b7722008-08-20 07:44:10 +00002332class ARMTargetInfo : public TargetInfo {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002333 // Possible FPU choices.
2334 enum FPUMode {
2335 NoFPU,
2336 VFP2FPU,
2337 VFP3FPU,
2338 NeonFPU
2339 };
2340
2341 static bool FPUModeIsVFP(FPUMode Mode) {
2342 return Mode >= VFP2FPU && Mode <= NeonFPU;
2343 }
2344
2345 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2346 static const char * const GCCRegNames[];
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002347
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002348 std::string ABI, CPU;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002349
2350 unsigned FPU : 3;
2351
Daniel Dunbar893d4752009-12-19 04:15:38 +00002352 unsigned IsThumb : 1;
2353
2354 // Initialized via features.
2355 unsigned SoftFloat : 1;
2356 unsigned SoftFloatABI : 1;
Daniel Dunbarb4091a92009-09-14 00:35:03 +00002357
Chris Lattner5cc15e02010-03-03 19:03:45 +00002358 static const Builtin::Info BuiltinInfo[];
2359
Chris Lattner17df24e2008-04-21 18:56:49 +00002360public:
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00002361 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002362 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbarb4091a92009-09-14 00:35:03 +00002363 {
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00002364 SizeType = UnsignedInt;
2365 PtrDiffType = SignedInt;
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00002366
Chris Lattner1a8f3942010-04-23 16:29:58 +00002367 // {} in inline assembly are neon specifiers, not assembly variant
2368 // specifiers.
2369 NoAsmVariants = true;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002370
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002371 // FIXME: Should we just treat this as a feature?
Daniel Dunbarc454ecf2009-12-18 19:57:13 +00002372 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbar03184792009-09-22 21:44:58 +00002373 if (IsThumb) {
Sandeep Patelf87b3732011-04-04 22:58:12 +00002374 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2375 // so set preferred for small types to 32.
Daniel Dunbar03184792009-09-22 21:44:58 +00002376 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
2377 "i64:64:64-f32:32:32-f64:64:64-"
Bob Wilsone3a15fe2011-04-04 16:53:11 +00002378 "v64:64:64-v128:64:128-a0:0:32-n32");
Daniel Dunbar03184792009-09-22 21:44:58 +00002379 } else {
2380 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2381 "i64:64:64-f32:32:32-f64:64:64-"
Bob Wilsone3a15fe2011-04-04 16:53:11 +00002382 "v64:64:64-v128:64:128-a0:0:64-n32");
Daniel Dunbar03184792009-09-22 21:44:58 +00002383 }
John McCall86353412010-08-21 22:46:04 +00002384
2385 // ARM targets default to using the ARM C++ ABI.
2386 CXXABI = CXXABI_ARM;
Eli Friedmanb5366062008-05-20 14:21:01 +00002387 }
Daniel Dunbarb4091a92009-09-14 00:35:03 +00002388 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00002389 virtual bool setABI(const std::string &Name) {
Daniel Dunbarb4091a92009-09-14 00:35:03 +00002390 ABI = Name;
2391
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00002392 // The defaults (above) are for AAPCS, check if we need to change them.
2393 //
2394 // FIXME: We need support for -meabi... we could just mangle it into the
2395 // name.
2396 if (Name == "apcs-gnu") {
Daniel Dunbar377dc2f2010-01-27 20:23:08 +00002397 DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00002398 SizeType = UnsignedLong;
2399
Daniel Dunbarf8125062010-04-22 16:14:54 +00002400 // Do not respect the alignment of bit-field types when laying out
2401 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
2402 UseBitFieldTypeAlignment = false;
2403
Chad Rosier18903ee2011-08-04 01:21:14 +00002404 /// Do force alignment of members that follow zero length bitfields. If
2405 /// the alignment of the zero-length bitfield is greater than the member
2406 /// that follows it, `bar', `bar' will be aligned as the type of the
2407 /// zero length bitfield.
2408 UseZeroLengthBitfieldAlignment = true;
2409
2410 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosiera336c6f2011-08-04 17:52:43 +00002411 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
2412 /// gcc.
Chad Rosier18903ee2011-08-04 01:21:14 +00002413 ZeroLengthBitfieldBoundary = 32;
2414
Daniel Dunbar03184792009-09-22 21:44:58 +00002415 if (IsThumb) {
Sandeep Patelf87b3732011-04-04 22:58:12 +00002416 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2417 // so set preferred for small types to 32.
Daniel Dunbar03184792009-09-22 21:44:58 +00002418 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 +00002419 "i64:32:64-f32:32:32-f64:32:64-"
Bob Wilsone3a15fe2011-04-04 16:53:11 +00002420 "v64:32:64-v128:32:128-a0:0:32-n32");
Daniel Dunbar03184792009-09-22 21:44:58 +00002421 } else {
2422 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 +00002423 "i64:32:64-f32:32:32-f64:32:64-"
2424 "v64:32:64-v128:32:128-a0:0:32-n32");
Daniel Dunbar03184792009-09-22 21:44:58 +00002425 }
2426
Chad Rosier99ee7822011-07-26 07:03:04 +00002427 // FIXME: Override "preferred align" for double and long long.
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00002428 } else if (Name == "aapcs") {
2429 // FIXME: Enumerated types are variable width in straight AAPCS.
2430 } else if (Name == "aapcs-linux") {
Chad Rosier99ee7822011-07-26 07:03:04 +00002431 ;
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00002432 } else
2433 return false;
2434
2435 return true;
2436 }
Daniel Dunbar893d4752009-12-19 04:15:38 +00002437
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00002438 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002439 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
2440 Features["vfp2"] = true;
2441 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
2442 Features["neon"] = true;
2443 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002444
Daniel Dunbar893d4752009-12-19 04:15:38 +00002445 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2446 const std::string &Name,
2447 bool Enabled) const {
Evan Cheng491f56d2011-07-08 06:40:11 +00002448 if (Name == "soft-float" || Name == "soft-float-abi" ||
2449 Name == "vfp2" || Name == "vfp3" || Name == "neon") {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002450 Features[Name] = Enabled;
2451 } else
Daniel Dunbar893d4752009-12-19 04:15:38 +00002452 return false;
2453
Daniel Dunbar893d4752009-12-19 04:15:38 +00002454 return true;
2455 }
2456
2457 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002458 FPU = NoFPU;
Daniel Dunbar893d4752009-12-19 04:15:38 +00002459 SoftFloat = SoftFloatABI = false;
2460 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
2461 if (Features[i] == "+soft-float")
2462 SoftFloat = true;
2463 else if (Features[i] == "+soft-float-abi")
2464 SoftFloatABI = true;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002465 else if (Features[i] == "+vfp2")
2466 FPU = VFP2FPU;
2467 else if (Features[i] == "+vfp3")
2468 FPU = VFP3FPU;
2469 else if (Features[i] == "+neon")
2470 FPU = NeonFPU;
Daniel Dunbar893d4752009-12-19 04:15:38 +00002471 }
2472
2473 // Remove front-end specific options which the backend handles differently.
2474 std::vector<std::string>::iterator it;
2475 it = std::find(Features.begin(), Features.end(), "+soft-float");
2476 if (it != Features.end())
2477 Features.erase(it);
2478 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2479 if (it != Features.end())
2480 Features.erase(it);
2481 }
2482
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002483 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002484 return llvm::StringSwitch<const char*>(Name)
2485 .Cases("arm8", "arm810", "4")
2486 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2487 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2488 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2489 .Case("ep9312", "4T")
2490 .Cases("arm10tdmi", "arm1020t", "5T")
2491 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2492 .Case("arm926ej-s", "5TEJ")
2493 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2494 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002495 .Case("arm1136j-s", "6J")
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002496 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002497 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002498 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2499 .Cases("cortex-a8", "cortex-a9", "7A")
Bob Wilson44acad82011-01-06 16:57:20 +00002500 .Case("cortex-m3", "7M")
Bob Wilson87ba1d32011-03-21 21:55:25 +00002501 .Case("cortex-m0", "6M")
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002502 .Default(0);
2503 }
2504 virtual bool setCPU(const std::string &Name) {
2505 if (!getCPUDefineSuffix(Name))
2506 return false;
2507
2508 CPU = Name;
2509 return true;
2510 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +00002511 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002512 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +00002513 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002514 Builder.defineMacro("__arm");
2515 Builder.defineMacro("__arm__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002516
Chris Lattnerecd49032009-03-02 22:27:17 +00002517 // Target properties.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002518 Builder.defineMacro("__ARMEL__");
2519 Builder.defineMacro("__LITTLE_ENDIAN__");
2520 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002521
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002522 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002523 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002524
Mike Stump9d54bd72009-04-08 02:07:04 +00002525 // Subtarget options.
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00002526
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002527 // FIXME: It's more complicated than this and we don't really support
2528 // interworking.
2529 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002530 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002531
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002532 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002533 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002534
Daniel Dunbar893d4752009-12-19 04:15:38 +00002535 if (SoftFloat)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002536 Builder.defineMacro("__SOFTFP__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002537
2538 if (CPU == "xscale")
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002539 Builder.defineMacro("__XSCALE__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00002540
Bob Wilson19c1b882011-05-13 18:56:03 +00002541 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00002542 if (IsThumb) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002543 Builder.defineMacro("__THUMBEL__");
2544 Builder.defineMacro("__thumb__");
Bob Wilson19c1b882011-05-13 18:56:03 +00002545 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002546 Builder.defineMacro("__thumb2__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00002547 }
2548
2549 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002550 Builder.defineMacro("__APCS_32__");
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002551
2552 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002553 Builder.defineMacro("__VFP_FP__");
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002554
2555 // This only gets set when Neon instructions are actually available, unlike
2556 // the VFP define, hence the soft float and arch check. This is subtly
2557 // different from gcc, we follow the intent which was that it should be set
2558 // when Neon instructions are actually available.
Bob Wilson19c1b882011-05-13 18:56:03 +00002559 if (FPU == NeonFPU && !SoftFloat && IsARMv7)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002560 Builder.defineMacro("__ARM_NEON__");
Chris Lattner17df24e2008-04-21 18:56:49 +00002561 }
2562 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2563 unsigned &NumRecords) const {
Chris Lattner5cc15e02010-03-03 19:03:45 +00002564 Records = BuiltinInfo;
2565 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner17df24e2008-04-21 18:56:49 +00002566 }
2567 virtual const char *getVAListDeclaration() const {
John McCalle155a3d2011-05-09 02:19:37 +00002568 return "typedef void* __builtin_va_list;";
Chris Lattner17df24e2008-04-21 18:56:49 +00002569 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002570 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002571 unsigned &NumNames) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002572 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002573 unsigned &NumAliases) const;
Anders Carlsson58436352009-02-28 17:11:49 +00002574 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +00002575 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanf05b7722008-08-20 07:44:10 +00002576 // FIXME: Check if this is complete
Anders Carlsson58436352009-02-28 17:11:49 +00002577 switch (*Name) {
Eli Friedmanf05b7722008-08-20 07:44:10 +00002578 default:
Nate Begeman2908fa02008-04-22 05:03:19 +00002579 case 'l': // r0-r7
2580 case 'h': // r8-r15
2581 case 'w': // VFP Floating point register single precision
2582 case 'P': // VFP Floating point register double precision
Chris Lattnerd9725f72009-04-26 07:16:29 +00002583 Info.setAllowsRegister();
Nate Begeman2908fa02008-04-22 05:03:19 +00002584 return true;
Eric Christopherb081ba62011-07-29 21:20:35 +00002585 case 'Q': // A memory address that is a single base register.
2586 Info.setAllowsMemory();
2587 return true;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00002588 case 'U': // a memory reference...
2589 switch (Name[1]) {
2590 case 'q': // ...ARMV4 ldrsb
2591 case 'v': // ...VFP load/store (reg+constant offset)
2592 case 'y': // ...iWMMXt load/store
Eric Christopherd1048542011-06-17 01:40:49 +00002593 case 't': // address valid for load/store opaque types wider
2594 // than 128-bits
2595 case 'n': // valid address for Neon doubleword vector load/store
2596 case 'm': // valid address for Neon element and structure load/store
2597 case 's': // valid address for non-offset loads/stores of quad-word
2598 // values in four ARM registers
Stuart Hastings7fdc6702011-06-07 23:45:05 +00002599 Info.setAllowsMemory();
2600 Name++;
2601 return true;
2602 }
Nate Begeman2908fa02008-04-22 05:03:19 +00002603 }
Chris Lattner17df24e2008-04-21 18:56:49 +00002604 return false;
2605 }
Evan Chengd863adb2011-06-16 19:13:15 +00002606 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings7fdc6702011-06-07 23:45:05 +00002607 std::string R;
2608 switch (*Constraint) {
2609 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings5b7b11c2011-06-08 16:06:31 +00002610 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings7fdc6702011-06-07 23:45:05 +00002611 Constraint++;
2612 break;
Eric Christopher7d237c12011-06-17 00:40:18 +00002613 case 'p': // 'p' should be translated to 'r' by default.
2614 R = std::string("r");
2615 break;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00002616 default:
2617 return std::string(1, *Constraint);
2618 }
2619 return R;
2620 }
Chris Lattner17df24e2008-04-21 18:56:49 +00002621 virtual const char *getClobbers() const {
Eli Friedmanf05b7722008-08-20 07:44:10 +00002622 // FIXME: Is this really right?
Chris Lattner17df24e2008-04-21 18:56:49 +00002623 return "";
2624 }
2625};
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002626
2627const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbar9034aa32010-08-11 02:17:20 +00002628 // Integer registers
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002629 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00002630 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
2631
2632 // Float registers
2633 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2634 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2635 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00002636 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00002637
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00002638 // Double registers
2639 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
2640 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend2b2ad02010-10-28 01:05:37 +00002641 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
2642 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00002643
2644 // Quad registers
Dale Johannesend2b2ad02010-10-28 01:05:37 +00002645 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
2646 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002647};
2648
2649void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar256e1f32010-08-11 02:17:11 +00002650 unsigned &NumNames) const {
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002651 Names = GCCRegNames;
2652 NumNames = llvm::array_lengthof(GCCRegNames);
2653}
2654
2655const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002656 { { "a1" }, "r0" },
2657 { { "a2" }, "r1" },
2658 { { "a3" }, "r2" },
2659 { { "a4" }, "r3" },
2660 { { "v1" }, "r4" },
2661 { { "v2" }, "r5" },
2662 { { "v3" }, "r6" },
2663 { { "v4" }, "r7" },
2664 { { "v5" }, "r8" },
2665 { { "v6", "rfp" }, "r9" },
2666 { { "sl" }, "r10" },
2667 { { "fp" }, "r11" },
2668 { { "ip" }, "r12" },
Daniel Dunbar256e1f32010-08-11 02:17:11 +00002669 { { "r13" }, "sp" },
2670 { { "r14" }, "lr" },
2671 { { "r15" }, "pc" },
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00002672 // The S, D and Q registers overlap, but aren't really aliases; we
2673 // don't want to substitute one of these for a different-sized one.
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002674};
2675
2676void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2677 unsigned &NumAliases) const {
2678 Aliases = GCCRegAliases;
2679 NumAliases = llvm::array_lengthof(GCCRegAliases);
2680}
Chris Lattner5cc15e02010-03-03 19:03:45 +00002681
2682const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00002683#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +00002684#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00002685 ALL_LANGUAGES },
Chris Lattner5cc15e02010-03-03 19:03:45 +00002686#include "clang/Basic/BuiltinsARM.def"
2687};
Chris Lattner17df24e2008-04-21 18:56:49 +00002688} // end anonymous namespace.
2689
Eli Friedmanf05b7722008-08-20 07:44:10 +00002690
2691namespace {
Mike Stump11289f42009-09-09 15:08:12 +00002692class DarwinARMTargetInfo :
Torok Edwinb2b37c62009-06-30 17:10:35 +00002693 public DarwinTargetInfo<ARMTargetInfo> {
2694protected:
Daniel Dunbar40165182009-08-24 09:10:05 +00002695 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002696 MacroBuilder &Builder) const {
Douglas Gregor20b2ebd2011-03-23 00:50:03 +00002697 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmand88c8a12009-04-19 21:38:35 +00002698 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00002699
Torok Edwinb2b37c62009-06-30 17:10:35 +00002700public:
Mike Stump11289f42009-09-09 15:08:12 +00002701 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar3eeeccd2010-05-27 07:00:26 +00002702 : DarwinTargetInfo<ARMTargetInfo>(triple) {
2703 HasAlignMac68kSupport = true;
2704 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00002705};
2706} // end anonymous namespace.
2707
Chris Lattner5ba61f02006-10-14 07:39:34 +00002708namespace {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002709class SparcV8TargetInfo : public TargetInfo {
Chris Lattner9b415d62009-01-27 01:58:38 +00002710 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2711 static const char * const GCCRegNames[];
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002712 bool SoftFloat;
Gabor Greif49991682008-02-21 16:29:08 +00002713public:
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002714 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
2715 // FIXME: Support Sparc quad-precision long double?
Eli Friedman873f65a2008-08-21 00:13:15 +00002716 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 +00002717 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002718 }
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002719 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2720 const std::string &Name,
2721 bool Enabled) const {
2722 if (Name == "soft-float")
2723 Features[Name] = Enabled;
2724 else
2725 return false;
2726
2727 return true;
2728 }
2729 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
2730 SoftFloat = false;
2731 for (unsigned i = 0, e = Features.size(); i != e; ++i)
2732 if (Features[i] == "+soft-float")
2733 SoftFloat = true;
2734 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +00002735 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002736 MacroBuilder &Builder) const {
2737 DefineStd(Builder, "sparc", Opts);
2738 Builder.defineMacro("__sparcv8");
2739 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002740
2741 if (SoftFloat)
2742 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif49991682008-02-21 16:29:08 +00002743 }
2744 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2745 unsigned &NumRecords) const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002746 // FIXME: Implement!
Gabor Greif49991682008-02-21 16:29:08 +00002747 }
2748 virtual const char *getVAListDeclaration() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002749 return "typedef void* __builtin_va_list;";
Gabor Greif49991682008-02-21 16:29:08 +00002750 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002751 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattner9b415d62009-01-27 01:58:38 +00002752 unsigned &NumNames) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002753 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner9b415d62009-01-27 01:58:38 +00002754 unsigned &NumAliases) const;
Anders Carlsson58436352009-02-28 17:11:49 +00002755 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif49991682008-02-21 16:29:08 +00002756 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002757 // FIXME: Implement!
2758 return false;
Gabor Greif49991682008-02-21 16:29:08 +00002759 }
2760 virtual const char *getClobbers() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002761 // FIXME: Implement!
2762 return "";
Gabor Greif49991682008-02-21 16:29:08 +00002763 }
2764};
2765
Chris Lattner9b415d62009-01-27 01:58:38 +00002766const char * const SparcV8TargetInfo::GCCRegNames[] = {
2767 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2768 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2769 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2770 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
2771};
2772
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002773void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattner9b415d62009-01-27 01:58:38 +00002774 unsigned &NumNames) const {
2775 Names = GCCRegNames;
2776 NumNames = llvm::array_lengthof(GCCRegNames);
2777}
2778
2779const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002780 { { "g0" }, "r0" },
2781 { { "g1" }, "r1" },
2782 { { "g2" }, "r2" },
2783 { { "g3" }, "r3" },
2784 { { "g4" }, "r4" },
2785 { { "g5" }, "r5" },
2786 { { "g6" }, "r6" },
2787 { { "g7" }, "r7" },
2788 { { "o0" }, "r8" },
2789 { { "o1" }, "r9" },
2790 { { "o2" }, "r10" },
2791 { { "o3" }, "r11" },
2792 { { "o4" }, "r12" },
2793 { { "o5" }, "r13" },
2794 { { "o6", "sp" }, "r14" },
2795 { { "o7" }, "r15" },
2796 { { "l0" }, "r16" },
2797 { { "l1" }, "r17" },
2798 { { "l2" }, "r18" },
2799 { { "l3" }, "r19" },
2800 { { "l4" }, "r20" },
2801 { { "l5" }, "r21" },
2802 { { "l6" }, "r22" },
2803 { { "l7" }, "r23" },
2804 { { "i0" }, "r24" },
2805 { { "i1" }, "r25" },
2806 { { "i2" }, "r26" },
2807 { { "i3" }, "r27" },
2808 { { "i4" }, "r28" },
2809 { { "i5" }, "r29" },
2810 { { "i6", "fp" }, "r30" },
2811 { { "i7" }, "r31" },
Chris Lattner9b415d62009-01-27 01:58:38 +00002812};
2813
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002814void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner9b415d62009-01-27 01:58:38 +00002815 unsigned &NumAliases) const {
2816 Aliases = GCCRegAliases;
2817 NumAliases = llvm::array_lengthof(GCCRegAliases);
2818}
Gabor Greif49991682008-02-21 16:29:08 +00002819} // end anonymous namespace.
2820
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002821namespace {
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +00002822class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
2823public:
2824 AuroraUXSparcV8TargetInfo(const std::string& triple) :
2825 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
2826 SizeType = UnsignedInt;
2827 PtrDiffType = SignedInt;
2828 }
2829};
Torok Edwinb2b37c62009-06-30 17:10:35 +00002830class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002831public:
2832 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwinb2b37c62009-06-30 17:10:35 +00002833 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmand50881c2008-11-02 02:43:55 +00002834 SizeType = UnsignedInt;
2835 PtrDiffType = SignedInt;
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002836 }
2837};
2838} // end anonymous namespace.
Chris Lattner5ba61f02006-10-14 07:39:34 +00002839
Chris Lattnerb781dc792008-05-08 05:58:21 +00002840namespace {
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002841 class MSP430TargetInfo : public TargetInfo {
2842 static const char * const GCCRegNames[];
2843 public:
2844 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
2845 TLSSupported = false;
Anton Korobeynikovcbc4e982010-01-30 12:55:11 +00002846 IntWidth = 16; IntAlign = 16;
2847 LongWidth = 32; LongLongWidth = 64;
2848 LongAlign = LongLongAlign = 16;
2849 PointerWidth = 16; PointerAlign = 16;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002850 SizeType = UnsignedInt;
2851 IntMaxType = SignedLong;
2852 UIntMaxType = UnsignedLong;
2853 IntPtrType = SignedShort;
2854 PtrDiffType = SignedInt;
Edward O'Callaghan847f2a12009-11-21 00:49:54 +00002855 SigAtomicType = SignedLong;
Anton Korobeynikovd94329a2009-12-19 01:32:37 +00002856 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002857 }
2858 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002859 MacroBuilder &Builder) const {
2860 Builder.defineMacro("MSP430");
2861 Builder.defineMacro("__MSP430__");
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002862 // FIXME: defines for different 'flavours' of MCU
2863 }
2864 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2865 unsigned &NumRecords) const {
2866 // FIXME: Implement.
2867 Records = 0;
2868 NumRecords = 0;
2869 }
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002870 virtual void getGCCRegNames(const char * const *&Names,
2871 unsigned &NumNames) const;
2872 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2873 unsigned &NumAliases) const {
2874 // No aliases.
2875 Aliases = 0;
2876 NumAliases = 0;
2877 }
2878 virtual bool validateAsmConstraint(const char *&Name,
2879 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov051913b2009-10-15 23:17:13 +00002880 // No target constraints for now.
2881 return false;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002882 }
2883 virtual const char *getClobbers() const {
2884 // FIXME: Is this really right?
2885 return "";
2886 }
2887 virtual const char *getVAListDeclaration() const {
2888 // FIXME: implement
Anton Korobeynikov2f910822009-05-08 18:24:57 +00002889 return "typedef char* __builtin_va_list;";
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002890 }
2891 };
2892
2893 const char * const MSP430TargetInfo::GCCRegNames[] = {
2894 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2895 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2896 };
2897
2898 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
2899 unsigned &NumNames) const {
2900 Names = GCCRegNames;
2901 NumNames = llvm::array_lengthof(GCCRegNames);
2902 }
2903}
2904
2905
Anton Korobeynikovb5b703b2009-07-16 20:09:57 +00002906namespace {
2907 class SystemZTargetInfo : public TargetInfo {
2908 static const char * const GCCRegNames[];
2909 public:
2910 SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
2911 TLSSupported = false;
2912 IntWidth = IntAlign = 32;
2913 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
2914 PointerWidth = PointerAlign = 64;
Chris Lattner5c67237f2009-11-07 18:59:41 +00002915 DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
2916 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
Anton Korobeynikovb5b703b2009-07-16 20:09:57 +00002917 }
2918 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002919 MacroBuilder &Builder) const {
2920 Builder.defineMacro("__s390__");
2921 Builder.defineMacro("__s390x__");
Anton Korobeynikovb5b703b2009-07-16 20:09:57 +00002922 }
2923 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2924 unsigned &NumRecords) const {
2925 // FIXME: Implement.
2926 Records = 0;
2927 NumRecords = 0;
2928 }
Anton Korobeynikovb5b703b2009-07-16 20:09:57 +00002929
Anton Korobeynikovb5b703b2009-07-16 20:09:57 +00002930 virtual void getGCCRegNames(const char * const *&Names,
2931 unsigned &NumNames) const;
2932 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2933 unsigned &NumAliases) const {
2934 // No aliases.
2935 Aliases = 0;
2936 NumAliases = 0;
2937 }
2938 virtual bool validateAsmConstraint(const char *&Name,
2939 TargetInfo::ConstraintInfo &info) const {
2940 // FIXME: implement
2941 return true;
2942 }
2943 virtual const char *getClobbers() const {
2944 // FIXME: Is this really right?
2945 return "";
2946 }
2947 virtual const char *getVAListDeclaration() const {
2948 // FIXME: implement
2949 return "typedef char* __builtin_va_list;";
2950 }
2951 };
2952
2953 const char * const SystemZTargetInfo::GCCRegNames[] = {
2954 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2955 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2956 };
2957
2958 void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
2959 unsigned &NumNames) const {
2960 Names = GCCRegNames;
2961 NumNames = llvm::array_lengthof(GCCRegNames);
2962 }
2963}
2964
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00002965namespace {
2966 class BlackfinTargetInfo : public TargetInfo {
2967 static const char * const GCCRegNames[];
2968 public:
2969 BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
2970 TLSSupported = false;
2971 DoubleAlign = 32;
2972 LongLongAlign = 32;
2973 LongDoubleAlign = 32;
Chris Lattner5c67237f2009-11-07 18:59:41 +00002974 DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00002975 }
2976
2977 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002978 MacroBuilder &Builder) const {
2979 DefineStd(Builder, "bfin", Opts);
2980 DefineStd(Builder, "BFIN", Opts);
2981 Builder.defineMacro("__ADSPBLACKFIN__");
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00002982 // FIXME: This one is really dependent on -mcpu
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002983 Builder.defineMacro("__ADSPLPBLACKFIN__");
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00002984 // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
2985 }
2986
2987 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2988 unsigned &NumRecords) const {
2989 // FIXME: Implement.
2990 Records = 0;
2991 NumRecords = 0;
2992 }
2993
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00002994 virtual void getGCCRegNames(const char * const *&Names,
2995 unsigned &NumNames) const;
2996
2997 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2998 unsigned &NumAliases) const {
2999 // No aliases.
3000 Aliases = 0;
3001 NumAliases = 0;
3002 }
3003
3004 virtual bool validateAsmConstraint(const char *&Name,
3005 TargetInfo::ConstraintInfo &Info) const {
3006 if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
3007 Info.setAllowsRegister();
3008 return true;
3009 }
3010 return false;
3011 }
3012
3013 virtual const char *getClobbers() const {
3014 return "";
3015 }
3016
3017 virtual const char *getVAListDeclaration() const {
3018 return "typedef char* __builtin_va_list;";
3019 }
3020 };
3021
3022 const char * const BlackfinTargetInfo::GCCRegNames[] = {
3023 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3024 "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
3025 "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
3026 "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
3027 "a0", "a1", "cc",
3028 "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
3029 "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
3030 };
3031
3032 void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
3033 unsigned &NumNames) const {
3034 Names = GCCRegNames;
3035 NumNames = llvm::array_lengthof(GCCRegNames);
3036 }
3037}
3038
Eli Friedmana9c3d712009-08-19 20:47:07 +00003039namespace {
3040
Mike Stump11289f42009-09-09 15:08:12 +00003041 // LLVM and Clang cannot be used directly to output native binaries for
3042 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmana9c3d712009-08-19 20:47:07 +00003043 // type and alignment information.
Mike Stump11289f42009-09-09 15:08:12 +00003044 //
3045 // TCE uses the llvm bitcode as input and uses it for generating customized
3046 // target processor and program binary. TCE co-design environment is
Eli Friedmana9c3d712009-08-19 20:47:07 +00003047 // publicly available in http://tce.cs.tut.fi
3048
3049 class TCETargetInfo : public TargetInfo{
3050 public:
3051 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
3052 TLSSupported = false;
3053 IntWidth = 32;
3054 LongWidth = LongLongWidth = 32;
Eli Friedmana9c3d712009-08-19 20:47:07 +00003055 PointerWidth = 32;
3056 IntAlign = 32;
3057 LongAlign = LongLongAlign = 32;
3058 PointerAlign = 32;
3059 SizeType = UnsignedInt;
3060 IntMaxType = SignedLong;
3061 UIntMaxType = UnsignedLong;
3062 IntPtrType = SignedInt;
3063 PtrDiffType = SignedInt;
3064 FloatWidth = 32;
3065 FloatAlign = 32;
3066 DoubleWidth = 32;
3067 DoubleAlign = 32;
3068 LongDoubleWidth = 32;
3069 LongDoubleAlign = 32;
3070 FloatFormat = &llvm::APFloat::IEEEsingle;
3071 DoubleFormat = &llvm::APFloat::IEEEsingle;
3072 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner09797542010-03-04 21:07:38 +00003073 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
3074 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumidba4ed32011-02-18 08:44:38 +00003075 "f32:32:32-f64:32:32-v64:32:32-"
3076 "v128:32:32-a0:0:32-n32";
Eli Friedmana9c3d712009-08-19 20:47:07 +00003077 }
3078
3079 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003080 MacroBuilder &Builder) const {
3081 DefineStd(Builder, "tce", Opts);
3082 Builder.defineMacro("__TCE__");
3083 Builder.defineMacro("__TCE_V1__");
Eli Friedmana9c3d712009-08-19 20:47:07 +00003084 }
3085 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3086 unsigned &NumRecords) const {}
Daniel Dunbar576d90d2009-08-24 09:54:37 +00003087 virtual const char *getClobbers() const {
3088 return "";
3089 }
Eli Friedmana9c3d712009-08-19 20:47:07 +00003090 virtual const char *getVAListDeclaration() const {
3091 return "typedef void* __builtin_va_list;";
3092 }
Eli Friedmana9c3d712009-08-19 20:47:07 +00003093 virtual void getGCCRegNames(const char * const *&Names,
3094 unsigned &NumNames) const {}
3095 virtual bool validateAsmConstraint(const char *&Name,
3096 TargetInfo::ConstraintInfo &info) const {
3097 return true;
3098 }
3099 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3100 unsigned &NumAliases) const {}
3101 };
3102}
3103
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003104namespace {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003105class MipsTargetInfoBase : public TargetInfo {
3106 std::string CPU;
3107protected:
3108 std::string ABI;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003109public:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003110 MipsTargetInfoBase(const std::string& triple, const std::string& ABIStr)
3111 : TargetInfo(triple), ABI(ABIStr) {
Akira Hatanakab579fe52011-06-02 00:09:17 +00003112 SizeType = UnsignedInt;
3113 PtrDiffType = SignedInt;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003114 }
Eric Christopher0b26a612010-03-02 02:41:08 +00003115 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003116 virtual bool setABI(const std::string &Name) = 0;
Eric Christopher0b26a612010-03-02 02:41:08 +00003117 virtual bool setCPU(const std::string &Name) {
3118 CPU = Name;
3119 return true;
3120 }
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00003121 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christopher0b26a612010-03-02 02:41:08 +00003122 Features[ABI] = true;
3123 Features[CPU] = true;
3124 }
3125 virtual void getArchDefines(const LangOptions &Opts,
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003126 MacroBuilder &Builder) const = 0;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003127 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003128 MacroBuilder &Builder) const = 0;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003129 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3130 unsigned &NumRecords) const {
3131 // FIXME: Implement!
3132 }
3133 virtual const char *getVAListDeclaration() const {
3134 return "typedef void* __builtin_va_list;";
3135 }
3136 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003137 unsigned &NumNames) const {
3138 static const char * const GCCRegNames[] = {
3139 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
3140 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
3141 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
3142 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
3143 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
3144 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
3145 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
3146 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
3147 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
3148 "$fcc5","$fcc6","$fcc7"
3149 };
3150 Names = GCCRegNames;
3151 NumNames = llvm::array_lengthof(GCCRegNames);
3152 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003153 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003154 unsigned &NumAliases) const = 0;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003155 virtual bool validateAsmConstraint(const char *&Name,
3156 TargetInfo::ConstraintInfo &Info) const {
3157 switch (*Name) {
3158 default:
3159 case 'r': // CPU registers.
3160 case 'd': // Equivalent to "r" unless generating MIPS16 code.
3161 case 'y': // Equivalent to "r", backwards compatibility only.
3162 case 'f': // floating-point registers.
3163 Info.setAllowsRegister();
3164 return true;
3165 }
3166 return false;
3167 }
3168
3169 virtual const char *getClobbers() const {
3170 // FIXME: Implement!
3171 return "";
3172 }
3173};
3174
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003175class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003176public:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003177 Mips32TargetInfoBase(const std::string& triple) :
3178 MipsTargetInfoBase(triple, "o32") {}
3179 virtual bool setABI(const std::string &Name) {
3180 if ((Name == "o32") || (Name == "eabi")) {
3181 ABI = Name;
3182 return true;
3183 } else
3184 return false;
3185 }
3186 virtual void getArchDefines(const LangOptions &Opts,
3187 MacroBuilder &Builder) const {
3188 if (ABI == "o32") {
3189 Builder.defineMacro("__mips_o32");
3190 Builder.defineMacro("_ABIO32", "1");
3191 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
3192 }
3193 else if (ABI == "eabi")
3194 Builder.defineMacro("__mips_eabi");
3195 else
David Blaikie83d382b2011-09-23 05:06:16 +00003196 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003197 }
3198 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3199 unsigned &NumAliases) const {
3200 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3201 { { "at" }, "$1" },
3202 { { "v0" }, "$2" },
3203 { { "v1" }, "$3" },
3204 { { "a0" }, "$4" },
3205 { { "a1" }, "$5" },
3206 { { "a2" }, "$6" },
3207 { { "a3" }, "$7" },
3208 { { "t0" }, "$8" },
3209 { { "t1" }, "$9" },
3210 { { "t2" }, "$10" },
3211 { { "t3" }, "$11" },
3212 { { "t4" }, "$12" },
3213 { { "t5" }, "$13" },
3214 { { "t6" }, "$14" },
3215 { { "t7" }, "$15" },
3216 { { "s0" }, "$16" },
3217 { { "s1" }, "$17" },
3218 { { "s2" }, "$18" },
3219 { { "s3" }, "$19" },
3220 { { "s4" }, "$20" },
3221 { { "s5" }, "$21" },
3222 { { "s6" }, "$22" },
3223 { { "s7" }, "$23" },
3224 { { "t8" }, "$24" },
3225 { { "t9" }, "$25" },
3226 { { "k0" }, "$26" },
3227 { { "k1" }, "$27" },
3228 { { "gp" }, "$28" },
3229 { { "sp" }, "$29" },
3230 { { "fp" }, "$30" },
3231 { { "ra" }, "$31" }
3232 };
3233 Aliases = GCCRegAliases;
3234 NumAliases = llvm::array_lengthof(GCCRegAliases);
3235 }
3236};
3237
3238class Mips32EBTargetInfo : public Mips32TargetInfoBase {
3239public:
3240 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
3241 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3242 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3243 }
3244 virtual void getTargetDefines(const LangOptions &Opts,
3245 MacroBuilder &Builder) const {
3246 DefineStd(Builder, "mips", Opts);
3247 Builder.defineMacro("_mips");
3248 DefineStd(Builder, "MIPSEB", Opts);
3249 Builder.defineMacro("_MIPSEB");
3250 Builder.defineMacro("__REGISTER_PREFIX__", "");
3251 getArchDefines(Opts, Builder);
3252 }
3253};
3254
3255class Mips32ELTargetInfo : public Mips32TargetInfoBase {
3256public:
3257 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003258 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 +00003259 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003260 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003261 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003262 MacroBuilder &Builder) const {
3263 DefineStd(Builder, "mips", Opts);
3264 Builder.defineMacro("_mips");
3265 DefineStd(Builder, "MIPSEL", Opts);
3266 Builder.defineMacro("_MIPSEL");
3267 Builder.defineMacro("__REGISTER_PREFIX__", "");
3268 getArchDefines(Opts, Builder);
3269 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003270};
Akira Hatanakabef17452011-09-20 19:21:49 +00003271
3272class Mips64TargetInfoBase : public MipsTargetInfoBase {
3273 virtual void SetDescriptionString(const std::string &Name) = 0;
3274public:
3275 Mips64TargetInfoBase(const std::string& triple) :
3276 MipsTargetInfoBase(triple, "n64") {}
3277 virtual bool setABI(const std::string &Name) {
3278 SetDescriptionString(Name);
3279 if ((Name == "n32") || (Name == "n64")) {
3280 ABI = Name;
3281 return true;
3282 } else
3283 return false;
3284 }
3285 virtual void getArchDefines(const LangOptions &Opts,
3286 MacroBuilder &Builder) const {
3287 if (ABI == "n32") {
3288 Builder.defineMacro("__mips_n32");
3289 Builder.defineMacro("_ABIN32", "2");
3290 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
3291 }
3292 else if (ABI == "n64") {
3293 Builder.defineMacro("__mips_n64");
3294 Builder.defineMacro("_ABI64", "3");
3295 Builder.defineMacro("_MIPS_SIM", "_ABI64");
3296 }
3297 else
David Blaikie83d382b2011-09-23 05:06:16 +00003298 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabef17452011-09-20 19:21:49 +00003299 }
3300 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3301 unsigned &NumAliases) const {
3302 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3303 { { "at" }, "$1" },
3304 { { "v0" }, "$2" },
3305 { { "v1" }, "$3" },
3306 { { "a0" }, "$4" },
3307 { { "a1" }, "$5" },
3308 { { "a2" }, "$6" },
3309 { { "a3" }, "$7" },
3310 { { "a4" }, "$8" },
3311 { { "a5" }, "$9" },
3312 { { "a6" }, "$10" },
3313 { { "a7" }, "$11" },
3314 { { "t0" }, "$12" },
3315 { { "t1" }, "$13" },
3316 { { "t2" }, "$14" },
3317 { { "t3" }, "$15" },
3318 { { "s0" }, "$16" },
3319 { { "s1" }, "$17" },
3320 { { "s2" }, "$18" },
3321 { { "s3" }, "$19" },
3322 { { "s4" }, "$20" },
3323 { { "s5" }, "$21" },
3324 { { "s6" }, "$22" },
3325 { { "s7" }, "$23" },
3326 { { "t8" }, "$24" },
3327 { { "t9" }, "$25" },
3328 { { "k0" }, "$26" },
3329 { { "k1" }, "$27" },
3330 { { "gp" }, "$28" },
3331 { { "sp" }, "$29" },
3332 { { "fp" }, "$30" },
3333 { { "ra" }, "$31" }
3334 };
3335 Aliases = GCCRegAliases;
3336 NumAliases = llvm::array_lengthof(GCCRegAliases);
3337 }
3338};
3339
3340class Mips64EBTargetInfo : public Mips64TargetInfoBase {
3341 virtual void SetDescriptionString(const std::string &Name) {
3342 // Change DescriptionString only if ABI is n32.
3343 if (Name == "n32")
3344 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3345 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3346 }
3347public:
3348 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3349 // Default ABI is n64.
3350 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3351 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3352 }
3353 virtual void getTargetDefines(const LangOptions &Opts,
3354 MacroBuilder &Builder) const {
3355 DefineStd(Builder, "mips", Opts);
3356 Builder.defineMacro("_mips");
3357 DefineStd(Builder, "MIPSEB", Opts);
3358 Builder.defineMacro("_MIPSEB");
3359 Builder.defineMacro("__REGISTER_PREFIX__", "");
3360 getArchDefines(Opts, Builder);
3361 }
3362};
3363
3364class Mips64ELTargetInfo : public Mips64TargetInfoBase {
3365 virtual void SetDescriptionString(const std::string &Name) {
3366 // Change DescriptionString only if ABI is n32.
3367 if (Name == "n32")
3368 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3369 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3370 }
3371public:
3372 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3373 // Default ABI is n64.
3374 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3375 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3376 }
3377 virtual void getTargetDefines(const LangOptions &Opts,
3378 MacroBuilder &Builder) const {
3379 DefineStd(Builder, "mips", Opts);
3380 Builder.defineMacro("_mips");
3381 DefineStd(Builder, "MIPSEL", Opts);
3382 Builder.defineMacro("_MIPSEL");
3383 Builder.defineMacro("__REGISTER_PREFIX__", "");
3384 getArchDefines(Opts, Builder);
3385 }
3386};
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003387} // end anonymous namespace.
3388
Ivan Krasindd7403e2011-08-24 20:22:22 +00003389namespace {
3390class PNaClTargetInfo : public TargetInfo {
3391public:
3392 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
3393 this->UserLabelPrefix = "";
3394 this->LongAlign = 32;
3395 this->LongWidth = 32;
3396 this->PointerAlign = 32;
3397 this->PointerWidth = 32;
3398 this->IntMaxType = TargetInfo::SignedLongLong;
3399 this->UIntMaxType = TargetInfo::UnsignedLongLong;
3400 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasin69a990b2011-08-29 22:39:12 +00003401 this->DoubleAlign = 64;
Ivan Krasin96a80612011-09-20 14:56:54 +00003402 this->LongDoubleWidth = 64;
Ivan Krasin69a990b2011-08-29 22:39:12 +00003403 this->LongDoubleAlign = 64;
Ivan Krasin96a80612011-09-20 14:56:54 +00003404 this->SizeType = TargetInfo::UnsignedInt;
3405 this->PtrDiffType = TargetInfo::SignedInt;
3406 this->IntPtrType = TargetInfo::SignedInt;
Ivan Krasindd7403e2011-08-24 20:22:22 +00003407 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
3408 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
3409 }
3410
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00003411 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasindd7403e2011-08-24 20:22:22 +00003412 }
3413 virtual void getArchDefines(const LangOptions &Opts,
3414 MacroBuilder &Builder) const {
3415 Builder.defineMacro("__le32__");
3416 Builder.defineMacro("__pnacl__");
3417 }
3418 virtual void getTargetDefines(const LangOptions &Opts,
3419 MacroBuilder &Builder) const {
Ivan Krasin9b2cbdf2011-08-25 23:49:20 +00003420 DefineStd(Builder, "unix", Opts);
3421 Builder.defineMacro("__ELF__");
3422 if (Opts.POSIXThreads)
3423 Builder.defineMacro("_REENTRANT");
3424 if (Opts.CPlusPlus)
3425 Builder.defineMacro("_GNU_SOURCE");
3426
Ivan Krasindd7403e2011-08-24 20:22:22 +00003427 Builder.defineMacro("__native_client__");
3428 getArchDefines(Opts, Builder);
3429 }
3430 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3431 unsigned &NumRecords) const {
3432 }
3433 virtual const char *getVAListDeclaration() const {
Ivan Krasin96a80612011-09-20 14:56:54 +00003434 return "typedef int __builtin_va_list[4];";
Ivan Krasindd7403e2011-08-24 20:22:22 +00003435 }
3436 virtual void getGCCRegNames(const char * const *&Names,
3437 unsigned &NumNames) const;
3438 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3439 unsigned &NumAliases) const;
3440 virtual bool validateAsmConstraint(const char *&Name,
3441 TargetInfo::ConstraintInfo &Info) const {
3442 return false;
3443 }
3444
3445 virtual const char *getClobbers() const {
3446 return "";
3447 }
3448};
3449
3450void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
3451 unsigned &NumNames) const {
3452 Names = NULL;
3453 NumNames = 0;
3454}
3455
3456void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3457 unsigned &NumAliases) const {
3458 Aliases = NULL;
3459 NumAliases = 0;
3460}
3461} // end anonymous namespace.
3462
3463
Chris Lattner5ba61f02006-10-14 07:39:34 +00003464//===----------------------------------------------------------------------===//
3465// Driver code
3466//===----------------------------------------------------------------------===//
3467
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003468static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar52322032009-08-18 05:47:58 +00003469 llvm::Triple Triple(T);
3470 llvm::Triple::OSType os = Triple.getOS();
Eli Friedmanb5366062008-05-20 14:21:01 +00003471
Daniel Dunbar52322032009-08-18 05:47:58 +00003472 switch (Triple.getArch()) {
3473 default:
3474 return NULL;
Eli Friedmanb5366062008-05-20 14:21:01 +00003475
Daniel Dunbar52322032009-08-18 05:47:58 +00003476 case llvm::Triple::arm:
Daniel Dunbar33a004e2009-09-11 01:14:50 +00003477 case llvm::Triple::thumb:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00003478 if (Triple.isOSDarwin())
3479 return new DarwinARMTargetInfo(T);
3480
Daniel Dunbar52322032009-08-18 05:47:58 +00003481 switch (os) {
Rafael Espindolaad8fed52010-06-10 00:46:51 +00003482 case llvm::Triple::Linux:
3483 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003484 case llvm::Triple::FreeBSD:
Torok Edwinb2b37c62009-06-30 17:10:35 +00003485 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003486 case llvm::Triple::NetBSD:
3487 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Douglas Gregor9fabd852011-07-01 22:41:14 +00003488 case llvm::Triple::RTEMS:
3489 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003490 default:
3491 return new ARMTargetInfo(T);
3492 }
Eli Friedmanb5366062008-05-20 14:21:01 +00003493
Daniel Dunbar52322032009-08-18 05:47:58 +00003494 case llvm::Triple::bfin:
Douglas Gregor9fabd852011-07-01 22:41:14 +00003495 if ( os == llvm::Triple::RTEMS )
3496 return new RTEMSTargetInfo<BlackfinTargetInfo>(T);
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00003497 return new BlackfinTargetInfo(T);
3498
Daniel Dunbar52322032009-08-18 05:47:58 +00003499 case llvm::Triple::msp430:
3500 return new MSP430TargetInfo(T);
Eli Friedmanb5366062008-05-20 14:21:01 +00003501
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003502 case llvm::Triple::mips:
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00003503 switch (os) {
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00003504 case llvm::Triple::Linux:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003505 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00003506 case llvm::Triple::RTEMS:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003507 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00003508 case llvm::Triple::FreeBSD:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003509 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00003510 case llvm::Triple::NetBSD:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003511 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00003512 default:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003513 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00003514 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003515
3516 case llvm::Triple::mipsel:
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00003517 switch (os) {
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00003518 case llvm::Triple::Linux:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003519 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00003520 case llvm::Triple::RTEMS:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003521 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00003522 case llvm::Triple::FreeBSD:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003523 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00003524 case llvm::Triple::NetBSD:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003525 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00003526 default:
Akira Hatanakaf6da3312011-09-20 19:00:23 +00003527 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00003528 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00003529
Akira Hatanakabef17452011-09-20 19:21:49 +00003530 case llvm::Triple::mips64:
3531 switch (os) {
3532 case llvm::Triple::Linux:
3533 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
3534 case llvm::Triple::RTEMS:
3535 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
3536 case llvm::Triple::FreeBSD:
3537 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
3538 case llvm::Triple::NetBSD:
3539 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
3540 default:
3541 return new Mips64EBTargetInfo(T);
3542 }
3543
3544 case llvm::Triple::mips64el:
3545 switch (os) {
3546 case llvm::Triple::Linux:
3547 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
3548 case llvm::Triple::RTEMS:
3549 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
3550 case llvm::Triple::FreeBSD:
3551 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
3552 case llvm::Triple::NetBSD:
3553 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
3554 default:
3555 return new Mips64ELTargetInfo(T);
3556 }
3557
Ivan Krasindd7403e2011-08-24 20:22:22 +00003558 case llvm::Triple::le32:
3559 switch (os) {
3560 case llvm::Triple::NativeClient:
3561 return new PNaClTargetInfo(T);
3562 default:
3563 return NULL;
3564 }
3565
Daniel Dunbar52322032009-08-18 05:47:58 +00003566 case llvm::Triple::ppc:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00003567 if (Triple.isOSDarwin())
Roman Divacky965b0b72011-01-06 08:27:10 +00003568 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003569 switch (os) {
3570 case llvm::Triple::FreeBSD:
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00003571 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003572 case llvm::Triple::NetBSD:
3573 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
3574 case llvm::Triple::RTEMS:
Douglas Gregor9fabd852011-07-01 22:41:14 +00003575 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003576 default:
3577 return new PPC32TargetInfo(T);
3578 }
Daniel Dunbar52322032009-08-18 05:47:58 +00003579
3580 case llvm::Triple::ppc64:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00003581 if (Triple.isOSDarwin())
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00003582 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003583 switch (os) {
3584 case llvm::Triple::Lv2:
John Thompsone467e192009-11-19 17:18:50 +00003585 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003586 case llvm::Triple::FreeBSD:
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00003587 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003588 case llvm::Triple::NetBSD:
3589 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
3590 default:
3591 return new PPC64TargetInfo(T);
3592 }
Daniel Dunbar52322032009-08-18 05:47:58 +00003593
Justin Holewinski514cce82011-04-20 19:34:15 +00003594 case llvm::Triple::ptx32:
3595 return new PTX32TargetInfo(T);
3596 case llvm::Triple::ptx64:
3597 return new PTX64TargetInfo(T);
3598
Chris Lattner5178f562010-03-06 21:21:27 +00003599 case llvm::Triple::mblaze:
3600 return new MBlazeTargetInfo(T);
3601
Daniel Dunbar52322032009-08-18 05:47:58 +00003602 case llvm::Triple::sparc:
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003603 switch (os) {
3604 case llvm::Triple::AuroraUX:
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +00003605 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003606 case llvm::Triple::Solaris:
Daniel Dunbar52322032009-08-18 05:47:58 +00003607 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003608 case llvm::Triple::NetBSD:
3609 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
3610 case llvm::Triple::RTEMS:
Douglas Gregor9fabd852011-07-01 22:41:14 +00003611 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00003612 default:
3613 return new SparcV8TargetInfo(T);
3614 }
Daniel Dunbar52322032009-08-18 05:47:58 +00003615
John Thompsone467e192009-11-19 17:18:50 +00003616 // FIXME: Need a real SPU target.
3617 case llvm::Triple::cellspu:
3618 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
3619
Daniel Dunbar52322032009-08-18 05:47:58 +00003620 case llvm::Triple::systemz:
3621 return new SystemZTargetInfo(T);
3622
Eli Friedmana9c3d712009-08-19 20:47:07 +00003623 case llvm::Triple::tce:
3624 return new TCETargetInfo(T);
3625
Daniel Dunbar52322032009-08-18 05:47:58 +00003626 case llvm::Triple::x86:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00003627 if (Triple.isOSDarwin())
3628 return new DarwinI386TargetInfo(T);
3629
Daniel Dunbar52322032009-08-18 05:47:58 +00003630 switch (os) {
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +00003631 case llvm::Triple::AuroraUX:
3632 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003633 case llvm::Triple::Linux:
3634 return new LinuxTargetInfo<X86_32TargetInfo>(T);
3635 case llvm::Triple::DragonFly:
3636 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
3637 case llvm::Triple::NetBSD:
3638 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
3639 case llvm::Triple::OpenBSD:
3640 return new OpenBSDI386TargetInfo(T);
3641 case llvm::Triple::FreeBSD:
3642 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner3e2ee142010-07-07 16:01:42 +00003643 case llvm::Triple::Minix:
3644 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003645 case llvm::Triple::Solaris:
3646 return new SolarisTargetInfo<X86_32TargetInfo>(T);
3647 case llvm::Triple::Cygwin:
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003648 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003649 case llvm::Triple::MinGW32:
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003650 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003651 case llvm::Triple::Win32:
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003652 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattnerb986aba2010-04-11 19:29:39 +00003653 case llvm::Triple::Haiku:
3654 return new HaikuX86_32TargetInfo(T);
Douglas Gregor9fabd852011-07-01 22:41:14 +00003655 case llvm::Triple::RTEMS:
3656 return new RTEMSX86_32TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003657 default:
3658 return new X86_32TargetInfo(T);
3659 }
3660
3661 case llvm::Triple::x86_64:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00003662 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
3663 return new DarwinX86_64TargetInfo(T);
3664
Daniel Dunbar52322032009-08-18 05:47:58 +00003665 switch (os) {
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +00003666 case llvm::Triple::AuroraUX:
3667 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003668 case llvm::Triple::Linux:
3669 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner002ba6b2010-01-09 05:41:14 +00003670 case llvm::Triple::DragonFly:
3671 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003672 case llvm::Triple::NetBSD:
3673 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
3674 case llvm::Triple::OpenBSD:
3675 return new OpenBSDX86_64TargetInfo(T);
3676 case llvm::Triple::FreeBSD:
3677 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
3678 case llvm::Triple::Solaris:
3679 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi31ea2f12011-02-17 08:51:38 +00003680 case llvm::Triple::MinGW32:
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003681 return new MinGWX86_64TargetInfo(T);
3682 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00003683 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003684 default:
3685 return new X86_64TargetInfo(T);
3686 }
3687 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00003688}
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003689
3690/// CreateTargetInfo - Return the target info object for the specified target
3691/// triple.
David Blaikie9c902b52011-09-25 23:23:43 +00003692TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00003693 TargetOptions &Opts) {
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003694 llvm::Triple Triple(Opts.Triple);
3695
3696 // Construct the target
3697 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
3698 if (!Target) {
3699 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
3700 return 0;
3701 }
3702
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003703 // Set the target CPU if specified.
3704 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
3705 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
3706 return 0;
3707 }
3708
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003709 // Set the target ABI if specified.
3710 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
3711 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
3712 return 0;
3713 }
3714
Charles Davis95a546e2010-06-11 01:06:47 +00003715 // Set the target C++ ABI.
John McCall86353412010-08-21 22:46:04 +00003716 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davis95a546e2010-06-11 01:06:47 +00003717 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
3718 return 0;
3719 }
3720
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003721 // Compute the default target features, we need the target to handle this
3722 // because features may have dependencies on one another.
3723 llvm::StringMap<bool> Features;
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00003724 Target->getDefaultFeatures(Features);
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003725
3726 // Apply the user specified deltas.
3727 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
3728 ie = Opts.Features.end(); it != ie; ++it) {
3729 const char *Name = it->c_str();
3730
3731 // Apply the feature via the target.
3732 if ((Name[0] != '-' && Name[0] != '+') ||
3733 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
3734 Diags.Report(diag::err_target_invalid_feature) << Name;
3735 return 0;
3736 }
3737 }
3738
3739 // Add the features to the compile options.
3740 //
3741 // FIXME: If we are completely confident that we have the right set, we only
3742 // need to pass the minuses.
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00003743 Opts.Features.clear();
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003744 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
3745 ie = Features.end(); it != ie; ++it)
Chris Lattnerd386df42011-07-14 18:24:21 +00003746 Opts.Features.push_back(std::string(it->second ? "+" : "-") +
Chris Lattner2dc4b552011-07-14 18:45:41 +00003747 it->first().str());
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00003748 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003749
3750 return Target.take();
3751}