blob: cc3dd0a6f6680d8005b8fee1992f09a6ed590488 [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
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000805 switch (getTriple().getOS()) {
806 case llvm::Triple::FreeBSD:
807 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000808 SizeType = UnsignedInt;
809 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +0000810 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000811 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000812 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000813 }
814
815 virtual const char *getVAListDeclaration() const {
816 // This is the ELF definition, and is overridden by the Darwin sub-target
817 return "typedef struct __va_list_tag {"
818 " unsigned char gpr;"
819 " unsigned char fpr;"
820 " unsigned short reserved;"
821 " void* overflow_arg_area;"
822 " void* reg_save_area;"
823 "} __builtin_va_list[1];";
Eli Friedmaned855cb2008-08-21 00:13:15 +0000824 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000825};
826} // end anonymous namespace.
827
828namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000829class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000830public:
Eli Friedmane4277982008-08-20 23:11:40 +0000831 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +0000832 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +0000833 IntMaxType = SignedLong;
834 UIntMaxType = UnsignedLong;
835 Int64Type = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +0000836 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 +0000837 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnerf291b102008-05-09 06:17:04 +0000838 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000839 virtual const char *getVAListDeclaration() const {
840 return "typedef char* __builtin_va_list;";
841 }
Eli Friedmane4277982008-08-20 23:11:40 +0000842};
843} // end anonymous namespace.
844
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000845
846namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +0000847class DarwinPPC32TargetInfo :
848 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000849public:
Roman Divackyc81f2a22011-01-06 08:27:10 +0000850 DarwinPPC32TargetInfo(const std::string& triple)
851 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000852 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +0000853 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
854 }
855 virtual const char *getVAListDeclaration() const {
856 return "typedef char* __builtin_va_list;";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000857 }
858};
859
860class DarwinPPC64TargetInfo :
861 public DarwinTargetInfo<PPC64TargetInfo> {
862public:
863 DarwinPPC64TargetInfo(const std::string& triple)
864 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
865 HasAlignMac68kSupport = true;
866 }
867};
868} // end anonymous namespace.
869
Reid Spencer5f016e22007-07-11 17:01:13 +0000870namespace {
Justin Holewinski285dc652011-04-20 19:34:15 +0000871 class PTXTargetInfo : public TargetInfo {
872 static const char * const GCCRegNames[];
873 static const Builtin::Info BuiltinInfo[];
874 public:
875 PTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
876 TLSSupported = false;
877 LongWidth = LongAlign = 64;
878 }
879 virtual void getTargetDefines(const LangOptions &Opts,
880 MacroBuilder &Builder) const {
881 Builder.defineMacro("__PTX__");
882 }
883 virtual void getTargetBuiltins(const Builtin::Info *&Records,
884 unsigned &NumRecords) const {
885 Records = BuiltinInfo;
886 NumRecords = clang::PTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
887 }
888
889 virtual void getGCCRegNames(const char * const *&Names,
890 unsigned &NumNames) const;
891 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
892 unsigned &NumAliases) const {
893 // No aliases.
894 Aliases = 0;
895 NumAliases = 0;
896 }
897 virtual bool validateAsmConstraint(const char *&Name,
898 TargetInfo::ConstraintInfo &info) const {
899 // FIXME: implement
900 return true;
901 }
902 virtual const char *getClobbers() const {
903 // FIXME: Is this really right?
904 return "";
905 }
906 virtual const char *getVAListDeclaration() const {
907 // FIXME: implement
908 return "typedef char* __builtin_va_list;";
909 }
910 };
911
912 const Builtin::Info PTXTargetInfo::BuiltinInfo[] = {
913#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES, false },
914#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
915 ALL_LANGUAGES, false },
916#include "clang/Basic/BuiltinsPTX.def"
917 };
918
919 const char * const PTXTargetInfo::GCCRegNames[] = {
920 "r0"
921 };
922
923 void PTXTargetInfo::getGCCRegNames(const char * const *&Names,
924 unsigned &NumNames) const {
925 Names = GCCRegNames;
926 NumNames = llvm::array_lengthof(GCCRegNames);
927 }
928
929
930 class PTX32TargetInfo : public PTXTargetInfo {
931 public:
932 PTX32TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
933 PointerWidth = PointerAlign = 32;
934 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
935 DescriptionString
936 = "e-p:32:32-i64:64:64-f64:64:64-n1:8:16:32:64";
937 }
938 };
939
940 class PTX64TargetInfo : public PTXTargetInfo {
941 public:
942 PTX64TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
943 PointerWidth = PointerAlign = 64;
944 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
945 DescriptionString
946 = "e-p:64:64-i64:64:64-f64:64:64-n1:8:16:32:64";
947 }
948 };
949}
950
951namespace {
Chris Lattner9cbeb632010-03-06 21:21:27 +0000952// MBlaze abstract base class
953class MBlazeTargetInfo : public TargetInfo {
954 static const char * const GCCRegNames[];
955 static const TargetInfo::GCCRegAlias GCCRegAliases[];
956
957public:
958 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +0000959 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner9cbeb632010-03-06 21:21:27 +0000960 }
961
962 virtual void getTargetBuiltins(const Builtin::Info *&Records,
963 unsigned &NumRecords) const {
964 // FIXME: Implement.
965 Records = 0;
966 NumRecords = 0;
967 }
968
969 virtual void getTargetDefines(const LangOptions &Opts,
970 MacroBuilder &Builder) const;
971
972 virtual const char *getVAListDeclaration() const {
973 return "typedef char* __builtin_va_list;";
974 }
975 virtual const char *getTargetPrefix() const {
976 return "mblaze";
977 }
978 virtual void getGCCRegNames(const char * const *&Names,
979 unsigned &NumNames) const;
980 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
981 unsigned &NumAliases) const;
982 virtual bool validateAsmConstraint(const char *&Name,
983 TargetInfo::ConstraintInfo &Info) const {
984 switch (*Name) {
985 default: return false;
986 case 'O': // Zero
987 return true;
988 case 'b': // Base register
989 case 'f': // Floating point register
990 Info.setAllowsRegister();
991 return true;
992 }
993 }
994 virtual const char *getClobbers() const {
995 return "";
996 }
997};
998
999/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1000/// #defines that are not tied to a specific subtarget.
1001void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1002 MacroBuilder &Builder) const {
1003 // Target identification.
1004 Builder.defineMacro("__microblaze__");
1005 Builder.defineMacro("_ARCH_MICROBLAZE");
1006 Builder.defineMacro("__MICROBLAZE__");
1007
1008 // Target properties.
1009 Builder.defineMacro("_BIG_ENDIAN");
1010 Builder.defineMacro("__BIG_ENDIAN__");
1011
1012 // Subtarget options.
1013 Builder.defineMacro("__REGISTER_PREFIX__", "");
1014}
1015
1016
1017const char * const MBlazeTargetInfo::GCCRegNames[] = {
1018 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1019 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1020 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1021 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1022 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1023 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1024 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1025 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1026 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1027 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1028};
1029
1030void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1031 unsigned &NumNames) const {
1032 Names = GCCRegNames;
1033 NumNames = llvm::array_lengthof(GCCRegNames);
1034}
1035
1036const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1037 { {"f0"}, "r0" },
1038 { {"f1"}, "r1" },
1039 { {"f2"}, "r2" },
1040 { {"f3"}, "r3" },
1041 { {"f4"}, "r4" },
1042 { {"f5"}, "r5" },
1043 { {"f6"}, "r6" },
1044 { {"f7"}, "r7" },
1045 { {"f8"}, "r8" },
1046 { {"f9"}, "r9" },
1047 { {"f10"}, "r10" },
1048 { {"f11"}, "r11" },
1049 { {"f12"}, "r12" },
1050 { {"f13"}, "r13" },
1051 { {"f14"}, "r14" },
1052 { {"f15"}, "r15" },
1053 { {"f16"}, "r16" },
1054 { {"f17"}, "r17" },
1055 { {"f18"}, "r18" },
1056 { {"f19"}, "r19" },
1057 { {"f20"}, "r20" },
1058 { {"f21"}, "r21" },
1059 { {"f22"}, "r22" },
1060 { {"f23"}, "r23" },
1061 { {"f24"}, "r24" },
1062 { {"f25"}, "r25" },
1063 { {"f26"}, "r26" },
1064 { {"f27"}, "r27" },
1065 { {"f28"}, "r28" },
1066 { {"f29"}, "r29" },
1067 { {"f30"}, "r30" },
1068 { {"f31"}, "r31" },
1069};
1070
1071void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1072 unsigned &NumAliases) const {
1073 Aliases = GCCRegAliases;
1074 NumAliases = llvm::array_lengthof(GCCRegAliases);
1075}
1076} // end anonymous namespace.
1077
1078namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001079// Namespace for x86 abstract base class
1080const Builtin::Info BuiltinInfo[] = {
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001081#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES, false },
1082#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1083 ALL_LANGUAGES, false },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001084#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001085};
Eli Friedman61538a72008-05-20 14:21:01 +00001086
Nuno Lopes2550d702009-12-23 17:49:57 +00001087static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001088 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1089 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
1090 "argp", "flags", "fspr", "dirflag", "frame",
1091 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1092 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1093 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001094 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001095};
1096
Eric Christophercfd323d2011-06-21 00:05:20 +00001097const TargetInfo::AddlRegName AddlRegNames[] = {
1098 { { "al", "ah", "eax", "rax" }, 0 },
1099 { { "bl", "bh", "ebx", "rbx" }, 3 },
1100 { { "cl", "ch", "ecx", "rcx" }, 2 },
1101 { { "dl", "dh", "edx", "rdx" }, 1 },
1102 { { "esi", "rsi" }, 4 },
1103 { { "edi", "rdi" }, 5 },
1104 { { "esp", "rsp" }, 7 },
1105 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001106};
1107
1108// X86 target abstract base class; x86-32 and x86-64 are very close, so
1109// most of the implementation can be shared.
1110class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001111 enum X86SSEEnum {
1112 NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
1113 } SSELevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001114 enum AMD3DNowEnum {
1115 NoAMD3DNow, AMD3DNow, AMD3DNowAthlon
1116 } AMD3DNowLevel;
1117
Eric Christophereea12d12010-04-02 23:50:19 +00001118 bool HasAES;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001119 bool HasAVX;
1120
Eli Friedman618234a2008-08-20 02:34:37 +00001121public:
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001122 X86TargetInfo(const std::string& triple)
Eric Christophereea12d12010-04-02 23:50:19 +00001123 : TargetInfo(triple), SSELevel(NoMMXSSE), AMD3DNowLevel(NoAMD3DNow),
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001124 HasAES(false), HasAVX(false) {
Eli Friedman618234a2008-08-20 02:34:37 +00001125 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001126 }
1127 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1128 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001129 Records = BuiltinInfo;
1130 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001131 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001132 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001133 unsigned &NumNames) const {
1134 Names = GCCRegNames;
1135 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001136 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001137 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001138 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001139 Aliases = 0;
1140 NumAliases = 0;
1141 }
1142 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1143 unsigned &NumNames) const {
1144 Names = AddlRegNames;
1145 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001146 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001147 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001148 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001149 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001150 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001151 return "~{dirflag},~{fpsr},~{flags}";
1152 }
Chris Lattner33328642009-03-20 15:52:06 +00001153 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001154 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001155 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1156 const std::string &Name,
1157 bool Enabled) const;
Mike Stump1eb44332009-09-09 15:08:12 +00001158 virtual void getDefaultFeatures(const std::string &CPU,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001159 llvm::StringMap<bool> &Features) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001160 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Reid Spencer5f016e22007-07-11 17:01:13 +00001161};
Chris Lattner3daed522009-03-02 22:20:04 +00001162
Mike Stump1eb44332009-09-09 15:08:12 +00001163void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001164 llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001165 // FIXME: This should not be here.
1166 Features["3dnow"] = false;
1167 Features["3dnowa"] = false;
1168 Features["mmx"] = false;
1169 Features["sse"] = false;
1170 Features["sse2"] = false;
1171 Features["sse3"] = false;
1172 Features["ssse3"] = false;
1173 Features["sse41"] = false;
1174 Features["sse42"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001175 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001176 Features["avx"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001177
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001178 // LLVM does not currently recognize this.
1179 // Features["sse4a"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001180
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001181 // FIXME: This *really* should not be here.
1182
1183 // X86_64 always has SSE2.
1184 if (PointerWidth == 64)
1185 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1186
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001187 if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
1188 CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
1189 ;
1190 else if (CPU == "pentium-mmx" || CPU == "pentium2")
1191 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001192 else if (CPU == "pentium3")
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001193 setFeatureEnabled(Features, "sse", true);
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001194 else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64")
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001195 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001196 else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona")
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001197 setFeatureEnabled(Features, "sse3", true);
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001198 else if (CPU == "core2")
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001199 setFeatureEnabled(Features, "ssse3", true);
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001200 else if (CPU == "penryn") {
1201 setFeatureEnabled(Features, "sse4", true);
1202 Features["sse42"] = false;
1203 } else if (CPU == "atom")
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001204 setFeatureEnabled(Features, "sse3", true);
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001205 else if (CPU == "corei7") {
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001206 setFeatureEnabled(Features, "sse4", true);
Eric Christophereea12d12010-04-02 23:50:19 +00001207 setFeatureEnabled(Features, "aes", true);
Benjamin Kramerb65b6722011-05-20 15:11:23 +00001208 } else if (CPU == "corei7-avx") {
Roman Divackybcaa3b82011-04-05 20:32:44 +00001209 setFeatureEnabled(Features, "sse4", true);
1210 setFeatureEnabled(Features, "aes", true);
1211// setFeatureEnabled(Features, "avx", true);
1212 } else if (CPU == "k6" || CPU == "winchip-c6")
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001213 setFeatureEnabled(Features, "mmx", true);
Mike Stump1eb44332009-09-09 15:08:12 +00001214 else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001215 CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
1216 setFeatureEnabled(Features, "mmx", true);
1217 setFeatureEnabled(Features, "3dnow", true);
1218 } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
1219 setFeatureEnabled(Features, "sse", true);
1220 setFeatureEnabled(Features, "3dnowa", true);
1221 } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
1222 CPU == "athlon-fx") {
Mike Stump1eb44332009-09-09 15:08:12 +00001223 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001224 setFeatureEnabled(Features, "3dnowa", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00001225 } else if (CPU == "k8-sse3") {
1226 setFeatureEnabled(Features, "sse3", true);
1227 setFeatureEnabled(Features, "3dnowa", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001228 } else if (CPU == "c3-2")
1229 setFeatureEnabled(Features, "sse", true);
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001230}
1231
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001232bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump1eb44332009-09-09 15:08:12 +00001233 const std::string &Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001234 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00001235 // FIXME: This *really* should not be here. We need some way of translating
1236 // options into llvm subtarget features.
1237 if (!Features.count(Name) &&
1238 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001239 return false;
1240
1241 if (Enabled) {
1242 if (Name == "mmx")
1243 Features["mmx"] = true;
1244 else if (Name == "sse")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001245 Features["mmx"] = Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001246 else if (Name == "sse2")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001247 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001248 else if (Name == "sse3")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001249 Features["mmx"] = Features["sse"] = Features["sse2"] =
1250 Features["sse3"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001251 else if (Name == "ssse3")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001252 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001253 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001254 else if (Name == "sse4" || Name == "sse4.2")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001255 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001256 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001257 else if (Name == "sse4.1")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001258 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00001259 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001260 else if (Name == "3dnow")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001261 Features["3dnowa"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001262 else if (Name == "3dnowa")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001263 Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00001264 else if (Name == "aes")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001265 Features["aes"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001266 else if (Name == "avx")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001267 Features["avx"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001268 } else {
1269 if (Name == "mmx")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001270 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] =
1271 Features["sse"] = Features["sse2"] = Features["sse3"] =
1272 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001273 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00001274 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001275 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001276 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00001277 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001278 Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001279 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00001280 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001281 Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001282 else if (Name == "ssse3")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001283 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00001284 else if (Name == "sse4" || Name == "sse4.1")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001285 Features["sse41"] = Features["sse42"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00001286 else if (Name == "sse4.2")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001287 Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001288 else if (Name == "3dnow")
1289 Features["3dnow"] = Features["3dnowa"] = false;
1290 else if (Name == "3dnowa")
1291 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001292 else if (Name == "aes")
1293 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001294 else if (Name == "avx")
1295 Features["avx"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001296 }
1297
1298 return true;
1299}
1300
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001301/// HandleTargetOptions - Perform initialization based on the user
1302/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001303void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001304 // Remember the maximum enabled sselevel.
1305 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1306 // Ignore disabled features.
1307 if (Features[i][0] == '-')
1308 continue;
1309
Eric Christophereea12d12010-04-02 23:50:19 +00001310 if (Features[i].substr(1) == "aes") {
1311 HasAES = true;
1312 continue;
1313 }
1314
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001315 // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1316 // For now let it be enabled together with other SSE levels.
1317 if (Features[i].substr(1) == "avx") {
1318 HasAVX = true;
1319 continue;
1320 }
1321
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001322 assert(Features[i][0] == '+' && "Invalid target feature!");
1323 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1324 .Case("sse42", SSE42)
1325 .Case("sse41", SSE41)
1326 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00001327 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001328 .Case("sse2", SSE2)
1329 .Case("sse", SSE1)
1330 .Case("mmx", MMX)
1331 .Default(NoMMXSSE);
1332 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001333
1334 AMD3DNowEnum ThreeDNowLevel =
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001335 llvm::StringSwitch<AMD3DNowEnum>(Features[i].substr(1))
1336 .Case("3dnowa", AMD3DNowAthlon)
1337 .Case("3dnow", AMD3DNow)
1338 .Default(NoAMD3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001339
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001340 AMD3DNowLevel = std::max(AMD3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001341 }
Chris Lattner3daed522009-03-02 22:20:04 +00001342}
Chris Lattnerc0f59212009-03-02 22:27:17 +00001343
1344/// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
1345/// that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00001346void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001347 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00001348 // Target identification.
1349 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00001350 Builder.defineMacro("_LP64");
1351 Builder.defineMacro("__LP64__");
1352 Builder.defineMacro("__amd64__");
1353 Builder.defineMacro("__amd64");
1354 Builder.defineMacro("__x86_64");
1355 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00001356 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00001357 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00001358 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001359
Eric Christophereea12d12010-04-02 23:50:19 +00001360 if (HasAES)
1361 Builder.defineMacro("__AES__");
1362
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001363 if (HasAVX)
1364 Builder.defineMacro("__AVX__");
1365
Chris Lattnerc0f59212009-03-02 22:27:17 +00001366 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00001367 Builder.defineMacro("__LITTLE_ENDIAN__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001368
Chris Lattnerc0f59212009-03-02 22:27:17 +00001369 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +00001370 Builder.defineMacro("__nocona");
1371 Builder.defineMacro("__nocona__");
1372 Builder.defineMacro("__tune_nocona__");
1373 Builder.defineMacro("__REGISTER_PREFIX__", "");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001374
Chris Lattner54175442009-04-19 17:32:33 +00001375 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1376 // functions in glibc header files that use FP Stack inline asm which the
1377 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00001378 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001379
Chris Lattner84f0ea82009-03-02 22:40:39 +00001380 // Each case falls through to the previous one here.
1381 switch (SSELevel) {
1382 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00001383 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001384 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00001385 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001386 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00001387 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001388 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00001389 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001390 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00001391 Builder.defineMacro("__SSE2__");
1392 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00001393 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00001394 Builder.defineMacro("__SSE__");
1395 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00001396 case MMX:
Benjamin Kramera9992772010-01-09 17:55:51 +00001397 Builder.defineMacro("__MMX__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001398 case NoMMXSSE:
1399 break;
1400 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00001401
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001402 if (Opts.Microsoft && PointerWidth == 32) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001403 switch (SSELevel) {
Michael J. Spencera764e832010-10-21 08:22:51 +00001404 case SSE42:
1405 case SSE41:
1406 case SSSE3:
1407 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001408 case SSE2:
1409 Builder.defineMacro("_M_IX86_FP", llvm::Twine(2));
1410 break;
1411 case SSE1:
1412 Builder.defineMacro("_M_IX86_FP", llvm::Twine(1));
1413 break;
1414 default:
1415 Builder.defineMacro("_M_IX86_FP", llvm::Twine(0));
1416 }
1417 }
1418
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001419 // Each case falls through to the previous one here.
1420 switch (AMD3DNowLevel) {
1421 case AMD3DNowAthlon:
1422 Builder.defineMacro("__3dNOW_A__");
1423 case AMD3DNow:
1424 Builder.defineMacro("__3dNOW__");
1425 case NoAMD3DNow:
1426 break;
1427 }
Chris Lattnerc0f59212009-03-02 22:27:17 +00001428}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001429
1430
Eli Friedman618234a2008-08-20 02:34:37 +00001431bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001432X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00001433 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001434 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00001435 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00001436 case 'Y': // first letter of a pair:
1437 switch (*(Name+1)) {
1438 default: return false;
1439 case '0': // First SSE register.
1440 case 't': // Any SSE register, when SSE2 is enabled.
1441 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
1442 case 'm': // any MMX register, when inter-unit moves enabled.
1443 break; // falls through to setAllowsRegister.
1444 }
Eli Friedman618234a2008-08-20 02:34:37 +00001445 case 'a': // eax.
1446 case 'b': // ebx.
1447 case 'c': // ecx.
1448 case 'd': // edx.
1449 case 'S': // esi.
1450 case 'D': // edi.
1451 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00001452 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00001453 case 't': // top of floating point stack.
1454 case 'u': // second from top of floating point stack.
1455 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00001456 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00001457 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00001458 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00001459 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
1460 case 'l': // "Index" registers: any general register that can be used as an
1461 // index in a base+index memory access.
1462 Info.setAllowsRegister();
1463 return true;
1464 case 'C': // SSE floating point constant.
1465 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001466 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00001467 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001468 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00001469 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00001470 return true;
1471 }
Dale Johannesen545be512010-08-24 22:33:12 +00001472 return false;
Eli Friedman618234a2008-08-20 02:34:37 +00001473}
1474
Dale Johannesenf6e2c202010-10-29 23:12:32 +00001475
Eli Friedman618234a2008-08-20 02:34:37 +00001476std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00001477X86TargetInfo::convertConstraint(const char *&Constraint) const {
1478 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00001479 case 'a': return std::string("{ax}");
1480 case 'b': return std::string("{bx}");
1481 case 'c': return std::string("{cx}");
1482 case 'd': return std::string("{dx}");
1483 case 'S': return std::string("{si}");
1484 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00001485 case 'p': // address
1486 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00001487 case 't': // top of floating point stack.
1488 return std::string("{st}");
1489 case 'u': // second from top of floating point stack.
1490 return std::string("{st(1)}"); // second from top of floating point stack.
1491 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00001492 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00001493 }
1494}
Eli Friedman618234a2008-08-20 02:34:37 +00001495} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00001496
1497namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001498// X86-32 generic target
1499class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001500public:
Eli Friedman618234a2008-08-20 02:34:37 +00001501 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1502 DoubleAlign = LongLongAlign = 32;
1503 LongDoubleWidth = 96;
1504 LongDoubleAlign = 32;
Eli Friedmaned855cb2008-08-21 00:13:15 +00001505 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1506 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner1932e122009-11-07 18:59:41 +00001507 "a0:0:64-f80:32:32-n8:16:32";
Eli Friedman1afabd92009-03-29 20:31:09 +00001508 SizeType = UnsignedInt;
1509 PtrDiffType = SignedInt;
1510 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00001511 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00001512
1513 // Use fpret for all types.
1514 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
1515 (1 << TargetInfo::Double) |
1516 (1 << TargetInfo::LongDouble));
Eli Friedman618234a2008-08-20 02:34:37 +00001517 }
1518 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00001519 return "typedef char* __builtin_va_list;";
Eli Friedman618234a2008-08-20 02:34:37 +00001520 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00001521
Chris Lattner21fb98e2009-09-23 06:06:36 +00001522 int getEHDataRegisterNumber(unsigned RegNo) const {
1523 if (RegNo == 0) return 0;
1524 if (RegNo == 1) return 2;
1525 return -1;
1526 }
Eli Friedman618234a2008-08-20 02:34:37 +00001527};
1528} // end anonymous namespace
1529
1530namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00001531class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
1532public:
1533 OpenBSDI386TargetInfo(const std::string& triple) :
1534 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
1535 SizeType = UnsignedLong;
1536 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00001537 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00001538 }
1539};
1540} // end anonymous namespace
1541
1542namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00001543class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00001544public:
Torok Edwin5f6c1942009-06-30 17:10:35 +00001545 DarwinI386TargetInfo(const std::string& triple) :
1546 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00001547 LongDoubleWidth = 128;
1548 LongDoubleAlign = 128;
Eli Friedman1afabd92009-03-29 20:31:09 +00001549 SizeType = UnsignedLong;
1550 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00001551 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1552 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner1932e122009-11-07 18:59:41 +00001553 "a0:0:64-f80:128:128-n8:16:32";
Daniel Dunbar613fd672010-05-27 00:35:16 +00001554 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00001555 }
1556
Eli Friedman618234a2008-08-20 02:34:37 +00001557};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00001558} // end anonymous namespace
1559
1560namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00001561// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001562class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00001563public:
1564 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001565 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00001566 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00001567 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00001568 DoubleAlign = LongLongAlign = 64;
1569 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 +00001570 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
1571 "v128:128:128-a0:0:64-f80:32:32-n8:16:32";
Eli Friedman29a30502008-08-21 01:40:19 +00001572 }
Michael J. Spencera764e832010-10-21 08:22:51 +00001573 virtual void getTargetDefines(const LangOptions &Opts,
1574 MacroBuilder &Builder) const {
1575 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
1576 }
1577};
1578} // end anonymous namespace
1579
1580namespace {
1581
1582// x86-32 Windows Visual Studio target
1583class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
1584public:
1585 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
1586 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00001587 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00001588 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
1589 }
1590 virtual void getTargetDefines(const LangOptions &Opts,
1591 MacroBuilder &Builder) const {
1592 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
1593 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
1594 // The value of the following reflects processor type.
1595 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
1596 // We lost the original triple, so we use the default.
1597 Builder.defineMacro("_M_IX86", "600");
1598 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001599};
1600} // end anonymous namespace
1601
1602namespace {
1603// x86-32 MinGW target
1604class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
1605public:
1606 MinGWX86_32TargetInfo(const std::string& triple)
1607 : WindowsX86_32TargetInfo(triple) {
1608 }
1609 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001610 MacroBuilder &Builder) const {
1611 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00001612 DefineStd(Builder, "WIN32", Opts);
1613 DefineStd(Builder, "WINNT", Opts);
1614 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00001615 Builder.defineMacro("__MSVCRT__");
1616 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00001617
1618 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
1619 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
1620 if (Opts.Microsoft)
1621 // Provide "as-is" __declspec.
1622 Builder.defineMacro("__declspec", "__declspec");
1623 else
1624 // Provide alias of __attribute__ like mingw32-gcc.
1625 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001626 }
1627};
1628} // end anonymous namespace
1629
1630namespace {
1631// x86-32 Cygwin target
1632class CygwinX86_32TargetInfo : public X86_32TargetInfo {
1633public:
1634 CygwinX86_32TargetInfo(const std::string& triple)
1635 : X86_32TargetInfo(triple) {
1636 TLSSupported = false;
1637 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001638 DoubleAlign = LongLongAlign = 64;
1639 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1640 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner1932e122009-11-07 18:59:41 +00001641 "a0:0:64-f80:32:32-n8:16:32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001642 }
1643 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001644 MacroBuilder &Builder) const {
1645 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1646 Builder.defineMacro("__CYGWIN__");
1647 Builder.defineMacro("__CYGWIN32__");
1648 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00001649 if (Opts.CPlusPlus)
1650 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00001651 }
Eli Friedman29a30502008-08-21 01:40:19 +00001652};
1653} // end anonymous namespace
1654
1655namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00001656// x86-32 Haiku target
1657class HaikuX86_32TargetInfo : public X86_32TargetInfo {
1658public:
1659 HaikuX86_32TargetInfo(const std::string& triple)
1660 : X86_32TargetInfo(triple) {
1661 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00001662 IntPtrType = SignedLong;
1663 PtrDiffType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00001664 this->UserLabelPrefix = "";
Eli Friedmana7e68452010-08-22 01:00:03 +00001665 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00001666 virtual void getTargetDefines(const LangOptions &Opts,
1667 MacroBuilder &Builder) const {
1668 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1669 Builder.defineMacro("__INTEL__");
1670 Builder.defineMacro("__HAIKU__");
1671 }
1672};
1673} // end anonymous namespace
1674
Douglas Gregordca52262011-07-01 22:41:14 +00001675// RTEMS Target
1676template<typename Target>
1677class RTEMSTargetInfo : public OSTargetInfo<Target> {
1678protected:
1679 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
1680 MacroBuilder &Builder) const {
1681 // RTEMS defines; list based off of gcc output
1682
1683 // FIXME: Move version number handling to llvm::Triple.
1684 llvm::StringRef Release = Triple.getOSName().substr(strlen("rtems"), 1);
1685
1686 Builder.defineMacro("__rtems__");
1687 Builder.defineMacro("__ELF__");
1688 }
1689public:
1690 RTEMSTargetInfo(const std::string &triple)
1691 : OSTargetInfo<Target>(triple) {
1692 this->UserLabelPrefix = "";
1693
1694 llvm::Triple Triple(triple);
1695 switch (Triple.getArch()) {
1696 default:
1697 case llvm::Triple::x86:
1698 // this->MCountName = ".mcount";
1699 break;
1700 case llvm::Triple::mips:
1701 case llvm::Triple::mipsel:
1702 case llvm::Triple::ppc:
1703 case llvm::Triple::ppc64:
1704 // this->MCountName = "_mcount";
1705 break;
1706 case llvm::Triple::arm:
1707 // this->MCountName = "__mcount";
1708 break;
1709 }
1710
1711 }
1712};
1713
1714namespace {
1715// x86-32 RTEMS target
1716class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
1717public:
1718 RTEMSX86_32TargetInfo(const std::string& triple)
1719 : X86_32TargetInfo(triple) {
1720 SizeType = UnsignedLong;
1721 IntPtrType = SignedLong;
1722 PtrDiffType = SignedLong;
1723 this->UserLabelPrefix = "";
1724 }
1725 virtual void getTargetDefines(const LangOptions &Opts,
1726 MacroBuilder &Builder) const {
1727 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1728 Builder.defineMacro("__INTEL__");
1729 Builder.defineMacro("__rtems__");
1730 }
1731};
1732} // end anonymous namespace
1733
Chris Lattner86ed3a32010-04-11 19:29:39 +00001734namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001735// x86-64 generic target
1736class X86_64TargetInfo : public X86TargetInfo {
1737public:
Chris Lattner33328642009-03-20 15:52:06 +00001738 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00001739 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00001740 LongDoubleWidth = 128;
1741 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00001742 LargeArrayMinWidth = 128;
1743 LargeArrayAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00001744 IntMaxType = SignedLong;
1745 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00001746 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00001747 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00001748
Eli Friedmaned855cb2008-08-21 00:13:15 +00001749 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1750 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner1932e122009-11-07 18:59:41 +00001751 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00001752
1753 // Use fpret only for long double.
1754 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Reid Spencer5f016e22007-07-11 17:01:13 +00001755 }
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001756 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00001757 return "typedef struct __va_list_tag {"
1758 " unsigned gp_offset;"
1759 " unsigned fp_offset;"
1760 " void* overflow_arg_area;"
1761 " void* reg_save_area;"
John McCall2b7baf02010-05-28 18:25:28 +00001762 "} __va_list_tag;"
Eli Friedmandc043162009-07-03 00:45:06 +00001763 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson3346ae62007-11-24 23:38:12 +00001764 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00001765
Chris Lattner21fb98e2009-09-23 06:06:36 +00001766 int getEHDataRegisterNumber(unsigned RegNo) const {
1767 if (RegNo == 0) return 0;
1768 if (RegNo == 1) return 1;
1769 return -1;
1770 }
Eli Friedman618234a2008-08-20 02:34:37 +00001771};
1772} // end anonymous namespace
1773
1774namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001775// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001776class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001777public:
1778 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001779 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001780 TLSSupported = false;
1781 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00001782 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00001783 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00001784 IntMaxType = SignedLongLong;
1785 UIntMaxType = UnsignedLongLong;
1786 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00001787 SizeType = UnsignedLongLong;
1788 PtrDiffType = SignedLongLong;
1789 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00001790 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001791 }
1792 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001793 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001794 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001795 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00001796 }
NAKAMURA Takumi79521992011-01-17 22:56:23 +00001797 virtual const char *getVAListDeclaration() const {
1798 return "typedef char* __builtin_va_list;";
1799 }
Michael J. Spencera764e832010-10-21 08:22:51 +00001800};
1801} // end anonymous namespace
1802
1803namespace {
1804// x86-64 Windows Visual Studio target
1805class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
1806public:
1807 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
1808 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00001809 LongDoubleWidth = LongDoubleAlign = 64;
1810 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00001811 }
1812 virtual void getTargetDefines(const LangOptions &Opts,
1813 MacroBuilder &Builder) const {
1814 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1815 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00001816 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001817 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001818 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001819};
1820} // end anonymous namespace
1821
1822namespace {
1823// x86-64 MinGW target
1824class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
1825public:
1826 MinGWX86_64TargetInfo(const std::string& triple)
1827 : WindowsX86_64TargetInfo(triple) {
1828 }
1829 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001830 MacroBuilder &Builder) const {
1831 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00001832 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00001833 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00001834 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00001835 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00001836
1837 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
1838 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
1839 if (Opts.Microsoft)
1840 // Provide "as-is" __declspec.
1841 Builder.defineMacro("__declspec", "__declspec");
1842 else
1843 // Provide alias of __attribute__ like mingw32-gcc.
1844 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00001845 }
1846};
1847} // end anonymous namespace
1848
1849namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00001850class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
1851public:
Mike Stump1eb44332009-09-09 15:08:12 +00001852 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman3c7b6e42009-07-01 03:36:11 +00001853 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
1854 Int64Type = SignedLongLong;
1855 }
1856};
1857} // end anonymous namespace
1858
1859namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00001860class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
1861public:
Mike Stump1eb44332009-09-09 15:08:12 +00001862 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman6036ebe2009-07-05 22:31:18 +00001863 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
1864 IntMaxType = SignedLongLong;
1865 UIntMaxType = UnsignedLongLong;
1866 Int64Type = SignedLongLong;
1867 }
1868};
1869} // end anonymous namespace
1870
1871namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00001872class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00001873 // Possible FPU choices.
1874 enum FPUMode {
1875 NoFPU,
1876 VFP2FPU,
1877 VFP3FPU,
1878 NeonFPU
1879 };
1880
1881 static bool FPUModeIsVFP(FPUMode Mode) {
1882 return Mode >= VFP2FPU && Mode <= NeonFPU;
1883 }
1884
1885 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1886 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00001887
Daniel Dunbareac7c532009-12-18 18:42:37 +00001888 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00001889
1890 unsigned FPU : 3;
1891
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00001892 unsigned IsThumb : 1;
1893
1894 // Initialized via features.
1895 unsigned SoftFloat : 1;
1896 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00001897
Chris Lattner2752c012010-03-03 19:03:45 +00001898 static const Builtin::Info BuiltinInfo[];
1899
Chris Lattner393ff042008-04-21 18:56:49 +00001900public:
Daniel Dunbare1f63b32009-09-17 16:21:10 +00001901 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbareac7c532009-12-18 18:42:37 +00001902 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00001903 {
Daniel Dunbara2a41612009-09-14 00:02:24 +00001904 SizeType = UnsignedInt;
1905 PtrDiffType = SignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00001906
Chris Lattner9bffb072010-04-23 16:29:58 +00001907 // {} in inline assembly are neon specifiers, not assembly variant
1908 // specifiers.
1909 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00001910
Daniel Dunbareac7c532009-12-18 18:42:37 +00001911 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00001912 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00001913 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00001914 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
1915 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00001916 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1917 "i64:64:64-f32:32:32-f64:64:64-"
Bob Wilsoncd5ce092011-04-04 16:53:11 +00001918 "v64:64:64-v128:64:128-a0:0:32-n32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00001919 } else {
1920 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1921 "i64:64:64-f32:32:32-f64:64:64-"
Bob Wilsoncd5ce092011-04-04 16:53:11 +00001922 "v64:64:64-v128:64:128-a0:0:64-n32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00001923 }
John McCallee79a4c2010-08-21 22:46:04 +00001924
1925 // ARM targets default to using the ARM C++ ABI.
1926 CXXABI = CXXABI_ARM;
Eli Friedman61538a72008-05-20 14:21:01 +00001927 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00001928 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00001929 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00001930 ABI = Name;
1931
Daniel Dunbara2a41612009-09-14 00:02:24 +00001932 // The defaults (above) are for AAPCS, check if we need to change them.
1933 //
1934 // FIXME: We need support for -meabi... we could just mangle it into the
1935 // name.
1936 if (Name == "apcs-gnu") {
Daniel Dunbard410fa22010-01-27 20:23:08 +00001937 DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
Daniel Dunbara2a41612009-09-14 00:02:24 +00001938 SizeType = UnsignedLong;
1939
Daniel Dunbar684de632010-04-22 16:14:54 +00001940 // Do not respect the alignment of bit-field types when laying out
1941 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
1942 UseBitFieldTypeAlignment = false;
1943
Daniel Dunbardff10dc2009-09-22 21:44:58 +00001944 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00001945 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
1946 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00001947 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 +00001948 "i64:32:64-f32:32:32-f64:32:64-"
Bob Wilsoncd5ce092011-04-04 16:53:11 +00001949 "v64:32:64-v128:32:128-a0:0:32-n32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00001950 } else {
1951 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 +00001952 "i64:32:64-f32:32:32-f64:32:64-"
1953 "v64:32:64-v128:32:128-a0:0:32-n32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00001954 }
1955
Daniel Dunbara2a41612009-09-14 00:02:24 +00001956 // FIXME: Override "preferred align" for double and long long.
1957 } else if (Name == "aapcs") {
1958 // FIXME: Enumerated types are variable width in straight AAPCS.
1959 } else if (Name == "aapcs-linux") {
1960 ;
1961 } else
1962 return false;
1963
1964 return true;
1965 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00001966
Daniel Dunbara91320b2009-12-21 23:28:17 +00001967 void getDefaultFeatures(const std::string &CPU,
1968 llvm::StringMap<bool> &Features) const {
1969 // FIXME: This should not be here.
1970 Features["vfp2"] = false;
1971 Features["vfp3"] = false;
1972 Features["neon"] = false;
1973
1974 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
1975 Features["vfp2"] = true;
1976 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
1977 Features["neon"] = true;
1978 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00001979
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00001980 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1981 const std::string &Name,
1982 bool Enabled) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00001983 if (Name == "soft-float" || Name == "soft-float-abi") {
1984 Features[Name] = Enabled;
1985 } else if (Name == "vfp2" || Name == "vfp3" || Name == "neon") {
1986 // These effectively are a single option, reset them when any is enabled.
1987 if (Enabled)
1988 Features["vfp2"] = Features["vfp3"] = Features["neon"] = false;
1989 Features[Name] = Enabled;
1990 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00001991 return false;
1992
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00001993 return true;
1994 }
1995
1996 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbara91320b2009-12-21 23:28:17 +00001997 FPU = NoFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00001998 SoftFloat = SoftFloatABI = false;
1999 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
2000 if (Features[i] == "+soft-float")
2001 SoftFloat = true;
2002 else if (Features[i] == "+soft-float-abi")
2003 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002004 else if (Features[i] == "+vfp2")
2005 FPU = VFP2FPU;
2006 else if (Features[i] == "+vfp3")
2007 FPU = VFP3FPU;
2008 else if (Features[i] == "+neon")
2009 FPU = NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002010 }
2011
2012 // Remove front-end specific options which the backend handles differently.
2013 std::vector<std::string>::iterator it;
2014 it = std::find(Features.begin(), Features.end(), "+soft-float");
2015 if (it != Features.end())
2016 Features.erase(it);
2017 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2018 if (it != Features.end())
2019 Features.erase(it);
2020 }
2021
Daniel Dunbareac7c532009-12-18 18:42:37 +00002022 static const char *getCPUDefineSuffix(llvm::StringRef Name) {
2023 return llvm::StringSwitch<const char*>(Name)
2024 .Cases("arm8", "arm810", "4")
2025 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2026 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2027 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2028 .Case("ep9312", "4T")
2029 .Cases("arm10tdmi", "arm1020t", "5T")
2030 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2031 .Case("arm926ej-s", "5TEJ")
2032 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2033 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002034 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002035 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002036 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002037 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2038 .Cases("cortex-a8", "cortex-a9", "7A")
Bob Wilson06f45632011-01-06 16:57:20 +00002039 .Case("cortex-m3", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00002040 .Case("cortex-m0", "6M")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002041 .Default(0);
2042 }
2043 virtual bool setCPU(const std::string &Name) {
2044 if (!getCPUDefineSuffix(Name))
2045 return false;
2046
2047 CPU = Name;
2048 return true;
2049 }
Chris Lattner33328642009-03-20 15:52:06 +00002050 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002051 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002052 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00002053 Builder.defineMacro("__arm");
2054 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002055
Chris Lattnerc0f59212009-03-02 22:27:17 +00002056 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00002057 Builder.defineMacro("__ARMEL__");
2058 Builder.defineMacro("__LITTLE_ENDIAN__");
2059 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002060
2061 llvm::StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00002062 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002063
Mike Stump437bb4b2009-04-08 02:07:04 +00002064 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002065
Daniel Dunbareac7c532009-12-18 18:42:37 +00002066 // FIXME: It's more complicated than this and we don't really support
2067 // interworking.
2068 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00002069 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002070
Daniel Dunbareac7c532009-12-18 18:42:37 +00002071 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramera9992772010-01-09 17:55:51 +00002072 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002073
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002074 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00002075 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002076
2077 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00002078 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002079
Bob Wilson84f95cf2011-05-13 18:56:03 +00002080 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002081 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002082 Builder.defineMacro("__THUMBEL__");
2083 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00002084 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002085 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002086 }
2087
2088 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00002089 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002090
2091 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramera9992772010-01-09 17:55:51 +00002092 Builder.defineMacro("__VFP_FP__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002093
2094 // This only gets set when Neon instructions are actually available, unlike
2095 // the VFP define, hence the soft float and arch check. This is subtly
2096 // different from gcc, we follow the intent which was that it should be set
2097 // when Neon instructions are actually available.
Bob Wilson84f95cf2011-05-13 18:56:03 +00002098 if (FPU == NeonFPU && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002099 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00002100 }
2101 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2102 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00002103 Records = BuiltinInfo;
2104 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00002105 }
2106 virtual const char *getVAListDeclaration() const {
John McCall0e9972c2011-05-09 02:19:37 +00002107 return "typedef void* __builtin_va_list;";
Chris Lattner393ff042008-04-21 18:56:49 +00002108 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002109 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002110 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002111 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002112 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002113 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002114 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002115 // FIXME: Check if this is complete
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002116 switch (*Name) {
Eli Friedmana9f54962008-08-20 07:44:10 +00002117 default:
Nate Begemanad487f42008-04-22 05:03:19 +00002118 case 'l': // r0-r7
2119 case 'h': // r8-r15
2120 case 'w': // VFP Floating point register single precision
2121 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00002122 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00002123 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00002124 case 'U': // a memory reference...
2125 switch (Name[1]) {
2126 case 'q': // ...ARMV4 ldrsb
2127 case 'v': // ...VFP load/store (reg+constant offset)
2128 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00002129 case 't': // address valid for load/store opaque types wider
2130 // than 128-bits
2131 case 'n': // valid address for Neon doubleword vector load/store
2132 case 'm': // valid address for Neon element and structure load/store
2133 case 's': // valid address for non-offset loads/stores of quad-word
2134 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00002135 Info.setAllowsMemory();
2136 Name++;
2137 return true;
2138 }
Nate Begemanad487f42008-04-22 05:03:19 +00002139 }
Chris Lattner393ff042008-04-21 18:56:49 +00002140 return false;
2141 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00002142 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00002143 std::string R;
2144 switch (*Constraint) {
2145 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00002146 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00002147 Constraint++;
2148 break;
Eric Christopher283f4472011-06-17 00:40:18 +00002149 case 'p': // 'p' should be translated to 'r' by default.
2150 R = std::string("r");
2151 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00002152 default:
2153 return std::string(1, *Constraint);
2154 }
2155 return R;
2156 }
Chris Lattner393ff042008-04-21 18:56:49 +00002157 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002158 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00002159 return "";
2160 }
2161};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002162
2163const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002164 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002165 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002166 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
2167
2168 // Float registers
2169 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2170 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2171 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002172 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002173
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002174 // Double registers
2175 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
2176 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00002177 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
2178 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002179
2180 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00002181 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
2182 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002183};
2184
2185void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002186 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002187 Names = GCCRegNames;
2188 NumNames = llvm::array_lengthof(GCCRegNames);
2189}
2190
2191const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002192 { { "a1" }, "r0" },
2193 { { "a2" }, "r1" },
2194 { { "a3" }, "r2" },
2195 { { "a4" }, "r3" },
2196 { { "v1" }, "r4" },
2197 { { "v2" }, "r5" },
2198 { { "v3" }, "r6" },
2199 { { "v4" }, "r7" },
2200 { { "v5" }, "r8" },
2201 { { "v6", "rfp" }, "r9" },
2202 { { "sl" }, "r10" },
2203 { { "fp" }, "r11" },
2204 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002205 { { "r13" }, "sp" },
2206 { { "r14" }, "lr" },
2207 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002208 // The S, D and Q registers overlap, but aren't really aliases; we
2209 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002210};
2211
2212void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2213 unsigned &NumAliases) const {
2214 Aliases = GCCRegAliases;
2215 NumAliases = llvm::array_lengthof(GCCRegAliases);
2216}
Chris Lattner2752c012010-03-03 19:03:45 +00002217
2218const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Fariborz Jahanian67aba812010-11-30 17:35:24 +00002219#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES, false },
2220#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
2221 ALL_LANGUAGES, false },
Chris Lattner2752c012010-03-03 19:03:45 +00002222#include "clang/Basic/BuiltinsARM.def"
2223};
Chris Lattner393ff042008-04-21 18:56:49 +00002224} // end anonymous namespace.
2225
Eli Friedmana9f54962008-08-20 07:44:10 +00002226
2227namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00002228class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00002229 public DarwinTargetInfo<ARMTargetInfo> {
2230protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00002231 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00002232 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00002233 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00002234 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002235
Torok Edwin5f6c1942009-06-30 17:10:35 +00002236public:
Mike Stump1eb44332009-09-09 15:08:12 +00002237 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar350b9f32010-05-27 07:00:26 +00002238 : DarwinTargetInfo<ARMTargetInfo>(triple) {
2239 HasAlignMac68kSupport = true;
2240 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002241};
2242} // end anonymous namespace.
2243
Reid Spencer5f016e22007-07-11 17:01:13 +00002244namespace {
Eli Friedman01b86682008-08-20 07:28:14 +00002245class SparcV8TargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00002246 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2247 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002248 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00002249public:
Eli Friedman01b86682008-08-20 07:28:14 +00002250 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
2251 // FIXME: Support Sparc quad-precision long double?
Eli Friedmaned855cb2008-08-21 00:13:15 +00002252 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 +00002253 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedman01b86682008-08-20 07:28:14 +00002254 }
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002255 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2256 const std::string &Name,
2257 bool Enabled) const {
2258 if (Name == "soft-float")
2259 Features[Name] = Enabled;
2260 else
2261 return false;
2262
2263 return true;
2264 }
2265 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
2266 SoftFloat = false;
2267 for (unsigned i = 0, e = Features.size(); i != e; ++i)
2268 if (Features[i] == "+soft-float")
2269 SoftFloat = true;
2270 }
Chris Lattner33328642009-03-20 15:52:06 +00002271 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002272 MacroBuilder &Builder) const {
2273 DefineStd(Builder, "sparc", Opts);
2274 Builder.defineMacro("__sparcv8");
2275 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002276
2277 if (SoftFloat)
2278 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00002279 }
2280 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2281 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00002282 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00002283 }
2284 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002285 return "typedef void* __builtin_va_list;";
Gabor Greif26658672008-02-21 16:29:08 +00002286 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002287 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00002288 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002289 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00002290 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002291 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00002292 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00002293 // FIXME: Implement!
2294 return false;
Gabor Greif26658672008-02-21 16:29:08 +00002295 }
2296 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002297 // FIXME: Implement!
2298 return "";
Gabor Greif26658672008-02-21 16:29:08 +00002299 }
2300};
2301
Chris Lattnere957f532009-01-27 01:58:38 +00002302const char * const SparcV8TargetInfo::GCCRegNames[] = {
2303 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2304 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2305 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2306 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
2307};
2308
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002309void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00002310 unsigned &NumNames) const {
2311 Names = GCCRegNames;
2312 NumNames = llvm::array_lengthof(GCCRegNames);
2313}
2314
2315const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002316 { { "g0" }, "r0" },
2317 { { "g1" }, "r1" },
2318 { { "g2" }, "r2" },
2319 { { "g3" }, "r3" },
2320 { { "g4" }, "r4" },
2321 { { "g5" }, "r5" },
2322 { { "g6" }, "r6" },
2323 { { "g7" }, "r7" },
2324 { { "o0" }, "r8" },
2325 { { "o1" }, "r9" },
2326 { { "o2" }, "r10" },
2327 { { "o3" }, "r11" },
2328 { { "o4" }, "r12" },
2329 { { "o5" }, "r13" },
2330 { { "o6", "sp" }, "r14" },
2331 { { "o7" }, "r15" },
2332 { { "l0" }, "r16" },
2333 { { "l1" }, "r17" },
2334 { { "l2" }, "r18" },
2335 { { "l3" }, "r19" },
2336 { { "l4" }, "r20" },
2337 { { "l5" }, "r21" },
2338 { { "l6" }, "r22" },
2339 { { "l7" }, "r23" },
2340 { { "i0" }, "r24" },
2341 { { "i1" }, "r25" },
2342 { { "i2" }, "r26" },
2343 { { "i3" }, "r27" },
2344 { { "i4" }, "r28" },
2345 { { "i5" }, "r29" },
2346 { { "i6", "fp" }, "r30" },
2347 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00002348};
2349
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002350void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00002351 unsigned &NumAliases) const {
2352 Aliases = GCCRegAliases;
2353 NumAliases = llvm::array_lengthof(GCCRegAliases);
2354}
Gabor Greif26658672008-02-21 16:29:08 +00002355} // end anonymous namespace.
2356
Eli Friedman01b86682008-08-20 07:28:14 +00002357namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00002358class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
2359public:
2360 AuroraUXSparcV8TargetInfo(const std::string& triple) :
2361 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
2362 SizeType = UnsignedInt;
2363 PtrDiffType = SignedInt;
2364 }
2365};
Torok Edwin5f6c1942009-06-30 17:10:35 +00002366class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00002367public:
2368 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwin5f6c1942009-06-30 17:10:35 +00002369 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00002370 SizeType = UnsignedInt;
2371 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00002372 }
2373};
2374} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00002375
Chris Lattner2621fd12008-05-08 05:58:21 +00002376namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002377 class MSP430TargetInfo : public TargetInfo {
2378 static const char * const GCCRegNames[];
2379 public:
2380 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
2381 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00002382 IntWidth = 16; IntAlign = 16;
2383 LongWidth = 32; LongLongWidth = 64;
2384 LongAlign = LongLongAlign = 16;
2385 PointerWidth = 16; PointerAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002386 SizeType = UnsignedInt;
2387 IntMaxType = SignedLong;
2388 UIntMaxType = UnsignedLong;
2389 IntPtrType = SignedShort;
2390 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00002391 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00002392 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002393 }
2394 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002395 MacroBuilder &Builder) const {
2396 Builder.defineMacro("MSP430");
2397 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002398 // FIXME: defines for different 'flavours' of MCU
2399 }
2400 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2401 unsigned &NumRecords) const {
2402 // FIXME: Implement.
2403 Records = 0;
2404 NumRecords = 0;
2405 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002406 virtual void getGCCRegNames(const char * const *&Names,
2407 unsigned &NumNames) const;
2408 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2409 unsigned &NumAliases) const {
2410 // No aliases.
2411 Aliases = 0;
2412 NumAliases = 0;
2413 }
2414 virtual bool validateAsmConstraint(const char *&Name,
2415 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00002416 // No target constraints for now.
2417 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002418 }
2419 virtual const char *getClobbers() const {
2420 // FIXME: Is this really right?
2421 return "";
2422 }
2423 virtual const char *getVAListDeclaration() const {
2424 // FIXME: implement
Anton Korobeynikoveb716852009-05-08 18:24:57 +00002425 return "typedef char* __builtin_va_list;";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002426 }
2427 };
2428
2429 const char * const MSP430TargetInfo::GCCRegNames[] = {
2430 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2431 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2432 };
2433
2434 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
2435 unsigned &NumNames) const {
2436 Names = GCCRegNames;
2437 NumNames = llvm::array_lengthof(GCCRegNames);
2438 }
2439}
2440
2441
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002442namespace {
2443 class SystemZTargetInfo : public TargetInfo {
2444 static const char * const GCCRegNames[];
2445 public:
2446 SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
2447 TLSSupported = false;
2448 IntWidth = IntAlign = 32;
2449 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
2450 PointerWidth = PointerAlign = 64;
Chris Lattner1932e122009-11-07 18:59:41 +00002451 DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
2452 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002453 }
2454 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002455 MacroBuilder &Builder) const {
2456 Builder.defineMacro("__s390__");
2457 Builder.defineMacro("__s390x__");
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002458 }
2459 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2460 unsigned &NumRecords) const {
2461 // FIXME: Implement.
2462 Records = 0;
2463 NumRecords = 0;
2464 }
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002465
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002466 virtual void getGCCRegNames(const char * const *&Names,
2467 unsigned &NumNames) const;
2468 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2469 unsigned &NumAliases) const {
2470 // No aliases.
2471 Aliases = 0;
2472 NumAliases = 0;
2473 }
2474 virtual bool validateAsmConstraint(const char *&Name,
2475 TargetInfo::ConstraintInfo &info) const {
2476 // FIXME: implement
2477 return true;
2478 }
2479 virtual const char *getClobbers() const {
2480 // FIXME: Is this really right?
2481 return "";
2482 }
2483 virtual const char *getVAListDeclaration() const {
2484 // FIXME: implement
2485 return "typedef char* __builtin_va_list;";
2486 }
2487 };
2488
2489 const char * const SystemZTargetInfo::GCCRegNames[] = {
2490 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2491 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2492 };
2493
2494 void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
2495 unsigned &NumNames) const {
2496 Names = GCCRegNames;
2497 NumNames = llvm::array_lengthof(GCCRegNames);
2498 }
2499}
2500
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002501namespace {
2502 class BlackfinTargetInfo : public TargetInfo {
2503 static const char * const GCCRegNames[];
2504 public:
2505 BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
2506 TLSSupported = false;
2507 DoubleAlign = 32;
2508 LongLongAlign = 32;
2509 LongDoubleAlign = 32;
Chris Lattner1932e122009-11-07 18:59:41 +00002510 DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002511 }
2512
2513 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002514 MacroBuilder &Builder) const {
2515 DefineStd(Builder, "bfin", Opts);
2516 DefineStd(Builder, "BFIN", Opts);
2517 Builder.defineMacro("__ADSPBLACKFIN__");
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002518 // FIXME: This one is really dependent on -mcpu
Benjamin Kramera9992772010-01-09 17:55:51 +00002519 Builder.defineMacro("__ADSPLPBLACKFIN__");
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002520 // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
2521 }
2522
2523 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2524 unsigned &NumRecords) const {
2525 // FIXME: Implement.
2526 Records = 0;
2527 NumRecords = 0;
2528 }
2529
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002530 virtual void getGCCRegNames(const char * const *&Names,
2531 unsigned &NumNames) const;
2532
2533 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2534 unsigned &NumAliases) const {
2535 // No aliases.
2536 Aliases = 0;
2537 NumAliases = 0;
2538 }
2539
2540 virtual bool validateAsmConstraint(const char *&Name,
2541 TargetInfo::ConstraintInfo &Info) const {
2542 if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
2543 Info.setAllowsRegister();
2544 return true;
2545 }
2546 return false;
2547 }
2548
2549 virtual const char *getClobbers() const {
2550 return "";
2551 }
2552
2553 virtual const char *getVAListDeclaration() const {
2554 return "typedef char* __builtin_va_list;";
2555 }
2556 };
2557
2558 const char * const BlackfinTargetInfo::GCCRegNames[] = {
2559 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2560 "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
2561 "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
2562 "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
2563 "a0", "a1", "cc",
2564 "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
2565 "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
2566 };
2567
2568 void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
2569 unsigned &NumNames) const {
2570 Names = GCCRegNames;
2571 NumNames = llvm::array_lengthof(GCCRegNames);
2572 }
2573}
2574
Eli Friedmanb63decf2009-08-19 20:47:07 +00002575namespace {
2576
Mike Stump1eb44332009-09-09 15:08:12 +00002577 // LLVM and Clang cannot be used directly to output native binaries for
2578 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00002579 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00002580 //
2581 // TCE uses the llvm bitcode as input and uses it for generating customized
2582 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00002583 // publicly available in http://tce.cs.tut.fi
2584
2585 class TCETargetInfo : public TargetInfo{
2586 public:
2587 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
2588 TLSSupported = false;
2589 IntWidth = 32;
2590 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00002591 PointerWidth = 32;
2592 IntAlign = 32;
2593 LongAlign = LongLongAlign = 32;
2594 PointerAlign = 32;
2595 SizeType = UnsignedInt;
2596 IntMaxType = SignedLong;
2597 UIntMaxType = UnsignedLong;
2598 IntPtrType = SignedInt;
2599 PtrDiffType = SignedInt;
2600 FloatWidth = 32;
2601 FloatAlign = 32;
2602 DoubleWidth = 32;
2603 DoubleAlign = 32;
2604 LongDoubleWidth = 32;
2605 LongDoubleAlign = 32;
2606 FloatFormat = &llvm::APFloat::IEEEsingle;
2607 DoubleFormat = &llvm::APFloat::IEEEsingle;
2608 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00002609 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
2610 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00002611 "f32:32:32-f64:32:32-v64:32:32-"
2612 "v128:32:32-a0:0:32-n32";
Eli Friedmanb63decf2009-08-19 20:47:07 +00002613 }
2614
2615 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002616 MacroBuilder &Builder) const {
2617 DefineStd(Builder, "tce", Opts);
2618 Builder.defineMacro("__TCE__");
2619 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00002620 }
2621 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2622 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00002623 virtual const char *getClobbers() const {
2624 return "";
2625 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00002626 virtual const char *getVAListDeclaration() const {
2627 return "typedef void* __builtin_va_list;";
2628 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00002629 virtual void getGCCRegNames(const char * const *&Names,
2630 unsigned &NumNames) const {}
2631 virtual bool validateAsmConstraint(const char *&Name,
2632 TargetInfo::ConstraintInfo &info) const {
2633 return true;
2634 }
2635 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2636 unsigned &NumAliases) const {}
2637 };
2638}
2639
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002640namespace {
2641class MipsTargetInfo : public TargetInfo {
Eric Christophered734732010-03-02 02:41:08 +00002642 std::string ABI, CPU;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002643 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2644 static const char * const GCCRegNames[];
2645public:
Eric Christophered734732010-03-02 02:41:08 +00002646 MipsTargetInfo(const std::string& triple) : TargetInfo(triple), ABI("o32") {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002647 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 +00002648 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
2649 SizeType = UnsignedInt;
2650 PtrDiffType = SignedInt;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002651 }
Eric Christophered734732010-03-02 02:41:08 +00002652 virtual const char *getABI() const { return ABI.c_str(); }
2653 virtual bool setABI(const std::string &Name) {
2654
2655 if ((Name == "o32") || (Name == "eabi")) {
2656 ABI = Name;
2657 return true;
2658 } else
2659 return false;
2660 }
2661 virtual bool setCPU(const std::string &Name) {
2662 CPU = Name;
2663 return true;
2664 }
2665 void getDefaultFeatures(const std::string &CPU,
2666 llvm::StringMap<bool> &Features) const {
2667 Features[ABI] = true;
2668 Features[CPU] = true;
2669 }
2670 virtual void getArchDefines(const LangOptions &Opts,
2671 MacroBuilder &Builder) const {
2672 if (ABI == "o32")
2673 Builder.defineMacro("__mips_o32");
2674 else if (ABI == "eabi")
2675 Builder.defineMacro("__mips_eabi");
2676 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002677 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002678 MacroBuilder &Builder) const {
2679 DefineStd(Builder, "mips", Opts);
2680 Builder.defineMacro("_mips");
2681 DefineStd(Builder, "MIPSEB", Opts);
2682 Builder.defineMacro("_MIPSEB");
2683 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christophered734732010-03-02 02:41:08 +00002684 getArchDefines(Opts, Builder);
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002685 }
2686 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2687 unsigned &NumRecords) const {
2688 // FIXME: Implement!
2689 }
2690 virtual const char *getVAListDeclaration() const {
2691 return "typedef void* __builtin_va_list;";
2692 }
2693 virtual void getGCCRegNames(const char * const *&Names,
2694 unsigned &NumNames) const;
2695 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2696 unsigned &NumAliases) const;
2697 virtual bool validateAsmConstraint(const char *&Name,
2698 TargetInfo::ConstraintInfo &Info) const {
2699 switch (*Name) {
2700 default:
2701 case 'r': // CPU registers.
2702 case 'd': // Equivalent to "r" unless generating MIPS16 code.
2703 case 'y': // Equivalent to "r", backwards compatibility only.
2704 case 'f': // floating-point registers.
2705 Info.setAllowsRegister();
2706 return true;
2707 }
2708 return false;
2709 }
2710
2711 virtual const char *getClobbers() const {
2712 // FIXME: Implement!
2713 return "";
2714 }
2715};
2716
2717const char * const MipsTargetInfo::GCCRegNames[] = {
Michael J. Spencer20249a12010-10-21 03:16:25 +00002718 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002719 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
2720 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
2721 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
2722 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
2723 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
2724 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
2725 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
2726 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
2727 "$fcc5","$fcc6","$fcc7"
2728};
2729
2730void MipsTargetInfo::getGCCRegNames(const char * const *&Names,
2731 unsigned &NumNames) const {
2732 Names = GCCRegNames;
2733 NumNames = llvm::array_lengthof(GCCRegNames);
2734}
2735
2736const TargetInfo::GCCRegAlias MipsTargetInfo::GCCRegAliases[] = {
2737 { { "at" }, "$1" },
2738 { { "v0" }, "$2" },
2739 { { "v1" }, "$3" },
2740 { { "a0" }, "$4" },
2741 { { "a1" }, "$5" },
2742 { { "a2" }, "$6" },
2743 { { "a3" }, "$7" },
2744 { { "t0" }, "$8" },
2745 { { "t1" }, "$9" },
2746 { { "t2" }, "$10" },
2747 { { "t3" }, "$11" },
2748 { { "t4" }, "$12" },
2749 { { "t5" }, "$13" },
2750 { { "t6" }, "$14" },
2751 { { "t7" }, "$15" },
2752 { { "s0" }, "$16" },
2753 { { "s1" }, "$17" },
2754 { { "s2" }, "$18" },
2755 { { "s3" }, "$19" },
2756 { { "s4" }, "$20" },
2757 { { "s5" }, "$21" },
2758 { { "s6" }, "$22" },
2759 { { "s7" }, "$23" },
2760 { { "t8" }, "$24" },
2761 { { "t9" }, "$25" },
2762 { { "k0" }, "$26" },
2763 { { "k1" }, "$27" },
2764 { { "gp" }, "$28" },
2765 { { "sp" }, "$29" },
2766 { { "fp" }, "$30" },
2767 { { "ra" }, "$31" }
2768};
2769
2770void MipsTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2771 unsigned &NumAliases) const {
2772 Aliases = GCCRegAliases;
2773 NumAliases = llvm::array_lengthof(GCCRegAliases);
2774}
2775} // end anonymous namespace.
2776
2777namespace {
2778class MipselTargetInfo : public MipsTargetInfo {
2779public:
2780 MipselTargetInfo(const std::string& triple) : MipsTargetInfo(triple) {
2781 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 +00002782 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002783 }
2784
2785 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002786 MacroBuilder &Builder) const;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002787};
2788
2789void MipselTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002790 MacroBuilder &Builder) const {
2791 DefineStd(Builder, "mips", Opts);
2792 Builder.defineMacro("_mips");
2793 DefineStd(Builder, "MIPSEL", Opts);
2794 Builder.defineMacro("_MIPSEL");
2795 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christophered734732010-03-02 02:41:08 +00002796 getArchDefines(Opts, Builder);
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002797}
2798} // end anonymous namespace.
2799
Reid Spencer5f016e22007-07-11 17:01:13 +00002800//===----------------------------------------------------------------------===//
2801// Driver code
2802//===----------------------------------------------------------------------===//
2803
Daniel Dunbard58c03f2009-11-15 06:48:46 +00002804static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002805 llvm::Triple Triple(T);
2806 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00002807
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002808 switch (Triple.getArch()) {
2809 default:
2810 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00002811
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002812 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00002813 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00002814 if (Triple.isOSDarwin())
2815 return new DarwinARMTargetInfo(T);
2816
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002817 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00002818 case llvm::Triple::Linux:
2819 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002820 case llvm::Triple::FreeBSD:
Torok Edwin5f6c1942009-06-30 17:10:35 +00002821 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00002822 case llvm::Triple::NetBSD:
2823 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00002824 case llvm::Triple::RTEMS:
2825 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002826 default:
2827 return new ARMTargetInfo(T);
2828 }
Eli Friedman61538a72008-05-20 14:21:01 +00002829
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002830 case llvm::Triple::bfin:
Douglas Gregordca52262011-07-01 22:41:14 +00002831 if ( os == llvm::Triple::RTEMS )
2832 return new RTEMSTargetInfo<BlackfinTargetInfo>(T);
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002833 return new BlackfinTargetInfo(T);
2834
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002835 case llvm::Triple::msp430:
2836 return new MSP430TargetInfo(T);
Eli Friedman61538a72008-05-20 14:21:01 +00002837
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002838 case llvm::Triple::mips:
2839 if (os == llvm::Triple::Psp)
2840 return new PSPTargetInfo<MipsTargetInfo>(T);
2841 if (os == llvm::Triple::Linux)
2842 return new LinuxTargetInfo<MipsTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00002843 if (os == llvm::Triple::RTEMS)
2844 return new RTEMSTargetInfo<MipsTargetInfo>(T);
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002845 return new MipsTargetInfo(T);
2846
2847 case llvm::Triple::mipsel:
2848 if (os == llvm::Triple::Psp)
2849 return new PSPTargetInfo<MipselTargetInfo>(T);
2850 if (os == llvm::Triple::Linux)
2851 return new LinuxTargetInfo<MipselTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00002852 if (os == llvm::Triple::RTEMS)
2853 return new RTEMSTargetInfo<MipselTargetInfo>(T);
Edward O'Callaghan84423a82009-11-15 10:22:07 +00002854 return new MipselTargetInfo(T);
2855
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002856 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00002857 if (Triple.isOSDarwin())
Roman Divackyc81f2a22011-01-06 08:27:10 +00002858 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00002859 switch (os) {
2860 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00002861 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00002862 case llvm::Triple::NetBSD:
2863 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
2864 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00002865 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00002866 default:
2867 return new PPC32TargetInfo(T);
2868 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002869
2870 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00002871 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00002872 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00002873 switch (os) {
2874 case llvm::Triple::Lv2:
John Thompson3f6918a2009-11-19 17:18:50 +00002875 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00002876 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00002877 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00002878 case llvm::Triple::NetBSD:
2879 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
2880 default:
2881 return new PPC64TargetInfo(T);
2882 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002883
Justin Holewinski285dc652011-04-20 19:34:15 +00002884 case llvm::Triple::ptx32:
2885 return new PTX32TargetInfo(T);
2886 case llvm::Triple::ptx64:
2887 return new PTX64TargetInfo(T);
2888
Chris Lattner9cbeb632010-03-06 21:21:27 +00002889 case llvm::Triple::mblaze:
2890 return new MBlazeTargetInfo(T);
2891
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002892 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00002893 switch (os) {
2894 case llvm::Triple::AuroraUX:
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00002895 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00002896 case llvm::Triple::Solaris:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002897 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00002898 case llvm::Triple::NetBSD:
2899 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
2900 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00002901 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00002902 default:
2903 return new SparcV8TargetInfo(T);
2904 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002905
John Thompson3f6918a2009-11-19 17:18:50 +00002906 // FIXME: Need a real SPU target.
2907 case llvm::Triple::cellspu:
2908 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
2909
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002910 case llvm::Triple::systemz:
2911 return new SystemZTargetInfo(T);
2912
Eli Friedmanb63decf2009-08-19 20:47:07 +00002913 case llvm::Triple::tce:
2914 return new TCETargetInfo(T);
2915
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002916 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00002917 if (Triple.isOSDarwin())
2918 return new DarwinI386TargetInfo(T);
2919
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002920 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00002921 case llvm::Triple::AuroraUX:
2922 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002923 case llvm::Triple::Linux:
2924 return new LinuxTargetInfo<X86_32TargetInfo>(T);
2925 case llvm::Triple::DragonFly:
2926 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
2927 case llvm::Triple::NetBSD:
2928 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
2929 case llvm::Triple::OpenBSD:
2930 return new OpenBSDI386TargetInfo(T);
2931 case llvm::Triple::FreeBSD:
2932 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner38e317d2010-07-07 16:01:42 +00002933 case llvm::Triple::Minix:
2934 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002935 case llvm::Triple::Solaris:
2936 return new SolarisTargetInfo<X86_32TargetInfo>(T);
2937 case llvm::Triple::Cygwin:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002938 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002939 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002940 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002941 case llvm::Triple::Win32:
Michael J. Spencera764e832010-10-21 08:22:51 +00002942 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattner86ed3a32010-04-11 19:29:39 +00002943 case llvm::Triple::Haiku:
2944 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00002945 case llvm::Triple::RTEMS:
2946 return new RTEMSX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002947 default:
2948 return new X86_32TargetInfo(T);
2949 }
2950
2951 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00002952 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
2953 return new DarwinX86_64TargetInfo(T);
2954
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002955 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00002956 case llvm::Triple::AuroraUX:
2957 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002958 case llvm::Triple::Linux:
2959 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner7a7ca282010-01-09 05:41:14 +00002960 case llvm::Triple::DragonFly:
2961 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002962 case llvm::Triple::NetBSD:
2963 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
2964 case llvm::Triple::OpenBSD:
2965 return new OpenBSDX86_64TargetInfo(T);
2966 case llvm::Triple::FreeBSD:
2967 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
2968 case llvm::Triple::Solaris:
2969 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00002970 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002971 return new MinGWX86_64TargetInfo(T);
2972 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00002973 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00002974 default:
2975 return new X86_64TargetInfo(T);
2976 }
2977 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002978}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00002979
2980/// CreateTargetInfo - Return the target info object for the specified target
2981/// triple.
2982TargetInfo *TargetInfo::CreateTargetInfo(Diagnostic &Diags,
Daniel Dunbarb93292a2009-12-19 03:30:57 +00002983 TargetOptions &Opts) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00002984 llvm::Triple Triple(Opts.Triple);
2985
2986 // Construct the target
2987 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
2988 if (!Target) {
2989 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
2990 return 0;
2991 }
2992
Daniel Dunbareac7c532009-12-18 18:42:37 +00002993 // Set the target CPU if specified.
2994 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
2995 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
2996 return 0;
2997 }
2998
Daniel Dunbard58c03f2009-11-15 06:48:46 +00002999 // Set the target ABI if specified.
3000 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
3001 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
3002 return 0;
3003 }
3004
Charles Davis98b7c5c2010-06-11 01:06:47 +00003005 // Set the target C++ ABI.
John McCallee79a4c2010-08-21 22:46:04 +00003006 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davis98b7c5c2010-06-11 01:06:47 +00003007 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
3008 return 0;
3009 }
3010
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003011 // Compute the default target features, we need the target to handle this
3012 // because features may have dependencies on one another.
3013 llvm::StringMap<bool> Features;
3014 Target->getDefaultFeatures(Opts.CPU, Features);
3015
3016 // Apply the user specified deltas.
3017 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
3018 ie = Opts.Features.end(); it != ie; ++it) {
3019 const char *Name = it->c_str();
3020
3021 // Apply the feature via the target.
3022 if ((Name[0] != '-' && Name[0] != '+') ||
3023 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
3024 Diags.Report(diag::err_target_invalid_feature) << Name;
3025 return 0;
3026 }
3027 }
3028
3029 // Add the features to the compile options.
3030 //
3031 // FIXME: If we are completely confident that we have the right set, we only
3032 // need to pass the minuses.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003033 Opts.Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003034 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
3035 ie = Features.end(); it != ie; ++it)
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003036 Opts.Features.push_back(std::string(it->second ? "+" : "-") + it->first());
3037 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003038
3039 return Target.take();
3040}