blob: 382dcab9719d11b37b07c97e10dc62c9099bc76e [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- Targets.cpp - Implement -arch option and targets -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
Anton Korobeynikova7c47172009-05-03 13:42:53 +000010// This file implements construction of a TargetInfo object from a
Ted Kremenekbbced582007-12-12 18:05:32 +000011// target triple.
Reid Spencer5f016e22007-07-11 17:01:13 +000012//
13//===----------------------------------------------------------------------===//
14
Reid Spencer5f016e22007-07-11 17:01:13 +000015#include "clang/Basic/TargetInfo.h"
Daniel Dunbard58c03f2009-11-15 06:48:46 +000016#include "clang/Basic/Builtins.h"
17#include "clang/Basic/Diagnostic.h"
Chris Lattner8fc4dfb2008-12-04 22:54:33 +000018#include "clang/Basic/LangOptions.h"
Chandler Carruth103b71c2010-01-20 06:13:02 +000019#include "clang/Basic/MacroBuilder.h"
Daniel Dunbard58c03f2009-11-15 06:48:46 +000020#include "clang/Basic/TargetBuiltins.h"
21#include "clang/Basic/TargetOptions.h"
Eli Friedman25531262008-05-20 14:27:34 +000022#include "llvm/ADT/APFloat.h"
Daniel Dunbard58c03f2009-11-15 06:48:46 +000023#include "llvm/ADT/OwningPtr.h"
Daniel Dunbar29a790b2009-11-11 09:38:56 +000024#include "llvm/ADT/STLExtras.h"
Daniel Dunbar77659342009-08-19 20:04:03 +000025#include "llvm/ADT/StringRef.h"
Daniel Dunbar29a790b2009-11-11 09:38:56 +000026#include "llvm/ADT/StringSwitch.h"
Chris Lattner4c28b1c2009-08-12 06:24:27 +000027#include "llvm/ADT/Triple.h"
Chris Lattner797c3c42009-08-10 19:03:04 +000028#include "llvm/MC/MCSectionMachO.h"
Dale Johannesen1e592cb2010-10-29 23:24:33 +000029#include "llvm/Type.h"
Benjamin Kramer48725082010-01-09 18:20:57 +000030#include <algorithm>
Reid Spencer5f016e22007-07-11 17:01:13 +000031using namespace clang;
32
Reid Spencer5f016e22007-07-11 17:01:13 +000033//===----------------------------------------------------------------------===//
34// Common code shared among targets.
35//===----------------------------------------------------------------------===//
36
Chris Lattnerca45cff2009-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 Kramera9992772010-01-09 17:55:51 +000040static void DefineStd(MacroBuilder &Builder, llvm::StringRef MacroName,
Chris Lattnerca45cff2009-03-20 16:06:38 +000041 const LangOptions &Opts) {
42 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000043
Chris Lattnerca45cff2009-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 Kramera9992772010-01-09 17:55:51 +000047 Builder.defineMacro(MacroName);
Anton Korobeynikova7c47172009-05-03 13:42:53 +000048
Chris Lattnerca45cff2009-03-20 16:06:38 +000049 // Define __unix.
Benjamin Kramera9992772010-01-09 17:55:51 +000050 Builder.defineMacro("__" + MacroName);
Anton Korobeynikova7c47172009-05-03 13:42:53 +000051
Chris Lattnerca45cff2009-03-20 16:06:38 +000052 // Define __unix__.
Benjamin Kramera9992772010-01-09 17:55:51 +000053 Builder.defineMacro("__" + MacroName + "__");
Chris Lattnerca45cff2009-03-20 16:06:38 +000054}
55
Chris Lattnerd29b6302008-10-05 21:50:58 +000056//===----------------------------------------------------------------------===//
57// Defines specific to certain operating systems.
58//===----------------------------------------------------------------------===//
Chris Lattner797c3c42009-08-10 19:03:04 +000059
Torok Edwin5f6c1942009-06-30 17:10:35 +000060namespace {
Douglas Gregora3844922009-07-01 15:12:53 +000061template<typename TgtInfo>
62class OSTargetInfo : public TgtInfo {
Torok Edwin5f6c1942009-06-30 17:10:35 +000063protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +000064 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +000065 MacroBuilder &Builder) const=0;
Torok Edwin5f6c1942009-06-30 17:10:35 +000066public:
Douglas Gregora3844922009-07-01 15:12:53 +000067 OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
Torok Edwin5f6c1942009-06-30 17:10:35 +000068 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +000069 MacroBuilder &Builder) const {
70 TgtInfo::getTargetDefines(Opts, Builder);
71 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Torok Edwinb0a5b242009-06-30 17:00:25 +000072 }
Torok Edwin5f6c1942009-06-30 17:10:35 +000073
74};
Chris Lattner4c28b1c2009-08-12 06:24:27 +000075} // end anonymous namespace
Torok Edwinb0a5b242009-06-30 17:00:25 +000076
Chris Lattner797c3c42009-08-10 19:03:04 +000077
Daniel Dunbar21ae3192010-01-26 01:44:04 +000078static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +000079 const llvm::Triple &Triple,
80 llvm::StringRef &PlatformName,
81 VersionTuple &PlatformMinVersion) {
Benjamin Kramera9992772010-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 Korobeynikova7c47172009-05-03 13:42:53 +000086
John McCall098df7f2011-06-16 00:03:19 +000087 if (!Opts.ObjCAutoRefCount) {
John McCallf85e1932011-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 Korobeynikova7c47172009-05-03 13:42:53 +000090
John McCallf85e1932011-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", "");
96
97 // __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", "");
101
102 // 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 McCall18164422011-06-17 21:23:37 +0000107 Builder.defineMacro("__bridge_retain", "");
John McCallf85e1932011-06-15 23:02:42 +0000108 }
109
Eli Friedman2de4fee2009-06-04 23:00:29 +0000110 if (Opts.Static)
Benjamin Kramera9992772010-01-09 17:55:51 +0000111 Builder.defineMacro("__STATIC__");
Eli Friedman2de4fee2009-06-04 23:00:29 +0000112 else
Benjamin Kramera9992772010-01-09 17:55:51 +0000113 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000114
115 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000116 Builder.defineMacro("_REENTRANT");
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000117
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000118 // Get the platform type and version number from the triple.
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000119 unsigned Maj, Min, Rev;
Mike Stump1eb44332009-09-09 15:08:12 +0000120
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000121 // If no version was given, default to to 10.4.0, for simplifying tests.
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000122 if (Triple.getOSName() == "darwin" || Triple.getOSName() == "osx") {
123 PlatformName = "macosx";
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000124 Min = Rev = 0;
125 Maj = 8;
Daniel Dunbar0d027ba2011-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 Dunbar0d027ba2011-04-19 21:40:34 +0000138 PlatformName = "macosx";
139 Rev = Min;
140 Min = Maj - 4;
141 Maj = 10;
142 }
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000143 } else {
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000144 Triple.getOSVersion(Maj, Min, Rev);
Daniel Dunbara4ff6482011-04-19 23:34:21 +0000145 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000146 }
147 }
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000148
149 // Set the appropriate OS version define.
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000150 if (PlatformName == "ios") {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000151 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-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);
160 } else {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000161 // Note that the Driver allows versions which aren't representable in the
162 // define (because we only get a single digit for the minor and micro
163 // revision numbers). So, we limit them to the maximum representable
164 // version.
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000165 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000166 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000167 char Str[5];
168 Str[0] = '0' + (Maj / 10);
169 Str[1] = '0' + (Maj % 10);
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000170 Str[2] = '0' + std::min(Min, 9U);
171 Str[3] = '0' + std::min(Rev, 9U);
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000172 Str[4] = '\0';
173 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000174 }
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000175
176 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman618234a2008-08-20 02:34:37 +0000177}
Reid Spencer5f016e22007-07-11 17:01:13 +0000178
Chris Lattner797c3c42009-08-10 19:03:04 +0000179namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000180template<typename Target>
181class DarwinTargetInfo : public OSTargetInfo<Target> {
182protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000183 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000184 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000185 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
186 this->PlatformMinVersion);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000187 }
Mike Stump1eb44332009-09-09 15:08:12 +0000188
Torok Edwin5f6c1942009-06-30 17:10:35 +0000189public:
190 DarwinTargetInfo(const std::string& triple) :
191 OSTargetInfo<Target>(triple) {
Eric Christopheraa7333c2011-07-02 00:20:22 +0000192 llvm::Triple T = llvm::Triple(triple);
193 this->TLSSupported = T.isMacOSX() && !T.isMacOSXVersionLT(10,7);
Daniel Dunbare177d3b2011-02-21 23:12:51 +0000194 this->MCountName = "\01mcount";
Torok Edwin5f6c1942009-06-30 17:10:35 +0000195 }
196
Anders Carlssonf959fb52010-01-30 18:33:31 +0000197 virtual std::string isValidSectionSpecifier(llvm::StringRef SR) const {
Chris Lattner797c3c42009-08-10 19:03:04 +0000198 // Let MCSectionMachO validate this.
199 llvm::StringRef Segment, Section;
200 unsigned TAA, StubSize;
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000201 bool HasTAA;
Chris Lattner797c3c42009-08-10 19:03:04 +0000202 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000203 TAA, HasTAA, StubSize);
Chris Lattner797c3c42009-08-10 19:03:04 +0000204 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000205
Anders Carlsson18af3682010-06-08 22:47:50 +0000206 virtual const char *getStaticInitSectionSpecifier() const {
207 // FIXME: We should return 0 when building kexts.
208 return "__TEXT,__StaticInit,regular,pure_instructions";
209 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000210
Torok Edwin5f6c1942009-06-30 17:10:35 +0000211};
212
Chris Lattner797c3c42009-08-10 19:03:04 +0000213
Torok Edwin5f6c1942009-06-30 17:10:35 +0000214// DragonFlyBSD Target
215template<typename Target>
216class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
217protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000218 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000219 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000220 // DragonFly defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000221 Builder.defineMacro("__DragonFly__");
222 Builder.defineMacro("__DragonFly_cc_version", "100001");
223 Builder.defineMacro("__ELF__");
224 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
225 Builder.defineMacro("__tune_i386__");
226 DefineStd(Builder, "unix", Opts);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000227 }
228public:
Mike Stump1eb44332009-09-09 15:08:12 +0000229 DragonFlyBSDTargetInfo(const std::string &triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000230 : OSTargetInfo<Target>(triple) {}
231};
232
233// FreeBSD Target
234template<typename Target>
235class FreeBSDTargetInfo : public OSTargetInfo<Target> {
236protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000237 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000238 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000239 // FreeBSD defines; list based off of gcc output
240
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000241 // FIXME: Move version number handling to llvm::Triple.
Benjamin Kramer3bb65302010-01-30 19:55:01 +0000242 llvm::StringRef Release = Triple.getOSName().substr(strlen("freebsd"), 1);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000243
Benjamin Kramer3bb65302010-01-30 19:55:01 +0000244 Builder.defineMacro("__FreeBSD__", Release);
245 Builder.defineMacro("__FreeBSD_cc_version", Release + "00001");
Benjamin Kramera9992772010-01-09 17:55:51 +0000246 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
247 DefineStd(Builder, "unix", Opts);
248 Builder.defineMacro("__ELF__");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000249 }
250public:
Mike Stump1eb44332009-09-09 15:08:12 +0000251 FreeBSDTargetInfo(const std::string &triple)
Duncan Sands1e90faf2009-07-08 13:55:08 +0000252 : OSTargetInfo<Target>(triple) {
253 this->UserLabelPrefix = "";
Roman Divackybe4c8702011-02-10 16:52:03 +0000254
255 llvm::Triple Triple(triple);
256 switch (Triple.getArch()) {
257 default:
258 case llvm::Triple::x86:
259 case llvm::Triple::x86_64:
260 this->MCountName = ".mcount";
261 break;
262 case llvm::Triple::mips:
263 case llvm::Triple::mipsel:
264 case llvm::Triple::ppc:
265 case llvm::Triple::ppc64:
266 this->MCountName = "_mcount";
267 break;
268 case llvm::Triple::arm:
269 this->MCountName = "__mcount";
270 break;
271 }
272
Duncan Sands1e90faf2009-07-08 13:55:08 +0000273 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000274};
275
Chris Lattner38e317d2010-07-07 16:01:42 +0000276// Minix Target
277template<typename Target>
278class MinixTargetInfo : public OSTargetInfo<Target> {
279protected:
280 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
281 MacroBuilder &Builder) const {
282 // Minix defines
283
284 Builder.defineMacro("__minix", "3");
285 Builder.defineMacro("_EM_WSIZE", "4");
286 Builder.defineMacro("_EM_PSIZE", "4");
287 Builder.defineMacro("_EM_SSIZE", "2");
288 Builder.defineMacro("_EM_LSIZE", "4");
289 Builder.defineMacro("_EM_FSIZE", "4");
290 Builder.defineMacro("_EM_DSIZE", "8");
291 DefineStd(Builder, "unix", Opts);
292 }
293public:
294 MinixTargetInfo(const std::string &triple)
295 : OSTargetInfo<Target>(triple) {
296 this->UserLabelPrefix = "";
297 }
298};
299
Torok Edwin5f6c1942009-06-30 17:10:35 +0000300// Linux target
301template<typename Target>
302class LinuxTargetInfo : public OSTargetInfo<Target> {
303protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000304 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000305 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000306 // Linux defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000307 DefineStd(Builder, "unix", Opts);
308 DefineStd(Builder, "linux", Opts);
309 Builder.defineMacro("__gnu_linux__");
310 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000311 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000312 Builder.defineMacro("_REENTRANT");
Douglas Gregor2b003fd2010-04-21 05:52:38 +0000313 if (Opts.CPlusPlus)
314 Builder.defineMacro("_GNU_SOURCE");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000315 }
316public:
Mike Stump1eb44332009-09-09 15:08:12 +0000317 LinuxTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000318 : OSTargetInfo<Target>(triple) {
319 this->UserLabelPrefix = "";
Douglas Gregor12e84642011-01-12 21:19:25 +0000320 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000321 }
322};
323
Chris Lattnerb62bb282009-07-13 20:29:08 +0000324// NetBSD Target
325template<typename Target>
326class NetBSDTargetInfo : public OSTargetInfo<Target> {
327protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000328 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000329 MacroBuilder &Builder) const {
Chris Lattnerb62bb282009-07-13 20:29:08 +0000330 // NetBSD defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000331 Builder.defineMacro("__NetBSD__");
332 Builder.defineMacro("__unix__");
333 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000334 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000335 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerb62bb282009-07-13 20:29:08 +0000336 }
337public:
Mike Stump1eb44332009-09-09 15:08:12 +0000338 NetBSDTargetInfo(const std::string &triple)
Chris Lattnerb62bb282009-07-13 20:29:08 +0000339 : OSTargetInfo<Target>(triple) {
340 this->UserLabelPrefix = "";
341 }
342};
343
Torok Edwin5f6c1942009-06-30 17:10:35 +0000344// OpenBSD Target
345template<typename Target>
346class OpenBSDTargetInfo : public OSTargetInfo<Target> {
347protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000348 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000349 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000350 // OpenBSD defines; list based off of gcc output
351
Benjamin Kramera9992772010-01-09 17:55:51 +0000352 Builder.defineMacro("__OpenBSD__");
353 DefineStd(Builder, "unix", Opts);
354 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000355 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000356 Builder.defineMacro("_POSIX_THREADS");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000357 }
358public:
Mike Stump1eb44332009-09-09 15:08:12 +0000359 OpenBSDTargetInfo(const std::string &triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000360 : OSTargetInfo<Target>(triple) {}
361};
362
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000363// PSP Target
364template<typename Target>
365class PSPTargetInfo : public OSTargetInfo<Target> {
366protected:
367 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000368 MacroBuilder &Builder) const {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000369 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramera9992772010-01-09 17:55:51 +0000370 Builder.defineMacro("PSP");
371 Builder.defineMacro("_PSP");
372 Builder.defineMacro("__psp__");
373 Builder.defineMacro("__ELF__");
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000374 }
375public:
376 PSPTargetInfo(const std::string& triple)
377 : OSTargetInfo<Target>(triple) {
378 this->UserLabelPrefix = "";
379 }
380};
381
John Thompson3f6918a2009-11-19 17:18:50 +0000382// PS3 PPU Target
383template<typename Target>
384class PS3PPUTargetInfo : public OSTargetInfo<Target> {
385protected:
386 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000387 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000388 // PS3 PPU defines.
John Thompsonfb457972010-03-25 16:18:32 +0000389 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000390 Builder.defineMacro("__PPU__");
391 Builder.defineMacro("__CELLOS_LV2__");
392 Builder.defineMacro("__ELF__");
393 Builder.defineMacro("__LP32__");
John Thompson8e6065a2010-06-24 22:44:13 +0000394 Builder.defineMacro("_ARCH_PPC64");
395 Builder.defineMacro("__powerpc64__");
John Thompson3f6918a2009-11-19 17:18:50 +0000396 }
397public:
398 PS3PPUTargetInfo(const std::string& triple)
399 : OSTargetInfo<Target>(triple) {
400 this->UserLabelPrefix = "";
John Thompsonec387af2009-12-18 14:21:08 +0000401 this->LongWidth = this->LongAlign = this->PointerWidth = this->PointerAlign = 32;
John Thompson8e6065a2010-06-24 22:44:13 +0000402 this->IntMaxType = TargetInfo::SignedLongLong;
403 this->UIntMaxType = TargetInfo::UnsignedLongLong;
404 this->Int64Type = TargetInfo::SignedLongLong;
John Thompsonec387af2009-12-18 14:21:08 +0000405 this->SizeType = TargetInfo::UnsignedInt;
John Thompson8e6065a2010-06-24 22:44:13 +0000406 this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
407 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompson3f6918a2009-11-19 17:18:50 +0000408 }
409};
410
411// FIXME: Need a real SPU target.
412// PS3 SPU Target
413template<typename Target>
414class PS3SPUTargetInfo : public OSTargetInfo<Target> {
415protected:
416 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000417 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000418 // PS3 PPU defines.
Benjamin Kramera9992772010-01-09 17:55:51 +0000419 Builder.defineMacro("__SPU__");
420 Builder.defineMacro("__ELF__");
John Thompson3f6918a2009-11-19 17:18:50 +0000421 }
422public:
423 PS3SPUTargetInfo(const std::string& triple)
424 : OSTargetInfo<Target>(triple) {
425 this->UserLabelPrefix = "";
426 }
427};
428
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000429// AuroraUX target
430template<typename Target>
431class AuroraUXTargetInfo : public OSTargetInfo<Target> {
432protected:
433 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000434 MacroBuilder &Builder) const {
435 DefineStd(Builder, "sun", Opts);
436 DefineStd(Builder, "unix", Opts);
437 Builder.defineMacro("__ELF__");
438 Builder.defineMacro("__svr4__");
439 Builder.defineMacro("__SVR4");
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000440 }
441public:
442 AuroraUXTargetInfo(const std::string& triple)
443 : OSTargetInfo<Target>(triple) {
444 this->UserLabelPrefix = "";
445 this->WCharType = this->SignedLong;
446 // FIXME: WIntType should be SignedLong
447 }
448};
449
Torok Edwin5f6c1942009-06-30 17:10:35 +0000450// Solaris target
451template<typename Target>
452class SolarisTargetInfo : public OSTargetInfo<Target> {
453protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000454 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000455 MacroBuilder &Builder) const {
456 DefineStd(Builder, "sun", Opts);
457 DefineStd(Builder, "unix", Opts);
458 Builder.defineMacro("__ELF__");
459 Builder.defineMacro("__svr4__");
460 Builder.defineMacro("__SVR4");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000461 }
462public:
Mike Stump1eb44332009-09-09 15:08:12 +0000463 SolarisTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000464 : OSTargetInfo<Target>(triple) {
465 this->UserLabelPrefix = "";
466 this->WCharType = this->SignedLong;
467 // FIXME: WIntType should be SignedLong
468 }
469};
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000470
471// Windows target
472template<typename Target>
473class WindowsTargetInfo : public OSTargetInfo<Target> {
474protected:
475 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
476 MacroBuilder &Builder) const {
Michael J. Spencera764e832010-10-21 08:22:51 +0000477 Builder.defineMacro("_WIN32");
478 }
479 void getVisualStudioDefines(const LangOptions &Opts,
480 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000481 if (Opts.CPlusPlus) {
482 if (Opts.RTTI)
483 Builder.defineMacro("_CPPRTTI");
484
485 if (Opts.Exceptions)
486 Builder.defineMacro("_CPPUNWIND");
487 }
488
489 if (!Opts.CharIsSigned)
490 Builder.defineMacro("_CHAR_UNSIGNED");
491
492 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
493 // but it works for now.
494 if (Opts.POSIXThreads)
495 Builder.defineMacro("_MT");
Michael J. Spencera764e832010-10-21 08:22:51 +0000496
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000497 if (Opts.MSCVersion != 0)
498 Builder.defineMacro("_MSC_VER", llvm::Twine(Opts.MSCVersion));
499
500 if (Opts.Microsoft) {
501 Builder.defineMacro("_MSC_EXTENSIONS");
502
503 if (Opts.CPlusPlus0x) {
504 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
505 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
506 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
507 }
508 }
509
510 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000511 }
512
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000513public:
514 WindowsTargetInfo(const std::string &triple)
515 : OSTargetInfo<Target>(triple) {}
516};
517
Mike Stump1eb44332009-09-09 15:08:12 +0000518} // end anonymous namespace.
Torok Edwin5f6c1942009-06-30 17:10:35 +0000519
Chris Lattnerd29b6302008-10-05 21:50:58 +0000520//===----------------------------------------------------------------------===//
Eli Friedmane4277982008-08-20 23:11:40 +0000521// Specific target implementations.
522//===----------------------------------------------------------------------===//
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +0000523
Eli Friedmane4277982008-08-20 23:11:40 +0000524namespace {
525// PPC abstract base class
526class PPCTargetInfo : public TargetInfo {
527 static const Builtin::Info BuiltinInfo[];
528 static const char * const GCCRegNames[];
529 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Eli Friedmane4277982008-08-20 23:11:40 +0000530public:
Eli Friedman15b91762009-06-05 07:05:05 +0000531 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
532
Eli Friedmane4277982008-08-20 23:11:40 +0000533 virtual void getTargetBuiltins(const Builtin::Info *&Records,
534 unsigned &NumRecords) const {
Reid Spencer5f016e22007-07-11 17:01:13 +0000535 Records = BuiltinInfo;
Eli Friedmane4277982008-08-20 23:11:40 +0000536 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +0000537 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000538
Chris Lattner33328642009-03-20 15:52:06 +0000539 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000540 MacroBuilder &Builder) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000541
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000542 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000543 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000544 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000545 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000546 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +0000547 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000548 switch (*Name) {
Anders Carlssond04c6e22007-11-27 04:11:28 +0000549 default: return false;
550 case 'O': // Zero
John Thompson8e6065a2010-06-24 22:44:13 +0000551 break;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000552 case 'b': // Base register
553 case 'f': // Floating point register
Chris Lattner44def072009-04-26 07:16:29 +0000554 Info.setAllowsRegister();
John Thompson8e6065a2010-06-24 22:44:13 +0000555 break;
556 // FIXME: The following are added to allow parsing.
557 // I just took a guess at what the actions should be.
558 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer20249a12010-10-21 03:16:25 +0000559 case 'd': // Floating point register (containing 64-bit value)
John Thompson8e6065a2010-06-24 22:44:13 +0000560 case 'v': // Altivec vector register
561 Info.setAllowsRegister();
562 break;
563 case 'w':
564 switch (Name[1]) {
Michael J. Spencer20249a12010-10-21 03:16:25 +0000565 case 'd':// VSX vector register to hold vector double data
566 case 'f':// VSX vector register to hold vector float data
567 case 's':// VSX vector register to hold scalar float data
568 case 'a':// Any VSX register
John Thompson8e6065a2010-06-24 22:44:13 +0000569 break;
570 default:
571 return false;
572 }
573 Info.setAllowsRegister();
574 Name++; // Skip over 'w'.
575 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000576 case 'h': // `MQ', `CTR', or `LINK' register
577 case 'q': // `MQ' register
578 case 'c': // `CTR' register
579 case 'l': // `LINK' register
580 case 'x': // `CR' register (condition register) number 0
581 case 'y': // `CR' register (condition register)
582 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson8e6065a2010-06-24 22:44:13 +0000583 Info.setAllowsRegister();
584 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000585 case 'I': // Signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000586 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer20249a12010-10-21 03:16:25 +0000587 // (use `L' instead for SImode constants)
588 case 'K': // Unsigned 16-bit constant
589 case 'L': // Signed 16-bit constant shifted left 16 bits
590 case 'M': // Constant larger than 31
591 case 'N': // Exact power of 2
592 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000593 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000594 // register with one instruction per word
John Thompson8e6065a2010-06-24 22:44:13 +0000595 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer20249a12010-10-21 03:16:25 +0000596 // into a register using three instructions
John Thompson8e6065a2010-06-24 22:44:13 +0000597 break;
598 case 'm': // Memory operand. Note that on PowerPC targets, m can
599 // include addresses that update the base register. It
600 // is therefore only safe to use `m' in an asm statement
601 // if that asm statement accesses the operand exactly once.
602 // The asm statement must also use `%U<opno>' as a
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000603 // placeholder for the "update" flag in the corresponding
Michael J. Spencer20249a12010-10-21 03:16:25 +0000604 // load or store instruction. For example:
John Thompson8e6065a2010-06-24 22:44:13 +0000605 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000606 // is correct but:
John Thompson8e6065a2010-06-24 22:44:13 +0000607 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
608 // is not. Use es rather than m if you don't want the base
Michael J. Spencer20249a12010-10-21 03:16:25 +0000609 // register to be updated.
610 case 'e':
John Thompson56b6eca2010-06-25 00:02:05 +0000611 if (Name[1] != 's')
612 return false;
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000613 // es: A "stable" memory operand; that is, one which does not
John Thompson8e6065a2010-06-24 22:44:13 +0000614 // include any automodification of the base register. Unlike
615 // `m', this constraint can be used in asm statements that
616 // might access the operand several times, or that might not
John Thompson56b6eca2010-06-25 00:02:05 +0000617 // access it at all.
John Thompson8e6065a2010-06-24 22:44:13 +0000618 Info.setAllowsMemory();
John Thompson56b6eca2010-06-25 00:02:05 +0000619 Name++; // Skip over 'e'.
John Thompson8e6065a2010-06-24 22:44:13 +0000620 break;
621 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer20249a12010-10-21 03:16:25 +0000622 // usually better to use `m' or `es' in asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000623 case 'Z': // Memory operand that is an indexed or indirect from a
624 // register (it is usually better to use `m' or `es' in
Michael J. Spencer20249a12010-10-21 03:16:25 +0000625 // asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000626 Info.setAllowsMemory();
627 Info.setAllowsRegister();
628 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000629 case 'R': // AIX TOC entry
John Thompson8e6065a2010-06-24 22:44:13 +0000630 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000631 // register (`p' is preferable for asm statements)
632 case 'S': // Constant suitable as a 64-bit mask operand
633 case 'T': // Constant suitable as a 32-bit mask operand
634 case 'U': // System V Release 4 small data area reference
John Thompson8e6065a2010-06-24 22:44:13 +0000635 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000636 // instructions
637 case 'W': // Vector constant that does not require memory
638 case 'j': // Vector constant that is all zeros.
John Thompson8e6065a2010-06-24 22:44:13 +0000639 break;
640 // End FIXME.
Anders Carlssond04c6e22007-11-27 04:11:28 +0000641 }
John Thompson8e6065a2010-06-24 22:44:13 +0000642 return true;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000643 }
Eli Friedmane4277982008-08-20 23:11:40 +0000644 virtual const char *getClobbers() const {
645 return "";
Anders Carlssond04c6e22007-11-27 04:11:28 +0000646 }
Eli Friedmane4277982008-08-20 23:11:40 +0000647};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000648
Eli Friedmane4277982008-08-20 23:11:40 +0000649const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000650#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES, false },
651#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
652 ALL_LANGUAGES, false },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000653#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000654};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000655
656
Chris Lattnerc0f59212009-03-02 22:27:17 +0000657/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
658/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000659void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000660 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000661 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000662 Builder.defineMacro("__ppc__");
663 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000664 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000665 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000666 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000667 Builder.defineMacro("_ARCH_PPC64");
668 Builder.defineMacro("_LP64");
669 Builder.defineMacro("__LP64__");
Chris Lattnere03ae302010-02-16 18:14:57 +0000670 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000671 Builder.defineMacro("__ppc64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000672 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +0000673 Builder.defineMacro("__ppc__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000674 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000675
Chris Lattnerc0f59212009-03-02 22:27:17 +0000676 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +0000677 Builder.defineMacro("_BIG_ENDIAN");
678 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000679
Chris Lattnerc0f59212009-03-02 22:27:17 +0000680 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000681 Builder.defineMacro("__NATURAL_ALIGNMENT__");
682 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000683
Chris Lattnerc0f59212009-03-02 22:27:17 +0000684 // FIXME: Should be controlled by command line option.
Benjamin Kramera9992772010-01-09 17:55:51 +0000685 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000686
John Thompson3f6918a2009-11-19 17:18:50 +0000687 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000688 Builder.defineMacro("__VEC__", "10206");
689 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000690 }
Chris Lattnerc0f59212009-03-02 22:27:17 +0000691}
692
Chris Lattner393ff042008-04-21 18:56:49 +0000693
Eli Friedmane4277982008-08-20 23:11:40 +0000694const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +0000695 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
696 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
697 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
698 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
699 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
700 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
701 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
702 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +0000703 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000704 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +0000705 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000706 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
707 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
708 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
709 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +0000710 "vrsave", "vscr",
711 "spe_acc", "spefscr",
712 "sfp"
713};
Reid Spencer5f016e22007-07-11 17:01:13 +0000714
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000715void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000716 unsigned &NumNames) const {
717 Names = GCCRegNames;
718 NumNames = llvm::array_lengthof(GCCRegNames);
719}
Reid Spencer5f016e22007-07-11 17:01:13 +0000720
Eli Friedmane4277982008-08-20 23:11:40 +0000721const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
722 // While some of these aliases do map to different registers
723 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000724 { { "0" }, "r0" },
725 { { "1"}, "r1" },
726 { { "2" }, "r2" },
727 { { "3" }, "r3" },
728 { { "4" }, "r4" },
729 { { "5" }, "r5" },
730 { { "6" }, "r6" },
731 { { "7" }, "r7" },
732 { { "8" }, "r8" },
733 { { "9" }, "r9" },
734 { { "10" }, "r10" },
735 { { "11" }, "r11" },
736 { { "12" }, "r12" },
737 { { "13" }, "r13" },
738 { { "14" }, "r14" },
739 { { "15" }, "r15" },
740 { { "16" }, "r16" },
741 { { "17" }, "r17" },
742 { { "18" }, "r18" },
743 { { "19" }, "r19" },
744 { { "20" }, "r20" },
745 { { "21" }, "r21" },
746 { { "22" }, "r22" },
747 { { "23" }, "r23" },
748 { { "24" }, "r24" },
749 { { "25" }, "r25" },
750 { { "26" }, "r26" },
751 { { "27" }, "r27" },
752 { { "28" }, "r28" },
753 { { "29" }, "r29" },
754 { { "30" }, "r30" },
755 { { "31" }, "r31" },
756 { { "fr0" }, "f0" },
757 { { "fr1" }, "f1" },
758 { { "fr2" }, "f2" },
759 { { "fr3" }, "f3" },
760 { { "fr4" }, "f4" },
761 { { "fr5" }, "f5" },
762 { { "fr6" }, "f6" },
763 { { "fr7" }, "f7" },
764 { { "fr8" }, "f8" },
765 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +0000766 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000767 { { "fr11" }, "f11" },
768 { { "fr12" }, "f12" },
769 { { "fr13" }, "f13" },
770 { { "fr14" }, "f14" },
771 { { "fr15" }, "f15" },
772 { { "fr16" }, "f16" },
773 { { "fr17" }, "f17" },
774 { { "fr18" }, "f18" },
775 { { "fr19" }, "f19" },
776 { { "fr20" }, "f20" },
777 { { "fr21" }, "f21" },
778 { { "fr22" }, "f22" },
779 { { "fr23" }, "f23" },
780 { { "fr24" }, "f24" },
781 { { "fr25" }, "f25" },
782 { { "fr26" }, "f26" },
783 { { "fr27" }, "f27" },
784 { { "fr28" }, "f28" },
785 { { "fr29" }, "f29" },
786 { { "fr30" }, "f30" },
787 { { "fr31" }, "f31" },
788 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +0000789};
790
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000791void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000792 unsigned &NumAliases) const {
793 Aliases = GCCRegAliases;
794 NumAliases = llvm::array_lengthof(GCCRegAliases);
795}
796} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +0000797
798namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000799class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000800public:
Chris Lattnere03ae302010-02-16 18:14:57 +0000801 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +0000802 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner1932e122009-11-07 18:59:41 +0000803 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +0000804
805 if (getTriple().getOS() == llvm::Triple::FreeBSD)
Roman Divackyc81f2a22011-01-06 08:27:10 +0000806 SizeType = UnsignedInt;
807 }
808
809 virtual const char *getVAListDeclaration() const {
810 // This is the ELF definition, and is overridden by the Darwin sub-target
811 return "typedef struct __va_list_tag {"
812 " unsigned char gpr;"
813 " unsigned char fpr;"
814 " unsigned short reserved;"
815 " void* overflow_arg_area;"
816 " void* reg_save_area;"
817 "} __builtin_va_list[1];";
Eli Friedmaned855cb2008-08-21 00:13:15 +0000818 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000819};
820} // end anonymous namespace.
821
822namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000823class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000824public:
Eli Friedmane4277982008-08-20 23:11:40 +0000825 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +0000826 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +0000827 IntMaxType = SignedLong;
828 UIntMaxType = UnsignedLong;
829 Int64Type = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +0000830 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner1932e122009-11-07 18:59:41 +0000831 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnerf291b102008-05-09 06:17:04 +0000832 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000833 virtual const char *getVAListDeclaration() const {
834 return "typedef char* __builtin_va_list;";
835 }
Eli Friedmane4277982008-08-20 23:11:40 +0000836};
837} // end anonymous namespace.
838
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000839
840namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +0000841class DarwinPPC32TargetInfo :
842 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000843public:
Roman Divackyc81f2a22011-01-06 08:27:10 +0000844 DarwinPPC32TargetInfo(const std::string& triple)
845 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000846 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +0000847 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
848 }
849 virtual const char *getVAListDeclaration() const {
850 return "typedef char* __builtin_va_list;";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000851 }
852};
853
854class DarwinPPC64TargetInfo :
855 public DarwinTargetInfo<PPC64TargetInfo> {
856public:
857 DarwinPPC64TargetInfo(const std::string& triple)
858 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
859 HasAlignMac68kSupport = true;
860 }
861};
862} // end anonymous namespace.
863
Reid Spencer5f016e22007-07-11 17:01:13 +0000864namespace {
Justin Holewinski285dc652011-04-20 19:34:15 +0000865 class PTXTargetInfo : public TargetInfo {
866 static const char * const GCCRegNames[];
867 static const Builtin::Info BuiltinInfo[];
868 public:
869 PTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
870 TLSSupported = false;
871 LongWidth = LongAlign = 64;
872 }
873 virtual void getTargetDefines(const LangOptions &Opts,
874 MacroBuilder &Builder) const {
875 Builder.defineMacro("__PTX__");
876 }
877 virtual void getTargetBuiltins(const Builtin::Info *&Records,
878 unsigned &NumRecords) const {
879 Records = BuiltinInfo;
880 NumRecords = clang::PTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
881 }
882
883 virtual void getGCCRegNames(const char * const *&Names,
884 unsigned &NumNames) const;
885 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
886 unsigned &NumAliases) const {
887 // No aliases.
888 Aliases = 0;
889 NumAliases = 0;
890 }
891 virtual bool validateAsmConstraint(const char *&Name,
892 TargetInfo::ConstraintInfo &info) const {
893 // FIXME: implement
894 return true;
895 }
896 virtual const char *getClobbers() const {
897 // FIXME: Is this really right?
898 return "";
899 }
900 virtual const char *getVAListDeclaration() const {
901 // FIXME: implement
902 return "typedef char* __builtin_va_list;";
903 }
904 };
905
906 const Builtin::Info PTXTargetInfo::BuiltinInfo[] = {
907#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES, false },
908#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
909 ALL_LANGUAGES, false },
910#include "clang/Basic/BuiltinsPTX.def"
911 };
912
913 const char * const PTXTargetInfo::GCCRegNames[] = {
914 "r0"
915 };
916
917 void PTXTargetInfo::getGCCRegNames(const char * const *&Names,
918 unsigned &NumNames) const {
919 Names = GCCRegNames;
920 NumNames = llvm::array_lengthof(GCCRegNames);
921 }
922
923
924 class PTX32TargetInfo : public PTXTargetInfo {
925 public:
926 PTX32TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
927 PointerWidth = PointerAlign = 32;
928 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
929 DescriptionString
930 = "e-p:32:32-i64:64:64-f64:64:64-n1:8:16:32:64";
931 }
932 };
933
934 class PTX64TargetInfo : public PTXTargetInfo {
935 public:
936 PTX64TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
937 PointerWidth = PointerAlign = 64;
938 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
939 DescriptionString
940 = "e-p:64:64-i64:64:64-f64:64:64-n1:8:16:32:64";
941 }
942 };
943}
944
945namespace {
Chris Lattner9cbeb632010-03-06 21:21:27 +0000946// MBlaze abstract base class
947class MBlazeTargetInfo : public TargetInfo {
948 static const char * const GCCRegNames[];
949 static const TargetInfo::GCCRegAlias GCCRegAliases[];
950
951public:
952 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +0000953 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner9cbeb632010-03-06 21:21:27 +0000954 }
955
956 virtual void getTargetBuiltins(const Builtin::Info *&Records,
957 unsigned &NumRecords) const {
958 // FIXME: Implement.
959 Records = 0;
960 NumRecords = 0;
961 }
962
963 virtual void getTargetDefines(const LangOptions &Opts,
964 MacroBuilder &Builder) const;
965
966 virtual const char *getVAListDeclaration() const {
967 return "typedef char* __builtin_va_list;";
968 }
969 virtual const char *getTargetPrefix() const {
970 return "mblaze";
971 }
972 virtual void getGCCRegNames(const char * const *&Names,
973 unsigned &NumNames) const;
974 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
975 unsigned &NumAliases) const;
976 virtual bool validateAsmConstraint(const char *&Name,
977 TargetInfo::ConstraintInfo &Info) const {
978 switch (*Name) {
979 default: return false;
980 case 'O': // Zero
981 return true;
982 case 'b': // Base register
983 case 'f': // Floating point register
984 Info.setAllowsRegister();
985 return true;
986 }
987 }
988 virtual const char *getClobbers() const {
989 return "";
990 }
991};
992
993/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
994/// #defines that are not tied to a specific subtarget.
995void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
996 MacroBuilder &Builder) const {
997 // Target identification.
998 Builder.defineMacro("__microblaze__");
999 Builder.defineMacro("_ARCH_MICROBLAZE");
1000 Builder.defineMacro("__MICROBLAZE__");
1001
1002 // Target properties.
1003 Builder.defineMacro("_BIG_ENDIAN");
1004 Builder.defineMacro("__BIG_ENDIAN__");
1005
1006 // Subtarget options.
1007 Builder.defineMacro("__REGISTER_PREFIX__", "");
1008}
1009
1010
1011const char * const MBlazeTargetInfo::GCCRegNames[] = {
1012 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1013 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1014 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1015 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1016 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1017 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1018 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1019 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1020 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1021 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1022};
1023
1024void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1025 unsigned &NumNames) const {
1026 Names = GCCRegNames;
1027 NumNames = llvm::array_lengthof(GCCRegNames);
1028}
1029
1030const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1031 { {"f0"}, "r0" },
1032 { {"f1"}, "r1" },
1033 { {"f2"}, "r2" },
1034 { {"f3"}, "r3" },
1035 { {"f4"}, "r4" },
1036 { {"f5"}, "r5" },
1037 { {"f6"}, "r6" },
1038 { {"f7"}, "r7" },
1039 { {"f8"}, "r8" },
1040 { {"f9"}, "r9" },
1041 { {"f10"}, "r10" },
1042 { {"f11"}, "r11" },
1043 { {"f12"}, "r12" },
1044 { {"f13"}, "r13" },
1045 { {"f14"}, "r14" },
1046 { {"f15"}, "r15" },
1047 { {"f16"}, "r16" },
1048 { {"f17"}, "r17" },
1049 { {"f18"}, "r18" },
1050 { {"f19"}, "r19" },
1051 { {"f20"}, "r20" },
1052 { {"f21"}, "r21" },
1053 { {"f22"}, "r22" },
1054 { {"f23"}, "r23" },
1055 { {"f24"}, "r24" },
1056 { {"f25"}, "r25" },
1057 { {"f26"}, "r26" },
1058 { {"f27"}, "r27" },
1059 { {"f28"}, "r28" },
1060 { {"f29"}, "r29" },
1061 { {"f30"}, "r30" },
1062 { {"f31"}, "r31" },
1063};
1064
1065void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1066 unsigned &NumAliases) const {
1067 Aliases = GCCRegAliases;
1068 NumAliases = llvm::array_lengthof(GCCRegAliases);
1069}
1070} // end anonymous namespace.
1071
1072namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001073// Namespace for x86 abstract base class
1074const Builtin::Info BuiltinInfo[] = {
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001075#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES, false },
1076#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1077 ALL_LANGUAGES, false },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001078#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001079};
Eli Friedman61538a72008-05-20 14:21:01 +00001080
Nuno Lopes2550d702009-12-23 17:49:57 +00001081static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001082 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1083 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
1084 "argp", "flags", "fspr", "dirflag", "frame",
1085 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1086 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1087 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001088 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001089};
1090
Eric Christophercfd323d2011-06-21 00:05:20 +00001091const TargetInfo::AddlRegName AddlRegNames[] = {
1092 { { "al", "ah", "eax", "rax" }, 0 },
1093 { { "bl", "bh", "ebx", "rbx" }, 3 },
1094 { { "cl", "ch", "ecx", "rcx" }, 2 },
1095 { { "dl", "dh", "edx", "rdx" }, 1 },
1096 { { "esi", "rsi" }, 4 },
1097 { { "edi", "rdi" }, 5 },
1098 { { "esp", "rsp" }, 7 },
1099 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001100};
1101
1102// X86 target abstract base class; x86-32 and x86-64 are very close, so
1103// most of the implementation can be shared.
1104class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001105 enum X86SSEEnum {
1106 NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
1107 } SSELevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001108 enum AMD3DNowEnum {
1109 NoAMD3DNow, AMD3DNow, AMD3DNowAthlon
1110 } AMD3DNowLevel;
1111
Eric Christophereea12d12010-04-02 23:50:19 +00001112 bool HasAES;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001113 bool HasAVX;
1114
Eli Friedman618234a2008-08-20 02:34:37 +00001115public:
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001116 X86TargetInfo(const std::string& triple)
Eric Christophereea12d12010-04-02 23:50:19 +00001117 : TargetInfo(triple), SSELevel(NoMMXSSE), AMD3DNowLevel(NoAMD3DNow),
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001118 HasAES(false), HasAVX(false) {
Eli Friedman618234a2008-08-20 02:34:37 +00001119 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001120 }
1121 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1122 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001123 Records = BuiltinInfo;
1124 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001125 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001126 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001127 unsigned &NumNames) const {
1128 Names = GCCRegNames;
1129 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001130 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001131 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001132 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001133 Aliases = 0;
1134 NumAliases = 0;
1135 }
1136 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1137 unsigned &NumNames) const {
1138 Names = AddlRegNames;
1139 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001140 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001141 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001142 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001143 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001144 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001145 return "~{dirflag},~{fpsr},~{flags}";
1146 }
Chris Lattner33328642009-03-20 15:52:06 +00001147 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001148 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001149 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1150 const std::string &Name,
1151 bool Enabled) const;
Mike Stump1eb44332009-09-09 15:08:12 +00001152 virtual void getDefaultFeatures(const std::string &CPU,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001153 llvm::StringMap<bool> &Features) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001154 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Reid Spencer5f016e22007-07-11 17:01:13 +00001155};
Chris Lattner3daed522009-03-02 22:20:04 +00001156
Mike Stump1eb44332009-09-09 15:08:12 +00001157void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001158 llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001159 // FIXME: This should not be here.
1160 Features["3dnow"] = false;
1161 Features["3dnowa"] = false;
1162 Features["mmx"] = false;
1163 Features["sse"] = false;
1164 Features["sse2"] = false;
1165 Features["sse3"] = false;
1166 Features["ssse3"] = false;
1167 Features["sse41"] = false;
1168 Features["sse42"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001169 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001170 Features["avx"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001171
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001172 // LLVM does not currently recognize this.
1173 // Features["sse4a"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001174
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001175 // FIXME: This *really* should not be here.
1176
1177 // X86_64 always has SSE2.
1178 if (PointerWidth == 64)
1179 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1180
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001181 if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
1182 CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
1183 ;
1184 else if (CPU == "pentium-mmx" || CPU == "pentium2")
1185 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001186 else if (CPU == "pentium3")
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001187 setFeatureEnabled(Features, "sse", true);
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001188 else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64")
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001189 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001190 else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona")
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001191 setFeatureEnabled(Features, "sse3", true);
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001192 else if (CPU == "core2")
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001193 setFeatureEnabled(Features, "ssse3", true);
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001194 else if (CPU == "penryn") {
1195 setFeatureEnabled(Features, "sse4", true);
1196 Features["sse42"] = false;
1197 } else if (CPU == "atom")
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001198 setFeatureEnabled(Features, "sse3", true);
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001199 else if (CPU == "corei7") {
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001200 setFeatureEnabled(Features, "sse4", true);
Eric Christophereea12d12010-04-02 23:50:19 +00001201 setFeatureEnabled(Features, "aes", true);
Benjamin Kramerb65b6722011-05-20 15:11:23 +00001202 } else if (CPU == "corei7-avx") {
Roman Divackybcaa3b82011-04-05 20:32:44 +00001203 setFeatureEnabled(Features, "sse4", true);
1204 setFeatureEnabled(Features, "aes", true);
1205// setFeatureEnabled(Features, "avx", true);
1206 } else if (CPU == "k6" || CPU == "winchip-c6")
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001207 setFeatureEnabled(Features, "mmx", true);
Mike Stump1eb44332009-09-09 15:08:12 +00001208 else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001209 CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
1210 setFeatureEnabled(Features, "mmx", true);
1211 setFeatureEnabled(Features, "3dnow", true);
1212 } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
1213 setFeatureEnabled(Features, "sse", true);
1214 setFeatureEnabled(Features, "3dnowa", true);
1215 } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
1216 CPU == "athlon-fx") {
Mike Stump1eb44332009-09-09 15:08:12 +00001217 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001218 setFeatureEnabled(Features, "3dnowa", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00001219 } else if (CPU == "k8-sse3") {
1220 setFeatureEnabled(Features, "sse3", true);
1221 setFeatureEnabled(Features, "3dnowa", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001222 } else if (CPU == "c3-2")
1223 setFeatureEnabled(Features, "sse", true);
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001224}
1225
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001226bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump1eb44332009-09-09 15:08:12 +00001227 const std::string &Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001228 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00001229 // FIXME: This *really* should not be here. We need some way of translating
1230 // options into llvm subtarget features.
1231 if (!Features.count(Name) &&
1232 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001233 return false;
1234
1235 if (Enabled) {
1236 if (Name == "mmx")
1237 Features["mmx"] = true;
1238 else if (Name == "sse")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001239 Features["mmx"] = Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001240 else if (Name == "sse2")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001241 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001242 else if (Name == "sse3")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001243 Features["mmx"] = Features["sse"] = Features["sse2"] =
1244 Features["sse3"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001245 else if (Name == "ssse3")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001246 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001247 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001248 else if (Name == "sse4" || Name == "sse4.2")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001249 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001250 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001251 else if (Name == "sse4.1")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001252 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00001253 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001254 else if (Name == "3dnow")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001255 Features["3dnowa"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001256 else if (Name == "3dnowa")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001257 Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00001258 else if (Name == "aes")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001259 Features["aes"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001260 else if (Name == "avx")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001261 Features["avx"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001262 } else {
1263 if (Name == "mmx")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001264 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] =
1265 Features["sse"] = Features["sse2"] = Features["sse3"] =
1266 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001267 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00001268 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001269 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001270 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00001271 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001272 Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001273 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00001274 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001275 Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001276 else if (Name == "ssse3")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001277 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00001278 else if (Name == "sse4" || Name == "sse4.1")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001279 Features["sse41"] = Features["sse42"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00001280 else if (Name == "sse4.2")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001281 Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001282 else if (Name == "3dnow")
1283 Features["3dnow"] = Features["3dnowa"] = false;
1284 else if (Name == "3dnowa")
1285 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001286 else if (Name == "aes")
1287 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001288 else if (Name == "avx")
1289 Features["avx"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001290 }
1291
1292 return true;
1293}
1294
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001295/// HandleTargetOptions - Perform initialization based on the user
1296/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001297void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001298 // Remember the maximum enabled sselevel.
1299 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1300 // Ignore disabled features.
1301 if (Features[i][0] == '-')
1302 continue;
1303
Eric Christophereea12d12010-04-02 23:50:19 +00001304 if (Features[i].substr(1) == "aes") {
1305 HasAES = true;
1306 continue;
1307 }
1308
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001309 // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1310 // For now let it be enabled together with other SSE levels.
1311 if (Features[i].substr(1) == "avx") {
1312 HasAVX = true;
1313 continue;
1314 }
1315
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001316 assert(Features[i][0] == '+' && "Invalid target feature!");
1317 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1318 .Case("sse42", SSE42)
1319 .Case("sse41", SSE41)
1320 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00001321 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001322 .Case("sse2", SSE2)
1323 .Case("sse", SSE1)
1324 .Case("mmx", MMX)
1325 .Default(NoMMXSSE);
1326 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001327
1328 AMD3DNowEnum ThreeDNowLevel =
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001329 llvm::StringSwitch<AMD3DNowEnum>(Features[i].substr(1))
1330 .Case("3dnowa", AMD3DNowAthlon)
1331 .Case("3dnow", AMD3DNow)
1332 .Default(NoAMD3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001333
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001334 AMD3DNowLevel = std::max(AMD3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001335 }
Chris Lattner3daed522009-03-02 22:20:04 +00001336}
Chris Lattnerc0f59212009-03-02 22:27:17 +00001337
1338/// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
1339/// that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00001340void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001341 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00001342 // Target identification.
1343 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00001344 Builder.defineMacro("_LP64");
1345 Builder.defineMacro("__LP64__");
1346 Builder.defineMacro("__amd64__");
1347 Builder.defineMacro("__amd64");
1348 Builder.defineMacro("__x86_64");
1349 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00001350 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00001351 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00001352 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001353
Eric Christophereea12d12010-04-02 23:50:19 +00001354 if (HasAES)
1355 Builder.defineMacro("__AES__");
1356
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001357 if (HasAVX)
1358 Builder.defineMacro("__AVX__");
1359
Chris Lattnerc0f59212009-03-02 22:27:17 +00001360 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00001361 Builder.defineMacro("__LITTLE_ENDIAN__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001362
Chris Lattnerc0f59212009-03-02 22:27:17 +00001363 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +00001364 Builder.defineMacro("__nocona");
1365 Builder.defineMacro("__nocona__");
1366 Builder.defineMacro("__tune_nocona__");
1367 Builder.defineMacro("__REGISTER_PREFIX__", "");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001368
Chris Lattner54175442009-04-19 17:32:33 +00001369 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1370 // functions in glibc header files that use FP Stack inline asm which the
1371 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00001372 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001373
Chris Lattner84f0ea82009-03-02 22:40:39 +00001374 // Each case falls through to the previous one here.
1375 switch (SSELevel) {
1376 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00001377 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001378 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00001379 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001380 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00001381 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001382 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00001383 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001384 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00001385 Builder.defineMacro("__SSE2__");
1386 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00001387 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00001388 Builder.defineMacro("__SSE__");
1389 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00001390 case MMX:
Benjamin Kramera9992772010-01-09 17:55:51 +00001391 Builder.defineMacro("__MMX__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001392 case NoMMXSSE:
1393 break;
1394 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00001395
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001396 if (Opts.Microsoft && PointerWidth == 32) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001397 switch (SSELevel) {
Michael J. Spencera764e832010-10-21 08:22:51 +00001398 case SSE42:
1399 case SSE41:
1400 case SSSE3:
1401 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001402 case SSE2:
1403 Builder.defineMacro("_M_IX86_FP", llvm::Twine(2));
1404 break;
1405 case SSE1:
1406 Builder.defineMacro("_M_IX86_FP", llvm::Twine(1));
1407 break;
1408 default:
1409 Builder.defineMacro("_M_IX86_FP", llvm::Twine(0));
1410 }
1411 }
1412
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001413 // Each case falls through to the previous one here.
1414 switch (AMD3DNowLevel) {
1415 case AMD3DNowAthlon:
1416 Builder.defineMacro("__3dNOW_A__");
1417 case AMD3DNow:
1418 Builder.defineMacro("__3dNOW__");
1419 case NoAMD3DNow:
1420 break;
1421 }
Chris Lattnerc0f59212009-03-02 22:27:17 +00001422}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001423
1424
Eli Friedman618234a2008-08-20 02:34:37 +00001425bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001426X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00001427 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001428 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00001429 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00001430 case 'Y': // first letter of a pair:
1431 switch (*(Name+1)) {
1432 default: return false;
1433 case '0': // First SSE register.
1434 case 't': // Any SSE register, when SSE2 is enabled.
1435 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
1436 case 'm': // any MMX register, when inter-unit moves enabled.
1437 break; // falls through to setAllowsRegister.
1438 }
Eli Friedman618234a2008-08-20 02:34:37 +00001439 case 'a': // eax.
1440 case 'b': // ebx.
1441 case 'c': // ecx.
1442 case 'd': // edx.
1443 case 'S': // esi.
1444 case 'D': // edi.
1445 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00001446 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00001447 case 't': // top of floating point stack.
1448 case 'u': // second from top of floating point stack.
1449 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00001450 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00001451 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00001452 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00001453 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
1454 case 'l': // "Index" registers: any general register that can be used as an
1455 // index in a base+index memory access.
1456 Info.setAllowsRegister();
1457 return true;
1458 case 'C': // SSE floating point constant.
1459 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001460 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00001461 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001462 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00001463 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00001464 return true;
1465 }
Dale Johannesen545be512010-08-24 22:33:12 +00001466 return false;
Eli Friedman618234a2008-08-20 02:34:37 +00001467}
1468
Dale Johannesenf6e2c202010-10-29 23:12:32 +00001469
Eli Friedman618234a2008-08-20 02:34:37 +00001470std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00001471X86TargetInfo::convertConstraint(const char *&Constraint) const {
1472 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00001473 case 'a': return std::string("{ax}");
1474 case 'b': return std::string("{bx}");
1475 case 'c': return std::string("{cx}");
1476 case 'd': return std::string("{dx}");
1477 case 'S': return std::string("{si}");
1478 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00001479 case 'p': // address
1480 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00001481 case 't': // top of floating point stack.
1482 return std::string("{st}");
1483 case 'u': // second from top of floating point stack.
1484 return std::string("{st(1)}"); // second from top of floating point stack.
1485 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00001486 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00001487 }
1488}
Eli Friedman618234a2008-08-20 02:34:37 +00001489} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00001490
1491namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001492// X86-32 generic target
1493class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001494public:
Eli Friedman618234a2008-08-20 02:34:37 +00001495 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1496 DoubleAlign = LongLongAlign = 32;
1497 LongDoubleWidth = 96;
1498 LongDoubleAlign = 32;
Eli Friedmaned855cb2008-08-21 00:13:15 +00001499 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1500 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner1932e122009-11-07 18:59:41 +00001501 "a0:0:64-f80:32:32-n8:16:32";
Eli Friedman1afabd92009-03-29 20:31:09 +00001502 SizeType = UnsignedInt;
1503 PtrDiffType = SignedInt;
1504 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00001505 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00001506
1507 // Use fpret for all types.
1508 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
1509 (1 << TargetInfo::Double) |
1510 (1 << TargetInfo::LongDouble));
Eli Friedman618234a2008-08-20 02:34:37 +00001511 }
1512 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00001513 return "typedef char* __builtin_va_list;";
Eli Friedman618234a2008-08-20 02:34:37 +00001514 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00001515
Chris Lattner21fb98e2009-09-23 06:06:36 +00001516 int getEHDataRegisterNumber(unsigned RegNo) const {
1517 if (RegNo == 0) return 0;
1518 if (RegNo == 1) return 2;
1519 return -1;
1520 }
Eli Friedman618234a2008-08-20 02:34:37 +00001521};
1522} // end anonymous namespace
1523
1524namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00001525class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
1526public:
1527 OpenBSDI386TargetInfo(const std::string& triple) :
1528 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
1529 SizeType = UnsignedLong;
1530 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00001531 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00001532 }
1533};
1534} // end anonymous namespace
1535
1536namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00001537class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00001538public:
Torok Edwin5f6c1942009-06-30 17:10:35 +00001539 DarwinI386TargetInfo(const std::string& triple) :
1540 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00001541 LongDoubleWidth = 128;
1542 LongDoubleAlign = 128;
Eli Friedman1afabd92009-03-29 20:31:09 +00001543 SizeType = UnsignedLong;
1544 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00001545 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1546 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner1932e122009-11-07 18:59:41 +00001547 "a0:0:64-f80:128:128-n8:16:32";
Daniel Dunbar613fd672010-05-27 00:35:16 +00001548 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00001549 }
1550
Eli Friedman618234a2008-08-20 02:34:37 +00001551};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00001552} // end anonymous namespace
1553
1554namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00001555// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001556class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00001557public:
1558 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001559 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00001560 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00001561 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00001562 DoubleAlign = LongLongAlign = 64;
1563 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Anton Korobeynikovb3814412009-12-19 02:05:07 +00001564 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
1565 "v128:128:128-a0:0:64-f80:32:32-n8:16:32";
Eli Friedman29a30502008-08-21 01:40:19 +00001566 }
Michael J. Spencera764e832010-10-21 08:22:51 +00001567 virtual void getTargetDefines(const LangOptions &Opts,
1568 MacroBuilder &Builder) const {
1569 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
1570 }
1571};
1572} // end anonymous namespace
1573
1574namespace {
1575
1576// x86-32 Windows Visual Studio target
1577class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
1578public:
1579 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
1580 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00001581 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00001582 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
1583 }
1584 virtual void getTargetDefines(const LangOptions &Opts,
1585 MacroBuilder &Builder) const {
1586 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
1587 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
1588 // The value of the following reflects processor type.
1589 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
1590 // We lost the original triple, so we use the default.
1591 Builder.defineMacro("_M_IX86", "600");
1592 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001593};
1594} // end anonymous namespace
1595
1596namespace {
1597// x86-32 MinGW target
1598class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
1599public:
1600 MinGWX86_32TargetInfo(const std::string& triple)
1601 : WindowsX86_32TargetInfo(triple) {
1602 }
1603 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001604 MacroBuilder &Builder) const {
1605 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00001606 DefineStd(Builder, "WIN32", Opts);
1607 DefineStd(Builder, "WINNT", Opts);
1608 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00001609 Builder.defineMacro("__MSVCRT__");
1610 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00001611
1612 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
1613 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
1614 if (Opts.Microsoft)
1615 // Provide "as-is" __declspec.
1616 Builder.defineMacro("__declspec", "__declspec");
1617 else
1618 // Provide alias of __attribute__ like mingw32-gcc.
1619 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001620 }
1621};
1622} // end anonymous namespace
1623
1624namespace {
1625// x86-32 Cygwin target
1626class CygwinX86_32TargetInfo : public X86_32TargetInfo {
1627public:
1628 CygwinX86_32TargetInfo(const std::string& triple)
1629 : X86_32TargetInfo(triple) {
1630 TLSSupported = false;
1631 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001632 DoubleAlign = LongLongAlign = 64;
1633 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1634 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner1932e122009-11-07 18:59:41 +00001635 "a0:0:64-f80:32:32-n8:16:32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001636 }
1637 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001638 MacroBuilder &Builder) const {
1639 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1640 Builder.defineMacro("__CYGWIN__");
1641 Builder.defineMacro("__CYGWIN32__");
1642 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00001643 if (Opts.CPlusPlus)
1644 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00001645 }
Eli Friedman29a30502008-08-21 01:40:19 +00001646};
1647} // end anonymous namespace
1648
1649namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00001650// x86-32 Haiku target
1651class HaikuX86_32TargetInfo : public X86_32TargetInfo {
1652public:
1653 HaikuX86_32TargetInfo(const std::string& triple)
1654 : X86_32TargetInfo(triple) {
1655 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00001656 IntPtrType = SignedLong;
1657 PtrDiffType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00001658 this->UserLabelPrefix = "";
Eli Friedmana7e68452010-08-22 01:00:03 +00001659 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00001660 virtual void getTargetDefines(const LangOptions &Opts,
1661 MacroBuilder &Builder) const {
1662 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1663 Builder.defineMacro("__INTEL__");
1664 Builder.defineMacro("__HAIKU__");
1665 }
1666};
1667} // end anonymous namespace
1668
Douglas Gregordca52262011-07-01 22:41:14 +00001669// RTEMS Target
1670template<typename Target>
1671class RTEMSTargetInfo : public OSTargetInfo<Target> {
1672protected:
1673 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
1674 MacroBuilder &Builder) const {
1675 // RTEMS defines; list based off of gcc output
1676
1677 // FIXME: Move version number handling to llvm::Triple.
1678 llvm::StringRef Release = Triple.getOSName().substr(strlen("rtems"), 1);
1679
1680 Builder.defineMacro("__rtems__");
1681 Builder.defineMacro("__ELF__");
1682 }
1683public:
1684 RTEMSTargetInfo(const std::string &triple)
1685 : OSTargetInfo<Target>(triple) {
1686 this->UserLabelPrefix = "";
1687
1688 llvm::Triple Triple(triple);
1689 switch (Triple.getArch()) {
1690 default:
1691 case llvm::Triple::x86:
1692 // this->MCountName = ".mcount";
1693 break;
1694 case llvm::Triple::mips:
1695 case llvm::Triple::mipsel:
1696 case llvm::Triple::ppc:
1697 case llvm::Triple::ppc64:
1698 // this->MCountName = "_mcount";
1699 break;
1700 case llvm::Triple::arm:
1701 // this->MCountName = "__mcount";
1702 break;
1703 }
1704
1705 }
1706};
1707
1708namespace {
1709// x86-32 RTEMS target
1710class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
1711public:
1712 RTEMSX86_32TargetInfo(const std::string& triple)
1713 : X86_32TargetInfo(triple) {
1714 SizeType = UnsignedLong;
1715 IntPtrType = SignedLong;
1716 PtrDiffType = SignedLong;
1717 this->UserLabelPrefix = "";
1718 }
1719 virtual void getTargetDefines(const LangOptions &Opts,
1720 MacroBuilder &Builder) const {
1721 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1722 Builder.defineMacro("__INTEL__");
1723 Builder.defineMacro("__rtems__");
1724 }
1725};
1726} // end anonymous namespace
1727
Chris Lattner86ed3a32010-04-11 19:29:39 +00001728namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001729// x86-64 generic target
1730class X86_64TargetInfo : public X86TargetInfo {
1731public:
Chris Lattner33328642009-03-20 15:52:06 +00001732 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00001733 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00001734 LongDoubleWidth = 128;
1735 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00001736 LargeArrayMinWidth = 128;
1737 LargeArrayAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00001738 IntMaxType = SignedLong;
1739 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00001740 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00001741 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00001742
Eli Friedmaned855cb2008-08-21 00:13:15 +00001743 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1744 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner1932e122009-11-07 18:59:41 +00001745 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00001746
1747 // Use fpret only for long double.
1748 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Reid Spencer5f016e22007-07-11 17:01:13 +00001749 }
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001750 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00001751 return "typedef struct __va_list_tag {"
1752 " unsigned gp_offset;"
1753 " unsigned fp_offset;"
1754 " void* overflow_arg_area;"
1755 " void* reg_save_area;"
John McCall2b7baf02010-05-28 18:25:28 +00001756 "} __va_list_tag;"
Eli Friedmandc043162009-07-03 00:45:06 +00001757 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson3346ae62007-11-24 23:38:12 +00001758 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00001759
Chris Lattner21fb98e2009-09-23 06:06:36 +00001760 int getEHDataRegisterNumber(unsigned RegNo) const {
1761 if (RegNo == 0) return 0;
1762 if (RegNo == 1) return 1;
1763 return -1;
1764 }
Eli Friedman618234a2008-08-20 02:34:37 +00001765};
1766} // end anonymous namespace
1767
1768namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001769// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001770class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001771public:
1772 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001773 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001774 TLSSupported = false;
1775 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00001776 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00001777 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00001778 IntMaxType = SignedLongLong;
1779 UIntMaxType = UnsignedLongLong;
1780 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00001781 SizeType = UnsignedLongLong;
1782 PtrDiffType = SignedLongLong;
1783 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00001784 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001785 }
1786 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001787 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001788 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001789 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00001790 }
NAKAMURA Takumi79521992011-01-17 22:56:23 +00001791 virtual const char *getVAListDeclaration() const {
1792 return "typedef char* __builtin_va_list;";
1793 }
Michael J. Spencera764e832010-10-21 08:22:51 +00001794};
1795} // end anonymous namespace
1796
1797namespace {
1798// x86-64 Windows Visual Studio target
1799class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
1800public:
1801 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
1802 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00001803 LongDoubleWidth = LongDoubleAlign = 64;
1804 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00001805 }
1806 virtual void getTargetDefines(const LangOptions &Opts,
1807 MacroBuilder &Builder) const {
1808 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1809 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00001810 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001811 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001812 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001813};
1814} // end anonymous namespace
1815
1816namespace {
1817// x86-64 MinGW target
1818class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
1819public:
1820 MinGWX86_64TargetInfo(const std::string& triple)
1821 : WindowsX86_64TargetInfo(triple) {
1822 }
1823 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001824 MacroBuilder &Builder) const {
1825 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00001826 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00001827 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00001828 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00001829 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00001830
1831 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
1832 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
1833 if (Opts.Microsoft)
1834 // Provide "as-is" __declspec.
1835 Builder.defineMacro("__declspec", "__declspec");
1836 else
1837 // Provide alias of __attribute__ like mingw32-gcc.
1838 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001839 }
1840};
1841} // end anonymous namespace
1842
1843namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00001844class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
1845public:
Mike Stump1eb44332009-09-09 15:08:12 +00001846 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman3c7b6e42009-07-01 03:36:11 +00001847 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
1848 Int64Type = SignedLongLong;
1849 }
1850};
1851} // end anonymous namespace
1852
1853namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00001854class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
1855public:
Mike Stump1eb44332009-09-09 15:08:12 +00001856 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman6036ebe2009-07-05 22:31:18 +00001857 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
1858 IntMaxType = SignedLongLong;
1859 UIntMaxType = UnsignedLongLong;
1860 Int64Type = SignedLongLong;
1861 }
1862};
1863} // end anonymous namespace
1864
1865namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00001866class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00001867 // Possible FPU choices.
1868 enum FPUMode {
1869 NoFPU,
1870 VFP2FPU,
1871 VFP3FPU,
1872 NeonFPU
1873 };
1874
1875 static bool FPUModeIsVFP(FPUMode Mode) {
1876 return Mode >= VFP2FPU && Mode <= NeonFPU;
1877 }
1878
1879 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1880 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00001881
Daniel Dunbareac7c532009-12-18 18:42:37 +00001882 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00001883
1884 unsigned FPU : 3;
1885
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00001886 unsigned IsThumb : 1;
1887
1888 // Initialized via features.
1889 unsigned SoftFloat : 1;
1890 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00001891
Chris Lattner2752c012010-03-03 19:03:45 +00001892 static const Builtin::Info BuiltinInfo[];
1893
Chris Lattner393ff042008-04-21 18:56:49 +00001894public:
Daniel Dunbare1f63b32009-09-17 16:21:10 +00001895 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbareac7c532009-12-18 18:42:37 +00001896 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00001897 {
Daniel Dunbara2a41612009-09-14 00:02:24 +00001898 SizeType = UnsignedInt;
1899 PtrDiffType = SignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00001900
Chris Lattner9bffb072010-04-23 16:29:58 +00001901 // {} in inline assembly are neon specifiers, not assembly variant
1902 // specifiers.
1903 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00001904
Daniel Dunbareac7c532009-12-18 18:42:37 +00001905 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00001906 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00001907 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00001908 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
1909 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00001910 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1911 "i64:64:64-f32:32:32-f64:64:64-"
Bob Wilsoncd5ce092011-04-04 16:53:11 +00001912 "v64:64:64-v128:64:128-a0:0:32-n32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00001913 } else {
1914 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1915 "i64:64:64-f32:32:32-f64:64:64-"
Bob Wilsoncd5ce092011-04-04 16:53:11 +00001916 "v64:64:64-v128:64:128-a0:0:64-n32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00001917 }
John McCallee79a4c2010-08-21 22:46:04 +00001918
1919 // ARM targets default to using the ARM C++ ABI.
1920 CXXABI = CXXABI_ARM;
Eli Friedman61538a72008-05-20 14:21:01 +00001921 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00001922 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00001923 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00001924 ABI = Name;
1925
Daniel Dunbara2a41612009-09-14 00:02:24 +00001926 // The defaults (above) are for AAPCS, check if we need to change them.
1927 //
1928 // FIXME: We need support for -meabi... we could just mangle it into the
1929 // name.
1930 if (Name == "apcs-gnu") {
Daniel Dunbard410fa22010-01-27 20:23:08 +00001931 DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
Daniel Dunbara2a41612009-09-14 00:02:24 +00001932 SizeType = UnsignedLong;
1933
Daniel Dunbar684de632010-04-22 16:14:54 +00001934 // Do not respect the alignment of bit-field types when laying out
1935 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
1936 UseBitFieldTypeAlignment = false;
1937
Daniel Dunbardff10dc2009-09-22 21:44:58 +00001938 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00001939 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
1940 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00001941 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
Bob Wilson949fd1a2011-06-29 16:09:20 +00001942 "i64:32:64-f32:32:32-f64:32:64-"
Bob Wilsoncd5ce092011-04-04 16:53:11 +00001943 "v64:32:64-v128:32:128-a0:0:32-n32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00001944 } else {
1945 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Bob Wilsoncd5ce092011-04-04 16:53:11 +00001946 "i64:32:64-f32:32:32-f64:32:64-"
1947 "v64:32:64-v128:32:128-a0:0:32-n32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00001948 }
1949
Daniel Dunbara2a41612009-09-14 00:02:24 +00001950 // FIXME: Override "preferred align" for double and long long.
1951 } else if (Name == "aapcs") {
1952 // FIXME: Enumerated types are variable width in straight AAPCS.
1953 } else if (Name == "aapcs-linux") {
1954 ;
1955 } else
1956 return false;
1957
1958 return true;
1959 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00001960
Daniel Dunbara91320b2009-12-21 23:28:17 +00001961 void getDefaultFeatures(const std::string &CPU,
1962 llvm::StringMap<bool> &Features) const {
1963 // FIXME: This should not be here.
1964 Features["vfp2"] = false;
1965 Features["vfp3"] = false;
1966 Features["neon"] = false;
1967
1968 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
1969 Features["vfp2"] = true;
1970 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
1971 Features["neon"] = true;
1972 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00001973
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00001974 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1975 const std::string &Name,
1976 bool Enabled) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00001977 if (Name == "soft-float" || Name == "soft-float-abi") {
1978 Features[Name] = Enabled;
1979 } else if (Name == "vfp2" || Name == "vfp3" || Name == "neon") {
1980 // These effectively are a single option, reset them when any is enabled.
1981 if (Enabled)
1982 Features["vfp2"] = Features["vfp3"] = Features["neon"] = false;
1983 Features[Name] = Enabled;
1984 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00001985 return false;
1986
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00001987 return true;
1988 }
1989
1990 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbara91320b2009-12-21 23:28:17 +00001991 FPU = NoFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00001992 SoftFloat = SoftFloatABI = false;
1993 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
1994 if (Features[i] == "+soft-float")
1995 SoftFloat = true;
1996 else if (Features[i] == "+soft-float-abi")
1997 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00001998 else if (Features[i] == "+vfp2")
1999 FPU = VFP2FPU;
2000 else if (Features[i] == "+vfp3")
2001 FPU = VFP3FPU;
2002 else if (Features[i] == "+neon")
2003 FPU = NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002004 }
2005
2006 // Remove front-end specific options which the backend handles differently.
2007 std::vector<std::string>::iterator it;
2008 it = std::find(Features.begin(), Features.end(), "+soft-float");
2009 if (it != Features.end())
2010 Features.erase(it);
2011 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2012 if (it != Features.end())
2013 Features.erase(it);
2014 }
2015
Daniel Dunbareac7c532009-12-18 18:42:37 +00002016 static const char *getCPUDefineSuffix(llvm::StringRef Name) {
2017 return llvm::StringSwitch<const char*>(Name)
2018 .Cases("arm8", "arm810", "4")
2019 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2020 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2021 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2022 .Case("ep9312", "4T")
2023 .Cases("arm10tdmi", "arm1020t", "5T")
2024 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2025 .Case("arm926ej-s", "5TEJ")
2026 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2027 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002028 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002029 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002030 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002031 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2032 .Cases("cortex-a8", "cortex-a9", "7A")
Bob Wilson06f45632011-01-06 16:57:20 +00002033 .Case("cortex-m3", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00002034 .Case("cortex-m0", "6M")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002035 .Default(0);
2036 }
2037 virtual bool setCPU(const std::string &Name) {
2038 if (!getCPUDefineSuffix(Name))
2039 return false;
2040
2041 CPU = Name;
2042 return true;
2043 }
Chris Lattner33328642009-03-20 15:52:06 +00002044 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002045 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002046 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00002047 Builder.defineMacro("__arm");
2048 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002049
Chris Lattnerc0f59212009-03-02 22:27:17 +00002050 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00002051 Builder.defineMacro("__ARMEL__");
2052 Builder.defineMacro("__LITTLE_ENDIAN__");
2053 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002054
2055 llvm::StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00002056 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002057
Mike Stump437bb4b2009-04-08 02:07:04 +00002058 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002059
Daniel Dunbareac7c532009-12-18 18:42:37 +00002060 // FIXME: It's more complicated than this and we don't really support
2061 // interworking.
2062 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00002063 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002064
Daniel Dunbareac7c532009-12-18 18:42:37 +00002065 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramera9992772010-01-09 17:55:51 +00002066 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002067
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002068 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00002069 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002070
2071 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00002072 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002073
Bob Wilson84f95cf2011-05-13 18:56:03 +00002074 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002075 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002076 Builder.defineMacro("__THUMBEL__");
2077 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00002078 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002079 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002080 }
2081
2082 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00002083 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002084
2085 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramera9992772010-01-09 17:55:51 +00002086 Builder.defineMacro("__VFP_FP__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002087
2088 // This only gets set when Neon instructions are actually available, unlike
2089 // the VFP define, hence the soft float and arch check. This is subtly
2090 // different from gcc, we follow the intent which was that it should be set
2091 // when Neon instructions are actually available.
Bob Wilson84f95cf2011-05-13 18:56:03 +00002092 if (FPU == NeonFPU && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002093 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00002094 }
2095 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2096 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00002097 Records = BuiltinInfo;
2098 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00002099 }
2100 virtual const char *getVAListDeclaration() const {
John McCall0e9972c2011-05-09 02:19:37 +00002101 return "typedef void* __builtin_va_list;";
Chris Lattner393ff042008-04-21 18:56:49 +00002102 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002103 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002104 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002105 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002106 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002107 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002108 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002109 // FIXME: Check if this is complete
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002110 switch (*Name) {
Eli Friedmana9f54962008-08-20 07:44:10 +00002111 default:
Nate Begemanad487f42008-04-22 05:03:19 +00002112 case 'l': // r0-r7
2113 case 'h': // r8-r15
2114 case 'w': // VFP Floating point register single precision
2115 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00002116 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00002117 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00002118 case 'U': // a memory reference...
2119 switch (Name[1]) {
2120 case 'q': // ...ARMV4 ldrsb
2121 case 'v': // ...VFP load/store (reg+constant offset)
2122 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00002123 case 't': // address valid for load/store opaque types wider
2124 // than 128-bits
2125 case 'n': // valid address for Neon doubleword vector load/store
2126 case 'm': // valid address for Neon element and structure load/store
2127 case 's': // valid address for non-offset loads/stores of quad-word
2128 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00002129 Info.setAllowsMemory();
2130 Name++;
2131 return true;
2132 }
Nate Begemanad487f42008-04-22 05:03:19 +00002133 }
Chris Lattner393ff042008-04-21 18:56:49 +00002134 return false;
2135 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00002136 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00002137 std::string R;
2138 switch (*Constraint) {
2139 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00002140 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00002141 Constraint++;
2142 break;
Eric Christopher283f4472011-06-17 00:40:18 +00002143 case 'p': // 'p' should be translated to 'r' by default.
2144 R = std::string("r");
2145 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00002146 default:
2147 return std::string(1, *Constraint);
2148 }
2149 return R;
2150 }
Chris Lattner393ff042008-04-21 18:56:49 +00002151 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002152 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00002153 return "";
2154 }
2155};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002156
2157const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002158 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002159 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002160 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
2161
2162 // Float registers
2163 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2164 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2165 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002166 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002167
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002168 // Double registers
2169 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
2170 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00002171 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
2172 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002173
2174 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00002175 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
2176 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002177};
2178
2179void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002180 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002181 Names = GCCRegNames;
2182 NumNames = llvm::array_lengthof(GCCRegNames);
2183}
2184
2185const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002186 { { "a1" }, "r0" },
2187 { { "a2" }, "r1" },
2188 { { "a3" }, "r2" },
2189 { { "a4" }, "r3" },
2190 { { "v1" }, "r4" },
2191 { { "v2" }, "r5" },
2192 { { "v3" }, "r6" },
2193 { { "v4" }, "r7" },
2194 { { "v5" }, "r8" },
2195 { { "v6", "rfp" }, "r9" },
2196 { { "sl" }, "r10" },
2197 { { "fp" }, "r11" },
2198 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002199 { { "r13" }, "sp" },
2200 { { "r14" }, "lr" },
2201 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002202 // The S, D and Q registers overlap, but aren't really aliases; we
2203 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002204};
2205
2206void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2207 unsigned &NumAliases) const {
2208 Aliases = GCCRegAliases;
2209 NumAliases = llvm::array_lengthof(GCCRegAliases);
2210}
Chris Lattner2752c012010-03-03 19:03:45 +00002211
2212const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Fariborz Jahanian67aba812010-11-30 17:35:24 +00002213#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES, false },
2214#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
2215 ALL_LANGUAGES, false },
Chris Lattner2752c012010-03-03 19:03:45 +00002216#include "clang/Basic/BuiltinsARM.def"
2217};
Chris Lattner393ff042008-04-21 18:56:49 +00002218} // end anonymous namespace.
2219
Eli Friedmana9f54962008-08-20 07:44:10 +00002220
2221namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00002222class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00002223 public DarwinTargetInfo<ARMTargetInfo> {
2224protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00002225 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00002226 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00002227 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00002228 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002229
Torok Edwin5f6c1942009-06-30 17:10:35 +00002230public:
Mike Stump1eb44332009-09-09 15:08:12 +00002231 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar350b9f32010-05-27 07:00:26 +00002232 : DarwinTargetInfo<ARMTargetInfo>(triple) {
2233 HasAlignMac68kSupport = true;
2234 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002235};
2236} // end anonymous namespace.
2237
Reid Spencer5f016e22007-07-11 17:01:13 +00002238namespace {
Eli Friedman01b86682008-08-20 07:28:14 +00002239class SparcV8TargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00002240 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2241 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002242 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00002243public:
Eli Friedman01b86682008-08-20 07:28:14 +00002244 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
2245 // FIXME: Support Sparc quad-precision long double?
Eli Friedmaned855cb2008-08-21 00:13:15 +00002246 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner1932e122009-11-07 18:59:41 +00002247 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedman01b86682008-08-20 07:28:14 +00002248 }
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002249 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2250 const std::string &Name,
2251 bool Enabled) const {
2252 if (Name == "soft-float")
2253 Features[Name] = Enabled;
2254 else
2255 return false;
2256
2257 return true;
2258 }
2259 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
2260 SoftFloat = false;
2261 for (unsigned i = 0, e = Features.size(); i != e; ++i)
2262 if (Features[i] == "+soft-float")
2263 SoftFloat = true;
2264 }
Chris Lattner33328642009-03-20 15:52:06 +00002265 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002266 MacroBuilder &Builder) const {
2267 DefineStd(Builder, "sparc", Opts);
2268 Builder.defineMacro("__sparcv8");
2269 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002270
2271 if (SoftFloat)
2272 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00002273 }
2274 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2275 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00002276 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00002277 }
2278 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002279 return "typedef void* __builtin_va_list;";
Gabor Greif26658672008-02-21 16:29:08 +00002280 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002281 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00002282 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002283 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00002284 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002285 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00002286 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00002287 // FIXME: Implement!
2288 return false;
Gabor Greif26658672008-02-21 16:29:08 +00002289 }
2290 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002291 // FIXME: Implement!
2292 return "";
Gabor Greif26658672008-02-21 16:29:08 +00002293 }
2294};
2295
Chris Lattnere957f532009-01-27 01:58:38 +00002296const char * const SparcV8TargetInfo::GCCRegNames[] = {
2297 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2298 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2299 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2300 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
2301};
2302
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002303void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00002304 unsigned &NumNames) const {
2305 Names = GCCRegNames;
2306 NumNames = llvm::array_lengthof(GCCRegNames);
2307}
2308
2309const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002310 { { "g0" }, "r0" },
2311 { { "g1" }, "r1" },
2312 { { "g2" }, "r2" },
2313 { { "g3" }, "r3" },
2314 { { "g4" }, "r4" },
2315 { { "g5" }, "r5" },
2316 { { "g6" }, "r6" },
2317 { { "g7" }, "r7" },
2318 { { "o0" }, "r8" },
2319 { { "o1" }, "r9" },
2320 { { "o2" }, "r10" },
2321 { { "o3" }, "r11" },
2322 { { "o4" }, "r12" },
2323 { { "o5" }, "r13" },
2324 { { "o6", "sp" }, "r14" },
2325 { { "o7" }, "r15" },
2326 { { "l0" }, "r16" },
2327 { { "l1" }, "r17" },
2328 { { "l2" }, "r18" },
2329 { { "l3" }, "r19" },
2330 { { "l4" }, "r20" },
2331 { { "l5" }, "r21" },
2332 { { "l6" }, "r22" },
2333 { { "l7" }, "r23" },
2334 { { "i0" }, "r24" },
2335 { { "i1" }, "r25" },
2336 { { "i2" }, "r26" },
2337 { { "i3" }, "r27" },
2338 { { "i4" }, "r28" },
2339 { { "i5" }, "r29" },
2340 { { "i6", "fp" }, "r30" },
2341 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00002342};
2343
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002344void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00002345 unsigned &NumAliases) const {
2346 Aliases = GCCRegAliases;
2347 NumAliases = llvm::array_lengthof(GCCRegAliases);
2348}
Gabor Greif26658672008-02-21 16:29:08 +00002349} // end anonymous namespace.
2350
Eli Friedman01b86682008-08-20 07:28:14 +00002351namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00002352class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
2353public:
2354 AuroraUXSparcV8TargetInfo(const std::string& triple) :
2355 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
2356 SizeType = UnsignedInt;
2357 PtrDiffType = SignedInt;
2358 }
2359};
Torok Edwin5f6c1942009-06-30 17:10:35 +00002360class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00002361public:
2362 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwin5f6c1942009-06-30 17:10:35 +00002363 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00002364 SizeType = UnsignedInt;
2365 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00002366 }
2367};
2368} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00002369
Chris Lattner2621fd12008-05-08 05:58:21 +00002370namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002371 class MSP430TargetInfo : public TargetInfo {
2372 static const char * const GCCRegNames[];
2373 public:
2374 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
2375 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00002376 IntWidth = 16; IntAlign = 16;
2377 LongWidth = 32; LongLongWidth = 64;
2378 LongAlign = LongLongAlign = 16;
2379 PointerWidth = 16; PointerAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002380 SizeType = UnsignedInt;
2381 IntMaxType = SignedLong;
2382 UIntMaxType = UnsignedLong;
2383 IntPtrType = SignedShort;
2384 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00002385 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00002386 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002387 }
2388 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002389 MacroBuilder &Builder) const {
2390 Builder.defineMacro("MSP430");
2391 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002392 // FIXME: defines for different 'flavours' of MCU
2393 }
2394 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2395 unsigned &NumRecords) const {
2396 // FIXME: Implement.
2397 Records = 0;
2398 NumRecords = 0;
2399 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002400 virtual void getGCCRegNames(const char * const *&Names,
2401 unsigned &NumNames) const;
2402 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2403 unsigned &NumAliases) const {
2404 // No aliases.
2405 Aliases = 0;
2406 NumAliases = 0;
2407 }
2408 virtual bool validateAsmConstraint(const char *&Name,
2409 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00002410 // No target constraints for now.
2411 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002412 }
2413 virtual const char *getClobbers() const {
2414 // FIXME: Is this really right?
2415 return "";
2416 }
2417 virtual const char *getVAListDeclaration() const {
2418 // FIXME: implement
Anton Korobeynikoveb716852009-05-08 18:24:57 +00002419 return "typedef char* __builtin_va_list;";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002420 }
2421 };
2422
2423 const char * const MSP430TargetInfo::GCCRegNames[] = {
2424 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2425 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2426 };
2427
2428 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
2429 unsigned &NumNames) const {
2430 Names = GCCRegNames;
2431 NumNames = llvm::array_lengthof(GCCRegNames);
2432 }
2433}
2434
2435
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002436namespace {
2437 class SystemZTargetInfo : public TargetInfo {
2438 static const char * const GCCRegNames[];
2439 public:
2440 SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
2441 TLSSupported = false;
2442 IntWidth = IntAlign = 32;
2443 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
2444 PointerWidth = PointerAlign = 64;
Chris Lattner1932e122009-11-07 18:59:41 +00002445 DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
2446 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002447 }
2448 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002449 MacroBuilder &Builder) const {
2450 Builder.defineMacro("__s390__");
2451 Builder.defineMacro("__s390x__");
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002452 }
2453 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2454 unsigned &NumRecords) const {
2455 // FIXME: Implement.
2456 Records = 0;
2457 NumRecords = 0;
2458 }
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002459
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002460 virtual void getGCCRegNames(const char * const *&Names,
2461 unsigned &NumNames) const;
2462 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2463 unsigned &NumAliases) const {
2464 // No aliases.
2465 Aliases = 0;
2466 NumAliases = 0;
2467 }
2468 virtual bool validateAsmConstraint(const char *&Name,
2469 TargetInfo::ConstraintInfo &info) const {
2470 // FIXME: implement
2471 return true;
2472 }
2473 virtual const char *getClobbers() const {
2474 // FIXME: Is this really right?
2475 return "";
2476 }
2477 virtual const char *getVAListDeclaration() const {
2478 // FIXME: implement
2479 return "typedef char* __builtin_va_list;";
2480 }
2481 };
2482
2483 const char * const SystemZTargetInfo::GCCRegNames[] = {
2484 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2485 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2486 };
2487
2488 void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
2489 unsigned &NumNames) const {
2490 Names = GCCRegNames;
2491 NumNames = llvm::array_lengthof(GCCRegNames);
2492 }
2493}
2494
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002495namespace {
2496 class BlackfinTargetInfo : public TargetInfo {
2497 static const char * const GCCRegNames[];
2498 public:
2499 BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
2500 TLSSupported = false;
2501 DoubleAlign = 32;
2502 LongLongAlign = 32;
2503 LongDoubleAlign = 32;
Chris Lattner1932e122009-11-07 18:59:41 +00002504 DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002505 }
2506
2507 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002508 MacroBuilder &Builder) const {
2509 DefineStd(Builder, "bfin", Opts);
2510 DefineStd(Builder, "BFIN", Opts);
2511 Builder.defineMacro("__ADSPBLACKFIN__");
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002512 // FIXME: This one is really dependent on -mcpu
Benjamin Kramera9992772010-01-09 17:55:51 +00002513 Builder.defineMacro("__ADSPLPBLACKFIN__");
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002514 // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
2515 }
2516
2517 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2518 unsigned &NumRecords) const {
2519 // FIXME: Implement.
2520 Records = 0;
2521 NumRecords = 0;
2522 }
2523
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002524 virtual void getGCCRegNames(const char * const *&Names,
2525 unsigned &NumNames) const;
2526
2527 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2528 unsigned &NumAliases) const {
2529 // No aliases.
2530 Aliases = 0;
2531 NumAliases = 0;
2532 }
2533
2534 virtual bool validateAsmConstraint(const char *&Name,
2535 TargetInfo::ConstraintInfo &Info) const {
2536 if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
2537 Info.setAllowsRegister();
2538 return true;
2539 }
2540 return false;
2541 }
2542
2543 virtual const char *getClobbers() const {
2544 return "";
2545 }
2546
2547 virtual const char *getVAListDeclaration() const {
2548 return "typedef char* __builtin_va_list;";
2549 }
2550 };
2551
2552 const char * const BlackfinTargetInfo::GCCRegNames[] = {
2553 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2554 "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
2555 "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
2556 "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
2557 "a0", "a1", "cc",
2558 "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
2559 "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
2560 };
2561
2562 void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
2563 unsigned &NumNames) const {
2564 Names = GCCRegNames;
2565 NumNames = llvm::array_lengthof(GCCRegNames);
2566 }
2567}
2568
Eli Friedmanb63decf2009-08-19 20:47:07 +00002569namespace {
2570
Mike Stump1eb44332009-09-09 15:08:12 +00002571 // LLVM and Clang cannot be used directly to output native binaries for
2572 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00002573 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00002574 //
2575 // TCE uses the llvm bitcode as input and uses it for generating customized
2576 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00002577 // publicly available in http://tce.cs.tut.fi
2578
2579 class TCETargetInfo : public TargetInfo{
2580 public:
2581 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
2582 TLSSupported = false;
2583 IntWidth = 32;
2584 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00002585 PointerWidth = 32;
2586 IntAlign = 32;
2587 LongAlign = LongLongAlign = 32;
2588 PointerAlign = 32;
2589 SizeType = UnsignedInt;
2590 IntMaxType = SignedLong;
2591 UIntMaxType = UnsignedLong;
2592 IntPtrType = SignedInt;
2593 PtrDiffType = SignedInt;
2594 FloatWidth = 32;
2595 FloatAlign = 32;
2596 DoubleWidth = 32;
2597 DoubleAlign = 32;
2598 LongDoubleWidth = 32;
2599 LongDoubleAlign = 32;
2600 FloatFormat = &llvm::APFloat::IEEEsingle;
2601 DoubleFormat = &llvm::APFloat::IEEEsingle;
2602 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00002603 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
2604 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00002605 "f32:32:32-f64:32:32-v64:32:32-"
2606 "v128:32:32-a0:0:32-n32";
Eli Friedmanb63decf2009-08-19 20:47:07 +00002607 }
2608
2609 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002610 MacroBuilder &Builder) const {
2611 DefineStd(Builder, "tce", Opts);
2612 Builder.defineMacro("__TCE__");
2613 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00002614 }
2615 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2616 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00002617 virtual const char *getClobbers() const {
2618 return "";
2619 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00002620 virtual const char *getVAListDeclaration() const {
2621 return "typedef void* __builtin_va_list;";
2622 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00002623 virtual void getGCCRegNames(const char * const *&Names,
2624 unsigned &NumNames) const {}
2625 virtual bool validateAsmConstraint(const char *&Name,
2626 TargetInfo::ConstraintInfo &info) const {
2627 return true;
2628 }
2629 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2630 unsigned &NumAliases) const {}
2631 };
2632}
2633
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002634namespace {
2635class MipsTargetInfo : public TargetInfo {
Eric Christophered734732010-03-02 02:41:08 +00002636 std::string ABI, CPU;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002637 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2638 static const char * const GCCRegNames[];
2639public:
Eric Christophered734732010-03-02 02:41:08 +00002640 MipsTargetInfo(const std::string& triple) : TargetInfo(triple), ABI("o32") {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002641 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanaka619e8872011-06-02 00:09:17 +00002642 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
2643 SizeType = UnsignedInt;
2644 PtrDiffType = SignedInt;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002645 }
Eric Christophered734732010-03-02 02:41:08 +00002646 virtual const char *getABI() const { return ABI.c_str(); }
2647 virtual bool setABI(const std::string &Name) {
2648
2649 if ((Name == "o32") || (Name == "eabi")) {
2650 ABI = Name;
2651 return true;
2652 } else
2653 return false;
2654 }
2655 virtual bool setCPU(const std::string &Name) {
2656 CPU = Name;
2657 return true;
2658 }
2659 void getDefaultFeatures(const std::string &CPU,
2660 llvm::StringMap<bool> &Features) const {
2661 Features[ABI] = true;
2662 Features[CPU] = true;
2663 }
2664 virtual void getArchDefines(const LangOptions &Opts,
2665 MacroBuilder &Builder) const {
2666 if (ABI == "o32")
2667 Builder.defineMacro("__mips_o32");
2668 else if (ABI == "eabi")
2669 Builder.defineMacro("__mips_eabi");
2670 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002671 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002672 MacroBuilder &Builder) const {
2673 DefineStd(Builder, "mips", Opts);
2674 Builder.defineMacro("_mips");
2675 DefineStd(Builder, "MIPSEB", Opts);
2676 Builder.defineMacro("_MIPSEB");
2677 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christophered734732010-03-02 02:41:08 +00002678 getArchDefines(Opts, Builder);
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002679 }
2680 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2681 unsigned &NumRecords) const {
2682 // FIXME: Implement!
2683 }
2684 virtual const char *getVAListDeclaration() const {
2685 return "typedef void* __builtin_va_list;";
2686 }
2687 virtual void getGCCRegNames(const char * const *&Names,
2688 unsigned &NumNames) const;
2689 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2690 unsigned &NumAliases) const;
2691 virtual bool validateAsmConstraint(const char *&Name,
2692 TargetInfo::ConstraintInfo &Info) const {
2693 switch (*Name) {
2694 default:
2695 case 'r': // CPU registers.
2696 case 'd': // Equivalent to "r" unless generating MIPS16 code.
2697 case 'y': // Equivalent to "r", backwards compatibility only.
2698 case 'f': // floating-point registers.
2699 Info.setAllowsRegister();
2700 return true;
2701 }
2702 return false;
2703 }
2704
2705 virtual const char *getClobbers() const {
2706 // FIXME: Implement!
2707 return "";
2708 }
2709};
2710
2711const char * const MipsTargetInfo::GCCRegNames[] = {
Michael J. Spencer20249a12010-10-21 03:16:25 +00002712 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002713 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
2714 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
2715 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
2716 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
2717 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
2718 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
2719 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
2720 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
2721 "$fcc5","$fcc6","$fcc7"
2722};
2723
2724void MipsTargetInfo::getGCCRegNames(const char * const *&Names,
2725 unsigned &NumNames) const {
2726 Names = GCCRegNames;
2727 NumNames = llvm::array_lengthof(GCCRegNames);
2728}
2729
2730const TargetInfo::GCCRegAlias MipsTargetInfo::GCCRegAliases[] = {
2731 { { "at" }, "$1" },
2732 { { "v0" }, "$2" },
2733 { { "v1" }, "$3" },
2734 { { "a0" }, "$4" },
2735 { { "a1" }, "$5" },
2736 { { "a2" }, "$6" },
2737 { { "a3" }, "$7" },
2738 { { "t0" }, "$8" },
2739 { { "t1" }, "$9" },
2740 { { "t2" }, "$10" },
2741 { { "t3" }, "$11" },
2742 { { "t4" }, "$12" },
2743 { { "t5" }, "$13" },
2744 { { "t6" }, "$14" },
2745 { { "t7" }, "$15" },
2746 { { "s0" }, "$16" },
2747 { { "s1" }, "$17" },
2748 { { "s2" }, "$18" },
2749 { { "s3" }, "$19" },
2750 { { "s4" }, "$20" },
2751 { { "s5" }, "$21" },
2752 { { "s6" }, "$22" },
2753 { { "s7" }, "$23" },
2754 { { "t8" }, "$24" },
2755 { { "t9" }, "$25" },
2756 { { "k0" }, "$26" },
2757 { { "k1" }, "$27" },
2758 { { "gp" }, "$28" },
2759 { { "sp" }, "$29" },
2760 { { "fp" }, "$30" },
2761 { { "ra" }, "$31" }
2762};
2763
2764void MipsTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2765 unsigned &NumAliases) const {
2766 Aliases = GCCRegAliases;
2767 NumAliases = llvm::array_lengthof(GCCRegAliases);
2768}
2769} // end anonymous namespace.
2770
2771namespace {
2772class MipselTargetInfo : public MipsTargetInfo {
2773public:
2774 MipselTargetInfo(const std::string& triple) : MipsTargetInfo(triple) {
2775 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanaka619e8872011-06-02 00:09:17 +00002776 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002777 }
2778
2779 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002780 MacroBuilder &Builder) const;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002781};
2782
2783void MipselTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002784 MacroBuilder &Builder) const {
2785 DefineStd(Builder, "mips", Opts);
2786 Builder.defineMacro("_mips");
2787 DefineStd(Builder, "MIPSEL", Opts);
2788 Builder.defineMacro("_MIPSEL");
2789 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christophered734732010-03-02 02:41:08 +00002790 getArchDefines(Opts, Builder);
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002791}
2792} // end anonymous namespace.
2793
Reid Spencer5f016e22007-07-11 17:01:13 +00002794//===----------------------------------------------------------------------===//
2795// Driver code
2796//===----------------------------------------------------------------------===//
2797
Daniel Dunbard58c03f2009-11-15 06:48:46 +00002798static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002799 llvm::Triple Triple(T);
2800 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00002801
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002802 switch (Triple.getArch()) {
2803 default:
2804 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00002805
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002806 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00002807 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00002808 if (Triple.isOSDarwin())
2809 return new DarwinARMTargetInfo(T);
2810
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002811 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00002812 case llvm::Triple::Linux:
2813 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002814 case llvm::Triple::FreeBSD:
Torok Edwin5f6c1942009-06-30 17:10:35 +00002815 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00002816 case llvm::Triple::RTEMS:
2817 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002818 default:
2819 return new ARMTargetInfo(T);
2820 }
Eli Friedman61538a72008-05-20 14:21:01 +00002821
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002822 case llvm::Triple::bfin:
Douglas Gregordca52262011-07-01 22:41:14 +00002823 if ( os == llvm::Triple::RTEMS )
2824 return new RTEMSTargetInfo<BlackfinTargetInfo>(T);
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002825 return new BlackfinTargetInfo(T);
2826
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002827 case llvm::Triple::msp430:
2828 return new MSP430TargetInfo(T);
Eli Friedman61538a72008-05-20 14:21:01 +00002829
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002830 case llvm::Triple::mips:
2831 if (os == llvm::Triple::Psp)
2832 return new PSPTargetInfo<MipsTargetInfo>(T);
2833 if (os == llvm::Triple::Linux)
2834 return new LinuxTargetInfo<MipsTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00002835 if (os == llvm::Triple::RTEMS)
2836 return new RTEMSTargetInfo<MipsTargetInfo>(T);
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002837 return new MipsTargetInfo(T);
2838
2839 case llvm::Triple::mipsel:
2840 if (os == llvm::Triple::Psp)
2841 return new PSPTargetInfo<MipselTargetInfo>(T);
2842 if (os == llvm::Triple::Linux)
2843 return new LinuxTargetInfo<MipselTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00002844 if (os == llvm::Triple::RTEMS)
2845 return new RTEMSTargetInfo<MipselTargetInfo>(T);
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002846 return new MipselTargetInfo(T);
2847
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002848 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00002849 if (Triple.isOSDarwin())
Roman Divackyc81f2a22011-01-06 08:27:10 +00002850 return new DarwinPPC32TargetInfo(T);
Chris Lattnere03ae302010-02-16 18:14:57 +00002851 else if (os == llvm::Triple::FreeBSD)
2852 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00002853 if ( os == llvm::Triple::RTEMS )
2854 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002855 return new PPC32TargetInfo(T);
2856
2857 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00002858 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00002859 return new DarwinPPC64TargetInfo(T);
John Thompson3f6918a2009-11-19 17:18:50 +00002860 else if (os == llvm::Triple::Lv2)
2861 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Chris Lattnere03ae302010-02-16 18:14:57 +00002862 else if (os == llvm::Triple::FreeBSD)
2863 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002864 return new PPC64TargetInfo(T);
2865
Justin Holewinski285dc652011-04-20 19:34:15 +00002866 case llvm::Triple::ptx32:
2867 return new PTX32TargetInfo(T);
2868 case llvm::Triple::ptx64:
2869 return new PTX64TargetInfo(T);
2870
Chris Lattner9cbeb632010-03-06 21:21:27 +00002871 case llvm::Triple::mblaze:
2872 return new MBlazeTargetInfo(T);
2873
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002874 case llvm::Triple::sparc:
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00002875 if (os == llvm::Triple::AuroraUX)
2876 return new AuroraUXSparcV8TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002877 if (os == llvm::Triple::Solaris)
2878 return new SolarisSparcV8TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00002879 if ( os == llvm::Triple::RTEMS )
2880 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002881 return new SparcV8TargetInfo(T);
2882
John Thompson3f6918a2009-11-19 17:18:50 +00002883 // FIXME: Need a real SPU target.
2884 case llvm::Triple::cellspu:
2885 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
2886
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002887 case llvm::Triple::systemz:
2888 return new SystemZTargetInfo(T);
2889
Eli Friedmanb63decf2009-08-19 20:47:07 +00002890 case llvm::Triple::tce:
2891 return new TCETargetInfo(T);
2892
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002893 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00002894 if (Triple.isOSDarwin())
2895 return new DarwinI386TargetInfo(T);
2896
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002897 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00002898 case llvm::Triple::AuroraUX:
2899 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002900 case llvm::Triple::Linux:
2901 return new LinuxTargetInfo<X86_32TargetInfo>(T);
2902 case llvm::Triple::DragonFly:
2903 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
2904 case llvm::Triple::NetBSD:
2905 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
2906 case llvm::Triple::OpenBSD:
2907 return new OpenBSDI386TargetInfo(T);
2908 case llvm::Triple::FreeBSD:
2909 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner38e317d2010-07-07 16:01:42 +00002910 case llvm::Triple::Minix:
2911 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002912 case llvm::Triple::Solaris:
2913 return new SolarisTargetInfo<X86_32TargetInfo>(T);
2914 case llvm::Triple::Cygwin:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002915 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002916 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002917 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002918 case llvm::Triple::Win32:
Michael J. Spencera764e832010-10-21 08:22:51 +00002919 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattner86ed3a32010-04-11 19:29:39 +00002920 case llvm::Triple::Haiku:
2921 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00002922 case llvm::Triple::RTEMS:
2923 return new RTEMSX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002924 default:
2925 return new X86_32TargetInfo(T);
2926 }
2927
2928 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00002929 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
2930 return new DarwinX86_64TargetInfo(T);
2931
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002932 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00002933 case llvm::Triple::AuroraUX:
2934 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002935 case llvm::Triple::Linux:
2936 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner7a7ca282010-01-09 05:41:14 +00002937 case llvm::Triple::DragonFly:
2938 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002939 case llvm::Triple::NetBSD:
2940 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
2941 case llvm::Triple::OpenBSD:
2942 return new OpenBSDX86_64TargetInfo(T);
2943 case llvm::Triple::FreeBSD:
2944 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
2945 case llvm::Triple::Solaris:
2946 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00002947 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002948 return new MinGWX86_64TargetInfo(T);
2949 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00002950 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002951 default:
2952 return new X86_64TargetInfo(T);
2953 }
2954 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002955}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00002956
2957/// CreateTargetInfo - Return the target info object for the specified target
2958/// triple.
2959TargetInfo *TargetInfo::CreateTargetInfo(Diagnostic &Diags,
Daniel Dunbarb93292a2009-12-19 03:30:57 +00002960 TargetOptions &Opts) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00002961 llvm::Triple Triple(Opts.Triple);
2962
2963 // Construct the target
2964 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
2965 if (!Target) {
2966 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
2967 return 0;
2968 }
2969
Daniel Dunbareac7c532009-12-18 18:42:37 +00002970 // Set the target CPU if specified.
2971 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
2972 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
2973 return 0;
2974 }
2975
Daniel Dunbard58c03f2009-11-15 06:48:46 +00002976 // Set the target ABI if specified.
2977 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
2978 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
2979 return 0;
2980 }
2981
Charles Davis98b7c5c2010-06-11 01:06:47 +00002982 // Set the target C++ ABI.
John McCallee79a4c2010-08-21 22:46:04 +00002983 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davis98b7c5c2010-06-11 01:06:47 +00002984 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
2985 return 0;
2986 }
2987
Daniel Dunbard58c03f2009-11-15 06:48:46 +00002988 // Compute the default target features, we need the target to handle this
2989 // because features may have dependencies on one another.
2990 llvm::StringMap<bool> Features;
2991 Target->getDefaultFeatures(Opts.CPU, Features);
2992
2993 // Apply the user specified deltas.
2994 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
2995 ie = Opts.Features.end(); it != ie; ++it) {
2996 const char *Name = it->c_str();
2997
2998 // Apply the feature via the target.
2999 if ((Name[0] != '-' && Name[0] != '+') ||
3000 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
3001 Diags.Report(diag::err_target_invalid_feature) << Name;
3002 return 0;
3003 }
3004 }
3005
3006 // Add the features to the compile options.
3007 //
3008 // FIXME: If we are completely confident that we have the right set, we only
3009 // need to pass the minuses.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003010 Opts.Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003011 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
3012 ie = Features.end(); it != ie; ++it)
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003013 Opts.Features.push_back(std::string(it->second ? "+" : "-") + it->first());
3014 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003015
3016 return Target.take();
3017}