blob: 244205400c6a0ccb75a8eb9a06cab0401c9871ca [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 Holewinski285dc652011-04-20 19:34:15 +0000881 class PTXTargetInfo : public TargetInfo {
882 static const char * const GCCRegNames[];
883 static const Builtin::Info BuiltinInfo[];
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000884 std::vector<llvm::StringRef> AvailableFeatures;
Justin Holewinski285dc652011-04-20 19:34:15 +0000885 public:
886 PTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
887 TLSSupported = false;
888 LongWidth = LongAlign = 64;
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000889 // Define available target features
890 // These must be defined in sorted order!
891 AvailableFeatures.push_back("compute10");
892 AvailableFeatures.push_back("compute11");
893 AvailableFeatures.push_back("compute12");
894 AvailableFeatures.push_back("compute13");
895 AvailableFeatures.push_back("compute20");
896 AvailableFeatures.push_back("double");
897 AvailableFeatures.push_back("no-fma");
898 AvailableFeatures.push_back("ptx20");
899 AvailableFeatures.push_back("ptx21");
900 AvailableFeatures.push_back("ptx22");
901 AvailableFeatures.push_back("ptx23");
902 AvailableFeatures.push_back("sm10");
903 AvailableFeatures.push_back("sm11");
904 AvailableFeatures.push_back("sm12");
905 AvailableFeatures.push_back("sm13");
906 AvailableFeatures.push_back("sm20");
907 AvailableFeatures.push_back("sm21");
908 AvailableFeatures.push_back("sm22");
909 AvailableFeatures.push_back("sm23");
Justin Holewinski285dc652011-04-20 19:34:15 +0000910 }
911 virtual void getTargetDefines(const LangOptions &Opts,
912 MacroBuilder &Builder) const {
913 Builder.defineMacro("__PTX__");
914 }
915 virtual void getTargetBuiltins(const Builtin::Info *&Records,
916 unsigned &NumRecords) const {
917 Records = BuiltinInfo;
918 NumRecords = clang::PTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
919 }
920
921 virtual void getGCCRegNames(const char * const *&Names,
922 unsigned &NumNames) const;
923 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
924 unsigned &NumAliases) const {
925 // No aliases.
926 Aliases = 0;
927 NumAliases = 0;
928 }
929 virtual bool validateAsmConstraint(const char *&Name,
930 TargetInfo::ConstraintInfo &info) const {
931 // FIXME: implement
932 return true;
933 }
934 virtual const char *getClobbers() const {
935 // FIXME: Is this really right?
936 return "";
937 }
938 virtual const char *getVAListDeclaration() const {
939 // FIXME: implement
940 return "typedef char* __builtin_va_list;";
941 }
Justin Holewinski808ef662011-09-15 12:13:38 +0000942
943 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
944 const std::string &Name,
945 bool Enabled) const;
Justin Holewinski285dc652011-04-20 19:34:15 +0000946 };
947
948 const Builtin::Info PTXTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000949#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +0000950#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000951 ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +0000952#include "clang/Basic/BuiltinsPTX.def"
953 };
954
955 const char * const PTXTargetInfo::GCCRegNames[] = {
956 "r0"
957 };
958
959 void PTXTargetInfo::getGCCRegNames(const char * const *&Names,
960 unsigned &NumNames) const {
961 Names = GCCRegNames;
962 NumNames = llvm::array_lengthof(GCCRegNames);
963 }
964
Justin Holewinski808ef662011-09-15 12:13:38 +0000965 bool PTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
966 const std::string &Name,
967 bool Enabled) const {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000968 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
969 Name)) {
970 Features[Name] = Enabled;
971 return true;
Justin Holewinski808ef662011-09-15 12:13:38 +0000972 } else {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000973 return false;
Justin Holewinski808ef662011-09-15 12:13:38 +0000974 }
Justin Holewinski808ef662011-09-15 12:13:38 +0000975 }
Justin Holewinski285dc652011-04-20 19:34:15 +0000976
977 class PTX32TargetInfo : public PTXTargetInfo {
978 public:
979 PTX32TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
980 PointerWidth = PointerAlign = 32;
981 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
982 DescriptionString
983 = "e-p:32:32-i64:64:64-f64:64:64-n1:8:16:32:64";
984 }
985 };
986
987 class PTX64TargetInfo : public PTXTargetInfo {
988 public:
989 PTX64TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
990 PointerWidth = PointerAlign = 64;
991 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
992 DescriptionString
993 = "e-p:64:64-i64:64:64-f64:64:64-n1:8:16:32:64";
994 }
995 };
996}
997
998namespace {
Chris Lattner9cbeb632010-03-06 21:21:27 +0000999// MBlaze abstract base class
1000class MBlazeTargetInfo : public TargetInfo {
1001 static const char * const GCCRegNames[];
1002 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1003
1004public:
1005 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +00001006 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner9cbeb632010-03-06 21:21:27 +00001007 }
1008
1009 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1010 unsigned &NumRecords) const {
1011 // FIXME: Implement.
1012 Records = 0;
1013 NumRecords = 0;
1014 }
1015
1016 virtual void getTargetDefines(const LangOptions &Opts,
1017 MacroBuilder &Builder) const;
1018
1019 virtual const char *getVAListDeclaration() const {
1020 return "typedef char* __builtin_va_list;";
1021 }
1022 virtual const char *getTargetPrefix() const {
1023 return "mblaze";
1024 }
1025 virtual void getGCCRegNames(const char * const *&Names,
1026 unsigned &NumNames) const;
1027 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1028 unsigned &NumAliases) const;
1029 virtual bool validateAsmConstraint(const char *&Name,
1030 TargetInfo::ConstraintInfo &Info) const {
1031 switch (*Name) {
1032 default: return false;
1033 case 'O': // Zero
1034 return true;
1035 case 'b': // Base register
1036 case 'f': // Floating point register
1037 Info.setAllowsRegister();
1038 return true;
1039 }
1040 }
1041 virtual const char *getClobbers() const {
1042 return "";
1043 }
1044};
1045
1046/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1047/// #defines that are not tied to a specific subtarget.
1048void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1049 MacroBuilder &Builder) const {
1050 // Target identification.
1051 Builder.defineMacro("__microblaze__");
1052 Builder.defineMacro("_ARCH_MICROBLAZE");
1053 Builder.defineMacro("__MICROBLAZE__");
1054
1055 // Target properties.
1056 Builder.defineMacro("_BIG_ENDIAN");
1057 Builder.defineMacro("__BIG_ENDIAN__");
1058
1059 // Subtarget options.
1060 Builder.defineMacro("__REGISTER_PREFIX__", "");
1061}
1062
1063
1064const char * const MBlazeTargetInfo::GCCRegNames[] = {
1065 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1066 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1067 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1068 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1069 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1070 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1071 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1072 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1073 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1074 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1075};
1076
1077void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1078 unsigned &NumNames) const {
1079 Names = GCCRegNames;
1080 NumNames = llvm::array_lengthof(GCCRegNames);
1081}
1082
1083const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1084 { {"f0"}, "r0" },
1085 { {"f1"}, "r1" },
1086 { {"f2"}, "r2" },
1087 { {"f3"}, "r3" },
1088 { {"f4"}, "r4" },
1089 { {"f5"}, "r5" },
1090 { {"f6"}, "r6" },
1091 { {"f7"}, "r7" },
1092 { {"f8"}, "r8" },
1093 { {"f9"}, "r9" },
1094 { {"f10"}, "r10" },
1095 { {"f11"}, "r11" },
1096 { {"f12"}, "r12" },
1097 { {"f13"}, "r13" },
1098 { {"f14"}, "r14" },
1099 { {"f15"}, "r15" },
1100 { {"f16"}, "r16" },
1101 { {"f17"}, "r17" },
1102 { {"f18"}, "r18" },
1103 { {"f19"}, "r19" },
1104 { {"f20"}, "r20" },
1105 { {"f21"}, "r21" },
1106 { {"f22"}, "r22" },
1107 { {"f23"}, "r23" },
1108 { {"f24"}, "r24" },
1109 { {"f25"}, "r25" },
1110 { {"f26"}, "r26" },
1111 { {"f27"}, "r27" },
1112 { {"f28"}, "r28" },
1113 { {"f29"}, "r29" },
1114 { {"f30"}, "r30" },
1115 { {"f31"}, "r31" },
1116};
1117
1118void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1119 unsigned &NumAliases) const {
1120 Aliases = GCCRegAliases;
1121 NumAliases = llvm::array_lengthof(GCCRegAliases);
1122}
1123} // end anonymous namespace.
1124
1125namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001126// Namespace for x86 abstract base class
1127const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001128#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001129#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001130 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001131#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001132};
Eli Friedman61538a72008-05-20 14:21:01 +00001133
Nuno Lopes2550d702009-12-23 17:49:57 +00001134static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001135 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1136 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001137 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001138 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1139 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1140 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001141 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001142};
1143
Eric Christophercfd323d2011-06-21 00:05:20 +00001144const TargetInfo::AddlRegName AddlRegNames[] = {
1145 { { "al", "ah", "eax", "rax" }, 0 },
1146 { { "bl", "bh", "ebx", "rbx" }, 3 },
1147 { { "cl", "ch", "ecx", "rcx" }, 2 },
1148 { { "dl", "dh", "edx", "rdx" }, 1 },
1149 { { "esi", "rsi" }, 4 },
1150 { { "edi", "rdi" }, 5 },
1151 { { "esp", "rsp" }, 7 },
1152 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001153};
1154
1155// X86 target abstract base class; x86-32 and x86-64 are very close, so
1156// most of the implementation can be shared.
1157class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001158 enum X86SSEEnum {
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001159 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
Chris Lattner84f0ea82009-03-02 22:40:39 +00001160 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001161 enum MMX3DNowEnum {
1162 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1163 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001164
Eric Christophereea12d12010-04-02 23:50:19 +00001165 bool HasAES;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001166 bool HasAVX;
1167
Chandler Carruth499d9722011-09-28 08:55:34 +00001168 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1169 ///
1170 /// Each enumeration represents a particular CPU supported by Clang. These
1171 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1172 enum CPUKind {
1173 CK_Generic,
1174
1175 /// \name i386
1176 /// i386-generation processors.
1177 //@{
1178 CK_i386,
1179 //@}
1180
1181 /// \name i486
1182 /// i486-generation processors.
1183 //@{
1184 CK_i486,
1185 CK_WinChipC6,
1186 CK_WinChip2,
1187 CK_C3,
1188 //@}
1189
1190 /// \name i586
1191 /// i586-generation processors, P5 microarchitecture based.
1192 //@{
1193 CK_i586,
1194 CK_Pentium,
1195 CK_PentiumMMX,
1196 //@}
1197
1198 /// \name i686
1199 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1200 //@{
1201 CK_i686,
1202 CK_PentiumPro,
1203 CK_Pentium2,
1204 CK_Pentium3,
1205 CK_Pentium3M,
1206 CK_PentiumM,
1207 CK_C3_2,
1208
1209 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1210 /// Clang however has some logic to suport this.
1211 // FIXME: Warn, deprecate, and potentially remove this.
1212 CK_Yonah,
1213 //@}
1214
1215 /// \name Netburst
1216 /// Netburt microarchitecture based processors.
1217 //@{
1218 CK_Pentium4,
1219 CK_Pentium4M,
1220 CK_Prescott,
1221 CK_Nocona,
1222 //@}
1223
1224 /// \name Core
1225 /// Core microarchitecture based processors.
1226 //@{
1227 CK_Core2,
1228
1229 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1230 /// codename which GCC no longer accepts as an option to -march, but Clang
1231 /// has some logic for recognizing it.
1232 // FIXME: Warn, deprecate, and potentially remove this.
1233 CK_Penryn,
1234 //@}
1235
1236 /// \name Atom
1237 /// Atom processors
1238 //@{
1239 CK_Atom,
1240 //@}
1241
1242 /// \name Nehalem
1243 /// Nehalem microarchitecture based processors.
1244 //@{
1245 CK_Corei7,
1246 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001247 CK_CoreAVXi,
Chandler Carruth499d9722011-09-28 08:55:34 +00001248 //@}
1249
1250 /// \name K6
1251 /// K6 architecture processors.
1252 //@{
1253 CK_K6,
1254 CK_K6_2,
1255 CK_K6_3,
1256 //@}
1257
1258 /// \name K7
1259 /// K7 architecture processors.
1260 //@{
1261 CK_Athlon,
1262 CK_AthlonThunderbird,
1263 CK_Athlon4,
1264 CK_AthlonXP,
1265 CK_AthlonMP,
1266 //@}
1267
1268 /// \name K8
1269 /// K8 architecture processors.
1270 //@{
1271 CK_Athlon64,
1272 CK_Athlon64SSE3,
1273 CK_AthlonFX,
1274 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001275 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001276 CK_Opteron,
1277 CK_OpteronSSE3,
1278
1279 /// This specification is deprecated and will be removed in the future.
1280 /// Users should prefer \see CK_K8.
1281 // FIXME: Warn on this when the CPU is set to it.
1282 CK_x86_64,
1283 //@}
1284
1285 /// \name Geode
1286 /// Geode processors.
1287 //@{
1288 CK_Geode
1289 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001290 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001291
Eli Friedman618234a2008-08-20 02:34:37 +00001292public:
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001293 X86TargetInfo(const std::string& triple)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001294 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001295 HasAES(false), HasAVX(false), CPU(CK_Generic) {
Eli Friedman618234a2008-08-20 02:34:37 +00001296 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001297 }
1298 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1299 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001300 Records = BuiltinInfo;
1301 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001302 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001303 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001304 unsigned &NumNames) const {
1305 Names = GCCRegNames;
1306 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001307 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001308 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001309 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001310 Aliases = 0;
1311 NumAliases = 0;
1312 }
1313 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1314 unsigned &NumNames) const {
1315 Names = AddlRegNames;
1316 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001317 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001318 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001319 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001320 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001321 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001322 return "~{dirflag},~{fpsr},~{flags}";
1323 }
Chris Lattner33328642009-03-20 15:52:06 +00001324 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001325 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001326 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1327 const std::string &Name,
1328 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001329 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001330 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001331 virtual const char* getABI() const {
1332 return MMX3DNowLevel == NoMMX3DNow ? "no-mmx" : "";
1333 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001334 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001335 CPU = llvm::StringSwitch<CPUKind>(Name)
1336 .Case("i386", CK_i386)
1337 .Case("i486", CK_i486)
1338 .Case("winchip-c6", CK_WinChipC6)
1339 .Case("winchip2", CK_WinChip2)
1340 .Case("c3", CK_C3)
1341 .Case("i586", CK_i586)
1342 .Case("pentium", CK_Pentium)
1343 .Case("pentium-mmx", CK_PentiumMMX)
1344 .Case("i686", CK_i686)
1345 .Case("pentiumpro", CK_PentiumPro)
1346 .Case("pentium2", CK_Pentium2)
1347 .Case("pentium3", CK_Pentium3)
1348 .Case("pentium3m", CK_Pentium3M)
1349 .Case("pentium-m", CK_PentiumM)
1350 .Case("c3-2", CK_C3_2)
1351 .Case("yonah", CK_Yonah)
1352 .Case("pentium4", CK_Pentium4)
1353 .Case("pentium4m", CK_Pentium4M)
1354 .Case("prescott", CK_Prescott)
1355 .Case("nocona", CK_Nocona)
1356 .Case("core2", CK_Core2)
1357 .Case("penryn", CK_Penryn)
1358 .Case("atom", CK_Atom)
1359 .Case("corei7", CK_Corei7)
1360 .Case("corei7-avx", CK_Corei7AVX)
1361 .Case("core-avx-i", CK_CoreAVXi)
1362 .Case("k6", CK_K6)
1363 .Case("k6-2", CK_K6_2)
1364 .Case("k6-3", CK_K6_3)
1365 .Case("athlon", CK_Athlon)
1366 .Case("athlon-tbird", CK_AthlonThunderbird)
1367 .Case("athlon-4", CK_Athlon4)
1368 .Case("athlon-xp", CK_AthlonXP)
1369 .Case("athlon-mp", CK_AthlonMP)
1370 .Case("athlon64", CK_Athlon64)
1371 .Case("athlon64-sse3", CK_Athlon64SSE3)
1372 .Case("athlon-fx", CK_AthlonFX)
1373 .Case("k8", CK_K8)
1374 .Case("k8-sse3", CK_K8SSE3)
1375 .Case("opteron", CK_Opteron)
1376 .Case("opteron-sse3", CK_OpteronSSE3)
1377 .Case("x86-64", CK_x86_64)
1378 .Case("geode", CK_Geode)
1379 .Default(CK_Generic);
1380
Chandler Carruth26a39142011-09-28 09:45:08 +00001381 // Perform any per-CPU checks necessary to determine if this CPU is
1382 // acceptable.
1383 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1384 // invalid without explaining *why*.
1385 switch (CPU) {
1386 case CK_Generic:
1387 // No processor selected!
1388 return false;
1389
1390 case CK_i386:
1391 case CK_i486:
1392 case CK_WinChipC6:
1393 case CK_WinChip2:
1394 case CK_C3:
1395 case CK_i586:
1396 case CK_Pentium:
1397 case CK_PentiumMMX:
1398 case CK_i686:
1399 case CK_PentiumPro:
1400 case CK_Pentium2:
1401 case CK_Pentium3:
1402 case CK_Pentium3M:
1403 case CK_PentiumM:
1404 case CK_Yonah:
1405 case CK_C3_2:
1406 case CK_Pentium4:
1407 case CK_Pentium4M:
1408 case CK_Prescott:
1409 case CK_K6:
1410 case CK_K6_2:
1411 case CK_K6_3:
1412 case CK_Athlon:
1413 case CK_AthlonThunderbird:
1414 case CK_Athlon4:
1415 case CK_AthlonXP:
1416 case CK_AthlonMP:
1417 case CK_Geode:
1418 // Only accept certain architectures when compiling in 32-bit mode.
1419 if (PointerWidth != 32)
1420 return false;
1421
1422 // Fallthrough
1423 case CK_Nocona:
1424 case CK_Core2:
1425 case CK_Penryn:
1426 case CK_Atom:
1427 case CK_Corei7:
1428 case CK_Corei7AVX:
1429 case CK_CoreAVXi:
1430 case CK_Athlon64:
1431 case CK_Athlon64SSE3:
1432 case CK_AthlonFX:
1433 case CK_K8:
1434 case CK_K8SSE3:
1435 case CK_Opteron:
1436 case CK_OpteronSSE3:
1437 case CK_x86_64:
1438 return true;
1439 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001440 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001441};
Chris Lattner3daed522009-03-02 22:20:04 +00001442
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001443void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001444 // FIXME: This should not be here.
1445 Features["3dnow"] = false;
1446 Features["3dnowa"] = false;
1447 Features["mmx"] = false;
1448 Features["sse"] = false;
1449 Features["sse2"] = false;
1450 Features["sse3"] = false;
1451 Features["ssse3"] = false;
1452 Features["sse41"] = false;
1453 Features["sse42"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001454 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001455 Features["avx"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001456
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001457 // LLVM does not currently recognize this.
1458 // Features["sse4a"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001459
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001460 // FIXME: This *really* should not be here.
1461
1462 // X86_64 always has SSE2.
1463 if (PointerWidth == 64)
1464 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1465
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001466 switch (CPU) {
1467 case CK_Generic:
1468 case CK_i386:
1469 case CK_i486:
1470 case CK_i586:
1471 case CK_Pentium:
1472 case CK_i686:
1473 case CK_PentiumPro:
1474 case CK_Geode:
1475 break;
1476 case CK_PentiumMMX:
1477 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001478 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001479 break;
1480 case CK_Pentium3:
1481 case CK_Pentium3M:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001482 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001483 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001484 break;
1485 case CK_PentiumM:
1486 case CK_Pentium4:
1487 case CK_Pentium4M:
1488 case CK_x86_64:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001489 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001490 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001491 break;
1492 case CK_Yonah:
1493 case CK_Prescott:
1494 case CK_Nocona:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001495 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001496 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001497 break;
1498 case CK_Core2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001499 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001500 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001501 break;
1502 case CK_Penryn:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001503 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001504 setFeatureEnabled(Features, "sse4", true);
1505 Features["sse42"] = false;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001506 break;
1507 case CK_Atom:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001508 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001509 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001510 break;
1511 case CK_Corei7:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001512 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001513 setFeatureEnabled(Features, "sse4", true);
Eric Christophereea12d12010-04-02 23:50:19 +00001514 setFeatureEnabled(Features, "aes", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001515 break;
1516 case CK_Corei7AVX:
1517 case CK_CoreAVXi:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001518 setFeatureEnabled(Features, "mmx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00001519 setFeatureEnabled(Features, "sse4", true);
1520 setFeatureEnabled(Features, "aes", true);
Bruno Cardoso Lopese02d3912011-07-11 23:33:46 +00001521 //setFeatureEnabled(Features, "avx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001522 break;
1523 case CK_K6:
1524 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001525 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001526 break;
1527 case CK_K6_2:
1528 case CK_K6_3:
1529 case CK_Athlon:
1530 case CK_AthlonThunderbird:
1531 case CK_WinChip2:
1532 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001533 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001534 break;
1535 case CK_Athlon4:
1536 case CK_AthlonXP:
1537 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001538 setFeatureEnabled(Features, "sse", true);
1539 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001540 break;
1541 case CK_K8:
1542 case CK_Opteron:
1543 case CK_Athlon64:
1544 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00001545 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001546 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001547 break;
1548 case CK_K8SSE3:
1549 case CK_OpteronSSE3:
1550 case CK_Athlon64SSE3:
Roman Divackyc8b09a12010-12-29 13:28:29 +00001551 setFeatureEnabled(Features, "sse3", true);
1552 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001553 break;
1554 case CK_C3_2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001555 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001556 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001557 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001558 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001559}
1560
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001561bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump1eb44332009-09-09 15:08:12 +00001562 const std::string &Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001563 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00001564 // FIXME: This *really* should not be here. We need some way of translating
1565 // options into llvm subtarget features.
1566 if (!Features.count(Name) &&
1567 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001568 return false;
1569
1570 if (Enabled) {
1571 if (Name == "mmx")
1572 Features["mmx"] = true;
1573 else if (Name == "sse")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001574 Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001575 else if (Name == "sse2")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001576 Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001577 else if (Name == "sse3")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001578 Features["sse"] = Features["sse2"] = Features["sse3"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001579 else if (Name == "ssse3")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001580 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001581 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001582 else if (Name == "sse4" || Name == "sse4.2")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001583 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001584 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001585 else if (Name == "sse4.1")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001586 Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00001587 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001588 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001589 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001590 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001591 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00001592 else if (Name == "aes")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001593 Features["aes"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001594 else if (Name == "avx")
Bruno Cardoso Lopes292772c2011-08-18 00:07:03 +00001595 Features["avx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1596 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001597 } else {
1598 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001599 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001600 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00001601 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001602 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001603 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00001604 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001605 Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001606 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00001607 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001608 Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001609 else if (Name == "ssse3")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001610 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00001611 else if (Name == "sse4" || Name == "sse4.1")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001612 Features["sse41"] = Features["sse42"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00001613 else if (Name == "sse4.2")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001614 Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001615 else if (Name == "3dnow")
1616 Features["3dnow"] = Features["3dnowa"] = false;
1617 else if (Name == "3dnowa")
1618 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001619 else if (Name == "aes")
1620 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001621 else if (Name == "avx")
1622 Features["avx"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001623 }
1624
1625 return true;
1626}
1627
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001628/// HandleTargetOptions - Perform initialization based on the user
1629/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001630void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001631 // Remember the maximum enabled sselevel.
1632 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1633 // Ignore disabled features.
1634 if (Features[i][0] == '-')
1635 continue;
1636
Eric Christophereea12d12010-04-02 23:50:19 +00001637 if (Features[i].substr(1) == "aes") {
1638 HasAES = true;
1639 continue;
1640 }
1641
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001642 // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1643 // For now let it be enabled together with other SSE levels.
1644 if (Features[i].substr(1) == "avx") {
1645 HasAVX = true;
1646 continue;
1647 }
1648
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001649 assert(Features[i][0] == '+' && "Invalid target feature!");
1650 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1651 .Case("sse42", SSE42)
1652 .Case("sse41", SSE41)
1653 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00001654 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001655 .Case("sse2", SSE2)
1656 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001657 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001658 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001659
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001660 MMX3DNowEnum ThreeDNowLevel =
1661 llvm::StringSwitch<MMX3DNowEnum>(Features[i].substr(1))
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001662 .Case("3dnowa", AMD3DNowAthlon)
1663 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001664 .Case("mmx", MMX)
1665 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001666
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001667 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001668 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001669
1670 // Don't tell the backend if we're turning off mmx; it will end up disabling
1671 // SSE, which we don't want.
1672 std::vector<std::string>::iterator it;
1673 it = std::find(Features.begin(), Features.end(), "-mmx");
1674 if (it != Features.end())
1675 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00001676}
Chris Lattnerc0f59212009-03-02 22:27:17 +00001677
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001678/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
1679/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00001680void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001681 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00001682 // Target identification.
1683 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00001684 Builder.defineMacro("_LP64");
1685 Builder.defineMacro("__LP64__");
1686 Builder.defineMacro("__amd64__");
1687 Builder.defineMacro("__amd64");
1688 Builder.defineMacro("__x86_64");
1689 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00001690 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00001691 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00001692 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001693
Chris Lattnerc0f59212009-03-02 22:27:17 +00001694 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001695 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
1696 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001697 switch (CPU) {
1698 case CK_Generic:
1699 break;
1700 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001701 // The rest are coming from the i386 define above.
1702 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001703 break;
1704 case CK_i486:
1705 case CK_WinChipC6:
1706 case CK_WinChip2:
1707 case CK_C3:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001708 Builder.defineMacro("__i486");
1709 Builder.defineMacro("__i486__");
1710 Builder.defineMacro("__tune_i486__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001711 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00001712 case CK_PentiumMMX:
1713 Builder.defineMacro("__pentium_mmx__");
1714 Builder.defineMacro("__tune_pentium_mmx__");
1715 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001716 case CK_i586:
1717 case CK_Pentium:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001718 Builder.defineMacro("__i586");
1719 Builder.defineMacro("__i586__");
1720 Builder.defineMacro("__tune_i586__");
1721 Builder.defineMacro("__pentium");
1722 Builder.defineMacro("__pentium__");
1723 Builder.defineMacro("__tune_pentium__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001724 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001725 case CK_Pentium3:
1726 case CK_Pentium3M:
1727 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001728 Builder.defineMacro("__tune_pentium3__");
1729 // Fallthrough
1730 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001731 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001732 Builder.defineMacro("__tune_pentium2__");
1733 // Fallthrough
1734 case CK_PentiumPro:
1735 Builder.defineMacro("__tune_i686__");
1736 Builder.defineMacro("__tune_pentiumpro__");
1737 // Fallthrough
1738 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001739 Builder.defineMacro("__i686");
1740 Builder.defineMacro("__i686__");
1741 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
1742 Builder.defineMacro("__pentiumpro");
1743 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001744 break;
1745 case CK_Pentium4:
1746 case CK_Pentium4M:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001747 Builder.defineMacro("__pentium4");
1748 Builder.defineMacro("__pentium4__");
1749 Builder.defineMacro("__tune_pentium4__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001750 break;
1751 case CK_Yonah:
1752 case CK_Prescott:
1753 case CK_Nocona:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001754 Builder.defineMacro("__nocona");
1755 Builder.defineMacro("__nocona__");
1756 Builder.defineMacro("__tune_nocona__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001757 break;
1758 case CK_Core2:
1759 case CK_Penryn:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001760 Builder.defineMacro("__core2");
1761 Builder.defineMacro("__core2__");
1762 Builder.defineMacro("__tune_core2__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001763 break;
1764 case CK_Atom:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001765 Builder.defineMacro("__atom");
1766 Builder.defineMacro("__atom__");
1767 Builder.defineMacro("__tune_atom__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001768 break;
1769 case CK_Corei7:
1770 case CK_Corei7AVX:
1771 case CK_CoreAVXi:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001772 Builder.defineMacro("__corei7");
1773 Builder.defineMacro("__corei7__");
1774 Builder.defineMacro("__tune_corei7__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001775 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001776 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001777 Builder.defineMacro("__k6_2__");
1778 Builder.defineMacro("__tune_k6_2__");
1779 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001780 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001781 if (CPU != CK_K6_2) { // In case of fallthrough
1782 // FIXME: GCC may be enabling these in cases where some other k6
1783 // architecture is specified but -m3dnow is explicitly provided. The
1784 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001785 Builder.defineMacro("__k6_3__");
1786 Builder.defineMacro("__tune_k6_3__");
1787 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00001788 // Fallthrough
1789 case CK_K6:
1790 Builder.defineMacro("__k6");
1791 Builder.defineMacro("__k6__");
1792 Builder.defineMacro("__tune_k6__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001793 break;
1794 case CK_Athlon:
1795 case CK_AthlonThunderbird:
1796 case CK_Athlon4:
1797 case CK_AthlonXP:
1798 case CK_AthlonMP:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001799 Builder.defineMacro("__athlon");
1800 Builder.defineMacro("__athlon__");
1801 Builder.defineMacro("__tune_athlon__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001802 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001803 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001804 Builder.defineMacro("__tune_athlon_sse__");
1805 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001806 break;
1807 case CK_K8:
1808 case CK_K8SSE3:
1809 case CK_x86_64:
1810 case CK_Opteron:
1811 case CK_OpteronSSE3:
1812 case CK_Athlon64:
1813 case CK_Athlon64SSE3:
1814 case CK_AthlonFX:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001815 Builder.defineMacro("__k8");
1816 Builder.defineMacro("__k8__");
1817 Builder.defineMacro("__tune_k8__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001818 break;
1819 case CK_Geode:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001820 Builder.defineMacro("__geode");
1821 Builder.defineMacro("__geode__");
1822 Builder.defineMacro("__tune_geode__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001823 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001824 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00001825
Chandler Carruth88c75b02011-09-28 09:54:07 +00001826 // Target properties.
1827 Builder.defineMacro("__LITTLE_ENDIAN__");
1828 Builder.defineMacro("__REGISTER_PREFIX__", "");
1829
Chris Lattner54175442009-04-19 17:32:33 +00001830 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1831 // functions in glibc header files that use FP Stack inline asm which the
1832 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00001833 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001834
Chandler Carruth88c75b02011-09-28 09:54:07 +00001835 if (HasAES)
1836 Builder.defineMacro("__AES__");
1837
1838 if (HasAVX)
1839 Builder.defineMacro("__AVX__");
1840
Chris Lattner84f0ea82009-03-02 22:40:39 +00001841 // Each case falls through to the previous one here.
1842 switch (SSELevel) {
1843 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00001844 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001845 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00001846 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001847 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00001848 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001849 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00001850 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001851 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00001852 Builder.defineMacro("__SSE2__");
1853 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00001854 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00001855 Builder.defineMacro("__SSE__");
1856 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001857 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00001858 break;
1859 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00001860
Francois Pichet62ec1f22011-09-17 17:15:52 +00001861 if (Opts.MicrosoftExt && PointerWidth == 32) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001862 switch (SSELevel) {
Michael J. Spencera764e832010-10-21 08:22:51 +00001863 case SSE42:
1864 case SSE41:
1865 case SSSE3:
1866 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001867 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001868 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001869 break;
1870 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001871 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001872 break;
1873 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001874 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001875 }
1876 }
1877
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001878 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001879 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001880 case AMD3DNowAthlon:
1881 Builder.defineMacro("__3dNOW_A__");
1882 case AMD3DNow:
1883 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001884 case MMX:
1885 Builder.defineMacro("__MMX__");
1886 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001887 break;
1888 }
Chris Lattnerc0f59212009-03-02 22:27:17 +00001889}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001890
1891
Eli Friedman618234a2008-08-20 02:34:37 +00001892bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001893X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00001894 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001895 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00001896 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00001897 case 'Y': // first letter of a pair:
1898 switch (*(Name+1)) {
1899 default: return false;
1900 case '0': // First SSE register.
1901 case 't': // Any SSE register, when SSE2 is enabled.
1902 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
1903 case 'm': // any MMX register, when inter-unit moves enabled.
1904 break; // falls through to setAllowsRegister.
1905 }
Eli Friedman618234a2008-08-20 02:34:37 +00001906 case 'a': // eax.
1907 case 'b': // ebx.
1908 case 'c': // ecx.
1909 case 'd': // edx.
1910 case 'S': // esi.
1911 case 'D': // edi.
1912 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00001913 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00001914 case 't': // top of floating point stack.
1915 case 'u': // second from top of floating point stack.
1916 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00001917 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00001918 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00001919 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00001920 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
1921 case 'l': // "Index" registers: any general register that can be used as an
1922 // index in a base+index memory access.
1923 Info.setAllowsRegister();
1924 return true;
1925 case 'C': // SSE floating point constant.
1926 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001927 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00001928 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001929 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00001930 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00001931 return true;
1932 }
Dale Johannesen545be512010-08-24 22:33:12 +00001933 return false;
Eli Friedman618234a2008-08-20 02:34:37 +00001934}
1935
Dale Johannesenf6e2c202010-10-29 23:12:32 +00001936
Eli Friedman618234a2008-08-20 02:34:37 +00001937std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00001938X86TargetInfo::convertConstraint(const char *&Constraint) const {
1939 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00001940 case 'a': return std::string("{ax}");
1941 case 'b': return std::string("{bx}");
1942 case 'c': return std::string("{cx}");
1943 case 'd': return std::string("{dx}");
1944 case 'S': return std::string("{si}");
1945 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00001946 case 'p': // address
1947 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00001948 case 't': // top of floating point stack.
1949 return std::string("{st}");
1950 case 'u': // second from top of floating point stack.
1951 return std::string("{st(1)}"); // second from top of floating point stack.
1952 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00001953 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00001954 }
1955}
Eli Friedman618234a2008-08-20 02:34:37 +00001956} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00001957
1958namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001959// X86-32 generic target
1960class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001961public:
Eli Friedman618234a2008-08-20 02:34:37 +00001962 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1963 DoubleAlign = LongLongAlign = 32;
1964 LongDoubleWidth = 96;
1965 LongDoubleAlign = 32;
Eli Friedmaned855cb2008-08-21 00:13:15 +00001966 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1967 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner1932e122009-11-07 18:59:41 +00001968 "a0:0:64-f80:32:32-n8:16:32";
Eli Friedman1afabd92009-03-29 20:31:09 +00001969 SizeType = UnsignedInt;
1970 PtrDiffType = SignedInt;
1971 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00001972 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00001973
1974 // Use fpret for all types.
1975 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
1976 (1 << TargetInfo::Double) |
1977 (1 << TargetInfo::LongDouble));
Eli Friedman618234a2008-08-20 02:34:37 +00001978 }
1979 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00001980 return "typedef char* __builtin_va_list;";
Eli Friedman618234a2008-08-20 02:34:37 +00001981 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00001982
Chris Lattner21fb98e2009-09-23 06:06:36 +00001983 int getEHDataRegisterNumber(unsigned RegNo) const {
1984 if (RegNo == 0) return 0;
1985 if (RegNo == 1) return 2;
1986 return -1;
1987 }
Eli Friedman618234a2008-08-20 02:34:37 +00001988};
1989} // end anonymous namespace
1990
1991namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00001992class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
1993public:
1994 OpenBSDI386TargetInfo(const std::string& triple) :
1995 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
1996 SizeType = UnsignedLong;
1997 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00001998 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00001999 }
2000};
2001} // end anonymous namespace
2002
2003namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002004class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002005public:
Torok Edwin5f6c1942009-06-30 17:10:35 +00002006 DarwinI386TargetInfo(const std::string& triple) :
2007 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002008 LongDoubleWidth = 128;
2009 LongDoubleAlign = 128;
Eli Friedman1afabd92009-03-29 20:31:09 +00002010 SizeType = UnsignedLong;
2011 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002012 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2013 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner1932e122009-11-07 18:59:41 +00002014 "a0:0:64-f80:128:128-n8:16:32";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002015 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002016 }
2017
Eli Friedman618234a2008-08-20 02:34:37 +00002018};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002019} // end anonymous namespace
2020
2021namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002022// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002023class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002024public:
2025 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002026 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002027 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002028 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002029 DoubleAlign = LongLongAlign = 64;
2030 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 +00002031 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
2032 "v128:128:128-a0:0:64-f80:32:32-n8:16:32";
Eli Friedman29a30502008-08-21 01:40:19 +00002033 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002034 virtual void getTargetDefines(const LangOptions &Opts,
2035 MacroBuilder &Builder) const {
2036 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2037 }
2038};
2039} // end anonymous namespace
2040
2041namespace {
2042
2043// x86-32 Windows Visual Studio target
2044class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2045public:
2046 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2047 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002048 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002049 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2050 }
2051 virtual void getTargetDefines(const LangOptions &Opts,
2052 MacroBuilder &Builder) const {
2053 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2054 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2055 // The value of the following reflects processor type.
2056 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2057 // We lost the original triple, so we use the default.
2058 Builder.defineMacro("_M_IX86", "600");
2059 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002060};
2061} // end anonymous namespace
2062
2063namespace {
2064// x86-32 MinGW target
2065class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2066public:
2067 MinGWX86_32TargetInfo(const std::string& triple)
2068 : WindowsX86_32TargetInfo(triple) {
2069 }
2070 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002071 MacroBuilder &Builder) const {
2072 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002073 DefineStd(Builder, "WIN32", Opts);
2074 DefineStd(Builder, "WINNT", Opts);
2075 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002076 Builder.defineMacro("__MSVCRT__");
2077 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002078
2079 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2080 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002081 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002082 // Provide "as-is" __declspec.
2083 Builder.defineMacro("__declspec", "__declspec");
2084 else
2085 // Provide alias of __attribute__ like mingw32-gcc.
2086 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002087 }
2088};
2089} // end anonymous namespace
2090
2091namespace {
2092// x86-32 Cygwin target
2093class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2094public:
2095 CygwinX86_32TargetInfo(const std::string& triple)
2096 : X86_32TargetInfo(triple) {
2097 TLSSupported = false;
2098 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002099 DoubleAlign = LongLongAlign = 64;
2100 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2101 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner1932e122009-11-07 18:59:41 +00002102 "a0:0:64-f80:32:32-n8:16:32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002103 }
2104 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002105 MacroBuilder &Builder) const {
2106 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2107 Builder.defineMacro("__CYGWIN__");
2108 Builder.defineMacro("__CYGWIN32__");
2109 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00002110 if (Opts.CPlusPlus)
2111 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00002112 }
Eli Friedman29a30502008-08-21 01:40:19 +00002113};
2114} // end anonymous namespace
2115
2116namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002117// x86-32 Haiku target
2118class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2119public:
2120 HaikuX86_32TargetInfo(const std::string& triple)
2121 : X86_32TargetInfo(triple) {
2122 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00002123 IntPtrType = SignedLong;
2124 PtrDiffType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00002125 this->UserLabelPrefix = "";
Eli Friedmana7e68452010-08-22 01:00:03 +00002126 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00002127 virtual void getTargetDefines(const LangOptions &Opts,
2128 MacroBuilder &Builder) const {
2129 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2130 Builder.defineMacro("__INTEL__");
2131 Builder.defineMacro("__HAIKU__");
2132 }
2133};
2134} // end anonymous namespace
2135
Douglas Gregordca52262011-07-01 22:41:14 +00002136// RTEMS Target
2137template<typename Target>
2138class RTEMSTargetInfo : public OSTargetInfo<Target> {
2139protected:
2140 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2141 MacroBuilder &Builder) const {
2142 // RTEMS defines; list based off of gcc output
2143
Douglas Gregordca52262011-07-01 22:41:14 +00002144 Builder.defineMacro("__rtems__");
2145 Builder.defineMacro("__ELF__");
2146 }
2147public:
2148 RTEMSTargetInfo(const std::string &triple)
2149 : OSTargetInfo<Target>(triple) {
2150 this->UserLabelPrefix = "";
2151
2152 llvm::Triple Triple(triple);
2153 switch (Triple.getArch()) {
2154 default:
2155 case llvm::Triple::x86:
2156 // this->MCountName = ".mcount";
2157 break;
2158 case llvm::Triple::mips:
2159 case llvm::Triple::mipsel:
2160 case llvm::Triple::ppc:
2161 case llvm::Triple::ppc64:
2162 // this->MCountName = "_mcount";
2163 break;
2164 case llvm::Triple::arm:
2165 // this->MCountName = "__mcount";
2166 break;
2167 }
2168
2169 }
2170};
2171
2172namespace {
2173// x86-32 RTEMS target
2174class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2175public:
2176 RTEMSX86_32TargetInfo(const std::string& triple)
2177 : X86_32TargetInfo(triple) {
2178 SizeType = UnsignedLong;
2179 IntPtrType = SignedLong;
2180 PtrDiffType = SignedLong;
2181 this->UserLabelPrefix = "";
2182 }
2183 virtual void getTargetDefines(const LangOptions &Opts,
2184 MacroBuilder &Builder) const {
2185 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2186 Builder.defineMacro("__INTEL__");
2187 Builder.defineMacro("__rtems__");
2188 }
2189};
2190} // end anonymous namespace
2191
Chris Lattner86ed3a32010-04-11 19:29:39 +00002192namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002193// x86-64 generic target
2194class X86_64TargetInfo : public X86TargetInfo {
2195public:
Chris Lattner33328642009-03-20 15:52:06 +00002196 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00002197 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002198 LongDoubleWidth = 128;
2199 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00002200 LargeArrayMinWidth = 128;
2201 LargeArrayAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00002202 IntMaxType = SignedLong;
2203 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002204 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002205 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00002206
Eli Friedmaned855cb2008-08-21 00:13:15 +00002207 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2208 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner1932e122009-11-07 18:59:41 +00002209 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002210
2211 // Use fpret only for long double.
2212 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Reid Spencer5f016e22007-07-11 17:01:13 +00002213 }
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00002214 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002215 return "typedef struct __va_list_tag {"
2216 " unsigned gp_offset;"
2217 " unsigned fp_offset;"
2218 " void* overflow_arg_area;"
2219 " void* reg_save_area;"
John McCall2b7baf02010-05-28 18:25:28 +00002220 "} __va_list_tag;"
Eli Friedmandc043162009-07-03 00:45:06 +00002221 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson3346ae62007-11-24 23:38:12 +00002222 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002223
Chris Lattner21fb98e2009-09-23 06:06:36 +00002224 int getEHDataRegisterNumber(unsigned RegNo) const {
2225 if (RegNo == 0) return 0;
2226 if (RegNo == 1) return 1;
2227 return -1;
2228 }
Eli Friedman618234a2008-08-20 02:34:37 +00002229};
2230} // end anonymous namespace
2231
2232namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002233// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002234class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002235public:
2236 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002237 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002238 TLSSupported = false;
2239 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00002240 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00002241 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00002242 IntMaxType = SignedLongLong;
2243 UIntMaxType = UnsignedLongLong;
2244 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00002245 SizeType = UnsignedLongLong;
2246 PtrDiffType = SignedLongLong;
2247 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00002248 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002249 }
2250 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002251 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002252 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002253 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00002254 }
NAKAMURA Takumi79521992011-01-17 22:56:23 +00002255 virtual const char *getVAListDeclaration() const {
2256 return "typedef char* __builtin_va_list;";
2257 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002258};
2259} // end anonymous namespace
2260
2261namespace {
2262// x86-64 Windows Visual Studio target
2263class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2264public:
2265 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2266 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002267 LongDoubleWidth = LongDoubleAlign = 64;
2268 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00002269 }
2270 virtual void getTargetDefines(const LangOptions &Opts,
2271 MacroBuilder &Builder) const {
2272 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
2273 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00002274 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002275 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002276 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002277};
2278} // end anonymous namespace
2279
2280namespace {
2281// x86-64 MinGW target
2282class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2283public:
2284 MinGWX86_64TargetInfo(const std::string& triple)
2285 : WindowsX86_64TargetInfo(triple) {
2286 }
2287 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002288 MacroBuilder &Builder) const {
2289 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002290 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00002291 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00002292 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00002293 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002294
2295 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2296 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002297 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002298 // Provide "as-is" __declspec.
2299 Builder.defineMacro("__declspec", "__declspec");
2300 else
2301 // Provide alias of __attribute__ like mingw32-gcc.
2302 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002303 }
2304};
2305} // end anonymous namespace
2306
2307namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002308class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2309public:
Mike Stump1eb44332009-09-09 15:08:12 +00002310 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002311 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2312 Int64Type = SignedLongLong;
2313 }
2314};
2315} // end anonymous namespace
2316
2317namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00002318class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
2319public:
Mike Stump1eb44332009-09-09 15:08:12 +00002320 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman6036ebe2009-07-05 22:31:18 +00002321 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
2322 IntMaxType = SignedLongLong;
2323 UIntMaxType = UnsignedLongLong;
2324 Int64Type = SignedLongLong;
2325 }
2326};
2327} // end anonymous namespace
2328
2329namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00002330class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002331 // Possible FPU choices.
2332 enum FPUMode {
2333 NoFPU,
2334 VFP2FPU,
2335 VFP3FPU,
2336 NeonFPU
2337 };
2338
2339 static bool FPUModeIsVFP(FPUMode Mode) {
2340 return Mode >= VFP2FPU && Mode <= NeonFPU;
2341 }
2342
2343 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2344 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002345
Daniel Dunbareac7c532009-12-18 18:42:37 +00002346 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002347
2348 unsigned FPU : 3;
2349
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002350 unsigned IsThumb : 1;
2351
2352 // Initialized via features.
2353 unsigned SoftFloat : 1;
2354 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002355
Chris Lattner2752c012010-03-03 19:03:45 +00002356 static const Builtin::Info BuiltinInfo[];
2357
Chris Lattner393ff042008-04-21 18:56:49 +00002358public:
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002359 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbareac7c532009-12-18 18:42:37 +00002360 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002361 {
Daniel Dunbara2a41612009-09-14 00:02:24 +00002362 SizeType = UnsignedInt;
2363 PtrDiffType = SignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002364
Chris Lattner9bffb072010-04-23 16:29:58 +00002365 // {} in inline assembly are neon specifiers, not assembly variant
2366 // specifiers.
2367 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00002368
Daniel Dunbareac7c532009-12-18 18:42:37 +00002369 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00002370 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002371 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002372 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2373 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002374 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
2375 "i64:64:64-f32:32:32-f64:64:64-"
Bob Wilsoncd5ce092011-04-04 16:53:11 +00002376 "v64:64:64-v128:64:128-a0:0:32-n32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002377 } else {
2378 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2379 "i64:64:64-f32:32:32-f64:64:64-"
Bob Wilsoncd5ce092011-04-04 16:53:11 +00002380 "v64:64:64-v128:64:128-a0:0:64-n32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002381 }
John McCallee79a4c2010-08-21 22:46:04 +00002382
2383 // ARM targets default to using the ARM C++ ABI.
2384 CXXABI = CXXABI_ARM;
Eli Friedman61538a72008-05-20 14:21:01 +00002385 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002386 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00002387 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002388 ABI = Name;
2389
Daniel Dunbara2a41612009-09-14 00:02:24 +00002390 // The defaults (above) are for AAPCS, check if we need to change them.
2391 //
2392 // FIXME: We need support for -meabi... we could just mangle it into the
2393 // name.
2394 if (Name == "apcs-gnu") {
Daniel Dunbard410fa22010-01-27 20:23:08 +00002395 DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002396 SizeType = UnsignedLong;
2397
Daniel Dunbar684de632010-04-22 16:14:54 +00002398 // Do not respect the alignment of bit-field types when laying out
2399 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
2400 UseBitFieldTypeAlignment = false;
2401
Chad Rosier61a62212011-08-04 01:21:14 +00002402 /// Do force alignment of members that follow zero length bitfields. If
2403 /// the alignment of the zero-length bitfield is greater than the member
2404 /// that follows it, `bar', `bar' will be aligned as the type of the
2405 /// zero length bitfield.
2406 UseZeroLengthBitfieldAlignment = true;
2407
2408 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00002409 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
2410 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00002411 ZeroLengthBitfieldBoundary = 32;
2412
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002413 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002414 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2415 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002416 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 +00002417 "i64:32:64-f32:32:32-f64:32:64-"
Bob Wilsoncd5ce092011-04-04 16:53:11 +00002418 "v64:32:64-v128:32:128-a0:0:32-n32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002419 } else {
2420 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 +00002421 "i64:32:64-f32:32:32-f64:32:64-"
2422 "v64:32:64-v128:32:128-a0:0:32-n32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002423 }
2424
Chad Rosier9f1210c2011-07-26 07:03:04 +00002425 // FIXME: Override "preferred align" for double and long long.
Daniel Dunbara2a41612009-09-14 00:02:24 +00002426 } else if (Name == "aapcs") {
2427 // FIXME: Enumerated types are variable width in straight AAPCS.
2428 } else if (Name == "aapcs-linux") {
Chad Rosier9f1210c2011-07-26 07:03:04 +00002429 ;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002430 } else
2431 return false;
2432
2433 return true;
2434 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002435
Chandler Carruthc3a2e652011-09-28 05:56:05 +00002436 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002437 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
2438 Features["vfp2"] = true;
2439 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
2440 Features["neon"] = true;
2441 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002442
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002443 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2444 const std::string &Name,
2445 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00002446 if (Name == "soft-float" || Name == "soft-float-abi" ||
2447 Name == "vfp2" || Name == "vfp3" || Name == "neon") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002448 Features[Name] = Enabled;
2449 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002450 return false;
2451
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002452 return true;
2453 }
2454
2455 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002456 FPU = NoFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002457 SoftFloat = SoftFloatABI = false;
2458 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
2459 if (Features[i] == "+soft-float")
2460 SoftFloat = true;
2461 else if (Features[i] == "+soft-float-abi")
2462 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002463 else if (Features[i] == "+vfp2")
2464 FPU = VFP2FPU;
2465 else if (Features[i] == "+vfp3")
2466 FPU = VFP3FPU;
2467 else if (Features[i] == "+neon")
2468 FPU = NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002469 }
2470
2471 // Remove front-end specific options which the backend handles differently.
2472 std::vector<std::string>::iterator it;
2473 it = std::find(Features.begin(), Features.end(), "+soft-float");
2474 if (it != Features.end())
2475 Features.erase(it);
2476 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2477 if (it != Features.end())
2478 Features.erase(it);
2479 }
2480
Chris Lattner5f9e2722011-07-23 10:55:15 +00002481 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00002482 return llvm::StringSwitch<const char*>(Name)
2483 .Cases("arm8", "arm810", "4")
2484 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2485 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2486 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2487 .Case("ep9312", "4T")
2488 .Cases("arm10tdmi", "arm1020t", "5T")
2489 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2490 .Case("arm926ej-s", "5TEJ")
2491 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2492 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002493 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002494 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002495 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002496 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2497 .Cases("cortex-a8", "cortex-a9", "7A")
Bob Wilson06f45632011-01-06 16:57:20 +00002498 .Case("cortex-m3", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00002499 .Case("cortex-m0", "6M")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002500 .Default(0);
2501 }
2502 virtual bool setCPU(const std::string &Name) {
2503 if (!getCPUDefineSuffix(Name))
2504 return false;
2505
2506 CPU = Name;
2507 return true;
2508 }
Chris Lattner33328642009-03-20 15:52:06 +00002509 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002510 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002511 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00002512 Builder.defineMacro("__arm");
2513 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002514
Chris Lattnerc0f59212009-03-02 22:27:17 +00002515 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00002516 Builder.defineMacro("__ARMEL__");
2517 Builder.defineMacro("__LITTLE_ENDIAN__");
2518 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002519
Chris Lattner5f9e2722011-07-23 10:55:15 +00002520 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00002521 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002522
Mike Stump437bb4b2009-04-08 02:07:04 +00002523 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002524
Daniel Dunbareac7c532009-12-18 18:42:37 +00002525 // FIXME: It's more complicated than this and we don't really support
2526 // interworking.
2527 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00002528 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002529
Daniel Dunbareac7c532009-12-18 18:42:37 +00002530 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramera9992772010-01-09 17:55:51 +00002531 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002532
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002533 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00002534 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002535
2536 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00002537 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002538
Bob Wilson84f95cf2011-05-13 18:56:03 +00002539 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002540 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002541 Builder.defineMacro("__THUMBEL__");
2542 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00002543 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002544 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002545 }
2546
2547 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00002548 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002549
2550 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramera9992772010-01-09 17:55:51 +00002551 Builder.defineMacro("__VFP_FP__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002552
2553 // This only gets set when Neon instructions are actually available, unlike
2554 // the VFP define, hence the soft float and arch check. This is subtly
2555 // different from gcc, we follow the intent which was that it should be set
2556 // when Neon instructions are actually available.
Bob Wilson84f95cf2011-05-13 18:56:03 +00002557 if (FPU == NeonFPU && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002558 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00002559 }
2560 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2561 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00002562 Records = BuiltinInfo;
2563 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00002564 }
2565 virtual const char *getVAListDeclaration() const {
John McCall0e9972c2011-05-09 02:19:37 +00002566 return "typedef void* __builtin_va_list;";
Chris Lattner393ff042008-04-21 18:56:49 +00002567 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002568 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002569 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002570 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002571 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002572 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002573 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002574 // FIXME: Check if this is complete
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002575 switch (*Name) {
Eli Friedmana9f54962008-08-20 07:44:10 +00002576 default:
Nate Begemanad487f42008-04-22 05:03:19 +00002577 case 'l': // r0-r7
2578 case 'h': // r8-r15
2579 case 'w': // VFP Floating point register single precision
2580 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00002581 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00002582 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00002583 case 'Q': // A memory address that is a single base register.
2584 Info.setAllowsMemory();
2585 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00002586 case 'U': // a memory reference...
2587 switch (Name[1]) {
2588 case 'q': // ...ARMV4 ldrsb
2589 case 'v': // ...VFP load/store (reg+constant offset)
2590 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00002591 case 't': // address valid for load/store opaque types wider
2592 // than 128-bits
2593 case 'n': // valid address for Neon doubleword vector load/store
2594 case 'm': // valid address for Neon element and structure load/store
2595 case 's': // valid address for non-offset loads/stores of quad-word
2596 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00002597 Info.setAllowsMemory();
2598 Name++;
2599 return true;
2600 }
Nate Begemanad487f42008-04-22 05:03:19 +00002601 }
Chris Lattner393ff042008-04-21 18:56:49 +00002602 return false;
2603 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00002604 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00002605 std::string R;
2606 switch (*Constraint) {
2607 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00002608 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00002609 Constraint++;
2610 break;
Eric Christopher283f4472011-06-17 00:40:18 +00002611 case 'p': // 'p' should be translated to 'r' by default.
2612 R = std::string("r");
2613 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00002614 default:
2615 return std::string(1, *Constraint);
2616 }
2617 return R;
2618 }
Chris Lattner393ff042008-04-21 18:56:49 +00002619 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002620 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00002621 return "";
2622 }
2623};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002624
2625const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002626 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002627 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002628 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
2629
2630 // Float registers
2631 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2632 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2633 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002634 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002635
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002636 // Double registers
2637 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
2638 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00002639 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
2640 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002641
2642 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00002643 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
2644 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002645};
2646
2647void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002648 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002649 Names = GCCRegNames;
2650 NumNames = llvm::array_lengthof(GCCRegNames);
2651}
2652
2653const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002654 { { "a1" }, "r0" },
2655 { { "a2" }, "r1" },
2656 { { "a3" }, "r2" },
2657 { { "a4" }, "r3" },
2658 { { "v1" }, "r4" },
2659 { { "v2" }, "r5" },
2660 { { "v3" }, "r6" },
2661 { { "v4" }, "r7" },
2662 { { "v5" }, "r8" },
2663 { { "v6", "rfp" }, "r9" },
2664 { { "sl" }, "r10" },
2665 { { "fp" }, "r11" },
2666 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002667 { { "r13" }, "sp" },
2668 { { "r14" }, "lr" },
2669 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002670 // The S, D and Q registers overlap, but aren't really aliases; we
2671 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002672};
2673
2674void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2675 unsigned &NumAliases) const {
2676 Aliases = GCCRegAliases;
2677 NumAliases = llvm::array_lengthof(GCCRegAliases);
2678}
Chris Lattner2752c012010-03-03 19:03:45 +00002679
2680const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00002681#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00002682#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00002683 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00002684#include "clang/Basic/BuiltinsARM.def"
2685};
Chris Lattner393ff042008-04-21 18:56:49 +00002686} // end anonymous namespace.
2687
Eli Friedmana9f54962008-08-20 07:44:10 +00002688
2689namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00002690class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00002691 public DarwinTargetInfo<ARMTargetInfo> {
2692protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00002693 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00002694 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00002695 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00002696 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002697
Torok Edwin5f6c1942009-06-30 17:10:35 +00002698public:
Mike Stump1eb44332009-09-09 15:08:12 +00002699 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar350b9f32010-05-27 07:00:26 +00002700 : DarwinTargetInfo<ARMTargetInfo>(triple) {
2701 HasAlignMac68kSupport = true;
2702 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002703};
2704} // end anonymous namespace.
2705
Reid Spencer5f016e22007-07-11 17:01:13 +00002706namespace {
Eli Friedman01b86682008-08-20 07:28:14 +00002707class SparcV8TargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00002708 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2709 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002710 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00002711public:
Eli Friedman01b86682008-08-20 07:28:14 +00002712 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
2713 // FIXME: Support Sparc quad-precision long double?
Eli Friedmaned855cb2008-08-21 00:13:15 +00002714 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 +00002715 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedman01b86682008-08-20 07:28:14 +00002716 }
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002717 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2718 const std::string &Name,
2719 bool Enabled) const {
2720 if (Name == "soft-float")
2721 Features[Name] = Enabled;
2722 else
2723 return false;
2724
2725 return true;
2726 }
2727 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
2728 SoftFloat = false;
2729 for (unsigned i = 0, e = Features.size(); i != e; ++i)
2730 if (Features[i] == "+soft-float")
2731 SoftFloat = true;
2732 }
Chris Lattner33328642009-03-20 15:52:06 +00002733 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002734 MacroBuilder &Builder) const {
2735 DefineStd(Builder, "sparc", Opts);
2736 Builder.defineMacro("__sparcv8");
2737 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002738
2739 if (SoftFloat)
2740 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00002741 }
2742 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2743 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00002744 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00002745 }
2746 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002747 return "typedef void* __builtin_va_list;";
Gabor Greif26658672008-02-21 16:29:08 +00002748 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002749 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00002750 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002751 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00002752 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002753 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00002754 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00002755 // FIXME: Implement!
2756 return false;
Gabor Greif26658672008-02-21 16:29:08 +00002757 }
2758 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002759 // FIXME: Implement!
2760 return "";
Gabor Greif26658672008-02-21 16:29:08 +00002761 }
2762};
2763
Chris Lattnere957f532009-01-27 01:58:38 +00002764const char * const SparcV8TargetInfo::GCCRegNames[] = {
2765 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2766 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2767 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2768 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
2769};
2770
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002771void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00002772 unsigned &NumNames) const {
2773 Names = GCCRegNames;
2774 NumNames = llvm::array_lengthof(GCCRegNames);
2775}
2776
2777const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002778 { { "g0" }, "r0" },
2779 { { "g1" }, "r1" },
2780 { { "g2" }, "r2" },
2781 { { "g3" }, "r3" },
2782 { { "g4" }, "r4" },
2783 { { "g5" }, "r5" },
2784 { { "g6" }, "r6" },
2785 { { "g7" }, "r7" },
2786 { { "o0" }, "r8" },
2787 { { "o1" }, "r9" },
2788 { { "o2" }, "r10" },
2789 { { "o3" }, "r11" },
2790 { { "o4" }, "r12" },
2791 { { "o5" }, "r13" },
2792 { { "o6", "sp" }, "r14" },
2793 { { "o7" }, "r15" },
2794 { { "l0" }, "r16" },
2795 { { "l1" }, "r17" },
2796 { { "l2" }, "r18" },
2797 { { "l3" }, "r19" },
2798 { { "l4" }, "r20" },
2799 { { "l5" }, "r21" },
2800 { { "l6" }, "r22" },
2801 { { "l7" }, "r23" },
2802 { { "i0" }, "r24" },
2803 { { "i1" }, "r25" },
2804 { { "i2" }, "r26" },
2805 { { "i3" }, "r27" },
2806 { { "i4" }, "r28" },
2807 { { "i5" }, "r29" },
2808 { { "i6", "fp" }, "r30" },
2809 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00002810};
2811
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002812void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00002813 unsigned &NumAliases) const {
2814 Aliases = GCCRegAliases;
2815 NumAliases = llvm::array_lengthof(GCCRegAliases);
2816}
Gabor Greif26658672008-02-21 16:29:08 +00002817} // end anonymous namespace.
2818
Eli Friedman01b86682008-08-20 07:28:14 +00002819namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00002820class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
2821public:
2822 AuroraUXSparcV8TargetInfo(const std::string& triple) :
2823 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
2824 SizeType = UnsignedInt;
2825 PtrDiffType = SignedInt;
2826 }
2827};
Torok Edwin5f6c1942009-06-30 17:10:35 +00002828class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00002829public:
2830 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwin5f6c1942009-06-30 17:10:35 +00002831 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00002832 SizeType = UnsignedInt;
2833 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00002834 }
2835};
2836} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00002837
Chris Lattner2621fd12008-05-08 05:58:21 +00002838namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002839 class MSP430TargetInfo : public TargetInfo {
2840 static const char * const GCCRegNames[];
2841 public:
2842 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
2843 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00002844 IntWidth = 16; IntAlign = 16;
2845 LongWidth = 32; LongLongWidth = 64;
2846 LongAlign = LongLongAlign = 16;
2847 PointerWidth = 16; PointerAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002848 SizeType = UnsignedInt;
2849 IntMaxType = SignedLong;
2850 UIntMaxType = UnsignedLong;
2851 IntPtrType = SignedShort;
2852 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00002853 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00002854 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002855 }
2856 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002857 MacroBuilder &Builder) const {
2858 Builder.defineMacro("MSP430");
2859 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002860 // FIXME: defines for different 'flavours' of MCU
2861 }
2862 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2863 unsigned &NumRecords) const {
2864 // FIXME: Implement.
2865 Records = 0;
2866 NumRecords = 0;
2867 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002868 virtual void getGCCRegNames(const char * const *&Names,
2869 unsigned &NumNames) const;
2870 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2871 unsigned &NumAliases) const {
2872 // No aliases.
2873 Aliases = 0;
2874 NumAliases = 0;
2875 }
2876 virtual bool validateAsmConstraint(const char *&Name,
2877 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00002878 // No target constraints for now.
2879 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002880 }
2881 virtual const char *getClobbers() const {
2882 // FIXME: Is this really right?
2883 return "";
2884 }
2885 virtual const char *getVAListDeclaration() const {
2886 // FIXME: implement
Anton Korobeynikoveb716852009-05-08 18:24:57 +00002887 return "typedef char* __builtin_va_list;";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002888 }
2889 };
2890
2891 const char * const MSP430TargetInfo::GCCRegNames[] = {
2892 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2893 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2894 };
2895
2896 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
2897 unsigned &NumNames) const {
2898 Names = GCCRegNames;
2899 NumNames = llvm::array_lengthof(GCCRegNames);
2900 }
2901}
2902
2903
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002904namespace {
2905 class SystemZTargetInfo : public TargetInfo {
2906 static const char * const GCCRegNames[];
2907 public:
2908 SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
2909 TLSSupported = false;
2910 IntWidth = IntAlign = 32;
2911 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
2912 PointerWidth = PointerAlign = 64;
Chris Lattner1932e122009-11-07 18:59:41 +00002913 DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
2914 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002915 }
2916 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002917 MacroBuilder &Builder) const {
2918 Builder.defineMacro("__s390__");
2919 Builder.defineMacro("__s390x__");
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002920 }
2921 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2922 unsigned &NumRecords) const {
2923 // FIXME: Implement.
2924 Records = 0;
2925 NumRecords = 0;
2926 }
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002927
Anton Korobeynikov89e887f2009-07-16 20:09:57 +00002928 virtual void getGCCRegNames(const char * const *&Names,
2929 unsigned &NumNames) const;
2930 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2931 unsigned &NumAliases) const {
2932 // No aliases.
2933 Aliases = 0;
2934 NumAliases = 0;
2935 }
2936 virtual bool validateAsmConstraint(const char *&Name,
2937 TargetInfo::ConstraintInfo &info) const {
2938 // FIXME: implement
2939 return true;
2940 }
2941 virtual const char *getClobbers() const {
2942 // FIXME: Is this really right?
2943 return "";
2944 }
2945 virtual const char *getVAListDeclaration() const {
2946 // FIXME: implement
2947 return "typedef char* __builtin_va_list;";
2948 }
2949 };
2950
2951 const char * const SystemZTargetInfo::GCCRegNames[] = {
2952 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2953 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2954 };
2955
2956 void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
2957 unsigned &NumNames) const {
2958 Names = GCCRegNames;
2959 NumNames = llvm::array_lengthof(GCCRegNames);
2960 }
2961}
2962
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002963namespace {
2964 class BlackfinTargetInfo : public TargetInfo {
2965 static const char * const GCCRegNames[];
2966 public:
2967 BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
2968 TLSSupported = false;
2969 DoubleAlign = 32;
2970 LongLongAlign = 32;
2971 LongDoubleAlign = 32;
Chris Lattner1932e122009-11-07 18:59:41 +00002972 DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002973 }
2974
2975 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002976 MacroBuilder &Builder) const {
2977 DefineStd(Builder, "bfin", Opts);
2978 DefineStd(Builder, "BFIN", Opts);
2979 Builder.defineMacro("__ADSPBLACKFIN__");
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002980 // FIXME: This one is really dependent on -mcpu
Benjamin Kramera9992772010-01-09 17:55:51 +00002981 Builder.defineMacro("__ADSPLPBLACKFIN__");
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002982 // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
2983 }
2984
2985 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2986 unsigned &NumRecords) const {
2987 // FIXME: Implement.
2988 Records = 0;
2989 NumRecords = 0;
2990 }
2991
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002992 virtual void getGCCRegNames(const char * const *&Names,
2993 unsigned &NumNames) const;
2994
2995 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2996 unsigned &NumAliases) const {
2997 // No aliases.
2998 Aliases = 0;
2999 NumAliases = 0;
3000 }
3001
3002 virtual bool validateAsmConstraint(const char *&Name,
3003 TargetInfo::ConstraintInfo &Info) const {
3004 if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
3005 Info.setAllowsRegister();
3006 return true;
3007 }
3008 return false;
3009 }
3010
3011 virtual const char *getClobbers() const {
3012 return "";
3013 }
3014
3015 virtual const char *getVAListDeclaration() const {
3016 return "typedef char* __builtin_va_list;";
3017 }
3018 };
3019
3020 const char * const BlackfinTargetInfo::GCCRegNames[] = {
3021 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3022 "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
3023 "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
3024 "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
3025 "a0", "a1", "cc",
3026 "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
3027 "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
3028 };
3029
3030 void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
3031 unsigned &NumNames) const {
3032 Names = GCCRegNames;
3033 NumNames = llvm::array_lengthof(GCCRegNames);
3034 }
3035}
3036
Eli Friedmanb63decf2009-08-19 20:47:07 +00003037namespace {
3038
Mike Stump1eb44332009-09-09 15:08:12 +00003039 // LLVM and Clang cannot be used directly to output native binaries for
3040 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00003041 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00003042 //
3043 // TCE uses the llvm bitcode as input and uses it for generating customized
3044 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00003045 // publicly available in http://tce.cs.tut.fi
3046
3047 class TCETargetInfo : public TargetInfo{
3048 public:
3049 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
3050 TLSSupported = false;
3051 IntWidth = 32;
3052 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003053 PointerWidth = 32;
3054 IntAlign = 32;
3055 LongAlign = LongLongAlign = 32;
3056 PointerAlign = 32;
3057 SizeType = UnsignedInt;
3058 IntMaxType = SignedLong;
3059 UIntMaxType = UnsignedLong;
3060 IntPtrType = SignedInt;
3061 PtrDiffType = SignedInt;
3062 FloatWidth = 32;
3063 FloatAlign = 32;
3064 DoubleWidth = 32;
3065 DoubleAlign = 32;
3066 LongDoubleWidth = 32;
3067 LongDoubleAlign = 32;
3068 FloatFormat = &llvm::APFloat::IEEEsingle;
3069 DoubleFormat = &llvm::APFloat::IEEEsingle;
3070 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00003071 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
3072 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00003073 "f32:32:32-f64:32:32-v64:32:32-"
3074 "v128:32:32-a0:0:32-n32";
Eli Friedmanb63decf2009-08-19 20:47:07 +00003075 }
3076
3077 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003078 MacroBuilder &Builder) const {
3079 DefineStd(Builder, "tce", Opts);
3080 Builder.defineMacro("__TCE__");
3081 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00003082 }
3083 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3084 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00003085 virtual const char *getClobbers() const {
3086 return "";
3087 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003088 virtual const char *getVAListDeclaration() const {
3089 return "typedef void* __builtin_va_list;";
3090 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003091 virtual void getGCCRegNames(const char * const *&Names,
3092 unsigned &NumNames) const {}
3093 virtual bool validateAsmConstraint(const char *&Name,
3094 TargetInfo::ConstraintInfo &info) const {
3095 return true;
3096 }
3097 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3098 unsigned &NumAliases) const {}
3099 };
3100}
3101
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003102namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003103class MipsTargetInfoBase : public TargetInfo {
3104 std::string CPU;
3105protected:
3106 std::string ABI;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003107public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003108 MipsTargetInfoBase(const std::string& triple, const std::string& ABIStr)
3109 : TargetInfo(triple), ABI(ABIStr) {
Akira Hatanaka619e8872011-06-02 00:09:17 +00003110 SizeType = UnsignedInt;
3111 PtrDiffType = SignedInt;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003112 }
Eric Christophered734732010-03-02 02:41:08 +00003113 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003114 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00003115 virtual bool setCPU(const std::string &Name) {
3116 CPU = Name;
3117 return true;
3118 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003119 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00003120 Features[ABI] = true;
3121 Features[CPU] = true;
3122 }
3123 virtual void getArchDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003124 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003125 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003126 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003127 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3128 unsigned &NumRecords) const {
3129 // FIXME: Implement!
3130 }
3131 virtual const char *getVAListDeclaration() const {
3132 return "typedef void* __builtin_va_list;";
3133 }
3134 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003135 unsigned &NumNames) const {
3136 static const char * const GCCRegNames[] = {
3137 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
3138 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
3139 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
3140 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
3141 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
3142 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
3143 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
3144 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
3145 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
3146 "$fcc5","$fcc6","$fcc7"
3147 };
3148 Names = GCCRegNames;
3149 NumNames = llvm::array_lengthof(GCCRegNames);
3150 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003151 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003152 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003153 virtual bool validateAsmConstraint(const char *&Name,
3154 TargetInfo::ConstraintInfo &Info) const {
3155 switch (*Name) {
3156 default:
3157 case 'r': // CPU registers.
3158 case 'd': // Equivalent to "r" unless generating MIPS16 code.
3159 case 'y': // Equivalent to "r", backwards compatibility only.
3160 case 'f': // floating-point registers.
3161 Info.setAllowsRegister();
3162 return true;
3163 }
3164 return false;
3165 }
3166
3167 virtual const char *getClobbers() const {
3168 // FIXME: Implement!
3169 return "";
3170 }
3171};
3172
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003173class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003174public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003175 Mips32TargetInfoBase(const std::string& triple) :
3176 MipsTargetInfoBase(triple, "o32") {}
3177 virtual bool setABI(const std::string &Name) {
3178 if ((Name == "o32") || (Name == "eabi")) {
3179 ABI = Name;
3180 return true;
3181 } else
3182 return false;
3183 }
3184 virtual void getArchDefines(const LangOptions &Opts,
3185 MacroBuilder &Builder) const {
3186 if (ABI == "o32") {
3187 Builder.defineMacro("__mips_o32");
3188 Builder.defineMacro("_ABIO32", "1");
3189 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
3190 }
3191 else if (ABI == "eabi")
3192 Builder.defineMacro("__mips_eabi");
3193 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003194 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003195 }
3196 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3197 unsigned &NumAliases) const {
3198 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3199 { { "at" }, "$1" },
3200 { { "v0" }, "$2" },
3201 { { "v1" }, "$3" },
3202 { { "a0" }, "$4" },
3203 { { "a1" }, "$5" },
3204 { { "a2" }, "$6" },
3205 { { "a3" }, "$7" },
3206 { { "t0" }, "$8" },
3207 { { "t1" }, "$9" },
3208 { { "t2" }, "$10" },
3209 { { "t3" }, "$11" },
3210 { { "t4" }, "$12" },
3211 { { "t5" }, "$13" },
3212 { { "t6" }, "$14" },
3213 { { "t7" }, "$15" },
3214 { { "s0" }, "$16" },
3215 { { "s1" }, "$17" },
3216 { { "s2" }, "$18" },
3217 { { "s3" }, "$19" },
3218 { { "s4" }, "$20" },
3219 { { "s5" }, "$21" },
3220 { { "s6" }, "$22" },
3221 { { "s7" }, "$23" },
3222 { { "t8" }, "$24" },
3223 { { "t9" }, "$25" },
3224 { { "k0" }, "$26" },
3225 { { "k1" }, "$27" },
3226 { { "gp" }, "$28" },
3227 { { "sp" }, "$29" },
3228 { { "fp" }, "$30" },
3229 { { "ra" }, "$31" }
3230 };
3231 Aliases = GCCRegAliases;
3232 NumAliases = llvm::array_lengthof(GCCRegAliases);
3233 }
3234};
3235
3236class Mips32EBTargetInfo : public Mips32TargetInfoBase {
3237public:
3238 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
3239 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3240 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3241 }
3242 virtual void getTargetDefines(const LangOptions &Opts,
3243 MacroBuilder &Builder) const {
3244 DefineStd(Builder, "mips", Opts);
3245 Builder.defineMacro("_mips");
3246 DefineStd(Builder, "MIPSEB", Opts);
3247 Builder.defineMacro("_MIPSEB");
3248 Builder.defineMacro("__REGISTER_PREFIX__", "");
3249 getArchDefines(Opts, Builder);
3250 }
3251};
3252
3253class Mips32ELTargetInfo : public Mips32TargetInfoBase {
3254public:
3255 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003256 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 +00003257 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003258 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003259 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003260 MacroBuilder &Builder) const {
3261 DefineStd(Builder, "mips", Opts);
3262 Builder.defineMacro("_mips");
3263 DefineStd(Builder, "MIPSEL", Opts);
3264 Builder.defineMacro("_MIPSEL");
3265 Builder.defineMacro("__REGISTER_PREFIX__", "");
3266 getArchDefines(Opts, Builder);
3267 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003268};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003269
3270class Mips64TargetInfoBase : public MipsTargetInfoBase {
3271 virtual void SetDescriptionString(const std::string &Name) = 0;
3272public:
3273 Mips64TargetInfoBase(const std::string& triple) :
3274 MipsTargetInfoBase(triple, "n64") {}
3275 virtual bool setABI(const std::string &Name) {
3276 SetDescriptionString(Name);
3277 if ((Name == "n32") || (Name == "n64")) {
3278 ABI = Name;
3279 return true;
3280 } else
3281 return false;
3282 }
3283 virtual void getArchDefines(const LangOptions &Opts,
3284 MacroBuilder &Builder) const {
3285 if (ABI == "n32") {
3286 Builder.defineMacro("__mips_n32");
3287 Builder.defineMacro("_ABIN32", "2");
3288 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
3289 }
3290 else if (ABI == "n64") {
3291 Builder.defineMacro("__mips_n64");
3292 Builder.defineMacro("_ABI64", "3");
3293 Builder.defineMacro("_MIPS_SIM", "_ABI64");
3294 }
3295 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003296 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003297 }
3298 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3299 unsigned &NumAliases) const {
3300 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3301 { { "at" }, "$1" },
3302 { { "v0" }, "$2" },
3303 { { "v1" }, "$3" },
3304 { { "a0" }, "$4" },
3305 { { "a1" }, "$5" },
3306 { { "a2" }, "$6" },
3307 { { "a3" }, "$7" },
3308 { { "a4" }, "$8" },
3309 { { "a5" }, "$9" },
3310 { { "a6" }, "$10" },
3311 { { "a7" }, "$11" },
3312 { { "t0" }, "$12" },
3313 { { "t1" }, "$13" },
3314 { { "t2" }, "$14" },
3315 { { "t3" }, "$15" },
3316 { { "s0" }, "$16" },
3317 { { "s1" }, "$17" },
3318 { { "s2" }, "$18" },
3319 { { "s3" }, "$19" },
3320 { { "s4" }, "$20" },
3321 { { "s5" }, "$21" },
3322 { { "s6" }, "$22" },
3323 { { "s7" }, "$23" },
3324 { { "t8" }, "$24" },
3325 { { "t9" }, "$25" },
3326 { { "k0" }, "$26" },
3327 { { "k1" }, "$27" },
3328 { { "gp" }, "$28" },
3329 { { "sp" }, "$29" },
3330 { { "fp" }, "$30" },
3331 { { "ra" }, "$31" }
3332 };
3333 Aliases = GCCRegAliases;
3334 NumAliases = llvm::array_lengthof(GCCRegAliases);
3335 }
3336};
3337
3338class Mips64EBTargetInfo : public Mips64TargetInfoBase {
3339 virtual void SetDescriptionString(const std::string &Name) {
3340 // Change DescriptionString only if ABI is n32.
3341 if (Name == "n32")
3342 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3343 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3344 }
3345public:
3346 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3347 // Default ABI is n64.
3348 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3349 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3350 }
3351 virtual void getTargetDefines(const LangOptions &Opts,
3352 MacroBuilder &Builder) const {
3353 DefineStd(Builder, "mips", Opts);
3354 Builder.defineMacro("_mips");
3355 DefineStd(Builder, "MIPSEB", Opts);
3356 Builder.defineMacro("_MIPSEB");
3357 Builder.defineMacro("__REGISTER_PREFIX__", "");
3358 getArchDefines(Opts, Builder);
3359 }
3360};
3361
3362class Mips64ELTargetInfo : public Mips64TargetInfoBase {
3363 virtual void SetDescriptionString(const std::string &Name) {
3364 // Change DescriptionString only if ABI is n32.
3365 if (Name == "n32")
3366 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3367 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3368 }
3369public:
3370 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3371 // Default ABI is n64.
3372 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3373 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3374 }
3375 virtual void getTargetDefines(const LangOptions &Opts,
3376 MacroBuilder &Builder) const {
3377 DefineStd(Builder, "mips", Opts);
3378 Builder.defineMacro("_mips");
3379 DefineStd(Builder, "MIPSEL", Opts);
3380 Builder.defineMacro("_MIPSEL");
3381 Builder.defineMacro("__REGISTER_PREFIX__", "");
3382 getArchDefines(Opts, Builder);
3383 }
3384};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003385} // end anonymous namespace.
3386
Ivan Krasinef05abd2011-08-24 20:22:22 +00003387namespace {
3388class PNaClTargetInfo : public TargetInfo {
3389public:
3390 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
3391 this->UserLabelPrefix = "";
3392 this->LongAlign = 32;
3393 this->LongWidth = 32;
3394 this->PointerAlign = 32;
3395 this->PointerWidth = 32;
3396 this->IntMaxType = TargetInfo::SignedLongLong;
3397 this->UIntMaxType = TargetInfo::UnsignedLongLong;
3398 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003399 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003400 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003401 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003402 this->SizeType = TargetInfo::UnsignedInt;
3403 this->PtrDiffType = TargetInfo::SignedInt;
3404 this->IntPtrType = TargetInfo::SignedInt;
Ivan Krasinef05abd2011-08-24 20:22:22 +00003405 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
3406 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
3407 }
3408
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003409 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00003410 }
3411 virtual void getArchDefines(const LangOptions &Opts,
3412 MacroBuilder &Builder) const {
3413 Builder.defineMacro("__le32__");
3414 Builder.defineMacro("__pnacl__");
3415 }
3416 virtual void getTargetDefines(const LangOptions &Opts,
3417 MacroBuilder &Builder) const {
Ivan Krasin089ee112011-08-25 23:49:20 +00003418 DefineStd(Builder, "unix", Opts);
3419 Builder.defineMacro("__ELF__");
3420 if (Opts.POSIXThreads)
3421 Builder.defineMacro("_REENTRANT");
3422 if (Opts.CPlusPlus)
3423 Builder.defineMacro("_GNU_SOURCE");
3424
Ivan Krasinef05abd2011-08-24 20:22:22 +00003425 Builder.defineMacro("__native_client__");
3426 getArchDefines(Opts, Builder);
3427 }
3428 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3429 unsigned &NumRecords) const {
3430 }
3431 virtual const char *getVAListDeclaration() const {
Ivan Krasin68018db2011-09-20 14:56:54 +00003432 return "typedef int __builtin_va_list[4];";
Ivan Krasinef05abd2011-08-24 20:22:22 +00003433 }
3434 virtual void getGCCRegNames(const char * const *&Names,
3435 unsigned &NumNames) const;
3436 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3437 unsigned &NumAliases) const;
3438 virtual bool validateAsmConstraint(const char *&Name,
3439 TargetInfo::ConstraintInfo &Info) const {
3440 return false;
3441 }
3442
3443 virtual const char *getClobbers() const {
3444 return "";
3445 }
3446};
3447
3448void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
3449 unsigned &NumNames) const {
3450 Names = NULL;
3451 NumNames = 0;
3452}
3453
3454void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3455 unsigned &NumAliases) const {
3456 Aliases = NULL;
3457 NumAliases = 0;
3458}
3459} // end anonymous namespace.
3460
3461
Reid Spencer5f016e22007-07-11 17:01:13 +00003462//===----------------------------------------------------------------------===//
3463// Driver code
3464//===----------------------------------------------------------------------===//
3465
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003466static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003467 llvm::Triple Triple(T);
3468 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00003469
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003470 switch (Triple.getArch()) {
3471 default:
3472 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00003473
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003474 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00003475 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003476 if (Triple.isOSDarwin())
3477 return new DarwinARMTargetInfo(T);
3478
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003479 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00003480 case llvm::Triple::Linux:
3481 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003482 case llvm::Triple::FreeBSD:
Torok Edwin5f6c1942009-06-30 17:10:35 +00003483 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003484 case llvm::Triple::NetBSD:
3485 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003486 case llvm::Triple::RTEMS:
3487 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003488 default:
3489 return new ARMTargetInfo(T);
3490 }
Eli Friedman61538a72008-05-20 14:21:01 +00003491
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003492 case llvm::Triple::bfin:
Douglas Gregordca52262011-07-01 22:41:14 +00003493 if ( os == llvm::Triple::RTEMS )
3494 return new RTEMSTargetInfo<BlackfinTargetInfo>(T);
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00003495 return new BlackfinTargetInfo(T);
3496
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003497 case llvm::Triple::msp430:
3498 return new MSP430TargetInfo(T);
Eli Friedman61538a72008-05-20 14:21:01 +00003499
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003500 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003501 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003502 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003503 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003504 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003505 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003506 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003507 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003508 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003509 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003510 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003511 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003512 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003513
3514 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003515 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003516 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003517 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003518 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003519 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003520 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003521 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003522 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003523 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003524 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003525 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003526 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003527
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003528 case llvm::Triple::mips64:
3529 switch (os) {
3530 case llvm::Triple::Linux:
3531 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
3532 case llvm::Triple::RTEMS:
3533 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
3534 case llvm::Triple::FreeBSD:
3535 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
3536 case llvm::Triple::NetBSD:
3537 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
3538 default:
3539 return new Mips64EBTargetInfo(T);
3540 }
3541
3542 case llvm::Triple::mips64el:
3543 switch (os) {
3544 case llvm::Triple::Linux:
3545 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
3546 case llvm::Triple::RTEMS:
3547 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
3548 case llvm::Triple::FreeBSD:
3549 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
3550 case llvm::Triple::NetBSD:
3551 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
3552 default:
3553 return new Mips64ELTargetInfo(T);
3554 }
3555
Ivan Krasinef05abd2011-08-24 20:22:22 +00003556 case llvm::Triple::le32:
3557 switch (os) {
3558 case llvm::Triple::NativeClient:
3559 return new PNaClTargetInfo(T);
3560 default:
3561 return NULL;
3562 }
3563
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003564 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003565 if (Triple.isOSDarwin())
Roman Divackyc81f2a22011-01-06 08:27:10 +00003566 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003567 switch (os) {
3568 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00003569 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003570 case llvm::Triple::NetBSD:
3571 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
3572 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003573 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003574 default:
3575 return new PPC32TargetInfo(T);
3576 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003577
3578 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003579 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00003580 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003581 switch (os) {
3582 case llvm::Triple::Lv2:
John Thompson3f6918a2009-11-19 17:18:50 +00003583 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003584 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00003585 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003586 case llvm::Triple::NetBSD:
3587 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
3588 default:
3589 return new PPC64TargetInfo(T);
3590 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003591
Justin Holewinski285dc652011-04-20 19:34:15 +00003592 case llvm::Triple::ptx32:
3593 return new PTX32TargetInfo(T);
3594 case llvm::Triple::ptx64:
3595 return new PTX64TargetInfo(T);
3596
Chris Lattner9cbeb632010-03-06 21:21:27 +00003597 case llvm::Triple::mblaze:
3598 return new MBlazeTargetInfo(T);
3599
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003600 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003601 switch (os) {
3602 case llvm::Triple::AuroraUX:
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003603 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003604 case llvm::Triple::Solaris:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003605 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003606 case llvm::Triple::NetBSD:
3607 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
3608 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003609 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003610 default:
3611 return new SparcV8TargetInfo(T);
3612 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003613
John Thompson3f6918a2009-11-19 17:18:50 +00003614 // FIXME: Need a real SPU target.
3615 case llvm::Triple::cellspu:
3616 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
3617
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003618 case llvm::Triple::systemz:
3619 return new SystemZTargetInfo(T);
3620
Eli Friedmanb63decf2009-08-19 20:47:07 +00003621 case llvm::Triple::tce:
3622 return new TCETargetInfo(T);
3623
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003624 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003625 if (Triple.isOSDarwin())
3626 return new DarwinI386TargetInfo(T);
3627
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003628 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003629 case llvm::Triple::AuroraUX:
3630 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003631 case llvm::Triple::Linux:
3632 return new LinuxTargetInfo<X86_32TargetInfo>(T);
3633 case llvm::Triple::DragonFly:
3634 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
3635 case llvm::Triple::NetBSD:
3636 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
3637 case llvm::Triple::OpenBSD:
3638 return new OpenBSDI386TargetInfo(T);
3639 case llvm::Triple::FreeBSD:
3640 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner38e317d2010-07-07 16:01:42 +00003641 case llvm::Triple::Minix:
3642 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003643 case llvm::Triple::Solaris:
3644 return new SolarisTargetInfo<X86_32TargetInfo>(T);
3645 case llvm::Triple::Cygwin:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003646 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003647 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003648 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003649 case llvm::Triple::Win32:
Michael J. Spencera764e832010-10-21 08:22:51 +00003650 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattner86ed3a32010-04-11 19:29:39 +00003651 case llvm::Triple::Haiku:
3652 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003653 case llvm::Triple::RTEMS:
3654 return new RTEMSX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003655 default:
3656 return new X86_32TargetInfo(T);
3657 }
3658
3659 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003660 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
3661 return new DarwinX86_64TargetInfo(T);
3662
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003663 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003664 case llvm::Triple::AuroraUX:
3665 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003666 case llvm::Triple::Linux:
3667 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner7a7ca282010-01-09 05:41:14 +00003668 case llvm::Triple::DragonFly:
3669 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003670 case llvm::Triple::NetBSD:
3671 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
3672 case llvm::Triple::OpenBSD:
3673 return new OpenBSDX86_64TargetInfo(T);
3674 case llvm::Triple::FreeBSD:
3675 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
3676 case llvm::Triple::Solaris:
3677 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00003678 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003679 return new MinGWX86_64TargetInfo(T);
3680 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003681 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003682 default:
3683 return new X86_64TargetInfo(T);
3684 }
3685 }
Reid Spencer5f016e22007-07-11 17:01:13 +00003686}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003687
3688/// CreateTargetInfo - Return the target info object for the specified target
3689/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00003690TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003691 TargetOptions &Opts) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003692 llvm::Triple Triple(Opts.Triple);
3693
3694 // Construct the target
3695 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
3696 if (!Target) {
3697 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
3698 return 0;
3699 }
3700
Daniel Dunbareac7c532009-12-18 18:42:37 +00003701 // Set the target CPU if specified.
3702 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
3703 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
3704 return 0;
3705 }
3706
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003707 // Set the target ABI if specified.
3708 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
3709 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
3710 return 0;
3711 }
3712
Charles Davis98b7c5c2010-06-11 01:06:47 +00003713 // Set the target C++ ABI.
John McCallee79a4c2010-08-21 22:46:04 +00003714 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davis98b7c5c2010-06-11 01:06:47 +00003715 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
3716 return 0;
3717 }
3718
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003719 // Compute the default target features, we need the target to handle this
3720 // because features may have dependencies on one another.
3721 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003722 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003723
3724 // Apply the user specified deltas.
3725 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
3726 ie = Opts.Features.end(); it != ie; ++it) {
3727 const char *Name = it->c_str();
3728
3729 // Apply the feature via the target.
3730 if ((Name[0] != '-' && Name[0] != '+') ||
3731 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
3732 Diags.Report(diag::err_target_invalid_feature) << Name;
3733 return 0;
3734 }
3735 }
3736
3737 // Add the features to the compile options.
3738 //
3739 // FIXME: If we are completely confident that we have the right set, we only
3740 // need to pass the minuses.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003741 Opts.Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003742 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
3743 ie = Features.end(); it != ie; ++it)
Chris Lattner1e5f83b2011-07-14 18:24:21 +00003744 Opts.Features.push_back(std::string(it->second ? "+" : "-") +
Chris Lattner48b78bd2011-07-14 18:45:41 +00003745 it->first().str());
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003746 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003747
3748 return Target.take();
3749}