blob: 889518bb2a993b63141d40ccd3de0c07485fe8f6 [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"
David Blaikie9fe8c742011-09-23 05:35:21 +000029#include "llvm/Support/ErrorHandling.h"
Dale Johannesen1e592cb2010-10-29 23:24:33 +000030#include "llvm/Type.h"
Benjamin Kramer48725082010-01-09 18:20:57 +000031#include <algorithm>
Reid Spencer5f016e22007-07-11 17:01:13 +000032using namespace clang;
33
Reid Spencer5f016e22007-07-11 17:01:13 +000034//===----------------------------------------------------------------------===//
35// Common code shared among targets.
36//===----------------------------------------------------------------------===//
37
Chris Lattnerca45cff2009-03-20 16:06:38 +000038/// DefineStd - Define a macro name and standard variants. For example if
39/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
40/// when in GNU mode.
Chris Lattner5f9e2722011-07-23 10:55:15 +000041static void DefineStd(MacroBuilder &Builder, StringRef MacroName,
Chris Lattnerca45cff2009-03-20 16:06:38 +000042 const LangOptions &Opts) {
43 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000044
Chris Lattnerca45cff2009-03-20 16:06:38 +000045 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
46 // in the user's namespace.
47 if (Opts.GNUMode)
Benjamin Kramera9992772010-01-09 17:55:51 +000048 Builder.defineMacro(MacroName);
Anton Korobeynikova7c47172009-05-03 13:42:53 +000049
Chris Lattnerca45cff2009-03-20 16:06:38 +000050 // Define __unix.
Benjamin Kramera9992772010-01-09 17:55:51 +000051 Builder.defineMacro("__" + MacroName);
Anton Korobeynikova7c47172009-05-03 13:42:53 +000052
Chris Lattnerca45cff2009-03-20 16:06:38 +000053 // Define __unix__.
Benjamin Kramera9992772010-01-09 17:55:51 +000054 Builder.defineMacro("__" + MacroName + "__");
Chris Lattnerca45cff2009-03-20 16:06:38 +000055}
56
Chris Lattnerd29b6302008-10-05 21:50:58 +000057//===----------------------------------------------------------------------===//
58// Defines specific to certain operating systems.
59//===----------------------------------------------------------------------===//
Chris Lattner797c3c42009-08-10 19:03:04 +000060
Torok Edwin5f6c1942009-06-30 17:10:35 +000061namespace {
Douglas Gregora3844922009-07-01 15:12:53 +000062template<typename TgtInfo>
63class OSTargetInfo : public TgtInfo {
Torok Edwin5f6c1942009-06-30 17:10:35 +000064protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +000065 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +000066 MacroBuilder &Builder) const=0;
Torok Edwin5f6c1942009-06-30 17:10:35 +000067public:
Douglas Gregora3844922009-07-01 15:12:53 +000068 OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
Torok Edwin5f6c1942009-06-30 17:10:35 +000069 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +000070 MacroBuilder &Builder) const {
71 TgtInfo::getTargetDefines(Opts, Builder);
72 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Torok Edwinb0a5b242009-06-30 17:00:25 +000073 }
Torok Edwin5f6c1942009-06-30 17:10:35 +000074
75};
Chris Lattner4c28b1c2009-08-12 06:24:27 +000076} // end anonymous namespace
Torok Edwinb0a5b242009-06-30 17:00:25 +000077
Chris Lattner797c3c42009-08-10 19:03:04 +000078
Daniel Dunbar21ae3192010-01-26 01:44:04 +000079static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +000080 const llvm::Triple &Triple,
Chris Lattner5f9e2722011-07-23 10:55:15 +000081 StringRef &PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +000082 VersionTuple &PlatformMinVersion) {
Benjamin Kramera9992772010-01-09 17:55:51 +000083 Builder.defineMacro("__APPLE_CC__", "5621");
84 Builder.defineMacro("__APPLE__");
85 Builder.defineMacro("__MACH__");
86 Builder.defineMacro("OBJC_NEW_PROPERTIES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000087
John McCall098df7f2011-06-16 00:03:19 +000088 if (!Opts.ObjCAutoRefCount) {
John McCallf85e1932011-06-15 23:02:42 +000089 // __weak is always defined, for use in blocks and with objc pointers.
90 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000091
John McCallf85e1932011-06-15 23:02:42 +000092 // Darwin defines __strong even in C mode (just to nothing).
Douglas Gregore289d812011-09-13 17:21:33 +000093 if (Opts.getGC() != LangOptions::NonGC)
John McCallf85e1932011-06-15 23:02:42 +000094 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
95 else
96 Builder.defineMacro("__strong", "");
Eric Christopher7c9adf92011-07-07 22:55:26 +000097
John McCallf85e1932011-06-15 23:02:42 +000098 // __unsafe_unretained is defined to nothing in non-ARC mode. We even
99 // allow this in C, since one might have block pointers in structs that
100 // are used in pure C code and in Objective-C ARC.
101 Builder.defineMacro("__unsafe_unretained", "");
Eric Christopher7c9adf92011-07-07 22:55:26 +0000102
John McCallf85e1932011-06-15 23:02:42 +0000103 // The Objective-C bridged cast keywords are defined to nothing in non-ARC
104 // mode; then they become normal, C-style casts.
105 Builder.defineMacro("__bridge", "");
106 Builder.defineMacro("__bridge_transfer", "");
107 Builder.defineMacro("__bridge_retained", "");
John McCall18164422011-06-17 21:23:37 +0000108 Builder.defineMacro("__bridge_retain", "");
John McCallf85e1932011-06-15 23:02:42 +0000109 }
Eric Christopher7c9adf92011-07-07 22:55:26 +0000110
Eli Friedman2de4fee2009-06-04 23:00:29 +0000111 if (Opts.Static)
Benjamin Kramera9992772010-01-09 17:55:51 +0000112 Builder.defineMacro("__STATIC__");
Eli Friedman2de4fee2009-06-04 23:00:29 +0000113 else
Benjamin Kramera9992772010-01-09 17:55:51 +0000114 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000115
116 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000117 Builder.defineMacro("_REENTRANT");
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000118
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000119 // Get the platform type and version number from the triple.
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000120 unsigned Maj, Min, Rev;
Mike Stump1eb44332009-09-09 15:08:12 +0000121
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000122 // If no version was given, default to to 10.4.0, for simplifying tests.
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000123 if (Triple.getOSName() == "darwin" || Triple.getOSName() == "osx") {
124 PlatformName = "macosx";
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000125 Min = Rev = 0;
126 Maj = 8;
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000127 } else {
128 // Otherwise, honor all three triple forms ("-darwinNNN[-iphoneos]",
129 // "-osxNNN", and "-iosNNN").
130
131 if (Triple.getOS() == llvm::Triple::Darwin) {
132 // For historical reasons that make little sense, the version passed here
133 // is the "darwin" version, which drops the 10 and offsets by 4.
134 Triple.getOSVersion(Maj, Min, Rev);
135
136 if (Triple.getEnvironmentName() == "iphoneos") {
137 PlatformName = "ios";
138 } else {
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000139 PlatformName = "macosx";
140 Rev = Min;
141 Min = Maj - 4;
142 Maj = 10;
143 }
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000144 } else {
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000145 Triple.getOSVersion(Maj, Min, Rev);
Daniel Dunbara4ff6482011-04-19 23:34:21 +0000146 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000147 }
148 }
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000149
Chad Rosierd9259f32011-07-19 20:00:06 +0000150 // If -ccc-host-triple arch-pc-win32-macho option specified, we're
Eric Christopher895d4222011-07-29 21:20:35 +0000151 // generating code for Win32 ABI. No need to emit
Chad Rosierd9259f32011-07-19 20:00:06 +0000152 // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
153 if (PlatformName == "win32") {
154 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
155 return;
156 }
157
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000158 // Set the appropriate OS version define.
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000159 if (PlatformName == "ios") {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000160 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000161 char Str[6];
162 Str[0] = '0' + Maj;
163 Str[1] = '0' + (Min / 10);
164 Str[2] = '0' + (Min % 10);
165 Str[3] = '0' + (Rev / 10);
166 Str[4] = '0' + (Rev % 10);
167 Str[5] = '\0';
168 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
169 } else {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000170 // Note that the Driver allows versions which aren't representable in the
171 // define (because we only get a single digit for the minor and micro
172 // revision numbers). So, we limit them to the maximum representable
173 // version.
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000174 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000175 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000176 char Str[5];
177 Str[0] = '0' + (Maj / 10);
178 Str[1] = '0' + (Maj % 10);
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000179 Str[2] = '0' + std::min(Min, 9U);
180 Str[3] = '0' + std::min(Rev, 9U);
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000181 Str[4] = '\0';
182 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000183 }
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000184
185 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman618234a2008-08-20 02:34:37 +0000186}
Reid Spencer5f016e22007-07-11 17:01:13 +0000187
Chris Lattner797c3c42009-08-10 19:03:04 +0000188namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000189template<typename Target>
190class DarwinTargetInfo : public OSTargetInfo<Target> {
191protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000192 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000193 MacroBuilder &Builder) const {
Eric Christopher7c9adf92011-07-07 22:55:26 +0000194 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000195 this->PlatformMinVersion);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000196 }
Mike Stump1eb44332009-09-09 15:08:12 +0000197
Torok Edwin5f6c1942009-06-30 17:10:35 +0000198public:
199 DarwinTargetInfo(const std::string& triple) :
200 OSTargetInfo<Target>(triple) {
Eric Christopheraa7333c2011-07-02 00:20:22 +0000201 llvm::Triple T = llvm::Triple(triple);
202 this->TLSSupported = T.isMacOSX() && !T.isMacOSXVersionLT(10,7);
Daniel Dunbare177d3b2011-02-21 23:12:51 +0000203 this->MCountName = "\01mcount";
Torok Edwin5f6c1942009-06-30 17:10:35 +0000204 }
205
Chris Lattner5f9e2722011-07-23 10:55:15 +0000206 virtual std::string isValidSectionSpecifier(StringRef SR) const {
Chris Lattner797c3c42009-08-10 19:03:04 +0000207 // Let MCSectionMachO validate this.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000208 StringRef Segment, Section;
Chris Lattner797c3c42009-08-10 19:03:04 +0000209 unsigned TAA, StubSize;
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000210 bool HasTAA;
Chris Lattner797c3c42009-08-10 19:03:04 +0000211 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000212 TAA, HasTAA, StubSize);
Chris Lattner797c3c42009-08-10 19:03:04 +0000213 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000214
Anders Carlsson18af3682010-06-08 22:47:50 +0000215 virtual const char *getStaticInitSectionSpecifier() const {
216 // FIXME: We should return 0 when building kexts.
217 return "__TEXT,__StaticInit,regular,pure_instructions";
218 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000219
Torok Edwin5f6c1942009-06-30 17:10:35 +0000220};
221
Chris Lattner797c3c42009-08-10 19:03:04 +0000222
Torok Edwin5f6c1942009-06-30 17:10:35 +0000223// DragonFlyBSD Target
224template<typename Target>
225class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
226protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000227 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000228 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000229 // DragonFly defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000230 Builder.defineMacro("__DragonFly__");
231 Builder.defineMacro("__DragonFly_cc_version", "100001");
232 Builder.defineMacro("__ELF__");
233 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
234 Builder.defineMacro("__tune_i386__");
235 DefineStd(Builder, "unix", Opts);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000236 }
237public:
Mike Stump1eb44332009-09-09 15:08:12 +0000238 DragonFlyBSDTargetInfo(const std::string &triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000239 : OSTargetInfo<Target>(triple) {}
240};
241
242// FreeBSD Target
243template<typename Target>
244class FreeBSDTargetInfo : public OSTargetInfo<Target> {
245protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000246 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000247 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000248 // FreeBSD defines; list based off of gcc output
249
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000250 // FIXME: Move version number handling to llvm::Triple.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000251 StringRef Release = Triple.getOSName().substr(strlen("freebsd"), 1);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000252
Benjamin Kramer3bb65302010-01-30 19:55:01 +0000253 Builder.defineMacro("__FreeBSD__", Release);
254 Builder.defineMacro("__FreeBSD_cc_version", Release + "00001");
Benjamin Kramera9992772010-01-09 17:55:51 +0000255 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
256 DefineStd(Builder, "unix", Opts);
257 Builder.defineMacro("__ELF__");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000258 }
259public:
Mike Stump1eb44332009-09-09 15:08:12 +0000260 FreeBSDTargetInfo(const std::string &triple)
Duncan Sands1e90faf2009-07-08 13:55:08 +0000261 : OSTargetInfo<Target>(triple) {
262 this->UserLabelPrefix = "";
Roman Divackybe4c8702011-02-10 16:52:03 +0000263
264 llvm::Triple Triple(triple);
265 switch (Triple.getArch()) {
266 default:
267 case llvm::Triple::x86:
268 case llvm::Triple::x86_64:
269 this->MCountName = ".mcount";
270 break;
271 case llvm::Triple::mips:
272 case llvm::Triple::mipsel:
273 case llvm::Triple::ppc:
274 case llvm::Triple::ppc64:
275 this->MCountName = "_mcount";
276 break;
277 case llvm::Triple::arm:
278 this->MCountName = "__mcount";
279 break;
280 }
281
Duncan Sands1e90faf2009-07-08 13:55:08 +0000282 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000283};
284
Chris Lattner38e317d2010-07-07 16:01:42 +0000285// Minix Target
286template<typename Target>
287class MinixTargetInfo : public OSTargetInfo<Target> {
288protected:
289 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
290 MacroBuilder &Builder) const {
291 // Minix defines
292
293 Builder.defineMacro("__minix", "3");
294 Builder.defineMacro("_EM_WSIZE", "4");
295 Builder.defineMacro("_EM_PSIZE", "4");
296 Builder.defineMacro("_EM_SSIZE", "2");
297 Builder.defineMacro("_EM_LSIZE", "4");
298 Builder.defineMacro("_EM_FSIZE", "4");
299 Builder.defineMacro("_EM_DSIZE", "8");
300 DefineStd(Builder, "unix", Opts);
301 }
302public:
303 MinixTargetInfo(const std::string &triple)
304 : OSTargetInfo<Target>(triple) {
305 this->UserLabelPrefix = "";
306 }
307};
308
Torok Edwin5f6c1942009-06-30 17:10:35 +0000309// Linux target
310template<typename Target>
311class LinuxTargetInfo : public OSTargetInfo<Target> {
312protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000313 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000314 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000315 // Linux defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000316 DefineStd(Builder, "unix", Opts);
317 DefineStd(Builder, "linux", Opts);
318 Builder.defineMacro("__gnu_linux__");
319 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000320 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000321 Builder.defineMacro("_REENTRANT");
Douglas Gregor2b003fd2010-04-21 05:52:38 +0000322 if (Opts.CPlusPlus)
323 Builder.defineMacro("_GNU_SOURCE");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000324 }
325public:
Mike Stump1eb44332009-09-09 15:08:12 +0000326 LinuxTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000327 : OSTargetInfo<Target>(triple) {
328 this->UserLabelPrefix = "";
Douglas Gregor12e84642011-01-12 21:19:25 +0000329 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000330 }
331};
332
Chris Lattnerb62bb282009-07-13 20:29:08 +0000333// NetBSD Target
334template<typename Target>
335class NetBSDTargetInfo : public OSTargetInfo<Target> {
336protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000337 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000338 MacroBuilder &Builder) const {
Chris Lattnerb62bb282009-07-13 20:29:08 +0000339 // NetBSD defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000340 Builder.defineMacro("__NetBSD__");
341 Builder.defineMacro("__unix__");
342 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000343 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000344 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerb62bb282009-07-13 20:29:08 +0000345 }
346public:
Mike Stump1eb44332009-09-09 15:08:12 +0000347 NetBSDTargetInfo(const std::string &triple)
Chris Lattnerb62bb282009-07-13 20:29:08 +0000348 : OSTargetInfo<Target>(triple) {
349 this->UserLabelPrefix = "";
350 }
351};
352
Torok Edwin5f6c1942009-06-30 17:10:35 +0000353// OpenBSD Target
354template<typename Target>
355class OpenBSDTargetInfo : public OSTargetInfo<Target> {
356protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000357 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000358 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000359 // OpenBSD defines; list based off of gcc output
360
Benjamin Kramera9992772010-01-09 17:55:51 +0000361 Builder.defineMacro("__OpenBSD__");
362 DefineStd(Builder, "unix", Opts);
363 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000364 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000365 Builder.defineMacro("_POSIX_THREADS");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000366 }
367public:
Mike Stump1eb44332009-09-09 15:08:12 +0000368 OpenBSDTargetInfo(const std::string &triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000369 : OSTargetInfo<Target>(triple) {}
370};
371
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000372// PSP Target
373template<typename Target>
374class PSPTargetInfo : public OSTargetInfo<Target> {
375protected:
376 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000377 MacroBuilder &Builder) const {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000378 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramera9992772010-01-09 17:55:51 +0000379 Builder.defineMacro("PSP");
380 Builder.defineMacro("_PSP");
381 Builder.defineMacro("__psp__");
382 Builder.defineMacro("__ELF__");
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000383 }
384public:
385 PSPTargetInfo(const std::string& triple)
386 : OSTargetInfo<Target>(triple) {
387 this->UserLabelPrefix = "";
388 }
389};
390
John Thompson3f6918a2009-11-19 17:18:50 +0000391// PS3 PPU Target
392template<typename Target>
393class PS3PPUTargetInfo : public OSTargetInfo<Target> {
394protected:
395 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000396 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000397 // PS3 PPU defines.
John Thompsonfb457972010-03-25 16:18:32 +0000398 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000399 Builder.defineMacro("__PPU__");
400 Builder.defineMacro("__CELLOS_LV2__");
401 Builder.defineMacro("__ELF__");
402 Builder.defineMacro("__LP32__");
John Thompson8e6065a2010-06-24 22:44:13 +0000403 Builder.defineMacro("_ARCH_PPC64");
404 Builder.defineMacro("__powerpc64__");
John Thompson3f6918a2009-11-19 17:18:50 +0000405 }
406public:
407 PS3PPUTargetInfo(const std::string& triple)
408 : OSTargetInfo<Target>(triple) {
409 this->UserLabelPrefix = "";
John Thompsonec387af2009-12-18 14:21:08 +0000410 this->LongWidth = this->LongAlign = this->PointerWidth = this->PointerAlign = 32;
John Thompson8e6065a2010-06-24 22:44:13 +0000411 this->IntMaxType = TargetInfo::SignedLongLong;
412 this->UIntMaxType = TargetInfo::UnsignedLongLong;
413 this->Int64Type = TargetInfo::SignedLongLong;
John Thompsonec387af2009-12-18 14:21:08 +0000414 this->SizeType = TargetInfo::UnsignedInt;
John Thompson8e6065a2010-06-24 22:44:13 +0000415 this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
416 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompson3f6918a2009-11-19 17:18:50 +0000417 }
418};
419
420// FIXME: Need a real SPU target.
421// PS3 SPU Target
422template<typename Target>
423class PS3SPUTargetInfo : public OSTargetInfo<Target> {
424protected:
425 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000426 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000427 // PS3 PPU defines.
Benjamin Kramera9992772010-01-09 17:55:51 +0000428 Builder.defineMacro("__SPU__");
429 Builder.defineMacro("__ELF__");
John Thompson3f6918a2009-11-19 17:18:50 +0000430 }
431public:
432 PS3SPUTargetInfo(const std::string& triple)
433 : OSTargetInfo<Target>(triple) {
434 this->UserLabelPrefix = "";
435 }
436};
437
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000438// AuroraUX target
439template<typename Target>
440class AuroraUXTargetInfo : public OSTargetInfo<Target> {
441protected:
442 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000443 MacroBuilder &Builder) const {
444 DefineStd(Builder, "sun", Opts);
445 DefineStd(Builder, "unix", Opts);
446 Builder.defineMacro("__ELF__");
447 Builder.defineMacro("__svr4__");
448 Builder.defineMacro("__SVR4");
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000449 }
450public:
451 AuroraUXTargetInfo(const std::string& triple)
452 : OSTargetInfo<Target>(triple) {
453 this->UserLabelPrefix = "";
454 this->WCharType = this->SignedLong;
455 // FIXME: WIntType should be SignedLong
456 }
457};
458
Torok Edwin5f6c1942009-06-30 17:10:35 +0000459// Solaris target
460template<typename Target>
461class SolarisTargetInfo : public OSTargetInfo<Target> {
462protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000463 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000464 MacroBuilder &Builder) const {
465 DefineStd(Builder, "sun", Opts);
466 DefineStd(Builder, "unix", Opts);
467 Builder.defineMacro("__ELF__");
468 Builder.defineMacro("__svr4__");
469 Builder.defineMacro("__SVR4");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000470 }
471public:
Mike Stump1eb44332009-09-09 15:08:12 +0000472 SolarisTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000473 : OSTargetInfo<Target>(triple) {
474 this->UserLabelPrefix = "";
475 this->WCharType = this->SignedLong;
476 // FIXME: WIntType should be SignedLong
477 }
478};
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000479
480// Windows target
481template<typename Target>
482class WindowsTargetInfo : public OSTargetInfo<Target> {
483protected:
484 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
485 MacroBuilder &Builder) const {
Michael J. Spencera764e832010-10-21 08:22:51 +0000486 Builder.defineMacro("_WIN32");
487 }
488 void getVisualStudioDefines(const LangOptions &Opts,
489 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000490 if (Opts.CPlusPlus) {
491 if (Opts.RTTI)
492 Builder.defineMacro("_CPPRTTI");
493
494 if (Opts.Exceptions)
495 Builder.defineMacro("_CPPUNWIND");
496 }
497
498 if (!Opts.CharIsSigned)
499 Builder.defineMacro("_CHAR_UNSIGNED");
500
501 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
502 // but it works for now.
503 if (Opts.POSIXThreads)
504 Builder.defineMacro("_MT");
Michael J. Spencera764e832010-10-21 08:22:51 +0000505
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000506 if (Opts.MSCVersion != 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000507 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000508
Francois Pichet62ec1f22011-09-17 17:15:52 +0000509 if (Opts.MicrosoftExt) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000510 Builder.defineMacro("_MSC_EXTENSIONS");
511
512 if (Opts.CPlusPlus0x) {
513 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
514 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
515 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
516 }
517 }
518
519 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000520 }
521
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000522public:
523 WindowsTargetInfo(const std::string &triple)
524 : OSTargetInfo<Target>(triple) {}
525};
526
Mike Stump1eb44332009-09-09 15:08:12 +0000527} // end anonymous namespace.
Torok Edwin5f6c1942009-06-30 17:10:35 +0000528
Chris Lattnerd29b6302008-10-05 21:50:58 +0000529//===----------------------------------------------------------------------===//
Eli Friedmane4277982008-08-20 23:11:40 +0000530// Specific target implementations.
531//===----------------------------------------------------------------------===//
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +0000532
Eli Friedmane4277982008-08-20 23:11:40 +0000533namespace {
534// PPC abstract base class
535class PPCTargetInfo : public TargetInfo {
536 static const Builtin::Info BuiltinInfo[];
537 static const char * const GCCRegNames[];
538 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Eli Friedmane4277982008-08-20 23:11:40 +0000539public:
Eli Friedman15b91762009-06-05 07:05:05 +0000540 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
541
Eli Friedmane4277982008-08-20 23:11:40 +0000542 virtual void getTargetBuiltins(const Builtin::Info *&Records,
543 unsigned &NumRecords) const {
Reid Spencer5f016e22007-07-11 17:01:13 +0000544 Records = BuiltinInfo;
Eli Friedmane4277982008-08-20 23:11:40 +0000545 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +0000546 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000547
Chris Lattner33328642009-03-20 15:52:06 +0000548 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000549 MacroBuilder &Builder) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000550
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000551 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000552 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000553 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000554 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000555 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +0000556 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000557 switch (*Name) {
Anders Carlssond04c6e22007-11-27 04:11:28 +0000558 default: return false;
559 case 'O': // Zero
John Thompson8e6065a2010-06-24 22:44:13 +0000560 break;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000561 case 'b': // Base register
562 case 'f': // Floating point register
Chris Lattner44def072009-04-26 07:16:29 +0000563 Info.setAllowsRegister();
John Thompson8e6065a2010-06-24 22:44:13 +0000564 break;
565 // FIXME: The following are added to allow parsing.
566 // I just took a guess at what the actions should be.
567 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer20249a12010-10-21 03:16:25 +0000568 case 'd': // Floating point register (containing 64-bit value)
John Thompson8e6065a2010-06-24 22:44:13 +0000569 case 'v': // Altivec vector register
570 Info.setAllowsRegister();
571 break;
572 case 'w':
573 switch (Name[1]) {
Michael J. Spencer20249a12010-10-21 03:16:25 +0000574 case 'd':// VSX vector register to hold vector double data
575 case 'f':// VSX vector register to hold vector float data
576 case 's':// VSX vector register to hold scalar float data
577 case 'a':// Any VSX register
John Thompson8e6065a2010-06-24 22:44:13 +0000578 break;
579 default:
580 return false;
581 }
582 Info.setAllowsRegister();
583 Name++; // Skip over 'w'.
584 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000585 case 'h': // `MQ', `CTR', or `LINK' register
586 case 'q': // `MQ' register
587 case 'c': // `CTR' register
588 case 'l': // `LINK' register
589 case 'x': // `CR' register (condition register) number 0
590 case 'y': // `CR' register (condition register)
591 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson8e6065a2010-06-24 22:44:13 +0000592 Info.setAllowsRegister();
593 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000594 case 'I': // Signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000595 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer20249a12010-10-21 03:16:25 +0000596 // (use `L' instead for SImode constants)
597 case 'K': // Unsigned 16-bit constant
598 case 'L': // Signed 16-bit constant shifted left 16 bits
599 case 'M': // Constant larger than 31
600 case 'N': // Exact power of 2
601 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000602 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000603 // register with one instruction per word
John Thompson8e6065a2010-06-24 22:44:13 +0000604 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer20249a12010-10-21 03:16:25 +0000605 // into a register using three instructions
John Thompson8e6065a2010-06-24 22:44:13 +0000606 break;
607 case 'm': // Memory operand. Note that on PowerPC targets, m can
608 // include addresses that update the base register. It
609 // is therefore only safe to use `m' in an asm statement
610 // if that asm statement accesses the operand exactly once.
611 // The asm statement must also use `%U<opno>' as a
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000612 // placeholder for the "update" flag in the corresponding
Michael J. Spencer20249a12010-10-21 03:16:25 +0000613 // load or store instruction. For example:
John Thompson8e6065a2010-06-24 22:44:13 +0000614 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000615 // is correct but:
John Thompson8e6065a2010-06-24 22:44:13 +0000616 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
617 // is not. Use es rather than m if you don't want the base
Michael J. Spencer20249a12010-10-21 03:16:25 +0000618 // register to be updated.
619 case 'e':
John Thompson56b6eca2010-06-25 00:02:05 +0000620 if (Name[1] != 's')
621 return false;
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000622 // es: A "stable" memory operand; that is, one which does not
John Thompson8e6065a2010-06-24 22:44:13 +0000623 // include any automodification of the base register. Unlike
624 // `m', this constraint can be used in asm statements that
625 // might access the operand several times, or that might not
John Thompson56b6eca2010-06-25 00:02:05 +0000626 // access it at all.
John Thompson8e6065a2010-06-24 22:44:13 +0000627 Info.setAllowsMemory();
John Thompson56b6eca2010-06-25 00:02:05 +0000628 Name++; // Skip over 'e'.
John Thompson8e6065a2010-06-24 22:44:13 +0000629 break;
630 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer20249a12010-10-21 03:16:25 +0000631 // usually better to use `m' or `es' in asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000632 case 'Z': // Memory operand that is an indexed or indirect from a
633 // register (it is usually better to use `m' or `es' in
Michael J. Spencer20249a12010-10-21 03:16:25 +0000634 // asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000635 Info.setAllowsMemory();
636 Info.setAllowsRegister();
637 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000638 case 'R': // AIX TOC entry
John Thompson8e6065a2010-06-24 22:44:13 +0000639 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000640 // register (`p' is preferable for asm statements)
641 case 'S': // Constant suitable as a 64-bit mask operand
642 case 'T': // Constant suitable as a 32-bit mask operand
643 case 'U': // System V Release 4 small data area reference
John Thompson8e6065a2010-06-24 22:44:13 +0000644 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000645 // instructions
646 case 'W': // Vector constant that does not require memory
647 case 'j': // Vector constant that is all zeros.
John Thompson8e6065a2010-06-24 22:44:13 +0000648 break;
649 // End FIXME.
Anders Carlssond04c6e22007-11-27 04:11:28 +0000650 }
John Thompson8e6065a2010-06-24 22:44:13 +0000651 return true;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000652 }
Eli Friedmane4277982008-08-20 23:11:40 +0000653 virtual const char *getClobbers() const {
654 return "";
Anders Carlssond04c6e22007-11-27 04:11:28 +0000655 }
Eli Friedmane4277982008-08-20 23:11:40 +0000656};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000657
Eli Friedmane4277982008-08-20 23:11:40 +0000658const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000659#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000660#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000661 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000662#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000663};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000664
665
Chris Lattnerc0f59212009-03-02 22:27:17 +0000666/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
667/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000668void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000669 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000670 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000671 Builder.defineMacro("__ppc__");
672 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000673 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000674 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000675 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000676 Builder.defineMacro("_ARCH_PPC64");
677 Builder.defineMacro("_LP64");
678 Builder.defineMacro("__LP64__");
Chris Lattnere03ae302010-02-16 18:14:57 +0000679 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000680 Builder.defineMacro("__ppc64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000681 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +0000682 Builder.defineMacro("__ppc__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000683 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000684
Chris Lattnerc0f59212009-03-02 22:27:17 +0000685 // Target properties.
Joerg Sonnenberger7cd1de52011-07-05 14:56:12 +0000686 if (getTriple().getOS() != llvm::Triple::NetBSD)
687 Builder.defineMacro("_BIG_ENDIAN");
Benjamin Kramera9992772010-01-09 17:55:51 +0000688 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000689
Chris Lattnerc0f59212009-03-02 22:27:17 +0000690 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000691 Builder.defineMacro("__NATURAL_ALIGNMENT__");
692 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000693
Chris Lattnerc0f59212009-03-02 22:27:17 +0000694 // FIXME: Should be controlled by command line option.
Benjamin Kramera9992772010-01-09 17:55:51 +0000695 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000696
John Thompson3f6918a2009-11-19 17:18:50 +0000697 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000698 Builder.defineMacro("__VEC__", "10206");
699 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000700 }
Chris Lattnerc0f59212009-03-02 22:27:17 +0000701}
702
Chris Lattner393ff042008-04-21 18:56:49 +0000703
Eli Friedmane4277982008-08-20 23:11:40 +0000704const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +0000705 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
706 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
707 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
708 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
709 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
710 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
711 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
712 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +0000713 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000714 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +0000715 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000716 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
717 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
718 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
719 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +0000720 "vrsave", "vscr",
721 "spe_acc", "spefscr",
722 "sfp"
723};
Reid Spencer5f016e22007-07-11 17:01:13 +0000724
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000725void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000726 unsigned &NumNames) const {
727 Names = GCCRegNames;
728 NumNames = llvm::array_lengthof(GCCRegNames);
729}
Reid Spencer5f016e22007-07-11 17:01:13 +0000730
Eli Friedmane4277982008-08-20 23:11:40 +0000731const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
732 // While some of these aliases do map to different registers
733 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000734 { { "0" }, "r0" },
735 { { "1"}, "r1" },
736 { { "2" }, "r2" },
737 { { "3" }, "r3" },
738 { { "4" }, "r4" },
739 { { "5" }, "r5" },
740 { { "6" }, "r6" },
741 { { "7" }, "r7" },
742 { { "8" }, "r8" },
743 { { "9" }, "r9" },
744 { { "10" }, "r10" },
745 { { "11" }, "r11" },
746 { { "12" }, "r12" },
747 { { "13" }, "r13" },
748 { { "14" }, "r14" },
749 { { "15" }, "r15" },
750 { { "16" }, "r16" },
751 { { "17" }, "r17" },
752 { { "18" }, "r18" },
753 { { "19" }, "r19" },
754 { { "20" }, "r20" },
755 { { "21" }, "r21" },
756 { { "22" }, "r22" },
757 { { "23" }, "r23" },
758 { { "24" }, "r24" },
759 { { "25" }, "r25" },
760 { { "26" }, "r26" },
761 { { "27" }, "r27" },
762 { { "28" }, "r28" },
763 { { "29" }, "r29" },
764 { { "30" }, "r30" },
765 { { "31" }, "r31" },
766 { { "fr0" }, "f0" },
767 { { "fr1" }, "f1" },
768 { { "fr2" }, "f2" },
769 { { "fr3" }, "f3" },
770 { { "fr4" }, "f4" },
771 { { "fr5" }, "f5" },
772 { { "fr6" }, "f6" },
773 { { "fr7" }, "f7" },
774 { { "fr8" }, "f8" },
775 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +0000776 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000777 { { "fr11" }, "f11" },
778 { { "fr12" }, "f12" },
779 { { "fr13" }, "f13" },
780 { { "fr14" }, "f14" },
781 { { "fr15" }, "f15" },
782 { { "fr16" }, "f16" },
783 { { "fr17" }, "f17" },
784 { { "fr18" }, "f18" },
785 { { "fr19" }, "f19" },
786 { { "fr20" }, "f20" },
787 { { "fr21" }, "f21" },
788 { { "fr22" }, "f22" },
789 { { "fr23" }, "f23" },
790 { { "fr24" }, "f24" },
791 { { "fr25" }, "f25" },
792 { { "fr26" }, "f26" },
793 { { "fr27" }, "f27" },
794 { { "fr28" }, "f28" },
795 { { "fr29" }, "f29" },
796 { { "fr30" }, "f30" },
797 { { "fr31" }, "f31" },
798 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +0000799};
800
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000801void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000802 unsigned &NumAliases) const {
803 Aliases = GCCRegAliases;
804 NumAliases = llvm::array_lengthof(GCCRegAliases);
805}
806} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +0000807
808namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000809class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000810public:
Chris Lattnere03ae302010-02-16 18:14:57 +0000811 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +0000812 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner1932e122009-11-07 18:59:41 +0000813 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +0000814
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000815 switch (getTriple().getOS()) {
816 case llvm::Triple::FreeBSD:
817 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000818 SizeType = UnsignedInt;
819 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +0000820 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000821 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000822 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000823 }
824
825 virtual const char *getVAListDeclaration() const {
826 // This is the ELF definition, and is overridden by the Darwin sub-target
827 return "typedef struct __va_list_tag {"
828 " unsigned char gpr;"
829 " unsigned char fpr;"
830 " unsigned short reserved;"
831 " void* overflow_arg_area;"
832 " void* reg_save_area;"
833 "} __builtin_va_list[1];";
Eli Friedmaned855cb2008-08-21 00:13:15 +0000834 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000835};
836} // end anonymous namespace.
837
838namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000839class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000840public:
Eli Friedmane4277982008-08-20 23:11:40 +0000841 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +0000842 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +0000843 IntMaxType = SignedLong;
844 UIntMaxType = UnsignedLong;
845 Int64Type = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +0000846 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner1932e122009-11-07 18:59:41 +0000847 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnerf291b102008-05-09 06:17:04 +0000848 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000849 virtual const char *getVAListDeclaration() const {
850 return "typedef char* __builtin_va_list;";
851 }
Eli Friedmane4277982008-08-20 23:11:40 +0000852};
853} // end anonymous namespace.
854
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000855
856namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +0000857class DarwinPPC32TargetInfo :
858 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000859public:
Roman Divackyc81f2a22011-01-06 08:27:10 +0000860 DarwinPPC32TargetInfo(const std::string& triple)
861 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000862 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +0000863 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
864 }
865 virtual const char *getVAListDeclaration() const {
866 return "typedef char* __builtin_va_list;";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000867 }
868};
869
870class DarwinPPC64TargetInfo :
871 public DarwinTargetInfo<PPC64TargetInfo> {
872public:
873 DarwinPPC64TargetInfo(const std::string& triple)
874 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
875 HasAlignMac68kSupport = true;
876 }
877};
878} // end anonymous namespace.
879
Reid Spencer5f016e22007-07-11 17:01:13 +0000880namespace {
Justin Holewinski25bedca2011-10-03 17:28:37 +0000881 static const unsigned PTXAddrSpaceMap[] = {
882 0, // opencl_global
883 4, // opencl_local
884 1 // opencl_constant
885 };
Justin Holewinski285dc652011-04-20 19:34:15 +0000886 class PTXTargetInfo : public TargetInfo {
887 static const char * const GCCRegNames[];
888 static const Builtin::Info BuiltinInfo[];
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000889 std::vector<llvm::StringRef> AvailableFeatures;
Justin Holewinski285dc652011-04-20 19:34:15 +0000890 public:
891 PTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
892 TLSSupported = false;
893 LongWidth = LongAlign = 64;
Justin Holewinski25bedca2011-10-03 17:28:37 +0000894 AddrSpaceMap = &PTXAddrSpaceMap;
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000895 // Define available target features
896 // These must be defined in sorted order!
897 AvailableFeatures.push_back("compute10");
898 AvailableFeatures.push_back("compute11");
899 AvailableFeatures.push_back("compute12");
900 AvailableFeatures.push_back("compute13");
901 AvailableFeatures.push_back("compute20");
902 AvailableFeatures.push_back("double");
903 AvailableFeatures.push_back("no-fma");
904 AvailableFeatures.push_back("ptx20");
905 AvailableFeatures.push_back("ptx21");
906 AvailableFeatures.push_back("ptx22");
907 AvailableFeatures.push_back("ptx23");
908 AvailableFeatures.push_back("sm10");
909 AvailableFeatures.push_back("sm11");
910 AvailableFeatures.push_back("sm12");
911 AvailableFeatures.push_back("sm13");
912 AvailableFeatures.push_back("sm20");
913 AvailableFeatures.push_back("sm21");
914 AvailableFeatures.push_back("sm22");
915 AvailableFeatures.push_back("sm23");
Justin Holewinski285dc652011-04-20 19:34:15 +0000916 }
917 virtual void getTargetDefines(const LangOptions &Opts,
918 MacroBuilder &Builder) const {
919 Builder.defineMacro("__PTX__");
920 }
921 virtual void getTargetBuiltins(const Builtin::Info *&Records,
922 unsigned &NumRecords) const {
923 Records = BuiltinInfo;
924 NumRecords = clang::PTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
925 }
926
927 virtual void getGCCRegNames(const char * const *&Names,
928 unsigned &NumNames) const;
929 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
930 unsigned &NumAliases) const {
931 // No aliases.
932 Aliases = 0;
933 NumAliases = 0;
934 }
935 virtual bool validateAsmConstraint(const char *&Name,
936 TargetInfo::ConstraintInfo &info) const {
937 // FIXME: implement
938 return true;
939 }
940 virtual const char *getClobbers() const {
941 // FIXME: Is this really right?
942 return "";
943 }
944 virtual const char *getVAListDeclaration() const {
945 // FIXME: implement
946 return "typedef char* __builtin_va_list;";
947 }
Justin Holewinski808ef662011-09-15 12:13:38 +0000948
949 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
950 const std::string &Name,
951 bool Enabled) const;
Justin Holewinski285dc652011-04-20 19:34:15 +0000952 };
953
954 const Builtin::Info PTXTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000955#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +0000956#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000957 ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +0000958#include "clang/Basic/BuiltinsPTX.def"
959 };
960
961 const char * const PTXTargetInfo::GCCRegNames[] = {
962 "r0"
963 };
964
965 void PTXTargetInfo::getGCCRegNames(const char * const *&Names,
966 unsigned &NumNames) const {
967 Names = GCCRegNames;
968 NumNames = llvm::array_lengthof(GCCRegNames);
969 }
970
Justin Holewinski808ef662011-09-15 12:13:38 +0000971 bool PTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
972 const std::string &Name,
973 bool Enabled) const {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000974 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
975 Name)) {
976 Features[Name] = Enabled;
977 return true;
Justin Holewinski808ef662011-09-15 12:13:38 +0000978 } else {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000979 return false;
Justin Holewinski808ef662011-09-15 12:13:38 +0000980 }
Justin Holewinski808ef662011-09-15 12:13:38 +0000981 }
Justin Holewinski285dc652011-04-20 19:34:15 +0000982
983 class PTX32TargetInfo : public PTXTargetInfo {
984 public:
985 PTX32TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
986 PointerWidth = PointerAlign = 32;
987 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
988 DescriptionString
989 = "e-p:32:32-i64:64:64-f64:64:64-n1:8:16:32:64";
990 }
991 };
992
993 class PTX64TargetInfo : public PTXTargetInfo {
994 public:
995 PTX64TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
996 PointerWidth = PointerAlign = 64;
997 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
998 DescriptionString
999 = "e-p:64:64-i64:64:64-f64:64:64-n1:8:16:32:64";
1000 }
1001 };
1002}
1003
1004namespace {
Chris Lattner9cbeb632010-03-06 21:21:27 +00001005// MBlaze abstract base class
1006class MBlazeTargetInfo : public TargetInfo {
1007 static const char * const GCCRegNames[];
1008 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1009
1010public:
1011 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +00001012 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner9cbeb632010-03-06 21:21:27 +00001013 }
1014
1015 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1016 unsigned &NumRecords) const {
1017 // FIXME: Implement.
1018 Records = 0;
1019 NumRecords = 0;
1020 }
1021
1022 virtual void getTargetDefines(const LangOptions &Opts,
1023 MacroBuilder &Builder) const;
1024
1025 virtual const char *getVAListDeclaration() const {
1026 return "typedef char* __builtin_va_list;";
1027 }
1028 virtual const char *getTargetPrefix() const {
1029 return "mblaze";
1030 }
1031 virtual void getGCCRegNames(const char * const *&Names,
1032 unsigned &NumNames) const;
1033 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1034 unsigned &NumAliases) const;
1035 virtual bool validateAsmConstraint(const char *&Name,
1036 TargetInfo::ConstraintInfo &Info) const {
1037 switch (*Name) {
1038 default: return false;
1039 case 'O': // Zero
1040 return true;
1041 case 'b': // Base register
1042 case 'f': // Floating point register
1043 Info.setAllowsRegister();
1044 return true;
1045 }
1046 }
1047 virtual const char *getClobbers() const {
1048 return "";
1049 }
1050};
1051
1052/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1053/// #defines that are not tied to a specific subtarget.
1054void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1055 MacroBuilder &Builder) const {
1056 // Target identification.
1057 Builder.defineMacro("__microblaze__");
1058 Builder.defineMacro("_ARCH_MICROBLAZE");
1059 Builder.defineMacro("__MICROBLAZE__");
1060
1061 // Target properties.
1062 Builder.defineMacro("_BIG_ENDIAN");
1063 Builder.defineMacro("__BIG_ENDIAN__");
1064
1065 // Subtarget options.
1066 Builder.defineMacro("__REGISTER_PREFIX__", "");
1067}
1068
1069
1070const char * const MBlazeTargetInfo::GCCRegNames[] = {
1071 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1072 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1073 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1074 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1075 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1076 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1077 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1078 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1079 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1080 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1081};
1082
1083void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1084 unsigned &NumNames) const {
1085 Names = GCCRegNames;
1086 NumNames = llvm::array_lengthof(GCCRegNames);
1087}
1088
1089const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1090 { {"f0"}, "r0" },
1091 { {"f1"}, "r1" },
1092 { {"f2"}, "r2" },
1093 { {"f3"}, "r3" },
1094 { {"f4"}, "r4" },
1095 { {"f5"}, "r5" },
1096 { {"f6"}, "r6" },
1097 { {"f7"}, "r7" },
1098 { {"f8"}, "r8" },
1099 { {"f9"}, "r9" },
1100 { {"f10"}, "r10" },
1101 { {"f11"}, "r11" },
1102 { {"f12"}, "r12" },
1103 { {"f13"}, "r13" },
1104 { {"f14"}, "r14" },
1105 { {"f15"}, "r15" },
1106 { {"f16"}, "r16" },
1107 { {"f17"}, "r17" },
1108 { {"f18"}, "r18" },
1109 { {"f19"}, "r19" },
1110 { {"f20"}, "r20" },
1111 { {"f21"}, "r21" },
1112 { {"f22"}, "r22" },
1113 { {"f23"}, "r23" },
1114 { {"f24"}, "r24" },
1115 { {"f25"}, "r25" },
1116 { {"f26"}, "r26" },
1117 { {"f27"}, "r27" },
1118 { {"f28"}, "r28" },
1119 { {"f29"}, "r29" },
1120 { {"f30"}, "r30" },
1121 { {"f31"}, "r31" },
1122};
1123
1124void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1125 unsigned &NumAliases) const {
1126 Aliases = GCCRegAliases;
1127 NumAliases = llvm::array_lengthof(GCCRegAliases);
1128}
1129} // end anonymous namespace.
1130
1131namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001132// Namespace for x86 abstract base class
1133const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001134#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001135#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001136 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001137#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001138};
Eli Friedman61538a72008-05-20 14:21:01 +00001139
Nuno Lopes2550d702009-12-23 17:49:57 +00001140static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001141 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1142 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001143 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001144 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1145 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1146 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001147 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001148};
1149
Eric Christophercfd323d2011-06-21 00:05:20 +00001150const TargetInfo::AddlRegName AddlRegNames[] = {
1151 { { "al", "ah", "eax", "rax" }, 0 },
1152 { { "bl", "bh", "ebx", "rbx" }, 3 },
1153 { { "cl", "ch", "ecx", "rcx" }, 2 },
1154 { { "dl", "dh", "edx", "rdx" }, 1 },
1155 { { "esi", "rsi" }, 4 },
1156 { { "edi", "rdi" }, 5 },
1157 { { "esp", "rsp" }, 7 },
1158 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001159};
1160
1161// X86 target abstract base class; x86-32 and x86-64 are very close, so
1162// most of the implementation can be shared.
1163class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001164 enum X86SSEEnum {
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001165 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
Chris Lattner84f0ea82009-03-02 22:40:39 +00001166 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001167 enum MMX3DNowEnum {
1168 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1169 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001170
Eric Christophereea12d12010-04-02 23:50:19 +00001171 bool HasAES;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001172 bool HasAVX;
1173
Chandler Carruth499d9722011-09-28 08:55:34 +00001174 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1175 ///
1176 /// Each enumeration represents a particular CPU supported by Clang. These
1177 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1178 enum CPUKind {
1179 CK_Generic,
1180
1181 /// \name i386
1182 /// i386-generation processors.
1183 //@{
1184 CK_i386,
1185 //@}
1186
1187 /// \name i486
1188 /// i486-generation processors.
1189 //@{
1190 CK_i486,
1191 CK_WinChipC6,
1192 CK_WinChip2,
1193 CK_C3,
1194 //@}
1195
1196 /// \name i586
1197 /// i586-generation processors, P5 microarchitecture based.
1198 //@{
1199 CK_i586,
1200 CK_Pentium,
1201 CK_PentiumMMX,
1202 //@}
1203
1204 /// \name i686
1205 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1206 //@{
1207 CK_i686,
1208 CK_PentiumPro,
1209 CK_Pentium2,
1210 CK_Pentium3,
1211 CK_Pentium3M,
1212 CK_PentiumM,
1213 CK_C3_2,
1214
1215 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1216 /// Clang however has some logic to suport this.
1217 // FIXME: Warn, deprecate, and potentially remove this.
1218 CK_Yonah,
1219 //@}
1220
1221 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001222 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001223 //@{
1224 CK_Pentium4,
1225 CK_Pentium4M,
1226 CK_Prescott,
1227 CK_Nocona,
1228 //@}
1229
1230 /// \name Core
1231 /// Core microarchitecture based processors.
1232 //@{
1233 CK_Core2,
1234
1235 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1236 /// codename which GCC no longer accepts as an option to -march, but Clang
1237 /// has some logic for recognizing it.
1238 // FIXME: Warn, deprecate, and potentially remove this.
1239 CK_Penryn,
1240 //@}
1241
1242 /// \name Atom
1243 /// Atom processors
1244 //@{
1245 CK_Atom,
1246 //@}
1247
1248 /// \name Nehalem
1249 /// Nehalem microarchitecture based processors.
1250 //@{
1251 CK_Corei7,
1252 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001253 CK_CoreAVXi,
Chandler Carruth499d9722011-09-28 08:55:34 +00001254 //@}
1255
1256 /// \name K6
1257 /// K6 architecture processors.
1258 //@{
1259 CK_K6,
1260 CK_K6_2,
1261 CK_K6_3,
1262 //@}
1263
1264 /// \name K7
1265 /// K7 architecture processors.
1266 //@{
1267 CK_Athlon,
1268 CK_AthlonThunderbird,
1269 CK_Athlon4,
1270 CK_AthlonXP,
1271 CK_AthlonMP,
1272 //@}
1273
1274 /// \name K8
1275 /// K8 architecture processors.
1276 //@{
1277 CK_Athlon64,
1278 CK_Athlon64SSE3,
1279 CK_AthlonFX,
1280 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001281 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001282 CK_Opteron,
1283 CK_OpteronSSE3,
1284
1285 /// This specification is deprecated and will be removed in the future.
1286 /// Users should prefer \see CK_K8.
1287 // FIXME: Warn on this when the CPU is set to it.
1288 CK_x86_64,
1289 //@}
1290
1291 /// \name Geode
1292 /// Geode processors.
1293 //@{
1294 CK_Geode
1295 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001296 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001297
Eli Friedman618234a2008-08-20 02:34:37 +00001298public:
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001299 X86TargetInfo(const std::string& triple)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001300 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001301 HasAES(false), HasAVX(false), CPU(CK_Generic) {
Eli Friedman618234a2008-08-20 02:34:37 +00001302 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001303 }
1304 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1305 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001306 Records = BuiltinInfo;
1307 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001308 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001309 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001310 unsigned &NumNames) const {
1311 Names = GCCRegNames;
1312 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001313 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001314 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001315 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001316 Aliases = 0;
1317 NumAliases = 0;
1318 }
1319 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1320 unsigned &NumNames) const {
1321 Names = AddlRegNames;
1322 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001323 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001324 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001325 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001326 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001327 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001328 return "~{dirflag},~{fpsr},~{flags}";
1329 }
Chris Lattner33328642009-03-20 15:52:06 +00001330 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001331 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001332 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1333 const std::string &Name,
1334 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001335 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001336 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001337 virtual const char* getABI() const {
1338 return MMX3DNowLevel == NoMMX3DNow ? "no-mmx" : "";
1339 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001340 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001341 CPU = llvm::StringSwitch<CPUKind>(Name)
1342 .Case("i386", CK_i386)
1343 .Case("i486", CK_i486)
1344 .Case("winchip-c6", CK_WinChipC6)
1345 .Case("winchip2", CK_WinChip2)
1346 .Case("c3", CK_C3)
1347 .Case("i586", CK_i586)
1348 .Case("pentium", CK_Pentium)
1349 .Case("pentium-mmx", CK_PentiumMMX)
1350 .Case("i686", CK_i686)
1351 .Case("pentiumpro", CK_PentiumPro)
1352 .Case("pentium2", CK_Pentium2)
1353 .Case("pentium3", CK_Pentium3)
1354 .Case("pentium3m", CK_Pentium3M)
1355 .Case("pentium-m", CK_PentiumM)
1356 .Case("c3-2", CK_C3_2)
1357 .Case("yonah", CK_Yonah)
1358 .Case("pentium4", CK_Pentium4)
1359 .Case("pentium4m", CK_Pentium4M)
1360 .Case("prescott", CK_Prescott)
1361 .Case("nocona", CK_Nocona)
1362 .Case("core2", CK_Core2)
1363 .Case("penryn", CK_Penryn)
1364 .Case("atom", CK_Atom)
1365 .Case("corei7", CK_Corei7)
1366 .Case("corei7-avx", CK_Corei7AVX)
1367 .Case("core-avx-i", CK_CoreAVXi)
1368 .Case("k6", CK_K6)
1369 .Case("k6-2", CK_K6_2)
1370 .Case("k6-3", CK_K6_3)
1371 .Case("athlon", CK_Athlon)
1372 .Case("athlon-tbird", CK_AthlonThunderbird)
1373 .Case("athlon-4", CK_Athlon4)
1374 .Case("athlon-xp", CK_AthlonXP)
1375 .Case("athlon-mp", CK_AthlonMP)
1376 .Case("athlon64", CK_Athlon64)
1377 .Case("athlon64-sse3", CK_Athlon64SSE3)
1378 .Case("athlon-fx", CK_AthlonFX)
1379 .Case("k8", CK_K8)
1380 .Case("k8-sse3", CK_K8SSE3)
1381 .Case("opteron", CK_Opteron)
1382 .Case("opteron-sse3", CK_OpteronSSE3)
1383 .Case("x86-64", CK_x86_64)
1384 .Case("geode", CK_Geode)
1385 .Default(CK_Generic);
1386
Chandler Carruth26a39142011-09-28 09:45:08 +00001387 // Perform any per-CPU checks necessary to determine if this CPU is
1388 // acceptable.
1389 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1390 // invalid without explaining *why*.
1391 switch (CPU) {
1392 case CK_Generic:
1393 // No processor selected!
1394 return false;
1395
1396 case CK_i386:
1397 case CK_i486:
1398 case CK_WinChipC6:
1399 case CK_WinChip2:
1400 case CK_C3:
1401 case CK_i586:
1402 case CK_Pentium:
1403 case CK_PentiumMMX:
1404 case CK_i686:
1405 case CK_PentiumPro:
1406 case CK_Pentium2:
1407 case CK_Pentium3:
1408 case CK_Pentium3M:
1409 case CK_PentiumM:
1410 case CK_Yonah:
1411 case CK_C3_2:
1412 case CK_Pentium4:
1413 case CK_Pentium4M:
1414 case CK_Prescott:
1415 case CK_K6:
1416 case CK_K6_2:
1417 case CK_K6_3:
1418 case CK_Athlon:
1419 case CK_AthlonThunderbird:
1420 case CK_Athlon4:
1421 case CK_AthlonXP:
1422 case CK_AthlonMP:
1423 case CK_Geode:
1424 // Only accept certain architectures when compiling in 32-bit mode.
1425 if (PointerWidth != 32)
1426 return false;
1427
1428 // Fallthrough
1429 case CK_Nocona:
1430 case CK_Core2:
1431 case CK_Penryn:
1432 case CK_Atom:
1433 case CK_Corei7:
1434 case CK_Corei7AVX:
1435 case CK_CoreAVXi:
1436 case CK_Athlon64:
1437 case CK_Athlon64SSE3:
1438 case CK_AthlonFX:
1439 case CK_K8:
1440 case CK_K8SSE3:
1441 case CK_Opteron:
1442 case CK_OpteronSSE3:
1443 case CK_x86_64:
1444 return true;
1445 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001446 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001447 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001448};
Chris Lattner3daed522009-03-02 22:20:04 +00001449
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001450void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001451 // FIXME: This should not be here.
1452 Features["3dnow"] = false;
1453 Features["3dnowa"] = false;
1454 Features["mmx"] = false;
1455 Features["sse"] = false;
1456 Features["sse2"] = false;
1457 Features["sse3"] = false;
1458 Features["ssse3"] = false;
1459 Features["sse41"] = false;
1460 Features["sse42"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001461 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001462 Features["avx"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001463
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001464 // LLVM does not currently recognize this.
1465 // Features["sse4a"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001466
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001467 // FIXME: This *really* should not be here.
1468
1469 // X86_64 always has SSE2.
1470 if (PointerWidth == 64)
1471 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1472
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001473 switch (CPU) {
1474 case CK_Generic:
1475 case CK_i386:
1476 case CK_i486:
1477 case CK_i586:
1478 case CK_Pentium:
1479 case CK_i686:
1480 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001481 break;
1482 case CK_PentiumMMX:
1483 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001484 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001485 break;
1486 case CK_Pentium3:
1487 case CK_Pentium3M:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001488 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001489 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001490 break;
1491 case CK_PentiumM:
1492 case CK_Pentium4:
1493 case CK_Pentium4M:
1494 case CK_x86_64:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001495 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001496 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001497 break;
1498 case CK_Yonah:
1499 case CK_Prescott:
1500 case CK_Nocona:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001501 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001502 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001503 break;
1504 case CK_Core2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001505 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001506 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001507 break;
1508 case CK_Penryn:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001509 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001510 setFeatureEnabled(Features, "sse4", true);
1511 Features["sse42"] = false;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001512 break;
1513 case CK_Atom:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001514 setFeatureEnabled(Features, "mmx", true);
Chandler Carruth49defe62011-09-28 10:36:46 +00001515 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001516 break;
1517 case CK_Corei7:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001518 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001519 setFeatureEnabled(Features, "sse4", true);
Eric Christophereea12d12010-04-02 23:50:19 +00001520 setFeatureEnabled(Features, "aes", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001521 break;
1522 case CK_Corei7AVX:
1523 case CK_CoreAVXi:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001524 setFeatureEnabled(Features, "mmx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00001525 setFeatureEnabled(Features, "sse4", true);
1526 setFeatureEnabled(Features, "aes", true);
Bruno Cardoso Lopese02d3912011-07-11 23:33:46 +00001527 //setFeatureEnabled(Features, "avx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001528 break;
1529 case CK_K6:
1530 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001531 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001532 break;
1533 case CK_K6_2:
1534 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001535 case CK_WinChip2:
1536 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001537 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001538 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00001539 case CK_Athlon:
1540 case CK_AthlonThunderbird:
1541 case CK_Geode:
1542 setFeatureEnabled(Features, "3dnowa", true);
1543 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001544 case CK_Athlon4:
1545 case CK_AthlonXP:
1546 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001547 setFeatureEnabled(Features, "sse", true);
1548 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001549 break;
1550 case CK_K8:
1551 case CK_Opteron:
1552 case CK_Athlon64:
1553 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00001554 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001555 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001556 break;
1557 case CK_K8SSE3:
1558 case CK_OpteronSSE3:
1559 case CK_Athlon64SSE3:
Roman Divackyc8b09a12010-12-29 13:28:29 +00001560 setFeatureEnabled(Features, "sse3", true);
1561 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001562 break;
1563 case CK_C3_2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001564 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001565 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001566 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001567 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001568}
1569
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001570bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump1eb44332009-09-09 15:08:12 +00001571 const std::string &Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001572 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00001573 // FIXME: This *really* should not be here. We need some way of translating
1574 // options into llvm subtarget features.
1575 if (!Features.count(Name) &&
1576 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001577 return false;
1578
1579 if (Enabled) {
1580 if (Name == "mmx")
1581 Features["mmx"] = true;
1582 else if (Name == "sse")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001583 Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001584 else if (Name == "sse2")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001585 Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001586 else if (Name == "sse3")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001587 Features["sse"] = Features["sse2"] = Features["sse3"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001588 else if (Name == "ssse3")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001589 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001590 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001591 else if (Name == "sse4" || Name == "sse4.2")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001592 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001593 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001594 else if (Name == "sse4.1")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001595 Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00001596 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001597 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001598 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001599 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001600 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00001601 else if (Name == "aes")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001602 Features["aes"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001603 else if (Name == "avx")
Bruno Cardoso Lopes292772c2011-08-18 00:07:03 +00001604 Features["avx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1605 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001606 } else {
1607 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001608 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001609 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00001610 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001611 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001612 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00001613 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001614 Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001615 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00001616 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001617 Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001618 else if (Name == "ssse3")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001619 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00001620 else if (Name == "sse4" || Name == "sse4.1")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001621 Features["sse41"] = Features["sse42"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00001622 else if (Name == "sse4.2")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001623 Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001624 else if (Name == "3dnow")
1625 Features["3dnow"] = Features["3dnowa"] = false;
1626 else if (Name == "3dnowa")
1627 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001628 else if (Name == "aes")
1629 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001630 else if (Name == "avx")
1631 Features["avx"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001632 }
1633
1634 return true;
1635}
1636
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001637/// HandleTargetOptions - Perform initialization based on the user
1638/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001639void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001640 // Remember the maximum enabled sselevel.
1641 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1642 // Ignore disabled features.
1643 if (Features[i][0] == '-')
1644 continue;
1645
Eric Christophereea12d12010-04-02 23:50:19 +00001646 if (Features[i].substr(1) == "aes") {
1647 HasAES = true;
1648 continue;
1649 }
1650
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001651 // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1652 // For now let it be enabled together with other SSE levels.
1653 if (Features[i].substr(1) == "avx") {
1654 HasAVX = true;
1655 continue;
1656 }
1657
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001658 assert(Features[i][0] == '+' && "Invalid target feature!");
1659 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1660 .Case("sse42", SSE42)
1661 .Case("sse41", SSE41)
1662 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00001663 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001664 .Case("sse2", SSE2)
1665 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001666 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001667 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001668
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001669 MMX3DNowEnum ThreeDNowLevel =
1670 llvm::StringSwitch<MMX3DNowEnum>(Features[i].substr(1))
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001671 .Case("3dnowa", AMD3DNowAthlon)
1672 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001673 .Case("mmx", MMX)
1674 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001675
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001676 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001677 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001678
1679 // Don't tell the backend if we're turning off mmx; it will end up disabling
1680 // SSE, which we don't want.
1681 std::vector<std::string>::iterator it;
1682 it = std::find(Features.begin(), Features.end(), "-mmx");
1683 if (it != Features.end())
1684 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00001685}
Chris Lattnerc0f59212009-03-02 22:27:17 +00001686
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001687/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
1688/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00001689void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001690 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00001691 // Target identification.
1692 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00001693 Builder.defineMacro("_LP64");
1694 Builder.defineMacro("__LP64__");
1695 Builder.defineMacro("__amd64__");
1696 Builder.defineMacro("__amd64");
1697 Builder.defineMacro("__x86_64");
1698 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00001699 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00001700 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00001701 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001702
Chris Lattnerc0f59212009-03-02 22:27:17 +00001703 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001704 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
1705 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001706 switch (CPU) {
1707 case CK_Generic:
1708 break;
1709 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001710 // The rest are coming from the i386 define above.
1711 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001712 break;
1713 case CK_i486:
1714 case CK_WinChipC6:
1715 case CK_WinChip2:
1716 case CK_C3:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001717 Builder.defineMacro("__i486");
1718 Builder.defineMacro("__i486__");
1719 Builder.defineMacro("__tune_i486__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001720 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00001721 case CK_PentiumMMX:
1722 Builder.defineMacro("__pentium_mmx__");
1723 Builder.defineMacro("__tune_pentium_mmx__");
1724 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001725 case CK_i586:
1726 case CK_Pentium:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001727 Builder.defineMacro("__i586");
1728 Builder.defineMacro("__i586__");
1729 Builder.defineMacro("__tune_i586__");
1730 Builder.defineMacro("__pentium");
1731 Builder.defineMacro("__pentium__");
1732 Builder.defineMacro("__tune_pentium__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001733 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001734 case CK_Pentium3:
1735 case CK_Pentium3M:
1736 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001737 Builder.defineMacro("__tune_pentium3__");
1738 // Fallthrough
1739 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001740 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001741 Builder.defineMacro("__tune_pentium2__");
1742 // Fallthrough
1743 case CK_PentiumPro:
1744 Builder.defineMacro("__tune_i686__");
1745 Builder.defineMacro("__tune_pentiumpro__");
1746 // Fallthrough
1747 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001748 Builder.defineMacro("__i686");
1749 Builder.defineMacro("__i686__");
1750 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
1751 Builder.defineMacro("__pentiumpro");
1752 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001753 break;
1754 case CK_Pentium4:
1755 case CK_Pentium4M:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001756 Builder.defineMacro("__pentium4");
1757 Builder.defineMacro("__pentium4__");
1758 Builder.defineMacro("__tune_pentium4__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001759 break;
1760 case CK_Yonah:
1761 case CK_Prescott:
1762 case CK_Nocona:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001763 Builder.defineMacro("__nocona");
1764 Builder.defineMacro("__nocona__");
1765 Builder.defineMacro("__tune_nocona__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001766 break;
1767 case CK_Core2:
1768 case CK_Penryn:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001769 Builder.defineMacro("__core2");
1770 Builder.defineMacro("__core2__");
1771 Builder.defineMacro("__tune_core2__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001772 break;
1773 case CK_Atom:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001774 Builder.defineMacro("__atom");
1775 Builder.defineMacro("__atom__");
1776 Builder.defineMacro("__tune_atom__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001777 break;
1778 case CK_Corei7:
1779 case CK_Corei7AVX:
1780 case CK_CoreAVXi:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001781 Builder.defineMacro("__corei7");
1782 Builder.defineMacro("__corei7__");
1783 Builder.defineMacro("__tune_corei7__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001784 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001785 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001786 Builder.defineMacro("__k6_2__");
1787 Builder.defineMacro("__tune_k6_2__");
1788 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001789 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001790 if (CPU != CK_K6_2) { // In case of fallthrough
1791 // FIXME: GCC may be enabling these in cases where some other k6
1792 // architecture is specified but -m3dnow is explicitly provided. The
1793 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001794 Builder.defineMacro("__k6_3__");
1795 Builder.defineMacro("__tune_k6_3__");
1796 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00001797 // Fallthrough
1798 case CK_K6:
1799 Builder.defineMacro("__k6");
1800 Builder.defineMacro("__k6__");
1801 Builder.defineMacro("__tune_k6__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001802 break;
1803 case CK_Athlon:
1804 case CK_AthlonThunderbird:
1805 case CK_Athlon4:
1806 case CK_AthlonXP:
1807 case CK_AthlonMP:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001808 Builder.defineMacro("__athlon");
1809 Builder.defineMacro("__athlon__");
1810 Builder.defineMacro("__tune_athlon__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001811 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001812 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001813 Builder.defineMacro("__tune_athlon_sse__");
1814 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001815 break;
1816 case CK_K8:
1817 case CK_K8SSE3:
1818 case CK_x86_64:
1819 case CK_Opteron:
1820 case CK_OpteronSSE3:
1821 case CK_Athlon64:
1822 case CK_Athlon64SSE3:
1823 case CK_AthlonFX:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001824 Builder.defineMacro("__k8");
1825 Builder.defineMacro("__k8__");
1826 Builder.defineMacro("__tune_k8__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001827 break;
1828 case CK_Geode:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001829 Builder.defineMacro("__geode");
1830 Builder.defineMacro("__geode__");
1831 Builder.defineMacro("__tune_geode__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001832 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001833 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00001834
Chandler Carruth88c75b02011-09-28 09:54:07 +00001835 // Target properties.
1836 Builder.defineMacro("__LITTLE_ENDIAN__");
1837 Builder.defineMacro("__REGISTER_PREFIX__", "");
1838
Chris Lattner54175442009-04-19 17:32:33 +00001839 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1840 // functions in glibc header files that use FP Stack inline asm which the
1841 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00001842 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001843
Chandler Carruth88c75b02011-09-28 09:54:07 +00001844 if (HasAES)
1845 Builder.defineMacro("__AES__");
1846
1847 if (HasAVX)
1848 Builder.defineMacro("__AVX__");
1849
Chris Lattner84f0ea82009-03-02 22:40:39 +00001850 // Each case falls through to the previous one here.
1851 switch (SSELevel) {
1852 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00001853 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001854 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00001855 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001856 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00001857 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001858 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00001859 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001860 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00001861 Builder.defineMacro("__SSE2__");
1862 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00001863 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00001864 Builder.defineMacro("__SSE__");
1865 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001866 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00001867 break;
1868 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00001869
Francois Pichet62ec1f22011-09-17 17:15:52 +00001870 if (Opts.MicrosoftExt && PointerWidth == 32) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001871 switch (SSELevel) {
Michael J. Spencera764e832010-10-21 08:22:51 +00001872 case SSE42:
1873 case SSE41:
1874 case SSSE3:
1875 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001876 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001877 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001878 break;
1879 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001880 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001881 break;
1882 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001883 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001884 }
1885 }
1886
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001887 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001888 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001889 case AMD3DNowAthlon:
1890 Builder.defineMacro("__3dNOW_A__");
1891 case AMD3DNow:
1892 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001893 case MMX:
1894 Builder.defineMacro("__MMX__");
1895 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001896 break;
1897 }
Chris Lattnerc0f59212009-03-02 22:27:17 +00001898}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001899
1900
Eli Friedman618234a2008-08-20 02:34:37 +00001901bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001902X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00001903 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001904 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00001905 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00001906 case 'Y': // first letter of a pair:
1907 switch (*(Name+1)) {
1908 default: return false;
1909 case '0': // First SSE register.
1910 case 't': // Any SSE register, when SSE2 is enabled.
1911 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
1912 case 'm': // any MMX register, when inter-unit moves enabled.
1913 break; // falls through to setAllowsRegister.
1914 }
Eli Friedman618234a2008-08-20 02:34:37 +00001915 case 'a': // eax.
1916 case 'b': // ebx.
1917 case 'c': // ecx.
1918 case 'd': // edx.
1919 case 'S': // esi.
1920 case 'D': // edi.
1921 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00001922 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00001923 case 't': // top of floating point stack.
1924 case 'u': // second from top of floating point stack.
1925 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00001926 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00001927 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00001928 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00001929 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
1930 case 'l': // "Index" registers: any general register that can be used as an
1931 // index in a base+index memory access.
1932 Info.setAllowsRegister();
1933 return true;
1934 case 'C': // SSE floating point constant.
1935 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001936 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00001937 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001938 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00001939 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00001940 return true;
1941 }
Dale Johannesen545be512010-08-24 22:33:12 +00001942 return false;
Eli Friedman618234a2008-08-20 02:34:37 +00001943}
1944
Dale Johannesenf6e2c202010-10-29 23:12:32 +00001945
Eli Friedman618234a2008-08-20 02:34:37 +00001946std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00001947X86TargetInfo::convertConstraint(const char *&Constraint) const {
1948 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00001949 case 'a': return std::string("{ax}");
1950 case 'b': return std::string("{bx}");
1951 case 'c': return std::string("{cx}");
1952 case 'd': return std::string("{dx}");
1953 case 'S': return std::string("{si}");
1954 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00001955 case 'p': // address
1956 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00001957 case 't': // top of floating point stack.
1958 return std::string("{st}");
1959 case 'u': // second from top of floating point stack.
1960 return std::string("{st(1)}"); // second from top of floating point stack.
1961 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00001962 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00001963 }
1964}
Eli Friedman618234a2008-08-20 02:34:37 +00001965} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00001966
1967namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001968// X86-32 generic target
1969class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001970public:
Eli Friedman618234a2008-08-20 02:34:37 +00001971 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1972 DoubleAlign = LongLongAlign = 32;
1973 LongDoubleWidth = 96;
1974 LongDoubleAlign = 32;
Eli Friedmaned855cb2008-08-21 00:13:15 +00001975 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1976 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00001977 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00001978 SizeType = UnsignedInt;
1979 PtrDiffType = SignedInt;
1980 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00001981 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00001982
1983 // Use fpret for all types.
1984 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
1985 (1 << TargetInfo::Double) |
1986 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00001987
1988 // x86-32 has atomics up to 8 bytes
1989 // FIXME: Check that we actually have cmpxchg8b before setting
1990 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
1991 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00001992 }
1993 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00001994 return "typedef char* __builtin_va_list;";
Eli Friedman618234a2008-08-20 02:34:37 +00001995 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00001996
Chris Lattner21fb98e2009-09-23 06:06:36 +00001997 int getEHDataRegisterNumber(unsigned RegNo) const {
1998 if (RegNo == 0) return 0;
1999 if (RegNo == 1) return 2;
2000 return -1;
2001 }
Eli Friedman618234a2008-08-20 02:34:37 +00002002};
2003} // end anonymous namespace
2004
2005namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002006class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2007public:
2008 OpenBSDI386TargetInfo(const std::string& triple) :
2009 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2010 SizeType = UnsignedLong;
2011 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002012 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002013 }
2014};
2015} // end anonymous namespace
2016
2017namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002018class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002019public:
Torok Edwin5f6c1942009-06-30 17:10:35 +00002020 DarwinI386TargetInfo(const std::string& triple) :
2021 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002022 LongDoubleWidth = 128;
2023 LongDoubleAlign = 128;
Eli Friedman1afabd92009-03-29 20:31:09 +00002024 SizeType = UnsignedLong;
2025 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002026 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2027 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002028 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002029 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002030 }
2031
Eli Friedman618234a2008-08-20 02:34:37 +00002032};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002033} // end anonymous namespace
2034
2035namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002036// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002037class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002038public:
2039 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002040 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002041 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002042 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002043 DoubleAlign = LongLongAlign = 64;
2044 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 +00002045 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002046 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002047 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002048 virtual void getTargetDefines(const LangOptions &Opts,
2049 MacroBuilder &Builder) const {
2050 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2051 }
2052};
2053} // end anonymous namespace
2054
2055namespace {
2056
2057// x86-32 Windows Visual Studio target
2058class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2059public:
2060 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2061 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002062 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002063 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2064 }
2065 virtual void getTargetDefines(const LangOptions &Opts,
2066 MacroBuilder &Builder) const {
2067 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2068 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2069 // The value of the following reflects processor type.
2070 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2071 // We lost the original triple, so we use the default.
2072 Builder.defineMacro("_M_IX86", "600");
2073 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002074};
2075} // end anonymous namespace
2076
2077namespace {
2078// x86-32 MinGW target
2079class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2080public:
2081 MinGWX86_32TargetInfo(const std::string& triple)
2082 : WindowsX86_32TargetInfo(triple) {
2083 }
2084 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002085 MacroBuilder &Builder) const {
2086 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002087 DefineStd(Builder, "WIN32", Opts);
2088 DefineStd(Builder, "WINNT", Opts);
2089 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002090 Builder.defineMacro("__MSVCRT__");
2091 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002092
2093 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2094 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002095 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002096 // Provide "as-is" __declspec.
2097 Builder.defineMacro("__declspec", "__declspec");
2098 else
2099 // Provide alias of __attribute__ like mingw32-gcc.
2100 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002101 }
2102};
2103} // end anonymous namespace
2104
2105namespace {
2106// x86-32 Cygwin target
2107class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2108public:
2109 CygwinX86_32TargetInfo(const std::string& triple)
2110 : X86_32TargetInfo(triple) {
2111 TLSSupported = false;
2112 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002113 DoubleAlign = LongLongAlign = 64;
2114 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2115 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002116 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002117 }
2118 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002119 MacroBuilder &Builder) const {
2120 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2121 Builder.defineMacro("__CYGWIN__");
2122 Builder.defineMacro("__CYGWIN32__");
2123 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00002124 if (Opts.CPlusPlus)
2125 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00002126 }
Eli Friedman29a30502008-08-21 01:40:19 +00002127};
2128} // end anonymous namespace
2129
2130namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002131// x86-32 Haiku target
2132class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2133public:
2134 HaikuX86_32TargetInfo(const std::string& triple)
2135 : X86_32TargetInfo(triple) {
2136 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00002137 IntPtrType = SignedLong;
2138 PtrDiffType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00002139 this->UserLabelPrefix = "";
Eli Friedmana7e68452010-08-22 01:00:03 +00002140 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00002141 virtual void getTargetDefines(const LangOptions &Opts,
2142 MacroBuilder &Builder) const {
2143 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2144 Builder.defineMacro("__INTEL__");
2145 Builder.defineMacro("__HAIKU__");
2146 }
2147};
2148} // end anonymous namespace
2149
Douglas Gregordca52262011-07-01 22:41:14 +00002150// RTEMS Target
2151template<typename Target>
2152class RTEMSTargetInfo : public OSTargetInfo<Target> {
2153protected:
2154 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2155 MacroBuilder &Builder) const {
2156 // RTEMS defines; list based off of gcc output
2157
Douglas Gregordca52262011-07-01 22:41:14 +00002158 Builder.defineMacro("__rtems__");
2159 Builder.defineMacro("__ELF__");
2160 }
2161public:
2162 RTEMSTargetInfo(const std::string &triple)
2163 : OSTargetInfo<Target>(triple) {
2164 this->UserLabelPrefix = "";
2165
2166 llvm::Triple Triple(triple);
2167 switch (Triple.getArch()) {
2168 default:
2169 case llvm::Triple::x86:
2170 // this->MCountName = ".mcount";
2171 break;
2172 case llvm::Triple::mips:
2173 case llvm::Triple::mipsel:
2174 case llvm::Triple::ppc:
2175 case llvm::Triple::ppc64:
2176 // this->MCountName = "_mcount";
2177 break;
2178 case llvm::Triple::arm:
2179 // this->MCountName = "__mcount";
2180 break;
2181 }
2182
2183 }
2184};
2185
2186namespace {
2187// x86-32 RTEMS target
2188class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2189public:
2190 RTEMSX86_32TargetInfo(const std::string& triple)
2191 : X86_32TargetInfo(triple) {
2192 SizeType = UnsignedLong;
2193 IntPtrType = SignedLong;
2194 PtrDiffType = SignedLong;
2195 this->UserLabelPrefix = "";
2196 }
2197 virtual void getTargetDefines(const LangOptions &Opts,
2198 MacroBuilder &Builder) const {
2199 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2200 Builder.defineMacro("__INTEL__");
2201 Builder.defineMacro("__rtems__");
2202 }
2203};
2204} // end anonymous namespace
2205
Chris Lattner86ed3a32010-04-11 19:29:39 +00002206namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002207// x86-64 generic target
2208class X86_64TargetInfo : public X86TargetInfo {
2209public:
Chris Lattner33328642009-03-20 15:52:06 +00002210 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00002211 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002212 LongDoubleWidth = 128;
2213 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00002214 LargeArrayMinWidth = 128;
2215 LargeArrayAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00002216 IntMaxType = SignedLong;
2217 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002218 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002219 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00002220
Eli Friedmaned855cb2008-08-21 00:13:15 +00002221 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2222 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002223 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002224
2225 // Use fpret only for long double.
2226 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00002227
2228 // x86-64 has atomics up to 16 bytes.
2229 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
2230 // on CPUs with cmpxchg16b
2231 MaxAtomicPromoteWidth = 128;
2232 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00002233 }
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00002234 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002235 return "typedef struct __va_list_tag {"
2236 " unsigned gp_offset;"
2237 " unsigned fp_offset;"
2238 " void* overflow_arg_area;"
2239 " void* reg_save_area;"
John McCall2b7baf02010-05-28 18:25:28 +00002240 "} __va_list_tag;"
Eli Friedmandc043162009-07-03 00:45:06 +00002241 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson3346ae62007-11-24 23:38:12 +00002242 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002243
Chris Lattner21fb98e2009-09-23 06:06:36 +00002244 int getEHDataRegisterNumber(unsigned RegNo) const {
2245 if (RegNo == 0) return 0;
2246 if (RegNo == 1) return 1;
2247 return -1;
2248 }
Eli Friedman618234a2008-08-20 02:34:37 +00002249};
2250} // end anonymous namespace
2251
2252namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002253// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002254class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002255public:
2256 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002257 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002258 TLSSupported = false;
2259 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00002260 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00002261 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00002262 IntMaxType = SignedLongLong;
2263 UIntMaxType = UnsignedLongLong;
2264 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00002265 SizeType = UnsignedLongLong;
2266 PtrDiffType = SignedLongLong;
2267 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00002268 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002269 }
2270 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002271 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002272 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002273 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00002274 }
NAKAMURA Takumi79521992011-01-17 22:56:23 +00002275 virtual const char *getVAListDeclaration() const {
2276 return "typedef char* __builtin_va_list;";
2277 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002278};
2279} // end anonymous namespace
2280
2281namespace {
2282// x86-64 Windows Visual Studio target
2283class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2284public:
2285 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2286 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002287 LongDoubleWidth = LongDoubleAlign = 64;
2288 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00002289 }
2290 virtual void getTargetDefines(const LangOptions &Opts,
2291 MacroBuilder &Builder) const {
2292 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
2293 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00002294 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002295 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002296 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002297};
2298} // end anonymous namespace
2299
2300namespace {
2301// x86-64 MinGW target
2302class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2303public:
2304 MinGWX86_64TargetInfo(const std::string& triple)
2305 : WindowsX86_64TargetInfo(triple) {
2306 }
2307 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002308 MacroBuilder &Builder) const {
2309 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002310 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00002311 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00002312 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00002313 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002314
2315 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2316 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002317 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002318 // Provide "as-is" __declspec.
2319 Builder.defineMacro("__declspec", "__declspec");
2320 else
2321 // Provide alias of __attribute__ like mingw32-gcc.
2322 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002323 }
2324};
2325} // end anonymous namespace
2326
2327namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002328class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2329public:
Mike Stump1eb44332009-09-09 15:08:12 +00002330 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002331 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2332 Int64Type = SignedLongLong;
2333 }
2334};
2335} // end anonymous namespace
2336
2337namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00002338class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
2339public:
Mike Stump1eb44332009-09-09 15:08:12 +00002340 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman6036ebe2009-07-05 22:31:18 +00002341 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
2342 IntMaxType = SignedLongLong;
2343 UIntMaxType = UnsignedLongLong;
2344 Int64Type = SignedLongLong;
2345 }
2346};
2347} // end anonymous namespace
2348
2349namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00002350class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002351 // Possible FPU choices.
2352 enum FPUMode {
2353 NoFPU,
2354 VFP2FPU,
2355 VFP3FPU,
2356 NeonFPU
2357 };
2358
2359 static bool FPUModeIsVFP(FPUMode Mode) {
2360 return Mode >= VFP2FPU && Mode <= NeonFPU;
2361 }
2362
2363 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2364 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002365
Daniel Dunbareac7c532009-12-18 18:42:37 +00002366 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002367
2368 unsigned FPU : 3;
2369
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002370 unsigned IsThumb : 1;
2371
2372 // Initialized via features.
2373 unsigned SoftFloat : 1;
2374 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002375
Chris Lattner2752c012010-03-03 19:03:45 +00002376 static const Builtin::Info BuiltinInfo[];
2377
Chris Lattner393ff042008-04-21 18:56:49 +00002378public:
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002379 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbareac7c532009-12-18 18:42:37 +00002380 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002381 {
Daniel Dunbara2a41612009-09-14 00:02:24 +00002382 SizeType = UnsignedInt;
2383 PtrDiffType = SignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002384
Chris Lattner9bffb072010-04-23 16:29:58 +00002385 // {} in inline assembly are neon specifiers, not assembly variant
2386 // specifiers.
2387 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00002388
Daniel Dunbareac7c532009-12-18 18:42:37 +00002389 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00002390 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002391 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002392 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2393 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002394 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
2395 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002396 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002397 } else {
2398 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2399 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002400 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002401 }
John McCallee79a4c2010-08-21 22:46:04 +00002402
2403 // ARM targets default to using the ARM C++ ABI.
2404 CXXABI = CXXABI_ARM;
Eli Friedman2be46072011-10-14 20:59:01 +00002405
2406 // ARM has atomics up to 8 bytes
2407 // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e
2408 MaxAtomicPromoteWidth = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002409 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002410 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00002411 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002412 ABI = Name;
2413
Daniel Dunbara2a41612009-09-14 00:02:24 +00002414 // The defaults (above) are for AAPCS, check if we need to change them.
2415 //
2416 // FIXME: We need support for -meabi... we could just mangle it into the
2417 // name.
2418 if (Name == "apcs-gnu") {
Daniel Dunbard410fa22010-01-27 20:23:08 +00002419 DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002420 SizeType = UnsignedLong;
2421
Daniel Dunbar684de632010-04-22 16:14:54 +00002422 // Do not respect the alignment of bit-field types when laying out
2423 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
2424 UseBitFieldTypeAlignment = false;
2425
Chad Rosier61a62212011-08-04 01:21:14 +00002426 /// Do force alignment of members that follow zero length bitfields. If
2427 /// the alignment of the zero-length bitfield is greater than the member
2428 /// that follows it, `bar', `bar' will be aligned as the type of the
2429 /// zero length bitfield.
2430 UseZeroLengthBitfieldAlignment = true;
2431
2432 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00002433 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
2434 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00002435 ZeroLengthBitfieldBoundary = 32;
2436
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002437 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002438 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2439 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002440 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 +00002441 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002442 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002443 } else {
2444 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 +00002445 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002446 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002447 }
2448
Chad Rosier9f1210c2011-07-26 07:03:04 +00002449 // FIXME: Override "preferred align" for double and long long.
Daniel Dunbara2a41612009-09-14 00:02:24 +00002450 } else if (Name == "aapcs") {
2451 // FIXME: Enumerated types are variable width in straight AAPCS.
2452 } else if (Name == "aapcs-linux") {
Chad Rosier9f1210c2011-07-26 07:03:04 +00002453 ;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002454 } else
2455 return false;
2456
2457 return true;
2458 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002459
Chandler Carruthc3a2e652011-09-28 05:56:05 +00002460 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002461 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
2462 Features["vfp2"] = true;
2463 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
2464 Features["neon"] = true;
2465 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002466
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002467 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2468 const std::string &Name,
2469 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00002470 if (Name == "soft-float" || Name == "soft-float-abi" ||
2471 Name == "vfp2" || Name == "vfp3" || Name == "neon") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002472 Features[Name] = Enabled;
2473 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002474 return false;
2475
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002476 return true;
2477 }
2478
2479 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002480 FPU = NoFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002481 SoftFloat = SoftFloatABI = false;
2482 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
2483 if (Features[i] == "+soft-float")
2484 SoftFloat = true;
2485 else if (Features[i] == "+soft-float-abi")
2486 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002487 else if (Features[i] == "+vfp2")
2488 FPU = VFP2FPU;
2489 else if (Features[i] == "+vfp3")
2490 FPU = VFP3FPU;
2491 else if (Features[i] == "+neon")
2492 FPU = NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002493 }
2494
2495 // Remove front-end specific options which the backend handles differently.
2496 std::vector<std::string>::iterator it;
2497 it = std::find(Features.begin(), Features.end(), "+soft-float");
2498 if (it != Features.end())
2499 Features.erase(it);
2500 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2501 if (it != Features.end())
2502 Features.erase(it);
2503 }
2504
Chris Lattner5f9e2722011-07-23 10:55:15 +00002505 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00002506 return llvm::StringSwitch<const char*>(Name)
2507 .Cases("arm8", "arm810", "4")
2508 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2509 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2510 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2511 .Case("ep9312", "4T")
2512 .Cases("arm10tdmi", "arm1020t", "5T")
2513 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2514 .Case("arm926ej-s", "5TEJ")
2515 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2516 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002517 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002518 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002519 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002520 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2521 .Cases("cortex-a8", "cortex-a9", "7A")
Bob Wilson06f45632011-01-06 16:57:20 +00002522 .Case("cortex-m3", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00002523 .Case("cortex-m0", "6M")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002524 .Default(0);
2525 }
2526 virtual bool setCPU(const std::string &Name) {
2527 if (!getCPUDefineSuffix(Name))
2528 return false;
2529
2530 CPU = Name;
2531 return true;
2532 }
Chris Lattner33328642009-03-20 15:52:06 +00002533 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002534 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002535 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00002536 Builder.defineMacro("__arm");
2537 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002538
Chris Lattnerc0f59212009-03-02 22:27:17 +00002539 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00002540 Builder.defineMacro("__ARMEL__");
2541 Builder.defineMacro("__LITTLE_ENDIAN__");
2542 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002543
Chris Lattner5f9e2722011-07-23 10:55:15 +00002544 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00002545 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002546
Mike Stump437bb4b2009-04-08 02:07:04 +00002547 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002548
Daniel Dunbareac7c532009-12-18 18:42:37 +00002549 // FIXME: It's more complicated than this and we don't really support
2550 // interworking.
2551 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00002552 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002553
Daniel Dunbareac7c532009-12-18 18:42:37 +00002554 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramera9992772010-01-09 17:55:51 +00002555 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002556
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002557 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00002558 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002559
2560 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00002561 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002562
Bob Wilson84f95cf2011-05-13 18:56:03 +00002563 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002564 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002565 Builder.defineMacro("__THUMBEL__");
2566 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00002567 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002568 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002569 }
2570
2571 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00002572 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002573
2574 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramera9992772010-01-09 17:55:51 +00002575 Builder.defineMacro("__VFP_FP__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002576
2577 // This only gets set when Neon instructions are actually available, unlike
2578 // the VFP define, hence the soft float and arch check. This is subtly
2579 // different from gcc, we follow the intent which was that it should be set
2580 // when Neon instructions are actually available.
Bob Wilson84f95cf2011-05-13 18:56:03 +00002581 if (FPU == NeonFPU && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002582 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00002583 }
2584 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2585 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00002586 Records = BuiltinInfo;
2587 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00002588 }
2589 virtual const char *getVAListDeclaration() const {
John McCall0e9972c2011-05-09 02:19:37 +00002590 return "typedef void* __builtin_va_list;";
Chris Lattner393ff042008-04-21 18:56:49 +00002591 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002592 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002593 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002594 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002595 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002596 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002597 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002598 // FIXME: Check if this is complete
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002599 switch (*Name) {
Eli Friedmana9f54962008-08-20 07:44:10 +00002600 default:
Nate Begemanad487f42008-04-22 05:03:19 +00002601 case 'l': // r0-r7
2602 case 'h': // r8-r15
2603 case 'w': // VFP Floating point register single precision
2604 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00002605 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00002606 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00002607 case 'Q': // A memory address that is a single base register.
2608 Info.setAllowsMemory();
2609 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00002610 case 'U': // a memory reference...
2611 switch (Name[1]) {
2612 case 'q': // ...ARMV4 ldrsb
2613 case 'v': // ...VFP load/store (reg+constant offset)
2614 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00002615 case 't': // address valid for load/store opaque types wider
2616 // than 128-bits
2617 case 'n': // valid address for Neon doubleword vector load/store
2618 case 'm': // valid address for Neon element and structure load/store
2619 case 's': // valid address for non-offset loads/stores of quad-word
2620 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00002621 Info.setAllowsMemory();
2622 Name++;
2623 return true;
2624 }
Nate Begemanad487f42008-04-22 05:03:19 +00002625 }
Chris Lattner393ff042008-04-21 18:56:49 +00002626 return false;
2627 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00002628 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00002629 std::string R;
2630 switch (*Constraint) {
2631 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00002632 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00002633 Constraint++;
2634 break;
Eric Christopher283f4472011-06-17 00:40:18 +00002635 case 'p': // 'p' should be translated to 'r' by default.
2636 R = std::string("r");
2637 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00002638 default:
2639 return std::string(1, *Constraint);
2640 }
2641 return R;
2642 }
Chris Lattner393ff042008-04-21 18:56:49 +00002643 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002644 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00002645 return "";
2646 }
2647};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002648
2649const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002650 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002651 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002652 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
2653
2654 // Float registers
2655 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2656 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2657 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002658 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002659
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002660 // Double registers
2661 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
2662 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00002663 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
2664 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002665
2666 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00002667 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
2668 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002669};
2670
2671void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002672 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002673 Names = GCCRegNames;
2674 NumNames = llvm::array_lengthof(GCCRegNames);
2675}
2676
2677const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002678 { { "a1" }, "r0" },
2679 { { "a2" }, "r1" },
2680 { { "a3" }, "r2" },
2681 { { "a4" }, "r3" },
2682 { { "v1" }, "r4" },
2683 { { "v2" }, "r5" },
2684 { { "v3" }, "r6" },
2685 { { "v4" }, "r7" },
2686 { { "v5" }, "r8" },
2687 { { "v6", "rfp" }, "r9" },
2688 { { "sl" }, "r10" },
2689 { { "fp" }, "r11" },
2690 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002691 { { "r13" }, "sp" },
2692 { { "r14" }, "lr" },
2693 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002694 // The S, D and Q registers overlap, but aren't really aliases; we
2695 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002696};
2697
2698void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2699 unsigned &NumAliases) const {
2700 Aliases = GCCRegAliases;
2701 NumAliases = llvm::array_lengthof(GCCRegAliases);
2702}
Chris Lattner2752c012010-03-03 19:03:45 +00002703
2704const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00002705#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00002706#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00002707 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00002708#include "clang/Basic/BuiltinsARM.def"
2709};
Chris Lattner393ff042008-04-21 18:56:49 +00002710} // end anonymous namespace.
2711
Eli Friedmana9f54962008-08-20 07:44:10 +00002712
2713namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00002714class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00002715 public DarwinTargetInfo<ARMTargetInfo> {
2716protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00002717 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00002718 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00002719 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00002720 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002721
Torok Edwin5f6c1942009-06-30 17:10:35 +00002722public:
Mike Stump1eb44332009-09-09 15:08:12 +00002723 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar350b9f32010-05-27 07:00:26 +00002724 : DarwinTargetInfo<ARMTargetInfo>(triple) {
2725 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00002726 // iOS always has 64-bit atomic instructions.
2727 // FIXME: This should be based off of the target features in ARMTargetInfo.
2728 MaxAtomicInlineWidth = 64;
Daniel Dunbar350b9f32010-05-27 07:00:26 +00002729 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002730};
2731} // end anonymous namespace.
2732
Reid Spencer5f016e22007-07-11 17:01:13 +00002733namespace {
Eli Friedman01b86682008-08-20 07:28:14 +00002734class SparcV8TargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00002735 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2736 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002737 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00002738public:
Eli Friedman01b86682008-08-20 07:28:14 +00002739 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
2740 // FIXME: Support Sparc quad-precision long double?
Eli Friedmaned855cb2008-08-21 00:13:15 +00002741 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 +00002742 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedman01b86682008-08-20 07:28:14 +00002743 }
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002744 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2745 const std::string &Name,
2746 bool Enabled) const {
2747 if (Name == "soft-float")
2748 Features[Name] = Enabled;
2749 else
2750 return false;
2751
2752 return true;
2753 }
2754 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
2755 SoftFloat = false;
2756 for (unsigned i = 0, e = Features.size(); i != e; ++i)
2757 if (Features[i] == "+soft-float")
2758 SoftFloat = true;
2759 }
Chris Lattner33328642009-03-20 15:52:06 +00002760 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002761 MacroBuilder &Builder) const {
2762 DefineStd(Builder, "sparc", Opts);
2763 Builder.defineMacro("__sparcv8");
2764 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002765
2766 if (SoftFloat)
2767 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00002768 }
2769 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2770 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00002771 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00002772 }
2773 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002774 return "typedef void* __builtin_va_list;";
Gabor Greif26658672008-02-21 16:29:08 +00002775 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002776 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00002777 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002778 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00002779 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002780 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00002781 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00002782 // FIXME: Implement!
2783 return false;
Gabor Greif26658672008-02-21 16:29:08 +00002784 }
2785 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002786 // FIXME: Implement!
2787 return "";
Gabor Greif26658672008-02-21 16:29:08 +00002788 }
2789};
2790
Chris Lattnere957f532009-01-27 01:58:38 +00002791const char * const SparcV8TargetInfo::GCCRegNames[] = {
2792 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2793 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2794 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2795 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
2796};
2797
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002798void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00002799 unsigned &NumNames) const {
2800 Names = GCCRegNames;
2801 NumNames = llvm::array_lengthof(GCCRegNames);
2802}
2803
2804const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002805 { { "g0" }, "r0" },
2806 { { "g1" }, "r1" },
2807 { { "g2" }, "r2" },
2808 { { "g3" }, "r3" },
2809 { { "g4" }, "r4" },
2810 { { "g5" }, "r5" },
2811 { { "g6" }, "r6" },
2812 { { "g7" }, "r7" },
2813 { { "o0" }, "r8" },
2814 { { "o1" }, "r9" },
2815 { { "o2" }, "r10" },
2816 { { "o3" }, "r11" },
2817 { { "o4" }, "r12" },
2818 { { "o5" }, "r13" },
2819 { { "o6", "sp" }, "r14" },
2820 { { "o7" }, "r15" },
2821 { { "l0" }, "r16" },
2822 { { "l1" }, "r17" },
2823 { { "l2" }, "r18" },
2824 { { "l3" }, "r19" },
2825 { { "l4" }, "r20" },
2826 { { "l5" }, "r21" },
2827 { { "l6" }, "r22" },
2828 { { "l7" }, "r23" },
2829 { { "i0" }, "r24" },
2830 { { "i1" }, "r25" },
2831 { { "i2" }, "r26" },
2832 { { "i3" }, "r27" },
2833 { { "i4" }, "r28" },
2834 { { "i5" }, "r29" },
2835 { { "i6", "fp" }, "r30" },
2836 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00002837};
2838
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002839void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00002840 unsigned &NumAliases) const {
2841 Aliases = GCCRegAliases;
2842 NumAliases = llvm::array_lengthof(GCCRegAliases);
2843}
Gabor Greif26658672008-02-21 16:29:08 +00002844} // end anonymous namespace.
2845
Eli Friedman01b86682008-08-20 07:28:14 +00002846namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00002847class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
2848public:
2849 AuroraUXSparcV8TargetInfo(const std::string& triple) :
2850 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
2851 SizeType = UnsignedInt;
2852 PtrDiffType = SignedInt;
2853 }
2854};
Torok Edwin5f6c1942009-06-30 17:10:35 +00002855class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00002856public:
2857 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwin5f6c1942009-06-30 17:10:35 +00002858 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00002859 SizeType = UnsignedInt;
2860 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00002861 }
2862};
2863} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00002864
Chris Lattner2621fd12008-05-08 05:58:21 +00002865namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002866 class MSP430TargetInfo : public TargetInfo {
2867 static const char * const GCCRegNames[];
2868 public:
2869 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
2870 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00002871 IntWidth = 16; IntAlign = 16;
2872 LongWidth = 32; LongLongWidth = 64;
2873 LongAlign = LongLongAlign = 16;
2874 PointerWidth = 16; PointerAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002875 SizeType = UnsignedInt;
2876 IntMaxType = SignedLong;
2877 UIntMaxType = UnsignedLong;
2878 IntPtrType = SignedShort;
2879 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00002880 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00002881 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002882 }
2883 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002884 MacroBuilder &Builder) const {
2885 Builder.defineMacro("MSP430");
2886 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002887 // FIXME: defines for different 'flavours' of MCU
2888 }
2889 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2890 unsigned &NumRecords) const {
2891 // FIXME: Implement.
2892 Records = 0;
2893 NumRecords = 0;
2894 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002895 virtual void getGCCRegNames(const char * const *&Names,
2896 unsigned &NumNames) const;
2897 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2898 unsigned &NumAliases) const {
2899 // No aliases.
2900 Aliases = 0;
2901 NumAliases = 0;
2902 }
2903 virtual bool validateAsmConstraint(const char *&Name,
2904 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00002905 // No target constraints for now.
2906 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002907 }
2908 virtual const char *getClobbers() const {
2909 // FIXME: Is this really right?
2910 return "";
2911 }
2912 virtual const char *getVAListDeclaration() const {
2913 // FIXME: implement
Anton Korobeynikoveb716852009-05-08 18:24:57 +00002914 return "typedef char* __builtin_va_list;";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002915 }
2916 };
2917
2918 const char * const MSP430TargetInfo::GCCRegNames[] = {
2919 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2920 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2921 };
2922
2923 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
2924 unsigned &NumNames) const {
2925 Names = GCCRegNames;
2926 NumNames = llvm::array_lengthof(GCCRegNames);
2927 }
2928}
2929
2930
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002931namespace {
2932 class SystemZTargetInfo : public TargetInfo {
2933 static const char * const GCCRegNames[];
2934 public:
2935 SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
2936 TLSSupported = false;
2937 IntWidth = IntAlign = 32;
2938 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
2939 PointerWidth = PointerAlign = 64;
Chris Lattner1932e122009-11-07 18:59:41 +00002940 DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
2941 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002942 }
2943 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002944 MacroBuilder &Builder) const {
2945 Builder.defineMacro("__s390__");
2946 Builder.defineMacro("__s390x__");
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002947 }
2948 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2949 unsigned &NumRecords) const {
2950 // FIXME: Implement.
2951 Records = 0;
2952 NumRecords = 0;
2953 }
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002954
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002955 virtual void getGCCRegNames(const char * const *&Names,
2956 unsigned &NumNames) const;
2957 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2958 unsigned &NumAliases) const {
2959 // No aliases.
2960 Aliases = 0;
2961 NumAliases = 0;
2962 }
2963 virtual bool validateAsmConstraint(const char *&Name,
2964 TargetInfo::ConstraintInfo &info) const {
2965 // FIXME: implement
2966 return true;
2967 }
2968 virtual const char *getClobbers() const {
2969 // FIXME: Is this really right?
2970 return "";
2971 }
2972 virtual const char *getVAListDeclaration() const {
2973 // FIXME: implement
2974 return "typedef char* __builtin_va_list;";
2975 }
2976 };
2977
2978 const char * const SystemZTargetInfo::GCCRegNames[] = {
2979 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2980 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2981 };
2982
2983 void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
2984 unsigned &NumNames) const {
2985 Names = GCCRegNames;
2986 NumNames = llvm::array_lengthof(GCCRegNames);
2987 }
2988}
2989
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002990namespace {
2991 class BlackfinTargetInfo : public TargetInfo {
2992 static const char * const GCCRegNames[];
2993 public:
2994 BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
2995 TLSSupported = false;
2996 DoubleAlign = 32;
2997 LongLongAlign = 32;
2998 LongDoubleAlign = 32;
Chris Lattner1932e122009-11-07 18:59:41 +00002999 DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00003000 }
3001
3002 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003003 MacroBuilder &Builder) const {
3004 DefineStd(Builder, "bfin", Opts);
3005 DefineStd(Builder, "BFIN", Opts);
3006 Builder.defineMacro("__ADSPBLACKFIN__");
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00003007 // FIXME: This one is really dependent on -mcpu
Benjamin Kramera9992772010-01-09 17:55:51 +00003008 Builder.defineMacro("__ADSPLPBLACKFIN__");
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00003009 // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
3010 }
3011
3012 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3013 unsigned &NumRecords) const {
3014 // FIXME: Implement.
3015 Records = 0;
3016 NumRecords = 0;
3017 }
3018
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00003019 virtual void getGCCRegNames(const char * const *&Names,
3020 unsigned &NumNames) const;
3021
3022 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3023 unsigned &NumAliases) const {
3024 // No aliases.
3025 Aliases = 0;
3026 NumAliases = 0;
3027 }
3028
3029 virtual bool validateAsmConstraint(const char *&Name,
3030 TargetInfo::ConstraintInfo &Info) const {
3031 if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
3032 Info.setAllowsRegister();
3033 return true;
3034 }
3035 return false;
3036 }
3037
3038 virtual const char *getClobbers() const {
3039 return "";
3040 }
3041
3042 virtual const char *getVAListDeclaration() const {
3043 return "typedef char* __builtin_va_list;";
3044 }
3045 };
3046
3047 const char * const BlackfinTargetInfo::GCCRegNames[] = {
3048 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3049 "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
3050 "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
3051 "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
3052 "a0", "a1", "cc",
3053 "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
3054 "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
3055 };
3056
3057 void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
3058 unsigned &NumNames) const {
3059 Names = GCCRegNames;
3060 NumNames = llvm::array_lengthof(GCCRegNames);
3061 }
3062}
3063
Eli Friedmanb63decf2009-08-19 20:47:07 +00003064namespace {
3065
Mike Stump1eb44332009-09-09 15:08:12 +00003066 // LLVM and Clang cannot be used directly to output native binaries for
3067 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00003068 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00003069 //
3070 // TCE uses the llvm bitcode as input and uses it for generating customized
3071 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00003072 // publicly available in http://tce.cs.tut.fi
3073
Eli Friedman209f5bb2011-10-07 19:51:42 +00003074 static const unsigned TCEOpenCLAddrSpaceMap[] = {
3075 3, // opencl_global
3076 4, // opencl_local
3077 5 // opencl_constant
3078 };
3079
Eli Friedmanb63decf2009-08-19 20:47:07 +00003080 class TCETargetInfo : public TargetInfo{
3081 public:
3082 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
3083 TLSSupported = false;
3084 IntWidth = 32;
3085 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003086 PointerWidth = 32;
3087 IntAlign = 32;
3088 LongAlign = LongLongAlign = 32;
3089 PointerAlign = 32;
3090 SizeType = UnsignedInt;
3091 IntMaxType = SignedLong;
3092 UIntMaxType = UnsignedLong;
3093 IntPtrType = SignedInt;
3094 PtrDiffType = SignedInt;
3095 FloatWidth = 32;
3096 FloatAlign = 32;
3097 DoubleWidth = 32;
3098 DoubleAlign = 32;
3099 LongDoubleWidth = 32;
3100 LongDoubleAlign = 32;
3101 FloatFormat = &llvm::APFloat::IEEEsingle;
3102 DoubleFormat = &llvm::APFloat::IEEEsingle;
3103 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00003104 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
3105 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00003106 "f32:32:32-f64:32:32-v64:32:32-"
3107 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00003108 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003109 }
3110
3111 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003112 MacroBuilder &Builder) const {
3113 DefineStd(Builder, "tce", Opts);
3114 Builder.defineMacro("__TCE__");
3115 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00003116 }
3117 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3118 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00003119 virtual const char *getClobbers() const {
3120 return "";
3121 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003122 virtual const char *getVAListDeclaration() const {
3123 return "typedef void* __builtin_va_list;";
3124 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003125 virtual void getGCCRegNames(const char * const *&Names,
3126 unsigned &NumNames) const {}
3127 virtual bool validateAsmConstraint(const char *&Name,
3128 TargetInfo::ConstraintInfo &info) const {
3129 return true;
3130 }
3131 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3132 unsigned &NumAliases) const {}
3133 };
3134}
3135
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003136namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003137class MipsTargetInfoBase : public TargetInfo {
3138 std::string CPU;
3139protected:
3140 std::string ABI;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003141public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003142 MipsTargetInfoBase(const std::string& triple, const std::string& ABIStr)
3143 : TargetInfo(triple), ABI(ABIStr) {
Akira Hatanaka619e8872011-06-02 00:09:17 +00003144 SizeType = UnsignedInt;
3145 PtrDiffType = SignedInt;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003146 }
Eric Christophered734732010-03-02 02:41:08 +00003147 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003148 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00003149 virtual bool setCPU(const std::string &Name) {
3150 CPU = Name;
3151 return true;
3152 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003153 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00003154 Features[ABI] = true;
3155 Features[CPU] = true;
3156 }
3157 virtual void getArchDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003158 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003159 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003160 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003161 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3162 unsigned &NumRecords) const {
3163 // FIXME: Implement!
3164 }
3165 virtual const char *getVAListDeclaration() const {
3166 return "typedef void* __builtin_va_list;";
3167 }
3168 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003169 unsigned &NumNames) const {
3170 static const char * const GCCRegNames[] = {
3171 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
3172 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
3173 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
3174 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
3175 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
3176 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
3177 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
3178 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
3179 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
3180 "$fcc5","$fcc6","$fcc7"
3181 };
3182 Names = GCCRegNames;
3183 NumNames = llvm::array_lengthof(GCCRegNames);
3184 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003185 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003186 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003187 virtual bool validateAsmConstraint(const char *&Name,
3188 TargetInfo::ConstraintInfo &Info) const {
3189 switch (*Name) {
3190 default:
3191 case 'r': // CPU registers.
3192 case 'd': // Equivalent to "r" unless generating MIPS16 code.
3193 case 'y': // Equivalent to "r", backwards compatibility only.
3194 case 'f': // floating-point registers.
3195 Info.setAllowsRegister();
3196 return true;
3197 }
3198 return false;
3199 }
3200
3201 virtual const char *getClobbers() const {
3202 // FIXME: Implement!
3203 return "";
3204 }
3205};
3206
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003207class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003208public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003209 Mips32TargetInfoBase(const std::string& triple) :
3210 MipsTargetInfoBase(triple, "o32") {}
3211 virtual bool setABI(const std::string &Name) {
3212 if ((Name == "o32") || (Name == "eabi")) {
3213 ABI = Name;
3214 return true;
3215 } else
3216 return false;
3217 }
3218 virtual void getArchDefines(const LangOptions &Opts,
3219 MacroBuilder &Builder) const {
3220 if (ABI == "o32") {
3221 Builder.defineMacro("__mips_o32");
3222 Builder.defineMacro("_ABIO32", "1");
3223 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
3224 }
3225 else if (ABI == "eabi")
3226 Builder.defineMacro("__mips_eabi");
3227 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003228 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003229 }
3230 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3231 unsigned &NumAliases) const {
3232 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3233 { { "at" }, "$1" },
3234 { { "v0" }, "$2" },
3235 { { "v1" }, "$3" },
3236 { { "a0" }, "$4" },
3237 { { "a1" }, "$5" },
3238 { { "a2" }, "$6" },
3239 { { "a3" }, "$7" },
3240 { { "t0" }, "$8" },
3241 { { "t1" }, "$9" },
3242 { { "t2" }, "$10" },
3243 { { "t3" }, "$11" },
3244 { { "t4" }, "$12" },
3245 { { "t5" }, "$13" },
3246 { { "t6" }, "$14" },
3247 { { "t7" }, "$15" },
3248 { { "s0" }, "$16" },
3249 { { "s1" }, "$17" },
3250 { { "s2" }, "$18" },
3251 { { "s3" }, "$19" },
3252 { { "s4" }, "$20" },
3253 { { "s5" }, "$21" },
3254 { { "s6" }, "$22" },
3255 { { "s7" }, "$23" },
3256 { { "t8" }, "$24" },
3257 { { "t9" }, "$25" },
3258 { { "k0" }, "$26" },
3259 { { "k1" }, "$27" },
3260 { { "gp" }, "$28" },
3261 { { "sp" }, "$29" },
3262 { { "fp" }, "$30" },
3263 { { "ra" }, "$31" }
3264 };
3265 Aliases = GCCRegAliases;
3266 NumAliases = llvm::array_lengthof(GCCRegAliases);
3267 }
3268};
3269
3270class Mips32EBTargetInfo : public Mips32TargetInfoBase {
3271public:
3272 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
3273 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3274 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3275 }
3276 virtual void getTargetDefines(const LangOptions &Opts,
3277 MacroBuilder &Builder) const {
3278 DefineStd(Builder, "mips", Opts);
3279 Builder.defineMacro("_mips");
3280 DefineStd(Builder, "MIPSEB", Opts);
3281 Builder.defineMacro("_MIPSEB");
3282 Builder.defineMacro("__REGISTER_PREFIX__", "");
3283 getArchDefines(Opts, Builder);
3284 }
3285};
3286
3287class Mips32ELTargetInfo : public Mips32TargetInfoBase {
3288public:
3289 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003290 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 +00003291 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003292 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003293 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003294 MacroBuilder &Builder) const {
3295 DefineStd(Builder, "mips", Opts);
3296 Builder.defineMacro("_mips");
3297 DefineStd(Builder, "MIPSEL", Opts);
3298 Builder.defineMacro("_MIPSEL");
3299 Builder.defineMacro("__REGISTER_PREFIX__", "");
3300 getArchDefines(Opts, Builder);
3301 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003302};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003303
3304class Mips64TargetInfoBase : public MipsTargetInfoBase {
3305 virtual void SetDescriptionString(const std::string &Name) = 0;
3306public:
3307 Mips64TargetInfoBase(const std::string& triple) :
3308 MipsTargetInfoBase(triple, "n64") {}
3309 virtual bool setABI(const std::string &Name) {
3310 SetDescriptionString(Name);
3311 if ((Name == "n32") || (Name == "n64")) {
3312 ABI = Name;
3313 return true;
3314 } else
3315 return false;
3316 }
3317 virtual void getArchDefines(const LangOptions &Opts,
3318 MacroBuilder &Builder) const {
3319 if (ABI == "n32") {
3320 Builder.defineMacro("__mips_n32");
3321 Builder.defineMacro("_ABIN32", "2");
3322 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
3323 }
3324 else if (ABI == "n64") {
3325 Builder.defineMacro("__mips_n64");
3326 Builder.defineMacro("_ABI64", "3");
3327 Builder.defineMacro("_MIPS_SIM", "_ABI64");
3328 }
3329 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003330 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003331 }
3332 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3333 unsigned &NumAliases) const {
3334 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3335 { { "at" }, "$1" },
3336 { { "v0" }, "$2" },
3337 { { "v1" }, "$3" },
3338 { { "a0" }, "$4" },
3339 { { "a1" }, "$5" },
3340 { { "a2" }, "$6" },
3341 { { "a3" }, "$7" },
3342 { { "a4" }, "$8" },
3343 { { "a5" }, "$9" },
3344 { { "a6" }, "$10" },
3345 { { "a7" }, "$11" },
3346 { { "t0" }, "$12" },
3347 { { "t1" }, "$13" },
3348 { { "t2" }, "$14" },
3349 { { "t3" }, "$15" },
3350 { { "s0" }, "$16" },
3351 { { "s1" }, "$17" },
3352 { { "s2" }, "$18" },
3353 { { "s3" }, "$19" },
3354 { { "s4" }, "$20" },
3355 { { "s5" }, "$21" },
3356 { { "s6" }, "$22" },
3357 { { "s7" }, "$23" },
3358 { { "t8" }, "$24" },
3359 { { "t9" }, "$25" },
3360 { { "k0" }, "$26" },
3361 { { "k1" }, "$27" },
3362 { { "gp" }, "$28" },
3363 { { "sp" }, "$29" },
3364 { { "fp" }, "$30" },
3365 { { "ra" }, "$31" }
3366 };
3367 Aliases = GCCRegAliases;
3368 NumAliases = llvm::array_lengthof(GCCRegAliases);
3369 }
3370};
3371
3372class Mips64EBTargetInfo : public Mips64TargetInfoBase {
3373 virtual void SetDescriptionString(const std::string &Name) {
3374 // Change DescriptionString only if ABI is n32.
3375 if (Name == "n32")
3376 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3377 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3378 }
3379public:
3380 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3381 // Default ABI is n64.
3382 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3383 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3384 }
3385 virtual void getTargetDefines(const LangOptions &Opts,
3386 MacroBuilder &Builder) const {
3387 DefineStd(Builder, "mips", Opts);
3388 Builder.defineMacro("_mips");
3389 DefineStd(Builder, "MIPSEB", Opts);
3390 Builder.defineMacro("_MIPSEB");
3391 Builder.defineMacro("__REGISTER_PREFIX__", "");
3392 getArchDefines(Opts, Builder);
3393 }
3394};
3395
3396class Mips64ELTargetInfo : public Mips64TargetInfoBase {
3397 virtual void SetDescriptionString(const std::string &Name) {
3398 // Change DescriptionString only if ABI is n32.
3399 if (Name == "n32")
3400 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3401 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3402 }
3403public:
3404 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3405 // Default ABI is n64.
3406 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3407 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3408 }
3409 virtual void getTargetDefines(const LangOptions &Opts,
3410 MacroBuilder &Builder) const {
3411 DefineStd(Builder, "mips", Opts);
3412 Builder.defineMacro("_mips");
3413 DefineStd(Builder, "MIPSEL", Opts);
3414 Builder.defineMacro("_MIPSEL");
3415 Builder.defineMacro("__REGISTER_PREFIX__", "");
3416 getArchDefines(Opts, Builder);
3417 }
3418};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003419} // end anonymous namespace.
3420
Ivan Krasinef05abd2011-08-24 20:22:22 +00003421namespace {
3422class PNaClTargetInfo : public TargetInfo {
3423public:
3424 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
3425 this->UserLabelPrefix = "";
3426 this->LongAlign = 32;
3427 this->LongWidth = 32;
3428 this->PointerAlign = 32;
3429 this->PointerWidth = 32;
3430 this->IntMaxType = TargetInfo::SignedLongLong;
3431 this->UIntMaxType = TargetInfo::UnsignedLongLong;
3432 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003433 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003434 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003435 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003436 this->SizeType = TargetInfo::UnsignedInt;
3437 this->PtrDiffType = TargetInfo::SignedInt;
3438 this->IntPtrType = TargetInfo::SignedInt;
David Meyerdd4a8892011-10-11 03:12:01 +00003439 this->RegParmMax = 2;
Ivan Krasinef05abd2011-08-24 20:22:22 +00003440 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
3441 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
3442 }
3443
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003444 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00003445 }
3446 virtual void getArchDefines(const LangOptions &Opts,
3447 MacroBuilder &Builder) const {
3448 Builder.defineMacro("__le32__");
3449 Builder.defineMacro("__pnacl__");
3450 }
3451 virtual void getTargetDefines(const LangOptions &Opts,
3452 MacroBuilder &Builder) const {
Ivan Krasin089ee112011-08-25 23:49:20 +00003453 DefineStd(Builder, "unix", Opts);
3454 Builder.defineMacro("__ELF__");
3455 if (Opts.POSIXThreads)
3456 Builder.defineMacro("_REENTRANT");
3457 if (Opts.CPlusPlus)
3458 Builder.defineMacro("_GNU_SOURCE");
3459
Ivan Krasinef05abd2011-08-24 20:22:22 +00003460 Builder.defineMacro("__native_client__");
3461 getArchDefines(Opts, Builder);
3462 }
3463 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3464 unsigned &NumRecords) const {
3465 }
3466 virtual const char *getVAListDeclaration() const {
Ivan Krasin68018db2011-09-20 14:56:54 +00003467 return "typedef int __builtin_va_list[4];";
Ivan Krasinef05abd2011-08-24 20:22:22 +00003468 }
3469 virtual void getGCCRegNames(const char * const *&Names,
3470 unsigned &NumNames) const;
3471 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3472 unsigned &NumAliases) const;
3473 virtual bool validateAsmConstraint(const char *&Name,
3474 TargetInfo::ConstraintInfo &Info) const {
3475 return false;
3476 }
3477
3478 virtual const char *getClobbers() const {
3479 return "";
3480 }
3481};
3482
3483void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
3484 unsigned &NumNames) const {
3485 Names = NULL;
3486 NumNames = 0;
3487}
3488
3489void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3490 unsigned &NumAliases) const {
3491 Aliases = NULL;
3492 NumAliases = 0;
3493}
3494} // end anonymous namespace.
3495
3496
Reid Spencer5f016e22007-07-11 17:01:13 +00003497//===----------------------------------------------------------------------===//
3498// Driver code
3499//===----------------------------------------------------------------------===//
3500
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003501static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003502 llvm::Triple Triple(T);
3503 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00003504
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003505 switch (Triple.getArch()) {
3506 default:
3507 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00003508
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003509 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00003510 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003511 if (Triple.isOSDarwin())
3512 return new DarwinARMTargetInfo(T);
3513
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003514 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00003515 case llvm::Triple::Linux:
3516 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003517 case llvm::Triple::FreeBSD:
Torok Edwin5f6c1942009-06-30 17:10:35 +00003518 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003519 case llvm::Triple::NetBSD:
3520 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003521 case llvm::Triple::RTEMS:
3522 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003523 default:
3524 return new ARMTargetInfo(T);
3525 }
Eli Friedman61538a72008-05-20 14:21:01 +00003526
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003527 case llvm::Triple::bfin:
Douglas Gregordca52262011-07-01 22:41:14 +00003528 if ( os == llvm::Triple::RTEMS )
3529 return new RTEMSTargetInfo<BlackfinTargetInfo>(T);
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00003530 return new BlackfinTargetInfo(T);
3531
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003532 case llvm::Triple::msp430:
3533 return new MSP430TargetInfo(T);
Eli Friedman61538a72008-05-20 14:21:01 +00003534
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003535 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003536 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003537 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003538 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003539 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003540 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003541 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003542 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003543 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003544 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003545 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003546 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003547 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003548
3549 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003550 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003551 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003552 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003553 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003554 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003555 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003556 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003557 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003558 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003559 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003560 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003561 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003562
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003563 case llvm::Triple::mips64:
3564 switch (os) {
3565 case llvm::Triple::Linux:
3566 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
3567 case llvm::Triple::RTEMS:
3568 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
3569 case llvm::Triple::FreeBSD:
3570 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
3571 case llvm::Triple::NetBSD:
3572 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
3573 default:
3574 return new Mips64EBTargetInfo(T);
3575 }
3576
3577 case llvm::Triple::mips64el:
3578 switch (os) {
3579 case llvm::Triple::Linux:
3580 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
3581 case llvm::Triple::RTEMS:
3582 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
3583 case llvm::Triple::FreeBSD:
3584 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
3585 case llvm::Triple::NetBSD:
3586 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
3587 default:
3588 return new Mips64ELTargetInfo(T);
3589 }
3590
Ivan Krasinef05abd2011-08-24 20:22:22 +00003591 case llvm::Triple::le32:
3592 switch (os) {
3593 case llvm::Triple::NativeClient:
3594 return new PNaClTargetInfo(T);
3595 default:
3596 return NULL;
3597 }
3598
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003599 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003600 if (Triple.isOSDarwin())
Roman Divackyc81f2a22011-01-06 08:27:10 +00003601 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003602 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003603 case llvm::Triple::Linux:
3604 return new LinuxTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003605 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00003606 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003607 case llvm::Triple::NetBSD:
3608 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
3609 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003610 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003611 default:
3612 return new PPC32TargetInfo(T);
3613 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003614
3615 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003616 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00003617 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003618 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003619 case llvm::Triple::Linux:
3620 return new LinuxTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003621 case llvm::Triple::Lv2:
John Thompson3f6918a2009-11-19 17:18:50 +00003622 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003623 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00003624 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003625 case llvm::Triple::NetBSD:
3626 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
3627 default:
3628 return new PPC64TargetInfo(T);
3629 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003630
Justin Holewinski285dc652011-04-20 19:34:15 +00003631 case llvm::Triple::ptx32:
3632 return new PTX32TargetInfo(T);
3633 case llvm::Triple::ptx64:
3634 return new PTX64TargetInfo(T);
3635
Chris Lattner9cbeb632010-03-06 21:21:27 +00003636 case llvm::Triple::mblaze:
3637 return new MBlazeTargetInfo(T);
3638
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003639 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003640 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003641 case llvm::Triple::Linux:
3642 return new LinuxTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003643 case llvm::Triple::AuroraUX:
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003644 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003645 case llvm::Triple::Solaris:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003646 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003647 case llvm::Triple::NetBSD:
3648 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
3649 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003650 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003651 default:
3652 return new SparcV8TargetInfo(T);
3653 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003654
John Thompson3f6918a2009-11-19 17:18:50 +00003655 // FIXME: Need a real SPU target.
3656 case llvm::Triple::cellspu:
3657 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
3658
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003659 case llvm::Triple::systemz:
3660 return new SystemZTargetInfo(T);
3661
Eli Friedmanb63decf2009-08-19 20:47:07 +00003662 case llvm::Triple::tce:
3663 return new TCETargetInfo(T);
3664
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003665 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003666 if (Triple.isOSDarwin())
3667 return new DarwinI386TargetInfo(T);
3668
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003669 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003670 case llvm::Triple::AuroraUX:
3671 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003672 case llvm::Triple::Linux:
3673 return new LinuxTargetInfo<X86_32TargetInfo>(T);
3674 case llvm::Triple::DragonFly:
3675 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
3676 case llvm::Triple::NetBSD:
3677 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
3678 case llvm::Triple::OpenBSD:
3679 return new OpenBSDI386TargetInfo(T);
3680 case llvm::Triple::FreeBSD:
3681 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner38e317d2010-07-07 16:01:42 +00003682 case llvm::Triple::Minix:
3683 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003684 case llvm::Triple::Solaris:
3685 return new SolarisTargetInfo<X86_32TargetInfo>(T);
3686 case llvm::Triple::Cygwin:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003687 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003688 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003689 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003690 case llvm::Triple::Win32:
Michael J. Spencera764e832010-10-21 08:22:51 +00003691 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattner86ed3a32010-04-11 19:29:39 +00003692 case llvm::Triple::Haiku:
3693 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003694 case llvm::Triple::RTEMS:
3695 return new RTEMSX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003696 default:
3697 return new X86_32TargetInfo(T);
3698 }
3699
3700 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003701 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
3702 return new DarwinX86_64TargetInfo(T);
3703
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003704 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003705 case llvm::Triple::AuroraUX:
3706 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003707 case llvm::Triple::Linux:
3708 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner7a7ca282010-01-09 05:41:14 +00003709 case llvm::Triple::DragonFly:
3710 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003711 case llvm::Triple::NetBSD:
3712 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
3713 case llvm::Triple::OpenBSD:
3714 return new OpenBSDX86_64TargetInfo(T);
3715 case llvm::Triple::FreeBSD:
3716 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
3717 case llvm::Triple::Solaris:
3718 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00003719 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003720 return new MinGWX86_64TargetInfo(T);
3721 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003722 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003723 default:
3724 return new X86_64TargetInfo(T);
3725 }
3726 }
Reid Spencer5f016e22007-07-11 17:01:13 +00003727}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003728
3729/// CreateTargetInfo - Return the target info object for the specified target
3730/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00003731TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003732 TargetOptions &Opts) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003733 llvm::Triple Triple(Opts.Triple);
3734
3735 // Construct the target
3736 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
3737 if (!Target) {
3738 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
3739 return 0;
3740 }
3741
Daniel Dunbareac7c532009-12-18 18:42:37 +00003742 // Set the target CPU if specified.
3743 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
3744 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
3745 return 0;
3746 }
3747
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003748 // Set the target ABI if specified.
3749 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
3750 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
3751 return 0;
3752 }
3753
Charles Davis98b7c5c2010-06-11 01:06:47 +00003754 // Set the target C++ ABI.
John McCallee79a4c2010-08-21 22:46:04 +00003755 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davis98b7c5c2010-06-11 01:06:47 +00003756 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
3757 return 0;
3758 }
3759
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003760 // Compute the default target features, we need the target to handle this
3761 // because features may have dependencies on one another.
3762 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003763 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003764
3765 // Apply the user specified deltas.
3766 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
3767 ie = Opts.Features.end(); it != ie; ++it) {
3768 const char *Name = it->c_str();
3769
3770 // Apply the feature via the target.
3771 if ((Name[0] != '-' && Name[0] != '+') ||
3772 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
3773 Diags.Report(diag::err_target_invalid_feature) << Name;
3774 return 0;
3775 }
3776 }
3777
3778 // Add the features to the compile options.
3779 //
3780 // FIXME: If we are completely confident that we have the right set, we only
3781 // need to pass the minuses.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003782 Opts.Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003783 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
3784 ie = Features.end(); it != ie; ++it)
Chris Lattner1e5f83b2011-07-14 18:24:21 +00003785 Opts.Features.push_back(std::string(it->second ? "+" : "-") +
Chris Lattner48b78bd2011-07-14 18:45:41 +00003786 it->first().str());
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003787 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003788
3789 return Target.take();
3790}