blob: 2a68d68ee67acc384897ce7ae34dec83f4318cdc [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"
Dale Johannesen182addf2010-10-29 23:24:33 +000029#include "llvm/Type.h"
Benjamin Kramerdc2f0062010-01-09 18:20:57 +000030#include <algorithm>
Chris Lattner5ba61f02006-10-14 07:39:34 +000031using namespace clang;
32
Chris Lattner5ba61f02006-10-14 07:39:34 +000033//===----------------------------------------------------------------------===//
Chris Lattner1f5ad112006-10-14 18:32:12 +000034// Common code shared among targets.
Chris Lattner5ba61f02006-10-14 07:39:34 +000035//===----------------------------------------------------------------------===//
36
Chris Lattner1e1c0b92009-03-20 16:06:38 +000037/// DefineStd - Define a macro name and standard variants. For example if
38/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
39/// when in GNU mode.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000040static void DefineStd(MacroBuilder &Builder, llvm::StringRef MacroName,
Chris Lattner1e1c0b92009-03-20 16:06:38 +000041 const LangOptions &Opts) {
42 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000043
Chris Lattner1e1c0b92009-03-20 16:06:38 +000044 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
45 // in the user's namespace.
46 if (Opts.GNUMode)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000047 Builder.defineMacro(MacroName);
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000048
Chris Lattner1e1c0b92009-03-20 16:06:38 +000049 // Define __unix.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000050 Builder.defineMacro("__" + MacroName);
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000051
Chris Lattner1e1c0b92009-03-20 16:06:38 +000052 // Define __unix__.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000053 Builder.defineMacro("__" + MacroName + "__");
Chris Lattner1e1c0b92009-03-20 16:06:38 +000054}
55
Chris Lattner09d98f52008-10-05 21:50:58 +000056//===----------------------------------------------------------------------===//
57// Defines specific to certain operating systems.
58//===----------------------------------------------------------------------===//
Chris Lattner30ba6742009-08-10 19:03:04 +000059
Torok Edwinb2b37c62009-06-30 17:10:35 +000060namespace {
Douglas Gregorc05d2a12009-07-01 15:12:53 +000061template<typename TgtInfo>
62class OSTargetInfo : public TgtInfo {
Torok Edwinb2b37c62009-06-30 17:10:35 +000063protected:
Daniel Dunbar40165182009-08-24 09:10:05 +000064 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000065 MacroBuilder &Builder) const=0;
Torok Edwinb2b37c62009-06-30 17:10:35 +000066public:
Douglas Gregorc05d2a12009-07-01 15:12:53 +000067 OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
Torok Edwinb2b37c62009-06-30 17:10:35 +000068 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000069 MacroBuilder &Builder) const {
70 TgtInfo::getTargetDefines(Opts, Builder);
71 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Torok Edwin4e054162009-06-30 17:00:25 +000072 }
Torok Edwinb2b37c62009-06-30 17:10:35 +000073
74};
Chris Lattner859c37a2009-08-12 06:24:27 +000075} // end anonymous namespace
Torok Edwin4e054162009-06-30 17:00:25 +000076
Chris Lattner30ba6742009-08-10 19:03:04 +000077
Daniel Dunbard86666f2010-01-26 01:44:04 +000078static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +000079 const llvm::Triple &Triple,
80 llvm::StringRef &PlatformName,
81 VersionTuple &PlatformMinVersion) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000082 Builder.defineMacro("__APPLE_CC__", "5621");
83 Builder.defineMacro("__APPLE__");
84 Builder.defineMacro("__MACH__");
85 Builder.defineMacro("OBJC_NEW_PROPERTIES");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000086
John McCall5d36a8c2011-06-16 00:03:19 +000087 if (!Opts.ObjCAutoRefCount) {
John McCall31168b02011-06-15 23:02:42 +000088 // __weak is always defined, for use in blocks and with objc pointers.
89 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000090
John McCall31168b02011-06-15 23:02:42 +000091 // Darwin defines __strong even in C mode (just to nothing).
92 if (Opts.getGCMode() != LangOptions::NonGC)
93 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
94 else
95 Builder.defineMacro("__strong", "");
Eric Christopher0c912c52011-07-07 22:55:26 +000096
John McCall31168b02011-06-15 23:02:42 +000097 // __unsafe_unretained is defined to nothing in non-ARC mode. We even
98 // allow this in C, since one might have block pointers in structs that
99 // are used in pure C code and in Objective-C ARC.
100 Builder.defineMacro("__unsafe_unretained", "");
Eric Christopher0c912c52011-07-07 22:55:26 +0000101
John McCall31168b02011-06-15 23:02:42 +0000102 // The Objective-C bridged cast keywords are defined to nothing in non-ARC
103 // mode; then they become normal, C-style casts.
104 Builder.defineMacro("__bridge", "");
105 Builder.defineMacro("__bridge_transfer", "");
106 Builder.defineMacro("__bridge_retained", "");
John McCall0c329252011-06-17 21:23:37 +0000107 Builder.defineMacro("__bridge_retain", "");
John McCall31168b02011-06-15 23:02:42 +0000108 }
Eric Christopher0c912c52011-07-07 22:55:26 +0000109
Eli Friedmanfd4b1552009-06-04 23:00:29 +0000110 if (Opts.Static)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000111 Builder.defineMacro("__STATIC__");
Eli Friedmanfd4b1552009-06-04 23:00:29 +0000112 else
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000113 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000114
115 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000116 Builder.defineMacro("_REENTRANT");
Daniel Dunbar497ff132009-04-10 19:52:24 +0000117
Daniel Dunbarecf13562011-04-19 21:40:34 +0000118 // Get the platform type and version number from the triple.
Daniel Dunbar497ff132009-04-10 19:52:24 +0000119 unsigned Maj, Min, Rev;
Mike Stump11289f42009-09-09 15:08:12 +0000120
Daniel Dunbard86666f2010-01-26 01:44:04 +0000121 // If no version was given, default to to 10.4.0, for simplifying tests.
Daniel Dunbarecf13562011-04-19 21:40:34 +0000122 if (Triple.getOSName() == "darwin" || Triple.getOSName() == "osx") {
123 PlatformName = "macosx";
Daniel Dunbard86666f2010-01-26 01:44:04 +0000124 Min = Rev = 0;
125 Maj = 8;
Daniel Dunbarecf13562011-04-19 21:40:34 +0000126 } else {
127 // Otherwise, honor all three triple forms ("-darwinNNN[-iphoneos]",
128 // "-osxNNN", and "-iosNNN").
129
130 if (Triple.getOS() == llvm::Triple::Darwin) {
131 // For historical reasons that make little sense, the version passed here
132 // is the "darwin" version, which drops the 10 and offsets by 4.
133 Triple.getOSVersion(Maj, Min, Rev);
134
135 if (Triple.getEnvironmentName() == "iphoneos") {
136 PlatformName = "ios";
137 } else {
Daniel Dunbarecf13562011-04-19 21:40:34 +0000138 PlatformName = "macosx";
139 Rev = Min;
140 Min = Maj - 4;
141 Maj = 10;
142 }
Daniel Dunbarecf13562011-04-19 21:40:34 +0000143 } else {
Daniel Dunbarecf13562011-04-19 21:40:34 +0000144 Triple.getOSVersion(Maj, Min, Rev);
Daniel Dunbarfcd23892011-04-19 23:34:21 +0000145 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbarecf13562011-04-19 21:40:34 +0000146 }
147 }
Daniel Dunbard86666f2010-01-26 01:44:04 +0000148
149 // Set the appropriate OS version define.
Daniel Dunbarecf13562011-04-19 21:40:34 +0000150 if (PlatformName == "ios") {
Daniel Dunbarbbd48222011-04-21 21:27:33 +0000151 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbard86666f2010-01-26 01:44:04 +0000152 char Str[6];
153 Str[0] = '0' + Maj;
154 Str[1] = '0' + (Min / 10);
155 Str[2] = '0' + (Min % 10);
156 Str[3] = '0' + (Rev / 10);
157 Str[4] = '0' + (Rev % 10);
158 Str[5] = '\0';
159 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
Chad Rosierdcf77322011-07-19 19:36:03 +0000160 } else if (PlatformName == "win32") {
161 // Due to option -ccc-host-triple arch-pc-win32-macho.
162 // Don't emit __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__ as we're generating
163 // code for Win32 ABI.
Daniel Dunbard86666f2010-01-26 01:44:04 +0000164 } else {
Daniel Dunbarbbd48222011-04-21 21:27:33 +0000165 // Note that the Driver allows versions which aren't representable in the
166 // define (because we only get a single digit for the minor and micro
167 // revision numbers). So, we limit them to the maximum representable
168 // version.
Daniel Dunbard86666f2010-01-26 01:44:04 +0000169 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
Daniel Dunbarbbd48222011-04-21 21:27:33 +0000170 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbard86666f2010-01-26 01:44:04 +0000171 char Str[5];
172 Str[0] = '0' + (Maj / 10);
173 Str[1] = '0' + (Maj % 10);
Daniel Dunbarbbd48222011-04-21 21:27:33 +0000174 Str[2] = '0' + std::min(Min, 9U);
175 Str[3] = '0' + std::min(Rev, 9U);
Daniel Dunbard86666f2010-01-26 01:44:04 +0000176 Str[4] = '\0';
177 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar497ff132009-04-10 19:52:24 +0000178 }
Daniel Dunbarecf13562011-04-19 21:40:34 +0000179
180 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman3fd920a2008-08-20 02:34:37 +0000181}
Chris Lattner5ba61f02006-10-14 07:39:34 +0000182
Chris Lattner30ba6742009-08-10 19:03:04 +0000183namespace {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000184template<typename Target>
185class DarwinTargetInfo : public OSTargetInfo<Target> {
186protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000187 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000188 MacroBuilder &Builder) const {
Eric Christopher0c912c52011-07-07 22:55:26 +0000189 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000190 this->PlatformMinVersion);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000191 }
Mike Stump11289f42009-09-09 15:08:12 +0000192
Torok Edwinb2b37c62009-06-30 17:10:35 +0000193public:
194 DarwinTargetInfo(const std::string& triple) :
195 OSTargetInfo<Target>(triple) {
Eric Christopherbf15d2b2011-07-02 00:20:22 +0000196 llvm::Triple T = llvm::Triple(triple);
197 this->TLSSupported = T.isMacOSX() && !T.isMacOSXVersionLT(10,7);
Daniel Dunbar13adc7f2011-02-21 23:12:51 +0000198 this->MCountName = "\01mcount";
Torok Edwinb2b37c62009-06-30 17:10:35 +0000199 }
200
Anders Carlsson0b0a1222010-01-30 18:33:31 +0000201 virtual std::string isValidSectionSpecifier(llvm::StringRef SR) const {
Chris Lattner30ba6742009-08-10 19:03:04 +0000202 // Let MCSectionMachO validate this.
203 llvm::StringRef Segment, Section;
204 unsigned TAA, StubSize;
Daniel Dunbar75942372011-03-19 02:06:21 +0000205 bool HasTAA;
Chris Lattner30ba6742009-08-10 19:03:04 +0000206 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar75942372011-03-19 02:06:21 +0000207 TAA, HasTAA, StubSize);
Chris Lattner30ba6742009-08-10 19:03:04 +0000208 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000209
Anders Carlsson851318a2010-06-08 22:47:50 +0000210 virtual const char *getStaticInitSectionSpecifier() const {
211 // FIXME: We should return 0 when building kexts.
212 return "__TEXT,__StaticInit,regular,pure_instructions";
213 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000214
Torok Edwinb2b37c62009-06-30 17:10:35 +0000215};
216
Chris Lattner30ba6742009-08-10 19:03:04 +0000217
Torok Edwinb2b37c62009-06-30 17:10:35 +0000218// DragonFlyBSD Target
219template<typename Target>
220class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
221protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000222 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000223 MacroBuilder &Builder) const {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000224 // DragonFly defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000225 Builder.defineMacro("__DragonFly__");
226 Builder.defineMacro("__DragonFly_cc_version", "100001");
227 Builder.defineMacro("__ELF__");
228 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
229 Builder.defineMacro("__tune_i386__");
230 DefineStd(Builder, "unix", Opts);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000231 }
232public:
Mike Stump11289f42009-09-09 15:08:12 +0000233 DragonFlyBSDTargetInfo(const std::string &triple)
Torok Edwinb2b37c62009-06-30 17:10:35 +0000234 : OSTargetInfo<Target>(triple) {}
235};
236
237// FreeBSD Target
238template<typename Target>
239class FreeBSDTargetInfo : public OSTargetInfo<Target> {
240protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000241 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000242 MacroBuilder &Builder) const {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000243 // FreeBSD defines; list based off of gcc output
244
Daniel Dunbar40165182009-08-24 09:10:05 +0000245 // FIXME: Move version number handling to llvm::Triple.
Benjamin Kramer31a68e72010-01-30 19:55:01 +0000246 llvm::StringRef Release = Triple.getOSName().substr(strlen("freebsd"), 1);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000247
Benjamin Kramer31a68e72010-01-30 19:55:01 +0000248 Builder.defineMacro("__FreeBSD__", Release);
249 Builder.defineMacro("__FreeBSD_cc_version", Release + "00001");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000250 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
251 DefineStd(Builder, "unix", Opts);
252 Builder.defineMacro("__ELF__");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000253 }
254public:
Mike Stump11289f42009-09-09 15:08:12 +0000255 FreeBSDTargetInfo(const std::string &triple)
Duncan Sands9cb27e92009-07-08 13:55:08 +0000256 : OSTargetInfo<Target>(triple) {
257 this->UserLabelPrefix = "";
Roman Divacky178e01602011-02-10 16:52:03 +0000258
259 llvm::Triple Triple(triple);
260 switch (Triple.getArch()) {
261 default:
262 case llvm::Triple::x86:
263 case llvm::Triple::x86_64:
264 this->MCountName = ".mcount";
265 break;
266 case llvm::Triple::mips:
267 case llvm::Triple::mipsel:
268 case llvm::Triple::ppc:
269 case llvm::Triple::ppc64:
270 this->MCountName = "_mcount";
271 break;
272 case llvm::Triple::arm:
273 this->MCountName = "__mcount";
274 break;
275 }
276
Duncan Sands9cb27e92009-07-08 13:55:08 +0000277 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000278};
279
Chris Lattner3e2ee142010-07-07 16:01:42 +0000280// Minix Target
281template<typename Target>
282class MinixTargetInfo : public OSTargetInfo<Target> {
283protected:
284 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
285 MacroBuilder &Builder) const {
286 // Minix defines
287
288 Builder.defineMacro("__minix", "3");
289 Builder.defineMacro("_EM_WSIZE", "4");
290 Builder.defineMacro("_EM_PSIZE", "4");
291 Builder.defineMacro("_EM_SSIZE", "2");
292 Builder.defineMacro("_EM_LSIZE", "4");
293 Builder.defineMacro("_EM_FSIZE", "4");
294 Builder.defineMacro("_EM_DSIZE", "8");
295 DefineStd(Builder, "unix", Opts);
296 }
297public:
298 MinixTargetInfo(const std::string &triple)
299 : OSTargetInfo<Target>(triple) {
300 this->UserLabelPrefix = "";
301 }
302};
303
Torok Edwinb2b37c62009-06-30 17:10:35 +0000304// Linux target
305template<typename Target>
306class LinuxTargetInfo : public OSTargetInfo<Target> {
307protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000308 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000309 MacroBuilder &Builder) const {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000310 // Linux defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000311 DefineStd(Builder, "unix", Opts);
312 DefineStd(Builder, "linux", Opts);
313 Builder.defineMacro("__gnu_linux__");
314 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000315 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000316 Builder.defineMacro("_REENTRANT");
Douglas Gregor3ecc6652010-04-21 05:52:38 +0000317 if (Opts.CPlusPlus)
318 Builder.defineMacro("_GNU_SOURCE");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000319 }
320public:
Mike Stump11289f42009-09-09 15:08:12 +0000321 LinuxTargetInfo(const std::string& triple)
Torok Edwinb2b37c62009-06-30 17:10:35 +0000322 : OSTargetInfo<Target>(triple) {
323 this->UserLabelPrefix = "";
Douglas Gregore6d6e512011-01-12 21:19:25 +0000324 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwinb2b37c62009-06-30 17:10:35 +0000325 }
326};
327
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000328// NetBSD Target
329template<typename Target>
330class NetBSDTargetInfo : public OSTargetInfo<Target> {
331protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000332 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000333 MacroBuilder &Builder) const {
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000334 // NetBSD defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000335 Builder.defineMacro("__NetBSD__");
336 Builder.defineMacro("__unix__");
337 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000338 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000339 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000340 }
341public:
Mike Stump11289f42009-09-09 15:08:12 +0000342 NetBSDTargetInfo(const std::string &triple)
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000343 : OSTargetInfo<Target>(triple) {
344 this->UserLabelPrefix = "";
345 }
346};
347
Torok Edwinb2b37c62009-06-30 17:10:35 +0000348// OpenBSD Target
349template<typename Target>
350class OpenBSDTargetInfo : public OSTargetInfo<Target> {
351protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000352 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000353 MacroBuilder &Builder) const {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000354 // OpenBSD defines; list based off of gcc output
355
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000356 Builder.defineMacro("__OpenBSD__");
357 DefineStd(Builder, "unix", Opts);
358 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000359 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000360 Builder.defineMacro("_POSIX_THREADS");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000361 }
362public:
Mike Stump11289f42009-09-09 15:08:12 +0000363 OpenBSDTargetInfo(const std::string &triple)
Torok Edwinb2b37c62009-06-30 17:10:35 +0000364 : OSTargetInfo<Target>(triple) {}
365};
366
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000367// PSP Target
368template<typename Target>
369class PSPTargetInfo : public OSTargetInfo<Target> {
370protected:
371 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000372 MacroBuilder &Builder) const {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000373 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000374 Builder.defineMacro("PSP");
375 Builder.defineMacro("_PSP");
376 Builder.defineMacro("__psp__");
377 Builder.defineMacro("__ELF__");
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000378 }
379public:
380 PSPTargetInfo(const std::string& triple)
381 : OSTargetInfo<Target>(triple) {
382 this->UserLabelPrefix = "";
383 }
384};
385
John Thompsone467e192009-11-19 17:18:50 +0000386// PS3 PPU Target
387template<typename Target>
388class PS3PPUTargetInfo : public OSTargetInfo<Target> {
389protected:
390 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000391 MacroBuilder &Builder) const {
John Thompsone467e192009-11-19 17:18:50 +0000392 // PS3 PPU defines.
John Thompson957816f2010-03-25 16:18:32 +0000393 Builder.defineMacro("__PPC__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000394 Builder.defineMacro("__PPU__");
395 Builder.defineMacro("__CELLOS_LV2__");
396 Builder.defineMacro("__ELF__");
397 Builder.defineMacro("__LP32__");
John Thompson07a61a42010-06-24 22:44:13 +0000398 Builder.defineMacro("_ARCH_PPC64");
399 Builder.defineMacro("__powerpc64__");
John Thompsone467e192009-11-19 17:18:50 +0000400 }
401public:
402 PS3PPUTargetInfo(const std::string& triple)
403 : OSTargetInfo<Target>(triple) {
404 this->UserLabelPrefix = "";
John Thompson6f8dba72009-12-18 14:21:08 +0000405 this->LongWidth = this->LongAlign = this->PointerWidth = this->PointerAlign = 32;
John Thompson07a61a42010-06-24 22:44:13 +0000406 this->IntMaxType = TargetInfo::SignedLongLong;
407 this->UIntMaxType = TargetInfo::UnsignedLongLong;
408 this->Int64Type = TargetInfo::SignedLongLong;
John Thompson6f8dba72009-12-18 14:21:08 +0000409 this->SizeType = TargetInfo::UnsignedInt;
John Thompson07a61a42010-06-24 22:44:13 +0000410 this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
411 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompsone467e192009-11-19 17:18:50 +0000412 }
413};
414
415// FIXME: Need a real SPU target.
416// PS3 SPU Target
417template<typename Target>
418class PS3SPUTargetInfo : public OSTargetInfo<Target> {
419protected:
420 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000421 MacroBuilder &Builder) const {
John Thompsone467e192009-11-19 17:18:50 +0000422 // PS3 PPU defines.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000423 Builder.defineMacro("__SPU__");
424 Builder.defineMacro("__ELF__");
John Thompsone467e192009-11-19 17:18:50 +0000425 }
426public:
427 PS3SPUTargetInfo(const std::string& triple)
428 : OSTargetInfo<Target>(triple) {
429 this->UserLabelPrefix = "";
430 }
431};
432
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +0000433// AuroraUX target
434template<typename Target>
435class AuroraUXTargetInfo : public OSTargetInfo<Target> {
436protected:
437 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000438 MacroBuilder &Builder) const {
439 DefineStd(Builder, "sun", Opts);
440 DefineStd(Builder, "unix", Opts);
441 Builder.defineMacro("__ELF__");
442 Builder.defineMacro("__svr4__");
443 Builder.defineMacro("__SVR4");
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +0000444 }
445public:
446 AuroraUXTargetInfo(const std::string& triple)
447 : OSTargetInfo<Target>(triple) {
448 this->UserLabelPrefix = "";
449 this->WCharType = this->SignedLong;
450 // FIXME: WIntType should be SignedLong
451 }
452};
453
Torok Edwinb2b37c62009-06-30 17:10:35 +0000454// Solaris target
455template<typename Target>
456class SolarisTargetInfo : public OSTargetInfo<Target> {
457protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000458 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000459 MacroBuilder &Builder) const {
460 DefineStd(Builder, "sun", Opts);
461 DefineStd(Builder, "unix", Opts);
462 Builder.defineMacro("__ELF__");
463 Builder.defineMacro("__svr4__");
464 Builder.defineMacro("__SVR4");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000465 }
466public:
Mike Stump11289f42009-09-09 15:08:12 +0000467 SolarisTargetInfo(const std::string& triple)
Torok Edwinb2b37c62009-06-30 17:10:35 +0000468 : OSTargetInfo<Target>(triple) {
469 this->UserLabelPrefix = "";
470 this->WCharType = this->SignedLong;
471 // FIXME: WIntType should be SignedLong
472 }
473};
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000474
475// Windows target
476template<typename Target>
477class WindowsTargetInfo : public OSTargetInfo<Target> {
478protected:
479 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
480 MacroBuilder &Builder) const {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +0000481 Builder.defineMacro("_WIN32");
482 }
483 void getVisualStudioDefines(const LangOptions &Opts,
484 MacroBuilder &Builder) const {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000485 if (Opts.CPlusPlus) {
486 if (Opts.RTTI)
487 Builder.defineMacro("_CPPRTTI");
488
489 if (Opts.Exceptions)
490 Builder.defineMacro("_CPPUNWIND");
491 }
492
493 if (!Opts.CharIsSigned)
494 Builder.defineMacro("_CHAR_UNSIGNED");
495
496 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
497 // but it works for now.
498 if (Opts.POSIXThreads)
499 Builder.defineMacro("_MT");
Michael J. Spencer54bf3c32010-10-21 08:22:51 +0000500
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000501 if (Opts.MSCVersion != 0)
502 Builder.defineMacro("_MSC_VER", llvm::Twine(Opts.MSCVersion));
503
504 if (Opts.Microsoft) {
505 Builder.defineMacro("_MSC_EXTENSIONS");
506
507 if (Opts.CPlusPlus0x) {
508 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
509 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
510 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
511 }
512 }
513
514 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000515 }
516
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000517public:
518 WindowsTargetInfo(const std::string &triple)
519 : OSTargetInfo<Target>(triple) {}
520};
521
Mike Stump11289f42009-09-09 15:08:12 +0000522} // end anonymous namespace.
Torok Edwinb2b37c62009-06-30 17:10:35 +0000523
Chris Lattner09d98f52008-10-05 21:50:58 +0000524//===----------------------------------------------------------------------===//
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000525// Specific target implementations.
526//===----------------------------------------------------------------------===//
Anders Carlssona7408e72007-10-13 00:45:48 +0000527
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000528namespace {
529// PPC abstract base class
530class PPCTargetInfo : public TargetInfo {
531 static const Builtin::Info BuiltinInfo[];
532 static const char * const GCCRegNames[];
533 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000534public:
Eli Friedman9ffd4a92009-06-05 07:05:05 +0000535 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
536
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000537 virtual void getTargetBuiltins(const Builtin::Info *&Records,
538 unsigned &NumRecords) const {
Chris Lattner10a5b382007-01-29 05:24:35 +0000539 Records = BuiltinInfo;
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000540 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner10a5b382007-01-29 05:24:35 +0000541 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000542
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000543 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000544 MacroBuilder &Builder) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000545
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000546 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000547 unsigned &NumNames) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000548 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000549 unsigned &NumAliases) const;
Anders Carlsson58436352009-02-28 17:11:49 +0000550 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +0000551 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson58436352009-02-28 17:11:49 +0000552 switch (*Name) {
Anders Carlssonf511f642007-11-27 04:11:28 +0000553 default: return false;
554 case 'O': // Zero
John Thompson07a61a42010-06-24 22:44:13 +0000555 break;
Anders Carlssonf511f642007-11-27 04:11:28 +0000556 case 'b': // Base register
557 case 'f': // Floating point register
Chris Lattnerd9725f72009-04-26 07:16:29 +0000558 Info.setAllowsRegister();
John Thompson07a61a42010-06-24 22:44:13 +0000559 break;
560 // FIXME: The following are added to allow parsing.
561 // I just took a guess at what the actions should be.
562 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000563 case 'd': // Floating point register (containing 64-bit value)
John Thompson07a61a42010-06-24 22:44:13 +0000564 case 'v': // Altivec vector register
565 Info.setAllowsRegister();
566 break;
567 case 'w':
568 switch (Name[1]) {
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000569 case 'd':// VSX vector register to hold vector double data
570 case 'f':// VSX vector register to hold vector float data
571 case 's':// VSX vector register to hold scalar float data
572 case 'a':// Any VSX register
John Thompson07a61a42010-06-24 22:44:13 +0000573 break;
574 default:
575 return false;
576 }
577 Info.setAllowsRegister();
578 Name++; // Skip over 'w'.
579 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000580 case 'h': // `MQ', `CTR', or `LINK' register
581 case 'q': // `MQ' register
582 case 'c': // `CTR' register
583 case 'l': // `LINK' register
584 case 'x': // `CR' register (condition register) number 0
585 case 'y': // `CR' register (condition register)
586 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson07a61a42010-06-24 22:44:13 +0000587 Info.setAllowsRegister();
588 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000589 case 'I': // Signed 16-bit constant
John Thompson07a61a42010-06-24 22:44:13 +0000590 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000591 // (use `L' instead for SImode constants)
592 case 'K': // Unsigned 16-bit constant
593 case 'L': // Signed 16-bit constant shifted left 16 bits
594 case 'M': // Constant larger than 31
595 case 'N': // Exact power of 2
596 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson07a61a42010-06-24 22:44:13 +0000597 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000598 // register with one instruction per word
John Thompson07a61a42010-06-24 22:44:13 +0000599 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000600 // into a register using three instructions
John Thompson07a61a42010-06-24 22:44:13 +0000601 break;
602 case 'm': // Memory operand. Note that on PowerPC targets, m can
603 // include addresses that update the base register. It
604 // is therefore only safe to use `m' in an asm statement
605 // if that asm statement accesses the operand exactly once.
606 // The asm statement must also use `%U<opno>' as a
Sebastian Redldd008712010-08-17 22:42:34 +0000607 // placeholder for the "update" flag in the corresponding
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000608 // load or store instruction. For example:
John Thompson07a61a42010-06-24 22:44:13 +0000609 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000610 // is correct but:
John Thompson07a61a42010-06-24 22:44:13 +0000611 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
612 // is not. Use es rather than m if you don't want the base
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000613 // register to be updated.
614 case 'e':
John Thompsonceebdf12010-06-25 00:02:05 +0000615 if (Name[1] != 's')
616 return false;
Sebastian Redldd008712010-08-17 22:42:34 +0000617 // es: A "stable" memory operand; that is, one which does not
John Thompson07a61a42010-06-24 22:44:13 +0000618 // include any automodification of the base register. Unlike
619 // `m', this constraint can be used in asm statements that
620 // might access the operand several times, or that might not
John Thompsonceebdf12010-06-25 00:02:05 +0000621 // access it at all.
John Thompson07a61a42010-06-24 22:44:13 +0000622 Info.setAllowsMemory();
John Thompsonceebdf12010-06-25 00:02:05 +0000623 Name++; // Skip over 'e'.
John Thompson07a61a42010-06-24 22:44:13 +0000624 break;
625 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000626 // usually better to use `m' or `es' in asm statements)
John Thompson07a61a42010-06-24 22:44:13 +0000627 case 'Z': // Memory operand that is an indexed or indirect from a
628 // register (it is usually better to use `m' or `es' in
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000629 // asm statements)
John Thompson07a61a42010-06-24 22:44:13 +0000630 Info.setAllowsMemory();
631 Info.setAllowsRegister();
632 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000633 case 'R': // AIX TOC entry
John Thompson07a61a42010-06-24 22:44:13 +0000634 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000635 // register (`p' is preferable for asm statements)
636 case 'S': // Constant suitable as a 64-bit mask operand
637 case 'T': // Constant suitable as a 32-bit mask operand
638 case 'U': // System V Release 4 small data area reference
John Thompson07a61a42010-06-24 22:44:13 +0000639 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000640 // instructions
641 case 'W': // Vector constant that does not require memory
642 case 'j': // Vector constant that is all zeros.
John Thompson07a61a42010-06-24 22:44:13 +0000643 break;
644 // End FIXME.
Anders Carlssonf511f642007-11-27 04:11:28 +0000645 }
John Thompson07a61a42010-06-24 22:44:13 +0000646 return true;
Anders Carlssonf511f642007-11-27 04:11:28 +0000647 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000648 virtual const char *getClobbers() const {
649 return "";
Anders Carlssonf511f642007-11-27 04:11:28 +0000650 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000651};
Anders Carlssonf511f642007-11-27 04:11:28 +0000652
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000653const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000654#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +0000655#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000656 ALL_LANGUAGES },
Chris Lattner5abdec72009-06-14 01:05:48 +0000657#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000658};
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000659
660
Chris Lattnerecd49032009-03-02 22:27:17 +0000661/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
662/// #defines that are not tied to a specific subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000663void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000664 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +0000665 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000666 Builder.defineMacro("__ppc__");
667 Builder.defineMacro("_ARCH_PPC");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000668 Builder.defineMacro("__powerpc__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000669 Builder.defineMacro("__POWERPC__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000670 if (PointerWidth == 64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000671 Builder.defineMacro("_ARCH_PPC64");
672 Builder.defineMacro("_LP64");
673 Builder.defineMacro("__LP64__");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000674 Builder.defineMacro("__powerpc64__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000675 Builder.defineMacro("__ppc64__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000676 } else {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000677 Builder.defineMacro("__ppc__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000678 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000679
Chris Lattnerecd49032009-03-02 22:27:17 +0000680 // Target properties.
Joerg Sonnenberger870b3c52011-07-05 14:56:12 +0000681 if (getTriple().getOS() != llvm::Triple::NetBSD)
682 Builder.defineMacro("_BIG_ENDIAN");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000683 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000684
Chris Lattnerecd49032009-03-02 22:27:17 +0000685 // Subtarget options.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000686 Builder.defineMacro("__NATURAL_ALIGNMENT__");
687 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000688
Chris Lattnerecd49032009-03-02 22:27:17 +0000689 // FIXME: Should be controlled by command line option.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000690 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000691
John Thompsone467e192009-11-19 17:18:50 +0000692 if (Opts.AltiVec) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000693 Builder.defineMacro("__VEC__", "10206");
694 Builder.defineMacro("__ALTIVEC__");
John Thompsone467e192009-11-19 17:18:50 +0000695 }
Chris Lattnerecd49032009-03-02 22:27:17 +0000696}
697
Chris Lattner17df24e2008-04-21 18:56:49 +0000698
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000699const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnerf7ff53d2009-09-16 05:05:27 +0000700 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
701 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
702 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
703 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
704 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
705 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
706 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
707 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000708 "mq", "lr", "ctr", "ap",
Chris Lattnerf7ff53d2009-09-16 05:05:27 +0000709 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000710 "xer",
Chris Lattnerf7ff53d2009-09-16 05:05:27 +0000711 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
712 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
713 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
714 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000715 "vrsave", "vscr",
716 "spe_acc", "spefscr",
717 "sfp"
718};
Chris Lattner10a5b382007-01-29 05:24:35 +0000719
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000720void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000721 unsigned &NumNames) const {
722 Names = GCCRegNames;
723 NumNames = llvm::array_lengthof(GCCRegNames);
724}
Chris Lattner5ba61f02006-10-14 07:39:34 +0000725
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000726const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
727 // While some of these aliases do map to different registers
728 // they still share the same register name.
Daniel Dunbar1da76c42009-09-17 07:03:19 +0000729 { { "0" }, "r0" },
730 { { "1"}, "r1" },
731 { { "2" }, "r2" },
732 { { "3" }, "r3" },
733 { { "4" }, "r4" },
734 { { "5" }, "r5" },
735 { { "6" }, "r6" },
736 { { "7" }, "r7" },
737 { { "8" }, "r8" },
738 { { "9" }, "r9" },
739 { { "10" }, "r10" },
740 { { "11" }, "r11" },
741 { { "12" }, "r12" },
742 { { "13" }, "r13" },
743 { { "14" }, "r14" },
744 { { "15" }, "r15" },
745 { { "16" }, "r16" },
746 { { "17" }, "r17" },
747 { { "18" }, "r18" },
748 { { "19" }, "r19" },
749 { { "20" }, "r20" },
750 { { "21" }, "r21" },
751 { { "22" }, "r22" },
752 { { "23" }, "r23" },
753 { { "24" }, "r24" },
754 { { "25" }, "r25" },
755 { { "26" }, "r26" },
756 { { "27" }, "r27" },
757 { { "28" }, "r28" },
758 { { "29" }, "r29" },
759 { { "30" }, "r30" },
760 { { "31" }, "r31" },
761 { { "fr0" }, "f0" },
762 { { "fr1" }, "f1" },
763 { { "fr2" }, "f2" },
764 { { "fr3" }, "f3" },
765 { { "fr4" }, "f4" },
766 { { "fr5" }, "f5" },
767 { { "fr6" }, "f6" },
768 { { "fr7" }, "f7" },
769 { { "fr8" }, "f8" },
770 { { "fr9" }, "f9" },
Mike Stumpfaacf012009-09-17 21:15:00 +0000771 { { "fr10" }, "f10" },
Daniel Dunbar1da76c42009-09-17 07:03:19 +0000772 { { "fr11" }, "f11" },
773 { { "fr12" }, "f12" },
774 { { "fr13" }, "f13" },
775 { { "fr14" }, "f14" },
776 { { "fr15" }, "f15" },
777 { { "fr16" }, "f16" },
778 { { "fr17" }, "f17" },
779 { { "fr18" }, "f18" },
780 { { "fr19" }, "f19" },
781 { { "fr20" }, "f20" },
782 { { "fr21" }, "f21" },
783 { { "fr22" }, "f22" },
784 { { "fr23" }, "f23" },
785 { { "fr24" }, "f24" },
786 { { "fr25" }, "f25" },
787 { { "fr26" }, "f26" },
788 { { "fr27" }, "f27" },
789 { { "fr28" }, "f28" },
790 { { "fr29" }, "f29" },
791 { { "fr30" }, "f30" },
792 { { "fr31" }, "f31" },
793 { { "cc" }, "cr0" },
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000794};
795
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000796void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000797 unsigned &NumAliases) const {
798 Aliases = GCCRegAliases;
799 NumAliases = llvm::array_lengthof(GCCRegAliases);
800}
801} // end anonymous namespace.
Chris Lattner02dffbd2006-10-14 07:50:21 +0000802
Chris Lattner5ba61f02006-10-14 07:39:34 +0000803namespace {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000804class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +0000805public:
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000806 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedman873f65a2008-08-21 00:13:15 +0000807 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 +0000808 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000809
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +0000810 switch (getTriple().getOS()) {
811 case llvm::Triple::FreeBSD:
812 case llvm::Triple::NetBSD:
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +0000813 SizeType = UnsignedInt;
814 break;
Joerg Sonnenbergerf031fd92011-07-04 23:11:58 +0000815 default:
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +0000816 break;
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +0000817 }
Roman Divacky965b0b72011-01-06 08:27:10 +0000818 }
819
820 virtual const char *getVAListDeclaration() const {
821 // This is the ELF definition, and is overridden by the Darwin sub-target
822 return "typedef struct __va_list_tag {"
823 " unsigned char gpr;"
824 " unsigned char fpr;"
825 " unsigned short reserved;"
826 " void* overflow_arg_area;"
827 " void* reg_save_area;"
828 "} __builtin_va_list[1];";
Eli Friedman873f65a2008-08-21 00:13:15 +0000829 }
Chris Lattner5ba61f02006-10-14 07:39:34 +0000830};
831} // end anonymous namespace.
832
833namespace {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000834class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +0000835public:
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000836 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerba7a6c12008-05-09 06:17:04 +0000837 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman2857ccb2009-07-01 03:36:11 +0000838 IntMaxType = SignedLong;
839 UIntMaxType = UnsignedLong;
840 Int64Type = SignedLong;
Eli Friedman873f65a2008-08-21 00:13:15 +0000841 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 +0000842 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnerba7a6c12008-05-09 06:17:04 +0000843 }
Roman Divacky965b0b72011-01-06 08:27:10 +0000844 virtual const char *getVAListDeclaration() const {
845 return "typedef char* __builtin_va_list;";
846 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000847};
848} // end anonymous namespace.
849
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +0000850
851namespace {
Roman Divacky965b0b72011-01-06 08:27:10 +0000852class DarwinPPC32TargetInfo :
853 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +0000854public:
Roman Divacky965b0b72011-01-06 08:27:10 +0000855 DarwinPPC32TargetInfo(const std::string& triple)
856 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +0000857 HasAlignMac68kSupport = true;
Roman Divacky965b0b72011-01-06 08:27:10 +0000858 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
859 }
860 virtual const char *getVAListDeclaration() const {
861 return "typedef char* __builtin_va_list;";
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +0000862 }
863};
864
865class DarwinPPC64TargetInfo :
866 public DarwinTargetInfo<PPC64TargetInfo> {
867public:
868 DarwinPPC64TargetInfo(const std::string& triple)
869 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
870 HasAlignMac68kSupport = true;
871 }
872};
873} // end anonymous namespace.
874
Chris Lattner5ba61f02006-10-14 07:39:34 +0000875namespace {
Justin Holewinski514cce82011-04-20 19:34:15 +0000876 class PTXTargetInfo : public TargetInfo {
877 static const char * const GCCRegNames[];
878 static const Builtin::Info BuiltinInfo[];
879 public:
880 PTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
881 TLSSupported = false;
882 LongWidth = LongAlign = 64;
883 }
884 virtual void getTargetDefines(const LangOptions &Opts,
885 MacroBuilder &Builder) const {
886 Builder.defineMacro("__PTX__");
887 }
888 virtual void getTargetBuiltins(const Builtin::Info *&Records,
889 unsigned &NumRecords) const {
890 Records = BuiltinInfo;
891 NumRecords = clang::PTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
892 }
893
894 virtual void getGCCRegNames(const char * const *&Names,
895 unsigned &NumNames) const;
896 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
897 unsigned &NumAliases) const {
898 // No aliases.
899 Aliases = 0;
900 NumAliases = 0;
901 }
902 virtual bool validateAsmConstraint(const char *&Name,
903 TargetInfo::ConstraintInfo &info) const {
904 // FIXME: implement
905 return true;
906 }
907 virtual const char *getClobbers() const {
908 // FIXME: Is this really right?
909 return "";
910 }
911 virtual const char *getVAListDeclaration() const {
912 // FIXME: implement
913 return "typedef char* __builtin_va_list;";
914 }
915 };
916
917 const Builtin::Info PTXTargetInfo::BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000918#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Justin Holewinski514cce82011-04-20 19:34:15 +0000919#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000920 ALL_LANGUAGES },
Justin Holewinski514cce82011-04-20 19:34:15 +0000921#include "clang/Basic/BuiltinsPTX.def"
922 };
923
924 const char * const PTXTargetInfo::GCCRegNames[] = {
925 "r0"
926 };
927
928 void PTXTargetInfo::getGCCRegNames(const char * const *&Names,
929 unsigned &NumNames) const {
930 Names = GCCRegNames;
931 NumNames = llvm::array_lengthof(GCCRegNames);
932 }
933
934
935 class PTX32TargetInfo : public PTXTargetInfo {
936 public:
937 PTX32TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
938 PointerWidth = PointerAlign = 32;
939 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
940 DescriptionString
941 = "e-p:32:32-i64:64:64-f64:64:64-n1:8:16:32:64";
942 }
943 };
944
945 class PTX64TargetInfo : public PTXTargetInfo {
946 public:
947 PTX64TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
948 PointerWidth = PointerAlign = 64;
949 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
950 DescriptionString
951 = "e-p:64:64-i64:64:64-f64:64:64-n1:8:16:32:64";
952 }
953 };
954}
955
956namespace {
Chris Lattner5178f562010-03-06 21:21:27 +0000957// MBlaze abstract base class
958class MBlazeTargetInfo : public TargetInfo {
959 static const char * const GCCRegNames[];
960 static const TargetInfo::GCCRegAlias GCCRegAliases[];
961
962public:
963 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Peck69bf1282010-12-12 20:56:47 +0000964 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner5178f562010-03-06 21:21:27 +0000965 }
966
967 virtual void getTargetBuiltins(const Builtin::Info *&Records,
968 unsigned &NumRecords) const {
969 // FIXME: Implement.
970 Records = 0;
971 NumRecords = 0;
972 }
973
974 virtual void getTargetDefines(const LangOptions &Opts,
975 MacroBuilder &Builder) const;
976
977 virtual const char *getVAListDeclaration() const {
978 return "typedef char* __builtin_va_list;";
979 }
980 virtual const char *getTargetPrefix() const {
981 return "mblaze";
982 }
983 virtual void getGCCRegNames(const char * const *&Names,
984 unsigned &NumNames) const;
985 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
986 unsigned &NumAliases) const;
987 virtual bool validateAsmConstraint(const char *&Name,
988 TargetInfo::ConstraintInfo &Info) const {
989 switch (*Name) {
990 default: return false;
991 case 'O': // Zero
992 return true;
993 case 'b': // Base register
994 case 'f': // Floating point register
995 Info.setAllowsRegister();
996 return true;
997 }
998 }
999 virtual const char *getClobbers() const {
1000 return "";
1001 }
1002};
1003
1004/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1005/// #defines that are not tied to a specific subtarget.
1006void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1007 MacroBuilder &Builder) const {
1008 // Target identification.
1009 Builder.defineMacro("__microblaze__");
1010 Builder.defineMacro("_ARCH_MICROBLAZE");
1011 Builder.defineMacro("__MICROBLAZE__");
1012
1013 // Target properties.
1014 Builder.defineMacro("_BIG_ENDIAN");
1015 Builder.defineMacro("__BIG_ENDIAN__");
1016
1017 // Subtarget options.
1018 Builder.defineMacro("__REGISTER_PREFIX__", "");
1019}
1020
1021
1022const char * const MBlazeTargetInfo::GCCRegNames[] = {
1023 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1024 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1025 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1026 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1027 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1028 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1029 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1030 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1031 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1032 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1033};
1034
1035void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1036 unsigned &NumNames) const {
1037 Names = GCCRegNames;
1038 NumNames = llvm::array_lengthof(GCCRegNames);
1039}
1040
1041const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1042 { {"f0"}, "r0" },
1043 { {"f1"}, "r1" },
1044 { {"f2"}, "r2" },
1045 { {"f3"}, "r3" },
1046 { {"f4"}, "r4" },
1047 { {"f5"}, "r5" },
1048 { {"f6"}, "r6" },
1049 { {"f7"}, "r7" },
1050 { {"f8"}, "r8" },
1051 { {"f9"}, "r9" },
1052 { {"f10"}, "r10" },
1053 { {"f11"}, "r11" },
1054 { {"f12"}, "r12" },
1055 { {"f13"}, "r13" },
1056 { {"f14"}, "r14" },
1057 { {"f15"}, "r15" },
1058 { {"f16"}, "r16" },
1059 { {"f17"}, "r17" },
1060 { {"f18"}, "r18" },
1061 { {"f19"}, "r19" },
1062 { {"f20"}, "r20" },
1063 { {"f21"}, "r21" },
1064 { {"f22"}, "r22" },
1065 { {"f23"}, "r23" },
1066 { {"f24"}, "r24" },
1067 { {"f25"}, "r25" },
1068 { {"f26"}, "r26" },
1069 { {"f27"}, "r27" },
1070 { {"f28"}, "r28" },
1071 { {"f29"}, "r29" },
1072 { {"f30"}, "r30" },
1073 { {"f31"}, "r31" },
1074};
1075
1076void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1077 unsigned &NumAliases) const {
1078 Aliases = GCCRegAliases;
1079 NumAliases = llvm::array_lengthof(GCCRegAliases);
1080}
1081} // end anonymous namespace.
1082
1083namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001084// Namespace for x86 abstract base class
1085const Builtin::Info BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00001086#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +00001087#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00001088 ALL_LANGUAGES },
Chris Lattner5abdec72009-06-14 01:05:48 +00001089#include "clang/Basic/BuiltinsX86.def"
Eli Friedman3fd920a2008-08-20 02:34:37 +00001090};
Eli Friedmanb5366062008-05-20 14:21:01 +00001091
Nuno Lopescfca1f02009-12-23 17:49:57 +00001092static const char* const GCCRegNames[] = {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001093 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1094 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher0c912c52011-07-07 22:55:26 +00001095 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman3fd920a2008-08-20 02:34:37 +00001096 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1097 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1098 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercdd36352011-06-21 00:05:20 +00001099 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eli Friedman3fd920a2008-08-20 02:34:37 +00001100};
1101
Eric Christophercdd36352011-06-21 00:05:20 +00001102const TargetInfo::AddlRegName AddlRegNames[] = {
1103 { { "al", "ah", "eax", "rax" }, 0 },
1104 { { "bl", "bh", "ebx", "rbx" }, 3 },
1105 { { "cl", "ch", "ecx", "rcx" }, 2 },
1106 { { "dl", "dh", "edx", "rdx" }, 1 },
1107 { { "esi", "rsi" }, 4 },
1108 { { "edi", "rdi" }, 5 },
1109 { { "esp", "rsp" }, 7 },
1110 { { "ebp", "rbp" }, 6 },
Eli Friedman3fd920a2008-08-20 02:34:37 +00001111};
1112
1113// X86 target abstract base class; x86-32 and x86-64 are very close, so
1114// most of the implementation can be shared.
1115class X86TargetInfo : public TargetInfo {
Chris Lattner96e43572009-03-02 22:40:39 +00001116 enum X86SSEEnum {
Eli Friedman33465822011-07-08 23:31:17 +00001117 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
Chris Lattner96e43572009-03-02 22:40:39 +00001118 } SSELevel;
Eli Friedman33465822011-07-08 23:31:17 +00001119 enum MMX3DNowEnum {
1120 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1121 } MMX3DNowLevel;
Anders Carlssone437c682010-01-27 03:47:49 +00001122
Eric Christophere1ddaf92010-04-02 23:50:19 +00001123 bool HasAES;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001124 bool HasAVX;
1125
Eli Friedman3fd920a2008-08-20 02:34:37 +00001126public:
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001127 X86TargetInfo(const std::string& triple)
Eli Friedman33465822011-07-08 23:31:17 +00001128 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001129 HasAES(false), HasAVX(false) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001130 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner1f5ad112006-10-14 18:32:12 +00001131 }
Chris Lattner10a5b382007-01-29 05:24:35 +00001132 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1133 unsigned &NumRecords) const {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001134 Records = BuiltinInfo;
1135 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner10a5b382007-01-29 05:24:35 +00001136 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001137 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman3fd920a2008-08-20 02:34:37 +00001138 unsigned &NumNames) const {
1139 Names = GCCRegNames;
1140 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson5fa3f342007-11-24 23:38:12 +00001141 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001142 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson5fa3f342007-11-24 23:38:12 +00001143 unsigned &NumAliases) const {
Eric Christophercdd36352011-06-21 00:05:20 +00001144 Aliases = 0;
1145 NumAliases = 0;
1146 }
1147 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1148 unsigned &NumNames) const {
1149 Names = AddlRegNames;
1150 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssona7408e72007-10-13 00:45:48 +00001151 }
Anders Carlsson58436352009-02-28 17:11:49 +00001152 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman3fd920a2008-08-20 02:34:37 +00001153 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00001154 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssonf511f642007-11-27 04:11:28 +00001155 virtual const char *getClobbers() const {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001156 return "~{dirflag},~{fpsr},~{flags}";
1157 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001158 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001159 MacroBuilder &Builder) const;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001160 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1161 const std::string &Name,
1162 bool Enabled) const;
Mike Stump11289f42009-09-09 15:08:12 +00001163 virtual void getDefaultFeatures(const std::string &CPU,
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001164 llvm::StringMap<bool> &Features) const;
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00001165 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedman33465822011-07-08 23:31:17 +00001166 virtual const char* getABI() const {
1167 return MMX3DNowLevel == NoMMX3DNow ? "no-mmx" : "";
1168 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00001169};
Chris Lattnerc25d8a72009-03-02 22:20:04 +00001170
Mike Stump11289f42009-09-09 15:08:12 +00001171void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001172 llvm::StringMap<bool> &Features) const {
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001173 // FIXME: This should not be here.
1174 Features["3dnow"] = false;
1175 Features["3dnowa"] = false;
1176 Features["mmx"] = false;
1177 Features["sse"] = false;
1178 Features["sse2"] = false;
1179 Features["sse3"] = false;
1180 Features["ssse3"] = false;
1181 Features["sse41"] = false;
1182 Features["sse42"] = false;
Eric Christophere1ddaf92010-04-02 23:50:19 +00001183 Features["aes"] = false;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001184 Features["avx"] = false;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001185
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001186 // LLVM does not currently recognize this.
1187 // Features["sse4a"] = false;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001188
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001189 // FIXME: This *really* should not be here.
1190
1191 // X86_64 always has SSE2.
1192 if (PointerWidth == 64)
1193 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1194
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001195 if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
1196 CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
1197 ;
1198 else if (CPU == "pentium-mmx" || CPU == "pentium2")
1199 setFeatureEnabled(Features, "mmx", true);
Eli Friedman33465822011-07-08 23:31:17 +00001200 else if (CPU == "pentium3") {
1201 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001202 setFeatureEnabled(Features, "sse", true);
Eli Friedman33465822011-07-08 23:31:17 +00001203 } else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64") {
1204 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001205 setFeatureEnabled(Features, "sse2", true);
Eli Friedman33465822011-07-08 23:31:17 +00001206 } else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona") {
1207 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001208 setFeatureEnabled(Features, "sse3", true);
Eli Friedman33465822011-07-08 23:31:17 +00001209 } else if (CPU == "core2") {
1210 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001211 setFeatureEnabled(Features, "ssse3", true);
Eli Friedman33465822011-07-08 23:31:17 +00001212 } else if (CPU == "penryn") {
1213 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001214 setFeatureEnabled(Features, "sse4", true);
1215 Features["sse42"] = false;
Eli Friedman33465822011-07-08 23:31:17 +00001216 } else if (CPU == "atom") {
1217 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001218 setFeatureEnabled(Features, "sse3", true);
Eli Friedman33465822011-07-08 23:31:17 +00001219 } else if (CPU == "corei7") {
1220 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001221 setFeatureEnabled(Features, "sse4", true);
Eric Christophere1ddaf92010-04-02 23:50:19 +00001222 setFeatureEnabled(Features, "aes", true);
Benjamin Kramer85e16642011-05-20 15:11:23 +00001223 } else if (CPU == "corei7-avx") {
Eli Friedman33465822011-07-08 23:31:17 +00001224 setFeatureEnabled(Features, "mmx", true);
Roman Divacky27ec14f2011-04-05 20:32:44 +00001225 setFeatureEnabled(Features, "sse4", true);
1226 setFeatureEnabled(Features, "aes", true);
Bruno Cardoso Lopes34728382011-07-11 23:33:46 +00001227 //setFeatureEnabled(Features, "avx", true);
Roman Divacky27ec14f2011-04-05 20:32:44 +00001228 } else if (CPU == "k6" || CPU == "winchip-c6")
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001229 setFeatureEnabled(Features, "mmx", true);
Mike Stump11289f42009-09-09 15:08:12 +00001230 else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001231 CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001232 setFeatureEnabled(Features, "3dnow", true);
1233 } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
1234 setFeatureEnabled(Features, "sse", true);
1235 setFeatureEnabled(Features, "3dnowa", true);
1236 } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
1237 CPU == "athlon-fx") {
Mike Stump11289f42009-09-09 15:08:12 +00001238 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001239 setFeatureEnabled(Features, "3dnowa", true);
Roman Divackydacbfe42010-12-29 13:28:29 +00001240 } else if (CPU == "k8-sse3") {
1241 setFeatureEnabled(Features, "sse3", true);
1242 setFeatureEnabled(Features, "3dnowa", true);
Eli Friedman33465822011-07-08 23:31:17 +00001243 } else if (CPU == "c3-2") {
1244 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001245 setFeatureEnabled(Features, "sse", true);
Eli Friedman33465822011-07-08 23:31:17 +00001246 }
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001247}
1248
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001249bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump11289f42009-09-09 15:08:12 +00001250 const std::string &Name,
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001251 bool Enabled) const {
Eric Christopher399ffa52010-03-04 02:26:37 +00001252 // FIXME: This *really* should not be here. We need some way of translating
1253 // options into llvm subtarget features.
1254 if (!Features.count(Name) &&
1255 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001256 return false;
1257
1258 if (Enabled) {
1259 if (Name == "mmx")
1260 Features["mmx"] = true;
1261 else if (Name == "sse")
Eli Friedman33465822011-07-08 23:31:17 +00001262 Features["sse"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001263 else if (Name == "sse2")
Eli Friedman33465822011-07-08 23:31:17 +00001264 Features["sse"] = Features["sse2"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001265 else if (Name == "sse3")
Eli Friedman33465822011-07-08 23:31:17 +00001266 Features["sse"] = Features["sse2"] = Features["sse3"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001267 else if (Name == "ssse3")
Eli Friedman33465822011-07-08 23:31:17 +00001268 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001269 Features["ssse3"] = true;
Eric Christopher399ffa52010-03-04 02:26:37 +00001270 else if (Name == "sse4" || Name == "sse4.2")
Eli Friedman33465822011-07-08 23:31:17 +00001271 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001272 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Eric Christopher399ffa52010-03-04 02:26:37 +00001273 else if (Name == "sse4.1")
Eli Friedman33465822011-07-08 23:31:17 +00001274 Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopher399ffa52010-03-04 02:26:37 +00001275 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001276 else if (Name == "3dnow")
Eli Friedman33465822011-07-08 23:31:17 +00001277 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001278 else if (Name == "3dnowa")
Eli Friedman33465822011-07-08 23:31:17 +00001279 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophere1ddaf92010-04-02 23:50:19 +00001280 else if (Name == "aes")
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001281 Features["aes"] = true;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001282 else if (Name == "avx")
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001283 Features["avx"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001284 } else {
1285 if (Name == "mmx")
Eli Friedman33465822011-07-08 23:31:17 +00001286 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001287 else if (Name == "sse")
Mike Stump11289f42009-09-09 15:08:12 +00001288 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001289 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001290 else if (Name == "sse2")
Mike Stump11289f42009-09-09 15:08:12 +00001291 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001292 Features["sse41"] = Features["sse42"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001293 else if (Name == "sse3")
Mike Stump11289f42009-09-09 15:08:12 +00001294 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001295 Features["sse42"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001296 else if (Name == "ssse3")
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001297 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Michael J. Spencera9e41172011-04-17 19:22:03 +00001298 else if (Name == "sse4" || Name == "sse4.1")
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001299 Features["sse41"] = Features["sse42"] = false;
Eric Christophercfeceff2010-03-04 02:31:44 +00001300 else if (Name == "sse4.2")
Daniel Dunbarea1f0982011-05-03 15:34:01 +00001301 Features["sse42"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001302 else if (Name == "3dnow")
1303 Features["3dnow"] = Features["3dnowa"] = false;
1304 else if (Name == "3dnowa")
1305 Features["3dnowa"] = false;
Eric Christophere1ddaf92010-04-02 23:50:19 +00001306 else if (Name == "aes")
1307 Features["aes"] = false;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001308 else if (Name == "avx")
1309 Features["avx"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001310 }
1311
1312 return true;
1313}
1314
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001315/// HandleTargetOptions - Perform initialization based on the user
1316/// configured set of features.
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00001317void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar979586e2009-11-11 09:38:56 +00001318 // Remember the maximum enabled sselevel.
1319 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1320 // Ignore disabled features.
1321 if (Features[i][0] == '-')
1322 continue;
1323
Eric Christophere1ddaf92010-04-02 23:50:19 +00001324 if (Features[i].substr(1) == "aes") {
1325 HasAES = true;
1326 continue;
1327 }
1328
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001329 // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1330 // For now let it be enabled together with other SSE levels.
1331 if (Features[i].substr(1) == "avx") {
1332 HasAVX = true;
1333 continue;
1334 }
1335
Daniel Dunbar979586e2009-11-11 09:38:56 +00001336 assert(Features[i][0] == '+' && "Invalid target feature!");
1337 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1338 .Case("sse42", SSE42)
1339 .Case("sse41", SSE41)
1340 .Case("ssse3", SSSE3)
Nuno Lopes4cbc8bd2010-03-12 10:20:09 +00001341 .Case("sse3", SSE3)
Daniel Dunbar979586e2009-11-11 09:38:56 +00001342 .Case("sse2", SSE2)
1343 .Case("sse", SSE1)
Eli Friedman33465822011-07-08 23:31:17 +00001344 .Default(NoSSE);
Daniel Dunbar979586e2009-11-11 09:38:56 +00001345 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001346
Eli Friedman33465822011-07-08 23:31:17 +00001347 MMX3DNowEnum ThreeDNowLevel =
1348 llvm::StringSwitch<MMX3DNowEnum>(Features[i].substr(1))
Anders Carlssone437c682010-01-27 03:47:49 +00001349 .Case("3dnowa", AMD3DNowAthlon)
1350 .Case("3dnow", AMD3DNow)
Eli Friedman33465822011-07-08 23:31:17 +00001351 .Case("mmx", MMX)
1352 .Default(NoMMX3DNow);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001353
Eli Friedman33465822011-07-08 23:31:17 +00001354 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar979586e2009-11-11 09:38:56 +00001355 }
Eli Friedman33465822011-07-08 23:31:17 +00001356
1357 // Don't tell the backend if we're turning off mmx; it will end up disabling
1358 // SSE, which we don't want.
1359 std::vector<std::string>::iterator it;
1360 it = std::find(Features.begin(), Features.end(), "-mmx");
1361 if (it != Features.end())
1362 Features.erase(it);
Chris Lattnerc25d8a72009-03-02 22:20:04 +00001363}
Chris Lattnerecd49032009-03-02 22:27:17 +00001364
1365/// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
1366/// that are not tied to a specific subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001367void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001368 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +00001369 // Target identification.
1370 if (PointerWidth == 64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001371 Builder.defineMacro("_LP64");
1372 Builder.defineMacro("__LP64__");
1373 Builder.defineMacro("__amd64__");
1374 Builder.defineMacro("__amd64");
1375 Builder.defineMacro("__x86_64");
1376 Builder.defineMacro("__x86_64__");
Chris Lattnerecd49032009-03-02 22:27:17 +00001377 } else {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001378 DefineStd(Builder, "i386", Opts);
Chris Lattnerecd49032009-03-02 22:27:17 +00001379 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001380
Eric Christophere1ddaf92010-04-02 23:50:19 +00001381 if (HasAES)
1382 Builder.defineMacro("__AES__");
1383
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001384 if (HasAVX)
1385 Builder.defineMacro("__AVX__");
1386
Chris Lattnerecd49032009-03-02 22:27:17 +00001387 // Target properties.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001388 Builder.defineMacro("__LITTLE_ENDIAN__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001389
Chris Lattnerecd49032009-03-02 22:27:17 +00001390 // Subtarget options.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001391 Builder.defineMacro("__nocona");
1392 Builder.defineMacro("__nocona__");
1393 Builder.defineMacro("__tune_nocona__");
1394 Builder.defineMacro("__REGISTER_PREFIX__", "");
Chris Lattner96e43572009-03-02 22:40:39 +00001395
Chris Lattner6df41af2009-04-19 17:32:33 +00001396 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1397 // functions in glibc header files that use FP Stack inline asm which the
1398 // backend can't deal with (PR879).
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001399 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001400
Chris Lattner96e43572009-03-02 22:40:39 +00001401 // Each case falls through to the previous one here.
1402 switch (SSELevel) {
1403 case SSE42:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001404 Builder.defineMacro("__SSE4_2__");
Chris Lattner96e43572009-03-02 22:40:39 +00001405 case SSE41:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001406 Builder.defineMacro("__SSE4_1__");
Chris Lattner96e43572009-03-02 22:40:39 +00001407 case SSSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001408 Builder.defineMacro("__SSSE3__");
Chris Lattner96e43572009-03-02 22:40:39 +00001409 case SSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001410 Builder.defineMacro("__SSE3__");
Chris Lattner96e43572009-03-02 22:40:39 +00001411 case SSE2:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001412 Builder.defineMacro("__SSE2__");
1413 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner96e43572009-03-02 22:40:39 +00001414 case SSE1:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001415 Builder.defineMacro("__SSE__");
1416 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedman33465822011-07-08 23:31:17 +00001417 case NoSSE:
Chris Lattner96e43572009-03-02 22:40:39 +00001418 break;
1419 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00001420
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001421 if (Opts.Microsoft && PointerWidth == 32) {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001422 switch (SSELevel) {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00001423 case SSE42:
1424 case SSE41:
1425 case SSSE3:
1426 case SSE3:
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001427 case SSE2:
1428 Builder.defineMacro("_M_IX86_FP", llvm::Twine(2));
1429 break;
1430 case SSE1:
1431 Builder.defineMacro("_M_IX86_FP", llvm::Twine(1));
1432 break;
1433 default:
1434 Builder.defineMacro("_M_IX86_FP", llvm::Twine(0));
1435 }
1436 }
1437
Anders Carlssone437c682010-01-27 03:47:49 +00001438 // Each case falls through to the previous one here.
Eli Friedman33465822011-07-08 23:31:17 +00001439 switch (MMX3DNowLevel) {
Anders Carlssone437c682010-01-27 03:47:49 +00001440 case AMD3DNowAthlon:
1441 Builder.defineMacro("__3dNOW_A__");
1442 case AMD3DNow:
1443 Builder.defineMacro("__3dNOW__");
Eli Friedman33465822011-07-08 23:31:17 +00001444 case MMX:
1445 Builder.defineMacro("__MMX__");
1446 case NoMMX3DNow:
Anders Carlssone437c682010-01-27 03:47:49 +00001447 break;
1448 }
Chris Lattnerecd49032009-03-02 22:27:17 +00001449}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001450
1451
Eli Friedman3fd920a2008-08-20 02:34:37 +00001452bool
Anders Carlsson58436352009-02-28 17:11:49 +00001453X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +00001454 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson58436352009-02-28 17:11:49 +00001455 switch (*Name) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001456 default: return false;
Dale Johannesen46742a42010-08-24 22:33:12 +00001457 case 'Y': // first letter of a pair:
1458 switch (*(Name+1)) {
1459 default: return false;
1460 case '0': // First SSE register.
1461 case 't': // Any SSE register, when SSE2 is enabled.
1462 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
1463 case 'm': // any MMX register, when inter-unit moves enabled.
1464 break; // falls through to setAllowsRegister.
1465 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00001466 case 'a': // eax.
1467 case 'b': // ebx.
1468 case 'c': // ecx.
1469 case 'd': // edx.
1470 case 'S': // esi.
1471 case 'D': // edi.
1472 case 'A': // edx:eax.
Dale Johannesen46742a42010-08-24 22:33:12 +00001473 case 'f': // any x87 floating point stack register.
Eli Friedman3fd920a2008-08-20 02:34:37 +00001474 case 't': // top of floating point stack.
1475 case 'u': // second from top of floating point stack.
1476 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson83661ac2008-10-06 00:41:45 +00001477 case 'y': // Any MMX register.
Anders Carlsson5f7ee682008-10-06 19:17:39 +00001478 case 'x': // Any SSE register.
Eli Friedman3fd920a2008-08-20 02:34:37 +00001479 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen46742a42010-08-24 22:33:12 +00001480 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
1481 case 'l': // "Index" registers: any general register that can be used as an
1482 // index in a base+index memory access.
1483 Info.setAllowsRegister();
1484 return true;
1485 case 'C': // SSE floating point constant.
1486 case 'G': // x87 floating point constant.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001487 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssona0b89212009-01-24 18:03:09 +00001488 // x86_64 instructions.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001489 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssona0b89212009-01-24 18:03:09 +00001490 // x86_64 instructions.
Eli Friedman3fd920a2008-08-20 02:34:37 +00001491 return true;
1492 }
Dale Johannesen46742a42010-08-24 22:33:12 +00001493 return false;
Eli Friedman3fd920a2008-08-20 02:34:37 +00001494}
1495
Dale Johannesen7d3dfc02010-10-29 23:12:32 +00001496
Eli Friedman3fd920a2008-08-20 02:34:37 +00001497std::string
Stuart Hastings7fdc6702011-06-07 23:45:05 +00001498X86TargetInfo::convertConstraint(const char *&Constraint) const {
1499 switch (*Constraint) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001500 case 'a': return std::string("{ax}");
1501 case 'b': return std::string("{bx}");
1502 case 'c': return std::string("{cx}");
1503 case 'd': return std::string("{dx}");
1504 case 'S': return std::string("{si}");
1505 case 'D': return std::string("{di}");
Dale Johannesen70f564e2010-10-22 21:07:10 +00001506 case 'p': // address
1507 return std::string("im");
Eli Friedman3fd920a2008-08-20 02:34:37 +00001508 case 't': // top of floating point stack.
1509 return std::string("{st}");
1510 case 'u': // second from top of floating point stack.
1511 return std::string("{st(1)}"); // second from top of floating point stack.
1512 default:
Stuart Hastings7fdc6702011-06-07 23:45:05 +00001513 return std::string(1, *Constraint);
Eli Friedman3fd920a2008-08-20 02:34:37 +00001514 }
1515}
Eli Friedman3fd920a2008-08-20 02:34:37 +00001516} // end anonymous namespace
Chris Lattner5ba61f02006-10-14 07:39:34 +00001517
1518namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001519// X86-32 generic target
1520class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00001521public:
Eli Friedman3fd920a2008-08-20 02:34:37 +00001522 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1523 DoubleAlign = LongLongAlign = 32;
1524 LongDoubleWidth = 96;
1525 LongDoubleAlign = 32;
Eli Friedman873f65a2008-08-21 00:13:15 +00001526 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1527 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00001528 "a0:0:64-f80:32:32-n8:16:32";
Eli Friedman32ca82a2009-03-29 20:31:09 +00001529 SizeType = UnsignedInt;
1530 PtrDiffType = SignedInt;
1531 IntPtrType = SignedInt;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00001532 RegParmMax = 3;
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00001533
1534 // Use fpret for all types.
1535 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
1536 (1 << TargetInfo::Double) |
1537 (1 << TargetInfo::LongDouble));
Eli Friedman3fd920a2008-08-20 02:34:37 +00001538 }
1539 virtual const char *getVAListDeclaration() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001540 return "typedef char* __builtin_va_list;";
Eli Friedman3fd920a2008-08-20 02:34:37 +00001541 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001542
Chris Lattnerd545ad12009-09-23 06:06:36 +00001543 int getEHDataRegisterNumber(unsigned RegNo) const {
1544 if (RegNo == 0) return 0;
1545 if (RegNo == 1) return 2;
1546 return -1;
1547 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00001548};
1549} // end anonymous namespace
1550
1551namespace {
Eli Friedmane3aa4542009-07-05 18:47:56 +00001552class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
1553public:
1554 OpenBSDI386TargetInfo(const std::string& triple) :
1555 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
1556 SizeType = UnsignedLong;
1557 IntPtrType = SignedLong;
Eli Friedman245f2292009-07-05 22:31:18 +00001558 PtrDiffType = SignedLong;
Eli Friedmane3aa4542009-07-05 18:47:56 +00001559 }
1560};
1561} // end anonymous namespace
1562
1563namespace {
Torok Edwinb2b37c62009-06-30 17:10:35 +00001564class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001565public:
Torok Edwinb2b37c62009-06-30 17:10:35 +00001566 DarwinI386TargetInfo(const std::string& triple) :
1567 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001568 LongDoubleWidth = 128;
1569 LongDoubleAlign = 128;
Eli Friedman32ca82a2009-03-29 20:31:09 +00001570 SizeType = UnsignedLong;
1571 IntPtrType = SignedLong;
Eli Friedman873f65a2008-08-21 00:13:15 +00001572 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1573 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00001574 "a0:0:64-f80:128:128-n8:16:32";
Daniel Dunbarbd606522010-05-27 00:35:16 +00001575 HasAlignMac68kSupport = true;
Torok Edwin4e054162009-06-30 17:00:25 +00001576 }
1577
Eli Friedman3fd920a2008-08-20 02:34:37 +00001578};
Daniel Dunbar10de9e62009-06-29 20:52:51 +00001579} // end anonymous namespace
1580
1581namespace {
Eli Friedmanc968a6a2008-08-21 01:40:19 +00001582// x86-32 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001583class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedmanc968a6a2008-08-21 01:40:19 +00001584public:
1585 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001586 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmand88c8a12009-04-19 21:38:35 +00001587 TLSSupported = false;
Chris Lattner46be2e12009-06-24 17:12:15 +00001588 WCharType = UnsignedShort;
Eli Friedmanebb9e4d2009-06-08 21:16:17 +00001589 DoubleAlign = LongLongAlign = 64;
1590 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 +00001591 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
1592 "v128:128:128-a0:0:64-f80:32:32-n8:16:32";
Eli Friedmanc968a6a2008-08-21 01:40:19 +00001593 }
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00001594 virtual void getTargetDefines(const LangOptions &Opts,
1595 MacroBuilder &Builder) const {
1596 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
1597 }
1598};
1599} // end anonymous namespace
1600
1601namespace {
1602
1603// x86-32 Windows Visual Studio target
1604class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
1605public:
1606 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
1607 : WindowsX86_32TargetInfo(triple) {
Eli Friedman015d6282011-03-22 21:25:11 +00001608 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00001609 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
1610 }
1611 virtual void getTargetDefines(const LangOptions &Opts,
1612 MacroBuilder &Builder) const {
1613 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
1614 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
1615 // The value of the following reflects processor type.
1616 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
1617 // We lost the original triple, so we use the default.
1618 Builder.defineMacro("_M_IX86", "600");
1619 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001620};
1621} // end anonymous namespace
1622
1623namespace {
1624// x86-32 MinGW target
1625class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
1626public:
1627 MinGWX86_32TargetInfo(const std::string& triple)
1628 : WindowsX86_32TargetInfo(triple) {
1629 }
1630 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001631 MacroBuilder &Builder) const {
1632 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00001633 DefineStd(Builder, "WIN32", Opts);
1634 DefineStd(Builder, "WINNT", Opts);
1635 Builder.defineMacro("_X86_");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001636 Builder.defineMacro("__MSVCRT__");
1637 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumib2beb012011-03-15 02:32:50 +00001638
1639 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
1640 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
1641 if (Opts.Microsoft)
1642 // Provide "as-is" __declspec.
1643 Builder.defineMacro("__declspec", "__declspec");
1644 else
1645 // Provide alias of __attribute__ like mingw32-gcc.
1646 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001647 }
1648};
1649} // end anonymous namespace
1650
1651namespace {
1652// x86-32 Cygwin target
1653class CygwinX86_32TargetInfo : public X86_32TargetInfo {
1654public:
1655 CygwinX86_32TargetInfo(const std::string& triple)
1656 : X86_32TargetInfo(triple) {
1657 TLSSupported = false;
1658 WCharType = UnsignedShort;
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001659 DoubleAlign = LongLongAlign = 64;
1660 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1661 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00001662 "a0:0:64-f80:32:32-n8:16:32";
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001663 }
1664 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001665 MacroBuilder &Builder) const {
1666 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1667 Builder.defineMacro("__CYGWIN__");
1668 Builder.defineMacro("__CYGWIN32__");
1669 DefineStd(Builder, "unix", Opts);
Douglas Gregor3ecc6652010-04-21 05:52:38 +00001670 if (Opts.CPlusPlus)
1671 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanaa27a872009-06-08 06:11:14 +00001672 }
Eli Friedmanc968a6a2008-08-21 01:40:19 +00001673};
1674} // end anonymous namespace
1675
1676namespace {
Chris Lattnerb986aba2010-04-11 19:29:39 +00001677// x86-32 Haiku target
1678class HaikuX86_32TargetInfo : public X86_32TargetInfo {
1679public:
1680 HaikuX86_32TargetInfo(const std::string& triple)
1681 : X86_32TargetInfo(triple) {
1682 SizeType = UnsignedLong;
Chris Lattner8b290212010-04-22 17:48:00 +00001683 IntPtrType = SignedLong;
1684 PtrDiffType = SignedLong;
Rafael Espindolac55be6d2010-11-09 16:41:02 +00001685 this->UserLabelPrefix = "";
Eli Friedman04831922010-08-22 01:00:03 +00001686 }
Chris Lattnerb986aba2010-04-11 19:29:39 +00001687 virtual void getTargetDefines(const LangOptions &Opts,
1688 MacroBuilder &Builder) const {
1689 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1690 Builder.defineMacro("__INTEL__");
1691 Builder.defineMacro("__HAIKU__");
1692 }
1693};
1694} // end anonymous namespace
1695
Douglas Gregor9fabd852011-07-01 22:41:14 +00001696// RTEMS Target
1697template<typename Target>
1698class RTEMSTargetInfo : public OSTargetInfo<Target> {
1699protected:
1700 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
1701 MacroBuilder &Builder) const {
1702 // RTEMS defines; list based off of gcc output
1703
1704 // FIXME: Move version number handling to llvm::Triple.
1705 llvm::StringRef Release = Triple.getOSName().substr(strlen("rtems"), 1);
1706
1707 Builder.defineMacro("__rtems__");
1708 Builder.defineMacro("__ELF__");
1709 }
1710public:
1711 RTEMSTargetInfo(const std::string &triple)
1712 : OSTargetInfo<Target>(triple) {
1713 this->UserLabelPrefix = "";
1714
1715 llvm::Triple Triple(triple);
1716 switch (Triple.getArch()) {
1717 default:
1718 case llvm::Triple::x86:
1719 // this->MCountName = ".mcount";
1720 break;
1721 case llvm::Triple::mips:
1722 case llvm::Triple::mipsel:
1723 case llvm::Triple::ppc:
1724 case llvm::Triple::ppc64:
1725 // this->MCountName = "_mcount";
1726 break;
1727 case llvm::Triple::arm:
1728 // this->MCountName = "__mcount";
1729 break;
1730 }
1731
1732 }
1733};
1734
1735namespace {
1736// x86-32 RTEMS target
1737class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
1738public:
1739 RTEMSX86_32TargetInfo(const std::string& triple)
1740 : X86_32TargetInfo(triple) {
1741 SizeType = UnsignedLong;
1742 IntPtrType = SignedLong;
1743 PtrDiffType = SignedLong;
1744 this->UserLabelPrefix = "";
1745 }
1746 virtual void getTargetDefines(const LangOptions &Opts,
1747 MacroBuilder &Builder) const {
1748 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1749 Builder.defineMacro("__INTEL__");
1750 Builder.defineMacro("__rtems__");
1751 }
1752};
1753} // end anonymous namespace
1754
Chris Lattnerb986aba2010-04-11 19:29:39 +00001755namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001756// x86-64 generic target
1757class X86_64TargetInfo : public X86TargetInfo {
1758public:
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001759 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerba7a6c12008-05-09 06:17:04 +00001760 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedmanb5366062008-05-20 14:21:01 +00001761 LongDoubleWidth = 128;
1762 LongDoubleAlign = 128;
Rafael Espindolae971b9a2010-06-04 23:15:27 +00001763 LargeArrayMinWidth = 128;
1764 LargeArrayAlign = 128;
Chris Lattnerd0a79b22009-02-05 07:32:46 +00001765 IntMaxType = SignedLong;
1766 UIntMaxType = UnsignedLong;
Eli Friedman2857ccb2009-07-01 03:36:11 +00001767 Int64Type = SignedLong;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00001768 RegParmMax = 6;
Chris Lattnerd0a79b22009-02-05 07:32:46 +00001769
Eli Friedman873f65a2008-08-21 00:13:15 +00001770 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1771 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00001772 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64";
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00001773
1774 // Use fpret only for long double.
1775 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Chris Lattner10a5b382007-01-29 05:24:35 +00001776 }
Anders Carlssona7408e72007-10-13 00:45:48 +00001777 virtual const char *getVAListDeclaration() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001778 return "typedef struct __va_list_tag {"
1779 " unsigned gp_offset;"
1780 " unsigned fp_offset;"
1781 " void* overflow_arg_area;"
1782 " void* reg_save_area;"
John McCall61d82582010-05-28 18:25:28 +00001783 "} __va_list_tag;"
Eli Friedmanfb36b022009-07-03 00:45:06 +00001784 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson5fa3f342007-11-24 23:38:12 +00001785 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00001786
Chris Lattnerd545ad12009-09-23 06:06:36 +00001787 int getEHDataRegisterNumber(unsigned RegNo) const {
1788 if (RegNo == 0) return 0;
1789 if (RegNo == 1) return 1;
1790 return -1;
1791 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00001792};
1793} // end anonymous namespace
1794
1795namespace {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001796// x86-64 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001797class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001798public:
1799 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001800 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001801 TLSSupported = false;
1802 WCharType = UnsignedShort;
Mike Stumpaf9afe92009-10-08 23:00:00 +00001803 LongWidth = LongAlign = 32;
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00001804 DoubleAlign = LongLongAlign = 64;
Nate Begeman6e8865a2010-07-21 02:02:56 +00001805 IntMaxType = SignedLongLong;
1806 UIntMaxType = UnsignedLongLong;
1807 Int64Type = SignedLongLong;
Cameron Esfahanieb856502010-09-15 00:28:12 +00001808 SizeType = UnsignedLongLong;
1809 PtrDiffType = SignedLongLong;
1810 IntPtrType = SignedLongLong;
NAKAMURA Takumif7c30222011-01-17 22:56:08 +00001811 this->UserLabelPrefix = "";
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001812 }
1813 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001814 MacroBuilder &Builder) const {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001815 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001816 Builder.defineMacro("_WIN64");
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00001817 }
NAKAMURA Takumia2e468c2011-01-17 22:56:23 +00001818 virtual const char *getVAListDeclaration() const {
1819 return "typedef char* __builtin_va_list;";
1820 }
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00001821};
1822} // end anonymous namespace
1823
1824namespace {
1825// x86-64 Windows Visual Studio target
1826class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
1827public:
1828 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
1829 : WindowsX86_64TargetInfo(triple) {
Eli Friedman015d6282011-03-22 21:25:11 +00001830 LongDoubleWidth = LongDoubleAlign = 64;
1831 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00001832 }
1833 virtual void getTargetDefines(const LangOptions &Opts,
1834 MacroBuilder &Builder) const {
1835 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1836 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001837 Builder.defineMacro("_M_X64");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001838 Builder.defineMacro("_M_AMD64");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001839 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001840};
1841} // end anonymous namespace
1842
1843namespace {
1844// x86-64 MinGW target
1845class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
1846public:
1847 MinGWX86_64TargetInfo(const std::string& triple)
1848 : WindowsX86_64TargetInfo(triple) {
1849 }
1850 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001851 MacroBuilder &Builder) const {
1852 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00001853 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001854 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi2b7eeb22011-03-08 12:06:46 +00001855 Builder.defineMacro("__MINGW32__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001856 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumib2beb012011-03-15 02:32:50 +00001857
1858 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
1859 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
1860 if (Opts.Microsoft)
1861 // Provide "as-is" __declspec.
1862 Builder.defineMacro("__declspec", "__declspec");
1863 else
1864 // Provide alias of __attribute__ like mingw32-gcc.
1865 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001866 }
1867};
1868} // end anonymous namespace
1869
1870namespace {
Eli Friedman2857ccb2009-07-01 03:36:11 +00001871class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
1872public:
Mike Stump11289f42009-09-09 15:08:12 +00001873 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman2857ccb2009-07-01 03:36:11 +00001874 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
1875 Int64Type = SignedLongLong;
1876 }
1877};
1878} // end anonymous namespace
1879
1880namespace {
Eli Friedman245f2292009-07-05 22:31:18 +00001881class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
1882public:
Mike Stump11289f42009-09-09 15:08:12 +00001883 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman245f2292009-07-05 22:31:18 +00001884 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
1885 IntMaxType = SignedLongLong;
1886 UIntMaxType = UnsignedLongLong;
1887 Int64Type = SignedLongLong;
1888 }
1889};
1890} // end anonymous namespace
1891
1892namespace {
Eli Friedmanf05b7722008-08-20 07:44:10 +00001893class ARMTargetInfo : public TargetInfo {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00001894 // Possible FPU choices.
1895 enum FPUMode {
1896 NoFPU,
1897 VFP2FPU,
1898 VFP3FPU,
1899 NeonFPU
1900 };
1901
1902 static bool FPUModeIsVFP(FPUMode Mode) {
1903 return Mode >= VFP2FPU && Mode <= NeonFPU;
1904 }
1905
1906 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1907 static const char * const GCCRegNames[];
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001908
Daniel Dunbaracde99e2009-12-18 18:42:37 +00001909 std::string ABI, CPU;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00001910
1911 unsigned FPU : 3;
1912
Daniel Dunbar893d4752009-12-19 04:15:38 +00001913 unsigned IsThumb : 1;
1914
1915 // Initialized via features.
1916 unsigned SoftFloat : 1;
1917 unsigned SoftFloatABI : 1;
Daniel Dunbarb4091a92009-09-14 00:35:03 +00001918
Chris Lattner5cc15e02010-03-03 19:03:45 +00001919 static const Builtin::Info BuiltinInfo[];
1920
Chris Lattner17df24e2008-04-21 18:56:49 +00001921public:
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00001922 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbaracde99e2009-12-18 18:42:37 +00001923 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbarb4091a92009-09-14 00:35:03 +00001924 {
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00001925 SizeType = UnsignedInt;
1926 PtrDiffType = SignedInt;
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00001927
Chris Lattner1a8f3942010-04-23 16:29:58 +00001928 // {} in inline assembly are neon specifiers, not assembly variant
1929 // specifiers.
1930 NoAsmVariants = true;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001931
Daniel Dunbaracde99e2009-12-18 18:42:37 +00001932 // FIXME: Should we just treat this as a feature?
Daniel Dunbarc454ecf2009-12-18 19:57:13 +00001933 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbar03184792009-09-22 21:44:58 +00001934 if (IsThumb) {
Sandeep Patelf87b3732011-04-04 22:58:12 +00001935 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
1936 // so set preferred for small types to 32.
Daniel Dunbar03184792009-09-22 21:44:58 +00001937 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1938 "i64:64:64-f32:32:32-f64:64:64-"
Bob Wilsone3a15fe2011-04-04 16:53:11 +00001939 "v64:64:64-v128:64:128-a0:0:32-n32");
Daniel Dunbar03184792009-09-22 21:44:58 +00001940 } else {
1941 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1942 "i64:64:64-f32:32:32-f64:64:64-"
Bob Wilsone3a15fe2011-04-04 16:53:11 +00001943 "v64:64:64-v128:64:128-a0:0:64-n32");
Daniel Dunbar03184792009-09-22 21:44:58 +00001944 }
John McCall86353412010-08-21 22:46:04 +00001945
1946 // ARM targets default to using the ARM C++ ABI.
1947 CXXABI = CXXABI_ARM;
Eli Friedmanb5366062008-05-20 14:21:01 +00001948 }
Daniel Dunbarb4091a92009-09-14 00:35:03 +00001949 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00001950 virtual bool setABI(const std::string &Name) {
Daniel Dunbarb4091a92009-09-14 00:35:03 +00001951 ABI = Name;
1952
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00001953 // The defaults (above) are for AAPCS, check if we need to change them.
1954 //
1955 // FIXME: We need support for -meabi... we could just mangle it into the
1956 // name.
1957 if (Name == "apcs-gnu") {
Daniel Dunbar377dc2f2010-01-27 20:23:08 +00001958 DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00001959 SizeType = UnsignedLong;
1960
Daniel Dunbarf8125062010-04-22 16:14:54 +00001961 // Do not respect the alignment of bit-field types when laying out
1962 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
1963 UseBitFieldTypeAlignment = false;
1964
Daniel Dunbar03184792009-09-22 21:44:58 +00001965 if (IsThumb) {
Sandeep Patelf87b3732011-04-04 22:58:12 +00001966 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
1967 // so set preferred for small types to 32.
Daniel Dunbar03184792009-09-22 21:44:58 +00001968 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 +00001969 "i64:32:64-f32:32:32-f64:32:64-"
Bob Wilsone3a15fe2011-04-04 16:53:11 +00001970 "v64:32:64-v128:32:128-a0:0:32-n32");
Daniel Dunbar03184792009-09-22 21:44:58 +00001971 } else {
1972 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 +00001973 "i64:32:64-f32:32:32-f64:32:64-"
1974 "v64:32:64-v128:32:128-a0:0:32-n32");
Daniel Dunbar03184792009-09-22 21:44:58 +00001975 }
1976
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00001977 // FIXME: Override "preferred align" for double and long long.
1978 } else if (Name == "aapcs") {
1979 // FIXME: Enumerated types are variable width in straight AAPCS.
1980 } else if (Name == "aapcs-linux") {
1981 ;
1982 } else
1983 return false;
1984
1985 return true;
1986 }
Daniel Dunbar893d4752009-12-19 04:15:38 +00001987
Daniel Dunbar0def3d12009-12-21 23:28:17 +00001988 void getDefaultFeatures(const std::string &CPU,
1989 llvm::StringMap<bool> &Features) const {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00001990 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
1991 Features["vfp2"] = true;
1992 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
1993 Features["neon"] = true;
1994 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001995
Daniel Dunbar893d4752009-12-19 04:15:38 +00001996 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1997 const std::string &Name,
1998 bool Enabled) const {
Evan Cheng491f56d2011-07-08 06:40:11 +00001999 if (Name == "soft-float" || Name == "soft-float-abi" ||
2000 Name == "vfp2" || Name == "vfp3" || Name == "neon") {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002001 Features[Name] = Enabled;
2002 } else
Daniel Dunbar893d4752009-12-19 04:15:38 +00002003 return false;
2004
Daniel Dunbar893d4752009-12-19 04:15:38 +00002005 return true;
2006 }
2007
2008 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002009 FPU = NoFPU;
Daniel Dunbar893d4752009-12-19 04:15:38 +00002010 SoftFloat = SoftFloatABI = false;
2011 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
2012 if (Features[i] == "+soft-float")
2013 SoftFloat = true;
2014 else if (Features[i] == "+soft-float-abi")
2015 SoftFloatABI = true;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002016 else if (Features[i] == "+vfp2")
2017 FPU = VFP2FPU;
2018 else if (Features[i] == "+vfp3")
2019 FPU = VFP3FPU;
2020 else if (Features[i] == "+neon")
2021 FPU = NeonFPU;
Daniel Dunbar893d4752009-12-19 04:15:38 +00002022 }
2023
2024 // Remove front-end specific options which the backend handles differently.
2025 std::vector<std::string>::iterator it;
2026 it = std::find(Features.begin(), Features.end(), "+soft-float");
2027 if (it != Features.end())
2028 Features.erase(it);
2029 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2030 if (it != Features.end())
2031 Features.erase(it);
2032 }
2033
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002034 static const char *getCPUDefineSuffix(llvm::StringRef Name) {
2035 return llvm::StringSwitch<const char*>(Name)
2036 .Cases("arm8", "arm810", "4")
2037 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2038 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2039 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2040 .Case("ep9312", "4T")
2041 .Cases("arm10tdmi", "arm1020t", "5T")
2042 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2043 .Case("arm926ej-s", "5TEJ")
2044 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2045 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002046 .Case("arm1136j-s", "6J")
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002047 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002048 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002049 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2050 .Cases("cortex-a8", "cortex-a9", "7A")
Bob Wilson44acad82011-01-06 16:57:20 +00002051 .Case("cortex-m3", "7M")
Bob Wilson87ba1d32011-03-21 21:55:25 +00002052 .Case("cortex-m0", "6M")
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002053 .Default(0);
2054 }
2055 virtual bool setCPU(const std::string &Name) {
2056 if (!getCPUDefineSuffix(Name))
2057 return false;
2058
2059 CPU = Name;
2060 return true;
2061 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +00002062 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002063 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +00002064 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002065 Builder.defineMacro("__arm");
2066 Builder.defineMacro("__arm__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002067
Chris Lattnerecd49032009-03-02 22:27:17 +00002068 // Target properties.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002069 Builder.defineMacro("__ARMEL__");
2070 Builder.defineMacro("__LITTLE_ENDIAN__");
2071 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002072
2073 llvm::StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002074 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002075
Mike Stump9d54bd72009-04-08 02:07:04 +00002076 // Subtarget options.
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00002077
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002078 // FIXME: It's more complicated than this and we don't really support
2079 // interworking.
2080 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002081 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002082
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002083 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002084 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002085
Daniel Dunbar893d4752009-12-19 04:15:38 +00002086 if (SoftFloat)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002087 Builder.defineMacro("__SOFTFP__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002088
2089 if (CPU == "xscale")
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002090 Builder.defineMacro("__XSCALE__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00002091
Bob Wilson19c1b882011-05-13 18:56:03 +00002092 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00002093 if (IsThumb) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002094 Builder.defineMacro("__THUMBEL__");
2095 Builder.defineMacro("__thumb__");
Bob Wilson19c1b882011-05-13 18:56:03 +00002096 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002097 Builder.defineMacro("__thumb2__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00002098 }
2099
2100 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002101 Builder.defineMacro("__APCS_32__");
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002102
2103 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002104 Builder.defineMacro("__VFP_FP__");
Daniel Dunbar0def3d12009-12-21 23:28:17 +00002105
2106 // This only gets set when Neon instructions are actually available, unlike
2107 // the VFP define, hence the soft float and arch check. This is subtly
2108 // different from gcc, we follow the intent which was that it should be set
2109 // when Neon instructions are actually available.
Bob Wilson19c1b882011-05-13 18:56:03 +00002110 if (FPU == NeonFPU && !SoftFloat && IsARMv7)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002111 Builder.defineMacro("__ARM_NEON__");
Chris Lattner17df24e2008-04-21 18:56:49 +00002112 }
2113 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2114 unsigned &NumRecords) const {
Chris Lattner5cc15e02010-03-03 19:03:45 +00002115 Records = BuiltinInfo;
2116 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner17df24e2008-04-21 18:56:49 +00002117 }
2118 virtual const char *getVAListDeclaration() const {
John McCalle155a3d2011-05-09 02:19:37 +00002119 return "typedef void* __builtin_va_list;";
Chris Lattner17df24e2008-04-21 18:56:49 +00002120 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002121 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002122 unsigned &NumNames) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002123 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002124 unsigned &NumAliases) const;
Anders Carlsson58436352009-02-28 17:11:49 +00002125 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +00002126 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanf05b7722008-08-20 07:44:10 +00002127 // FIXME: Check if this is complete
Anders Carlsson58436352009-02-28 17:11:49 +00002128 switch (*Name) {
Eli Friedmanf05b7722008-08-20 07:44:10 +00002129 default:
Nate Begeman2908fa02008-04-22 05:03:19 +00002130 case 'l': // r0-r7
2131 case 'h': // r8-r15
2132 case 'w': // VFP Floating point register single precision
2133 case 'P': // VFP Floating point register double precision
Chris Lattnerd9725f72009-04-26 07:16:29 +00002134 Info.setAllowsRegister();
Nate Begeman2908fa02008-04-22 05:03:19 +00002135 return true;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00002136 case 'U': // a memory reference...
2137 switch (Name[1]) {
2138 case 'q': // ...ARMV4 ldrsb
2139 case 'v': // ...VFP load/store (reg+constant offset)
2140 case 'y': // ...iWMMXt load/store
Eric Christopherd1048542011-06-17 01:40:49 +00002141 case 't': // address valid for load/store opaque types wider
2142 // than 128-bits
2143 case 'n': // valid address for Neon doubleword vector load/store
2144 case 'm': // valid address for Neon element and structure load/store
2145 case 's': // valid address for non-offset loads/stores of quad-word
2146 // values in four ARM registers
Stuart Hastings7fdc6702011-06-07 23:45:05 +00002147 Info.setAllowsMemory();
2148 Name++;
2149 return true;
2150 }
Nate Begeman2908fa02008-04-22 05:03:19 +00002151 }
Chris Lattner17df24e2008-04-21 18:56:49 +00002152 return false;
2153 }
Evan Chengd863adb2011-06-16 19:13:15 +00002154 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings7fdc6702011-06-07 23:45:05 +00002155 std::string R;
2156 switch (*Constraint) {
2157 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings5b7b11c2011-06-08 16:06:31 +00002158 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings7fdc6702011-06-07 23:45:05 +00002159 Constraint++;
2160 break;
Eric Christopher7d237c12011-06-17 00:40:18 +00002161 case 'p': // 'p' should be translated to 'r' by default.
2162 R = std::string("r");
2163 break;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00002164 default:
2165 return std::string(1, *Constraint);
2166 }
2167 return R;
2168 }
Chris Lattner17df24e2008-04-21 18:56:49 +00002169 virtual const char *getClobbers() const {
Eli Friedmanf05b7722008-08-20 07:44:10 +00002170 // FIXME: Is this really right?
Chris Lattner17df24e2008-04-21 18:56:49 +00002171 return "";
2172 }
2173};
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002174
2175const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbar9034aa32010-08-11 02:17:20 +00002176 // Integer registers
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002177 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00002178 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
2179
2180 // Float registers
2181 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2182 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2183 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00002184 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00002185
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00002186 // Double registers
2187 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
2188 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend2b2ad02010-10-28 01:05:37 +00002189 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
2190 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00002191
2192 // Quad registers
Dale Johannesend2b2ad02010-10-28 01:05:37 +00002193 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
2194 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002195};
2196
2197void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar256e1f32010-08-11 02:17:11 +00002198 unsigned &NumNames) const {
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002199 Names = GCCRegNames;
2200 NumNames = llvm::array_lengthof(GCCRegNames);
2201}
2202
2203const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002204 { { "a1" }, "r0" },
2205 { { "a2" }, "r1" },
2206 { { "a3" }, "r2" },
2207 { { "a4" }, "r3" },
2208 { { "v1" }, "r4" },
2209 { { "v2" }, "r5" },
2210 { { "v3" }, "r6" },
2211 { { "v4" }, "r7" },
2212 { { "v5" }, "r8" },
2213 { { "v6", "rfp" }, "r9" },
2214 { { "sl" }, "r10" },
2215 { { "fp" }, "r11" },
2216 { { "ip" }, "r12" },
Daniel Dunbar256e1f32010-08-11 02:17:11 +00002217 { { "r13" }, "sp" },
2218 { { "r14" }, "lr" },
2219 { { "r15" }, "pc" },
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00002220 // The S, D and Q registers overlap, but aren't really aliases; we
2221 // don't want to substitute one of these for a different-sized one.
Daniel Dunbar1da76c42009-09-17 07:03:19 +00002222};
2223
2224void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2225 unsigned &NumAliases) const {
2226 Aliases = GCCRegAliases;
2227 NumAliases = llvm::array_lengthof(GCCRegAliases);
2228}
Chris Lattner5cc15e02010-03-03 19:03:45 +00002229
2230const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00002231#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +00002232#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00002233 ALL_LANGUAGES },
Chris Lattner5cc15e02010-03-03 19:03:45 +00002234#include "clang/Basic/BuiltinsARM.def"
2235};
Chris Lattner17df24e2008-04-21 18:56:49 +00002236} // end anonymous namespace.
2237
Eli Friedmanf05b7722008-08-20 07:44:10 +00002238
2239namespace {
Mike Stump11289f42009-09-09 15:08:12 +00002240class DarwinARMTargetInfo :
Torok Edwinb2b37c62009-06-30 17:10:35 +00002241 public DarwinTargetInfo<ARMTargetInfo> {
2242protected:
Daniel Dunbar40165182009-08-24 09:10:05 +00002243 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002244 MacroBuilder &Builder) const {
Douglas Gregor20b2ebd2011-03-23 00:50:03 +00002245 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmand88c8a12009-04-19 21:38:35 +00002246 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00002247
Torok Edwinb2b37c62009-06-30 17:10:35 +00002248public:
Mike Stump11289f42009-09-09 15:08:12 +00002249 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar3eeeccd2010-05-27 07:00:26 +00002250 : DarwinTargetInfo<ARMTargetInfo>(triple) {
2251 HasAlignMac68kSupport = true;
2252 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00002253};
2254} // end anonymous namespace.
2255
Chris Lattner5ba61f02006-10-14 07:39:34 +00002256namespace {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002257class SparcV8TargetInfo : public TargetInfo {
Chris Lattner9b415d62009-01-27 01:58:38 +00002258 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2259 static const char * const GCCRegNames[];
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002260 bool SoftFloat;
Gabor Greif49991682008-02-21 16:29:08 +00002261public:
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002262 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
2263 // FIXME: Support Sparc quad-precision long double?
Eli Friedman873f65a2008-08-21 00:13:15 +00002264 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 +00002265 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002266 }
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002267 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2268 const std::string &Name,
2269 bool Enabled) const {
2270 if (Name == "soft-float")
2271 Features[Name] = Enabled;
2272 else
2273 return false;
2274
2275 return true;
2276 }
2277 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
2278 SoftFloat = false;
2279 for (unsigned i = 0, e = Features.size(); i != e; ++i)
2280 if (Features[i] == "+soft-float")
2281 SoftFloat = true;
2282 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +00002283 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002284 MacroBuilder &Builder) const {
2285 DefineStd(Builder, "sparc", Opts);
2286 Builder.defineMacro("__sparcv8");
2287 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00002288
2289 if (SoftFloat)
2290 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif49991682008-02-21 16:29:08 +00002291 }
2292 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2293 unsigned &NumRecords) const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002294 // FIXME: Implement!
Gabor Greif49991682008-02-21 16:29:08 +00002295 }
2296 virtual const char *getVAListDeclaration() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002297 return "typedef void* __builtin_va_list;";
Gabor Greif49991682008-02-21 16:29:08 +00002298 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002299 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattner9b415d62009-01-27 01:58:38 +00002300 unsigned &NumNames) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002301 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner9b415d62009-01-27 01:58:38 +00002302 unsigned &NumAliases) const;
Anders Carlsson58436352009-02-28 17:11:49 +00002303 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif49991682008-02-21 16:29:08 +00002304 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002305 // FIXME: Implement!
2306 return false;
Gabor Greif49991682008-02-21 16:29:08 +00002307 }
2308 virtual const char *getClobbers() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002309 // FIXME: Implement!
2310 return "";
Gabor Greif49991682008-02-21 16:29:08 +00002311 }
2312};
2313
Chris Lattner9b415d62009-01-27 01:58:38 +00002314const char * const SparcV8TargetInfo::GCCRegNames[] = {
2315 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2316 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2317 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2318 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
2319};
2320
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002321void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattner9b415d62009-01-27 01:58:38 +00002322 unsigned &NumNames) const {
2323 Names = GCCRegNames;
2324 NumNames = llvm::array_lengthof(GCCRegNames);
2325}
2326
2327const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002328 { { "g0" }, "r0" },
2329 { { "g1" }, "r1" },
2330 { { "g2" }, "r2" },
2331 { { "g3" }, "r3" },
2332 { { "g4" }, "r4" },
2333 { { "g5" }, "r5" },
2334 { { "g6" }, "r6" },
2335 { { "g7" }, "r7" },
2336 { { "o0" }, "r8" },
2337 { { "o1" }, "r9" },
2338 { { "o2" }, "r10" },
2339 { { "o3" }, "r11" },
2340 { { "o4" }, "r12" },
2341 { { "o5" }, "r13" },
2342 { { "o6", "sp" }, "r14" },
2343 { { "o7" }, "r15" },
2344 { { "l0" }, "r16" },
2345 { { "l1" }, "r17" },
2346 { { "l2" }, "r18" },
2347 { { "l3" }, "r19" },
2348 { { "l4" }, "r20" },
2349 { { "l5" }, "r21" },
2350 { { "l6" }, "r22" },
2351 { { "l7" }, "r23" },
2352 { { "i0" }, "r24" },
2353 { { "i1" }, "r25" },
2354 { { "i2" }, "r26" },
2355 { { "i3" }, "r27" },
2356 { { "i4" }, "r28" },
2357 { { "i5" }, "r29" },
2358 { { "i6", "fp" }, "r30" },
2359 { { "i7" }, "r31" },
Chris Lattner9b415d62009-01-27 01:58:38 +00002360};
2361
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002362void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner9b415d62009-01-27 01:58:38 +00002363 unsigned &NumAliases) const {
2364 Aliases = GCCRegAliases;
2365 NumAliases = llvm::array_lengthof(GCCRegAliases);
2366}
Gabor Greif49991682008-02-21 16:29:08 +00002367} // end anonymous namespace.
2368
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002369namespace {
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +00002370class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
2371public:
2372 AuroraUXSparcV8TargetInfo(const std::string& triple) :
2373 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
2374 SizeType = UnsignedInt;
2375 PtrDiffType = SignedInt;
2376 }
2377};
Torok Edwinb2b37c62009-06-30 17:10:35 +00002378class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002379public:
2380 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwinb2b37c62009-06-30 17:10:35 +00002381 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmand50881c2008-11-02 02:43:55 +00002382 SizeType = UnsignedInt;
2383 PtrDiffType = SignedInt;
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002384 }
2385};
2386} // end anonymous namespace.
Chris Lattner5ba61f02006-10-14 07:39:34 +00002387
Chris Lattnerb781dc792008-05-08 05:58:21 +00002388namespace {
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002389 class MSP430TargetInfo : public TargetInfo {
2390 static const char * const GCCRegNames[];
2391 public:
2392 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
2393 TLSSupported = false;
Anton Korobeynikovcbc4e982010-01-30 12:55:11 +00002394 IntWidth = 16; IntAlign = 16;
2395 LongWidth = 32; LongLongWidth = 64;
2396 LongAlign = LongLongAlign = 16;
2397 PointerWidth = 16; PointerAlign = 16;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002398 SizeType = UnsignedInt;
2399 IntMaxType = SignedLong;
2400 UIntMaxType = UnsignedLong;
2401 IntPtrType = SignedShort;
2402 PtrDiffType = SignedInt;
Edward O'Callaghan847f2a12009-11-21 00:49:54 +00002403 SigAtomicType = SignedLong;
Anton Korobeynikovd94329a2009-12-19 01:32:37 +00002404 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002405 }
2406 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002407 MacroBuilder &Builder) const {
2408 Builder.defineMacro("MSP430");
2409 Builder.defineMacro("__MSP430__");
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002410 // FIXME: defines for different 'flavours' of MCU
2411 }
2412 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2413 unsigned &NumRecords) const {
2414 // FIXME: Implement.
2415 Records = 0;
2416 NumRecords = 0;
2417 }
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002418 virtual void getGCCRegNames(const char * const *&Names,
2419 unsigned &NumNames) const;
2420 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2421 unsigned &NumAliases) const {
2422 // No aliases.
2423 Aliases = 0;
2424 NumAliases = 0;
2425 }
2426 virtual bool validateAsmConstraint(const char *&Name,
2427 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov051913b2009-10-15 23:17:13 +00002428 // No target constraints for now.
2429 return false;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002430 }
2431 virtual const char *getClobbers() const {
2432 // FIXME: Is this really right?
2433 return "";
2434 }
2435 virtual const char *getVAListDeclaration() const {
2436 // FIXME: implement
Anton Korobeynikov2f910822009-05-08 18:24:57 +00002437 return "typedef char* __builtin_va_list;";
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002438 }
2439 };
2440
2441 const char * const MSP430TargetInfo::GCCRegNames[] = {
2442 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2443 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2444 };
2445
2446 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
2447 unsigned &NumNames) const {
2448 Names = GCCRegNames;
2449 NumNames = llvm::array_lengthof(GCCRegNames);
2450 }
2451}
2452
2453
Anton Korobeynikovb5b703b2009-07-16 20:09:57 +00002454namespace {
2455 class SystemZTargetInfo : public TargetInfo {
2456 static const char * const GCCRegNames[];
2457 public:
2458 SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
2459 TLSSupported = false;
2460 IntWidth = IntAlign = 32;
2461 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
2462 PointerWidth = PointerAlign = 64;
Chris Lattner5c67237f2009-11-07 18:59:41 +00002463 DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
2464 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
Anton Korobeynikovb5b703b2009-07-16 20:09:57 +00002465 }
2466 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002467 MacroBuilder &Builder) const {
2468 Builder.defineMacro("__s390__");
2469 Builder.defineMacro("__s390x__");
Anton Korobeynikovb5b703b2009-07-16 20:09:57 +00002470 }
2471 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2472 unsigned &NumRecords) const {
2473 // FIXME: Implement.
2474 Records = 0;
2475 NumRecords = 0;
2476 }
Anton Korobeynikovb5b703b2009-07-16 20:09:57 +00002477
Anton Korobeynikovb5b703b2009-07-16 20:09:57 +00002478 virtual void getGCCRegNames(const char * const *&Names,
2479 unsigned &NumNames) const;
2480 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2481 unsigned &NumAliases) const {
2482 // No aliases.
2483 Aliases = 0;
2484 NumAliases = 0;
2485 }
2486 virtual bool validateAsmConstraint(const char *&Name,
2487 TargetInfo::ConstraintInfo &info) const {
2488 // FIXME: implement
2489 return true;
2490 }
2491 virtual const char *getClobbers() const {
2492 // FIXME: Is this really right?
2493 return "";
2494 }
2495 virtual const char *getVAListDeclaration() const {
2496 // FIXME: implement
2497 return "typedef char* __builtin_va_list;";
2498 }
2499 };
2500
2501 const char * const SystemZTargetInfo::GCCRegNames[] = {
2502 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2503 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2504 };
2505
2506 void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
2507 unsigned &NumNames) const {
2508 Names = GCCRegNames;
2509 NumNames = llvm::array_lengthof(GCCRegNames);
2510 }
2511}
2512
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00002513namespace {
2514 class BlackfinTargetInfo : public TargetInfo {
2515 static const char * const GCCRegNames[];
2516 public:
2517 BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
2518 TLSSupported = false;
2519 DoubleAlign = 32;
2520 LongLongAlign = 32;
2521 LongDoubleAlign = 32;
Chris Lattner5c67237f2009-11-07 18:59:41 +00002522 DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00002523 }
2524
2525 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002526 MacroBuilder &Builder) const {
2527 DefineStd(Builder, "bfin", Opts);
2528 DefineStd(Builder, "BFIN", Opts);
2529 Builder.defineMacro("__ADSPBLACKFIN__");
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00002530 // FIXME: This one is really dependent on -mcpu
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002531 Builder.defineMacro("__ADSPLPBLACKFIN__");
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00002532 // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
2533 }
2534
2535 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2536 unsigned &NumRecords) const {
2537 // FIXME: Implement.
2538 Records = 0;
2539 NumRecords = 0;
2540 }
2541
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00002542 virtual void getGCCRegNames(const char * const *&Names,
2543 unsigned &NumNames) const;
2544
2545 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2546 unsigned &NumAliases) const {
2547 // No aliases.
2548 Aliases = 0;
2549 NumAliases = 0;
2550 }
2551
2552 virtual bool validateAsmConstraint(const char *&Name,
2553 TargetInfo::ConstraintInfo &Info) const {
2554 if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
2555 Info.setAllowsRegister();
2556 return true;
2557 }
2558 return false;
2559 }
2560
2561 virtual const char *getClobbers() const {
2562 return "";
2563 }
2564
2565 virtual const char *getVAListDeclaration() const {
2566 return "typedef char* __builtin_va_list;";
2567 }
2568 };
2569
2570 const char * const BlackfinTargetInfo::GCCRegNames[] = {
2571 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2572 "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
2573 "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
2574 "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
2575 "a0", "a1", "cc",
2576 "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
2577 "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
2578 };
2579
2580 void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
2581 unsigned &NumNames) const {
2582 Names = GCCRegNames;
2583 NumNames = llvm::array_lengthof(GCCRegNames);
2584 }
2585}
2586
Eli Friedmana9c3d712009-08-19 20:47:07 +00002587namespace {
2588
Mike Stump11289f42009-09-09 15:08:12 +00002589 // LLVM and Clang cannot be used directly to output native binaries for
2590 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmana9c3d712009-08-19 20:47:07 +00002591 // type and alignment information.
Mike Stump11289f42009-09-09 15:08:12 +00002592 //
2593 // TCE uses the llvm bitcode as input and uses it for generating customized
2594 // target processor and program binary. TCE co-design environment is
Eli Friedmana9c3d712009-08-19 20:47:07 +00002595 // publicly available in http://tce.cs.tut.fi
2596
2597 class TCETargetInfo : public TargetInfo{
2598 public:
2599 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
2600 TLSSupported = false;
2601 IntWidth = 32;
2602 LongWidth = LongLongWidth = 32;
Eli Friedmana9c3d712009-08-19 20:47:07 +00002603 PointerWidth = 32;
2604 IntAlign = 32;
2605 LongAlign = LongLongAlign = 32;
2606 PointerAlign = 32;
2607 SizeType = UnsignedInt;
2608 IntMaxType = SignedLong;
2609 UIntMaxType = UnsignedLong;
2610 IntPtrType = SignedInt;
2611 PtrDiffType = SignedInt;
2612 FloatWidth = 32;
2613 FloatAlign = 32;
2614 DoubleWidth = 32;
2615 DoubleAlign = 32;
2616 LongDoubleWidth = 32;
2617 LongDoubleAlign = 32;
2618 FloatFormat = &llvm::APFloat::IEEEsingle;
2619 DoubleFormat = &llvm::APFloat::IEEEsingle;
2620 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner09797542010-03-04 21:07:38 +00002621 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
2622 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumidba4ed32011-02-18 08:44:38 +00002623 "f32:32:32-f64:32:32-v64:32:32-"
2624 "v128:32:32-a0:0:32-n32";
Eli Friedmana9c3d712009-08-19 20:47:07 +00002625 }
2626
2627 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002628 MacroBuilder &Builder) const {
2629 DefineStd(Builder, "tce", Opts);
2630 Builder.defineMacro("__TCE__");
2631 Builder.defineMacro("__TCE_V1__");
Eli Friedmana9c3d712009-08-19 20:47:07 +00002632 }
2633 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2634 unsigned &NumRecords) const {}
Daniel Dunbar576d90d2009-08-24 09:54:37 +00002635 virtual const char *getClobbers() const {
2636 return "";
2637 }
Eli Friedmana9c3d712009-08-19 20:47:07 +00002638 virtual const char *getVAListDeclaration() const {
2639 return "typedef void* __builtin_va_list;";
2640 }
Eli Friedmana9c3d712009-08-19 20:47:07 +00002641 virtual void getGCCRegNames(const char * const *&Names,
2642 unsigned &NumNames) const {}
2643 virtual bool validateAsmConstraint(const char *&Name,
2644 TargetInfo::ConstraintInfo &info) const {
2645 return true;
2646 }
2647 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2648 unsigned &NumAliases) const {}
2649 };
2650}
2651
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002652namespace {
2653class MipsTargetInfo : public TargetInfo {
Eric Christopher0b26a612010-03-02 02:41:08 +00002654 std::string ABI, CPU;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002655 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2656 static const char * const GCCRegNames[];
2657public:
Eric Christopher0b26a612010-03-02 02:41:08 +00002658 MipsTargetInfo(const std::string& triple) : TargetInfo(triple), ABI("o32") {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002659 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 +00002660 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
2661 SizeType = UnsignedInt;
2662 PtrDiffType = SignedInt;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002663 }
Eric Christopher0b26a612010-03-02 02:41:08 +00002664 virtual const char *getABI() const { return ABI.c_str(); }
2665 virtual bool setABI(const std::string &Name) {
2666
2667 if ((Name == "o32") || (Name == "eabi")) {
2668 ABI = Name;
2669 return true;
2670 } else
2671 return false;
2672 }
2673 virtual bool setCPU(const std::string &Name) {
2674 CPU = Name;
2675 return true;
2676 }
2677 void getDefaultFeatures(const std::string &CPU,
2678 llvm::StringMap<bool> &Features) const {
2679 Features[ABI] = true;
2680 Features[CPU] = true;
2681 }
2682 virtual void getArchDefines(const LangOptions &Opts,
2683 MacroBuilder &Builder) const {
2684 if (ABI == "o32")
2685 Builder.defineMacro("__mips_o32");
2686 else if (ABI == "eabi")
2687 Builder.defineMacro("__mips_eabi");
2688 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002689 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002690 MacroBuilder &Builder) const {
2691 DefineStd(Builder, "mips", Opts);
2692 Builder.defineMacro("_mips");
2693 DefineStd(Builder, "MIPSEB", Opts);
2694 Builder.defineMacro("_MIPSEB");
2695 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christopher0b26a612010-03-02 02:41:08 +00002696 getArchDefines(Opts, Builder);
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002697 }
2698 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2699 unsigned &NumRecords) const {
2700 // FIXME: Implement!
2701 }
2702 virtual const char *getVAListDeclaration() const {
2703 return "typedef void* __builtin_va_list;";
2704 }
2705 virtual void getGCCRegNames(const char * const *&Names,
2706 unsigned &NumNames) const;
2707 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2708 unsigned &NumAliases) const;
2709 virtual bool validateAsmConstraint(const char *&Name,
2710 TargetInfo::ConstraintInfo &Info) const {
2711 switch (*Name) {
2712 default:
2713 case 'r': // CPU registers.
2714 case 'd': // Equivalent to "r" unless generating MIPS16 code.
2715 case 'y': // Equivalent to "r", backwards compatibility only.
2716 case 'f': // floating-point registers.
2717 Info.setAllowsRegister();
2718 return true;
2719 }
2720 return false;
2721 }
2722
2723 virtual const char *getClobbers() const {
2724 // FIXME: Implement!
2725 return "";
2726 }
2727};
2728
2729const char * const MipsTargetInfo::GCCRegNames[] = {
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002730 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002731 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
2732 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
2733 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
2734 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
2735 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
2736 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
2737 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
2738 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
2739 "$fcc5","$fcc6","$fcc7"
2740};
2741
2742void MipsTargetInfo::getGCCRegNames(const char * const *&Names,
2743 unsigned &NumNames) const {
2744 Names = GCCRegNames;
2745 NumNames = llvm::array_lengthof(GCCRegNames);
2746}
2747
2748const TargetInfo::GCCRegAlias MipsTargetInfo::GCCRegAliases[] = {
2749 { { "at" }, "$1" },
2750 { { "v0" }, "$2" },
2751 { { "v1" }, "$3" },
2752 { { "a0" }, "$4" },
2753 { { "a1" }, "$5" },
2754 { { "a2" }, "$6" },
2755 { { "a3" }, "$7" },
2756 { { "t0" }, "$8" },
2757 { { "t1" }, "$9" },
2758 { { "t2" }, "$10" },
2759 { { "t3" }, "$11" },
2760 { { "t4" }, "$12" },
2761 { { "t5" }, "$13" },
2762 { { "t6" }, "$14" },
2763 { { "t7" }, "$15" },
2764 { { "s0" }, "$16" },
2765 { { "s1" }, "$17" },
2766 { { "s2" }, "$18" },
2767 { { "s3" }, "$19" },
2768 { { "s4" }, "$20" },
2769 { { "s5" }, "$21" },
2770 { { "s6" }, "$22" },
2771 { { "s7" }, "$23" },
2772 { { "t8" }, "$24" },
2773 { { "t9" }, "$25" },
2774 { { "k0" }, "$26" },
2775 { { "k1" }, "$27" },
2776 { { "gp" }, "$28" },
2777 { { "sp" }, "$29" },
2778 { { "fp" }, "$30" },
2779 { { "ra" }, "$31" }
2780};
2781
2782void MipsTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2783 unsigned &NumAliases) const {
2784 Aliases = GCCRegAliases;
2785 NumAliases = llvm::array_lengthof(GCCRegAliases);
2786}
2787} // end anonymous namespace.
2788
2789namespace {
2790class MipselTargetInfo : public MipsTargetInfo {
2791public:
2792 MipselTargetInfo(const std::string& triple) : MipsTargetInfo(triple) {
2793 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 +00002794 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002795 }
2796
2797 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002798 MacroBuilder &Builder) const;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002799};
2800
2801void MipselTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002802 MacroBuilder &Builder) const {
2803 DefineStd(Builder, "mips", Opts);
2804 Builder.defineMacro("_mips");
2805 DefineStd(Builder, "MIPSEL", Opts);
2806 Builder.defineMacro("_MIPSEL");
2807 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christopher0b26a612010-03-02 02:41:08 +00002808 getArchDefines(Opts, Builder);
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002809}
2810} // end anonymous namespace.
2811
Chris Lattner5ba61f02006-10-14 07:39:34 +00002812//===----------------------------------------------------------------------===//
2813// Driver code
2814//===----------------------------------------------------------------------===//
2815
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00002816static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar52322032009-08-18 05:47:58 +00002817 llvm::Triple Triple(T);
2818 llvm::Triple::OSType os = Triple.getOS();
Eli Friedmanb5366062008-05-20 14:21:01 +00002819
Daniel Dunbar52322032009-08-18 05:47:58 +00002820 switch (Triple.getArch()) {
2821 default:
2822 return NULL;
Eli Friedmanb5366062008-05-20 14:21:01 +00002823
Daniel Dunbar52322032009-08-18 05:47:58 +00002824 case llvm::Triple::arm:
Daniel Dunbar33a004e2009-09-11 01:14:50 +00002825 case llvm::Triple::thumb:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00002826 if (Triple.isOSDarwin())
2827 return new DarwinARMTargetInfo(T);
2828
Daniel Dunbar52322032009-08-18 05:47:58 +00002829 switch (os) {
Rafael Espindolaad8fed52010-06-10 00:46:51 +00002830 case llvm::Triple::Linux:
2831 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002832 case llvm::Triple::FreeBSD:
Torok Edwinb2b37c62009-06-30 17:10:35 +00002833 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00002834 case llvm::Triple::NetBSD:
2835 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Douglas Gregor9fabd852011-07-01 22:41:14 +00002836 case llvm::Triple::RTEMS:
2837 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002838 default:
2839 return new ARMTargetInfo(T);
2840 }
Eli Friedmanb5366062008-05-20 14:21:01 +00002841
Daniel Dunbar52322032009-08-18 05:47:58 +00002842 case llvm::Triple::bfin:
Douglas Gregor9fabd852011-07-01 22:41:14 +00002843 if ( os == llvm::Triple::RTEMS )
2844 return new RTEMSTargetInfo<BlackfinTargetInfo>(T);
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00002845 return new BlackfinTargetInfo(T);
2846
Daniel Dunbar52322032009-08-18 05:47:58 +00002847 case llvm::Triple::msp430:
2848 return new MSP430TargetInfo(T);
Eli Friedmanb5366062008-05-20 14:21:01 +00002849
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002850 case llvm::Triple::mips:
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00002851 switch (os) {
2852 case llvm::Triple::Psp:
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002853 return new PSPTargetInfo<MipsTargetInfo>(T);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00002854 case llvm::Triple::Linux:
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002855 return new LinuxTargetInfo<MipsTargetInfo>(T);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00002856 case llvm::Triple::RTEMS:
Douglas Gregor9fabd852011-07-01 22:41:14 +00002857 return new RTEMSTargetInfo<MipsTargetInfo>(T);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00002858 case llvm::Triple::FreeBSD:
Joerg Sonnenbergerc46e3ce2011-07-07 17:01:45 +00002859 return new FreeBSDTargetInfo<MipsTargetInfo>(T);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00002860 case llvm::Triple::NetBSD:
2861 return new NetBSDTargetInfo<MipsTargetInfo>(T);
2862 default:
2863 return new MipsTargetInfo(T);
2864 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002865
2866 case llvm::Triple::mipsel:
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00002867 switch (os) {
2868 case llvm::Triple::Psp:
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002869 return new PSPTargetInfo<MipselTargetInfo>(T);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00002870 case llvm::Triple::Linux:
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002871 return new LinuxTargetInfo<MipselTargetInfo>(T);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00002872 case llvm::Triple::RTEMS:
Douglas Gregor9fabd852011-07-01 22:41:14 +00002873 return new RTEMSTargetInfo<MipselTargetInfo>(T);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00002874 case llvm::Triple::FreeBSD:
Joerg Sonnenbergerfbc0b3a2011-07-06 11:00:56 +00002875 return new FreeBSDTargetInfo<MipselTargetInfo>(T);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00002876 case llvm::Triple::NetBSD:
2877 return new NetBSDTargetInfo<MipselTargetInfo>(T);
2878 default:
2879 return new MipsTargetInfo(T);
2880 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002881
Daniel Dunbar52322032009-08-18 05:47:58 +00002882 case llvm::Triple::ppc:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00002883 if (Triple.isOSDarwin())
Roman Divacky965b0b72011-01-06 08:27:10 +00002884 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00002885 switch (os) {
2886 case llvm::Triple::FreeBSD:
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00002887 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00002888 case llvm::Triple::NetBSD:
2889 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
2890 case llvm::Triple::RTEMS:
Douglas Gregor9fabd852011-07-01 22:41:14 +00002891 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00002892 default:
2893 return new PPC32TargetInfo(T);
2894 }
Daniel Dunbar52322032009-08-18 05:47:58 +00002895
2896 case llvm::Triple::ppc64:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00002897 if (Triple.isOSDarwin())
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00002898 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00002899 switch (os) {
2900 case llvm::Triple::Lv2:
John Thompsone467e192009-11-19 17:18:50 +00002901 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00002902 case llvm::Triple::FreeBSD:
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00002903 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00002904 case llvm::Triple::NetBSD:
2905 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
2906 default:
2907 return new PPC64TargetInfo(T);
2908 }
Daniel Dunbar52322032009-08-18 05:47:58 +00002909
Justin Holewinski514cce82011-04-20 19:34:15 +00002910 case llvm::Triple::ptx32:
2911 return new PTX32TargetInfo(T);
2912 case llvm::Triple::ptx64:
2913 return new PTX64TargetInfo(T);
2914
Chris Lattner5178f562010-03-06 21:21:27 +00002915 case llvm::Triple::mblaze:
2916 return new MBlazeTargetInfo(T);
2917
Daniel Dunbar52322032009-08-18 05:47:58 +00002918 case llvm::Triple::sparc:
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00002919 switch (os) {
2920 case llvm::Triple::AuroraUX:
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +00002921 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00002922 case llvm::Triple::Solaris:
Daniel Dunbar52322032009-08-18 05:47:58 +00002923 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00002924 case llvm::Triple::NetBSD:
2925 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
2926 case llvm::Triple::RTEMS:
Douglas Gregor9fabd852011-07-01 22:41:14 +00002927 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00002928 default:
2929 return new SparcV8TargetInfo(T);
2930 }
Daniel Dunbar52322032009-08-18 05:47:58 +00002931
John Thompsone467e192009-11-19 17:18:50 +00002932 // FIXME: Need a real SPU target.
2933 case llvm::Triple::cellspu:
2934 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
2935
Daniel Dunbar52322032009-08-18 05:47:58 +00002936 case llvm::Triple::systemz:
2937 return new SystemZTargetInfo(T);
2938
Eli Friedmana9c3d712009-08-19 20:47:07 +00002939 case llvm::Triple::tce:
2940 return new TCETargetInfo(T);
2941
Daniel Dunbar52322032009-08-18 05:47:58 +00002942 case llvm::Triple::x86:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00002943 if (Triple.isOSDarwin())
2944 return new DarwinI386TargetInfo(T);
2945
Daniel Dunbar52322032009-08-18 05:47:58 +00002946 switch (os) {
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +00002947 case llvm::Triple::AuroraUX:
2948 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002949 case llvm::Triple::Linux:
2950 return new LinuxTargetInfo<X86_32TargetInfo>(T);
2951 case llvm::Triple::DragonFly:
2952 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
2953 case llvm::Triple::NetBSD:
2954 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
2955 case llvm::Triple::OpenBSD:
2956 return new OpenBSDI386TargetInfo(T);
2957 case llvm::Triple::FreeBSD:
2958 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner3e2ee142010-07-07 16:01:42 +00002959 case llvm::Triple::Minix:
2960 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002961 case llvm::Triple::Solaris:
2962 return new SolarisTargetInfo<X86_32TargetInfo>(T);
2963 case llvm::Triple::Cygwin:
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002964 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002965 case llvm::Triple::MinGW32:
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002966 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002967 case llvm::Triple::Win32:
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002968 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattnerb986aba2010-04-11 19:29:39 +00002969 case llvm::Triple::Haiku:
2970 return new HaikuX86_32TargetInfo(T);
Douglas Gregor9fabd852011-07-01 22:41:14 +00002971 case llvm::Triple::RTEMS:
2972 return new RTEMSX86_32TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002973 default:
2974 return new X86_32TargetInfo(T);
2975 }
2976
2977 case llvm::Triple::x86_64:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00002978 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
2979 return new DarwinX86_64TargetInfo(T);
2980
Daniel Dunbar52322032009-08-18 05:47:58 +00002981 switch (os) {
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +00002982 case llvm::Triple::AuroraUX:
2983 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002984 case llvm::Triple::Linux:
2985 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner002ba6b2010-01-09 05:41:14 +00002986 case llvm::Triple::DragonFly:
2987 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002988 case llvm::Triple::NetBSD:
2989 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
2990 case llvm::Triple::OpenBSD:
2991 return new OpenBSDX86_64TargetInfo(T);
2992 case llvm::Triple::FreeBSD:
2993 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
2994 case llvm::Triple::Solaris:
2995 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi31ea2f12011-02-17 08:51:38 +00002996 case llvm::Triple::MinGW32:
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002997 return new MinGWX86_64TargetInfo(T);
2998 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00002999 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00003000 default:
3001 return new X86_64TargetInfo(T);
3002 }
3003 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00003004}
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003005
3006/// CreateTargetInfo - Return the target info object for the specified target
3007/// triple.
3008TargetInfo *TargetInfo::CreateTargetInfo(Diagnostic &Diags,
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00003009 TargetOptions &Opts) {
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003010 llvm::Triple Triple(Opts.Triple);
3011
3012 // Construct the target
3013 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
3014 if (!Target) {
3015 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
3016 return 0;
3017 }
3018
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003019 // Set the target CPU if specified.
3020 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
3021 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
3022 return 0;
3023 }
3024
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003025 // Set the target ABI if specified.
3026 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
3027 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
3028 return 0;
3029 }
3030
Charles Davis95a546e2010-06-11 01:06:47 +00003031 // Set the target C++ ABI.
John McCall86353412010-08-21 22:46:04 +00003032 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davis95a546e2010-06-11 01:06:47 +00003033 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
3034 return 0;
3035 }
3036
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003037 // Compute the default target features, we need the target to handle this
3038 // because features may have dependencies on one another.
3039 llvm::StringMap<bool> Features;
3040 Target->getDefaultFeatures(Opts.CPU, Features);
3041
3042 // Apply the user specified deltas.
3043 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
3044 ie = Opts.Features.end(); it != ie; ++it) {
3045 const char *Name = it->c_str();
3046
3047 // Apply the feature via the target.
3048 if ((Name[0] != '-' && Name[0] != '+') ||
3049 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
3050 Diags.Report(diag::err_target_invalid_feature) << Name;
3051 return 0;
3052 }
3053 }
3054
3055 // Add the features to the compile options.
3056 //
3057 // FIXME: If we are completely confident that we have the right set, we only
3058 // need to pass the minuses.
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00003059 Opts.Features.clear();
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003060 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
3061 ie = Features.end(); it != ie; ++it)
Chris Lattnerd386df42011-07-14 18:24:21 +00003062 Opts.Features.push_back(std::string(it->second ? "+" : "-") +
Chris Lattner2dc4b552011-07-14 18:45:41 +00003063 it->first().str());
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00003064 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00003065
3066 return Target.take();
3067}