blob: 1dcdf93ba70e790be689bc4aee7ae4dd06dc0440 [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
Benjamin Kramer474202f2011-10-18 10:10:08 +0000250 unsigned Release = Triple.getOSMajorVersion();
251 if (Release == 0U)
252 Release = 8;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000253
Benjamin Kramer474202f2011-10-18 10:10:08 +0000254 Builder.defineMacro("__FreeBSD__", Twine(Release));
255 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramera9992772010-01-09 17:55:51 +0000256 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
257 DefineStd(Builder, "unix", Opts);
258 Builder.defineMacro("__ELF__");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000259 }
260public:
Mike Stump1eb44332009-09-09 15:08:12 +0000261 FreeBSDTargetInfo(const std::string &triple)
Duncan Sands1e90faf2009-07-08 13:55:08 +0000262 : OSTargetInfo<Target>(triple) {
263 this->UserLabelPrefix = "";
Roman Divackybe4c8702011-02-10 16:52:03 +0000264
265 llvm::Triple Triple(triple);
266 switch (Triple.getArch()) {
267 default:
268 case llvm::Triple::x86:
269 case llvm::Triple::x86_64:
270 this->MCountName = ".mcount";
271 break;
272 case llvm::Triple::mips:
273 case llvm::Triple::mipsel:
274 case llvm::Triple::ppc:
275 case llvm::Triple::ppc64:
276 this->MCountName = "_mcount";
277 break;
278 case llvm::Triple::arm:
279 this->MCountName = "__mcount";
280 break;
281 }
282
Duncan Sands1e90faf2009-07-08 13:55:08 +0000283 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000284};
285
Chris Lattner38e317d2010-07-07 16:01:42 +0000286// Minix Target
287template<typename Target>
288class MinixTargetInfo : public OSTargetInfo<Target> {
289protected:
290 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
291 MacroBuilder &Builder) const {
292 // Minix defines
293
294 Builder.defineMacro("__minix", "3");
295 Builder.defineMacro("_EM_WSIZE", "4");
296 Builder.defineMacro("_EM_PSIZE", "4");
297 Builder.defineMacro("_EM_SSIZE", "2");
298 Builder.defineMacro("_EM_LSIZE", "4");
299 Builder.defineMacro("_EM_FSIZE", "4");
300 Builder.defineMacro("_EM_DSIZE", "8");
301 DefineStd(Builder, "unix", Opts);
302 }
303public:
304 MinixTargetInfo(const std::string &triple)
305 : OSTargetInfo<Target>(triple) {
306 this->UserLabelPrefix = "";
307 }
308};
309
Torok Edwin5f6c1942009-06-30 17:10:35 +0000310// Linux target
311template<typename Target>
312class LinuxTargetInfo : public OSTargetInfo<Target> {
313protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000314 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000315 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000316 // Linux defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000317 DefineStd(Builder, "unix", Opts);
318 DefineStd(Builder, "linux", Opts);
319 Builder.defineMacro("__gnu_linux__");
320 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000321 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000322 Builder.defineMacro("_REENTRANT");
Douglas Gregor2b003fd2010-04-21 05:52:38 +0000323 if (Opts.CPlusPlus)
324 Builder.defineMacro("_GNU_SOURCE");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000325 }
326public:
Mike Stump1eb44332009-09-09 15:08:12 +0000327 LinuxTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000328 : OSTargetInfo<Target>(triple) {
329 this->UserLabelPrefix = "";
Douglas Gregor12e84642011-01-12 21:19:25 +0000330 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000331 }
Benjamin Kramer86d18c52011-10-15 17:53:33 +0000332
333 virtual const char *getStaticInitSectionSpecifier() const {
334 return ".text.startup";
335 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000336};
337
Chris Lattnerb62bb282009-07-13 20:29:08 +0000338// NetBSD Target
339template<typename Target>
340class NetBSDTargetInfo : public OSTargetInfo<Target> {
341protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000342 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000343 MacroBuilder &Builder) const {
Chris Lattnerb62bb282009-07-13 20:29:08 +0000344 // NetBSD defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000345 Builder.defineMacro("__NetBSD__");
346 Builder.defineMacro("__unix__");
347 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000348 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000349 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerb62bb282009-07-13 20:29:08 +0000350 }
351public:
Mike Stump1eb44332009-09-09 15:08:12 +0000352 NetBSDTargetInfo(const std::string &triple)
Chris Lattnerb62bb282009-07-13 20:29:08 +0000353 : OSTargetInfo<Target>(triple) {
354 this->UserLabelPrefix = "";
355 }
356};
357
Torok Edwin5f6c1942009-06-30 17:10:35 +0000358// OpenBSD Target
359template<typename Target>
360class OpenBSDTargetInfo : public OSTargetInfo<Target> {
361protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000362 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000363 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000364 // OpenBSD defines; list based off of gcc output
365
Benjamin Kramera9992772010-01-09 17:55:51 +0000366 Builder.defineMacro("__OpenBSD__");
367 DefineStd(Builder, "unix", Opts);
368 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000369 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000370 Builder.defineMacro("_POSIX_THREADS");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000371 }
372public:
Mike Stump1eb44332009-09-09 15:08:12 +0000373 OpenBSDTargetInfo(const std::string &triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000374 : OSTargetInfo<Target>(triple) {}
375};
376
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000377// PSP Target
378template<typename Target>
379class PSPTargetInfo : public OSTargetInfo<Target> {
380protected:
381 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000382 MacroBuilder &Builder) const {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000383 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramera9992772010-01-09 17:55:51 +0000384 Builder.defineMacro("PSP");
385 Builder.defineMacro("_PSP");
386 Builder.defineMacro("__psp__");
387 Builder.defineMacro("__ELF__");
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000388 }
389public:
390 PSPTargetInfo(const std::string& triple)
391 : OSTargetInfo<Target>(triple) {
392 this->UserLabelPrefix = "";
393 }
394};
395
John Thompson3f6918a2009-11-19 17:18:50 +0000396// PS3 PPU Target
397template<typename Target>
398class PS3PPUTargetInfo : public OSTargetInfo<Target> {
399protected:
400 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000401 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000402 // PS3 PPU defines.
John Thompsonfb457972010-03-25 16:18:32 +0000403 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000404 Builder.defineMacro("__PPU__");
405 Builder.defineMacro("__CELLOS_LV2__");
406 Builder.defineMacro("__ELF__");
407 Builder.defineMacro("__LP32__");
John Thompson8e6065a2010-06-24 22:44:13 +0000408 Builder.defineMacro("_ARCH_PPC64");
409 Builder.defineMacro("__powerpc64__");
John Thompson3f6918a2009-11-19 17:18:50 +0000410 }
411public:
412 PS3PPUTargetInfo(const std::string& triple)
413 : OSTargetInfo<Target>(triple) {
414 this->UserLabelPrefix = "";
John Thompsonec387af2009-12-18 14:21:08 +0000415 this->LongWidth = this->LongAlign = this->PointerWidth = this->PointerAlign = 32;
John Thompson8e6065a2010-06-24 22:44:13 +0000416 this->IntMaxType = TargetInfo::SignedLongLong;
417 this->UIntMaxType = TargetInfo::UnsignedLongLong;
418 this->Int64Type = TargetInfo::SignedLongLong;
John Thompsonec387af2009-12-18 14:21:08 +0000419 this->SizeType = TargetInfo::UnsignedInt;
John Thompson8e6065a2010-06-24 22:44:13 +0000420 this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
421 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompson3f6918a2009-11-19 17:18:50 +0000422 }
423};
424
425// FIXME: Need a real SPU target.
426// PS3 SPU Target
427template<typename Target>
428class PS3SPUTargetInfo : public OSTargetInfo<Target> {
429protected:
430 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000431 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000432 // PS3 PPU defines.
Benjamin Kramera9992772010-01-09 17:55:51 +0000433 Builder.defineMacro("__SPU__");
434 Builder.defineMacro("__ELF__");
John Thompson3f6918a2009-11-19 17:18:50 +0000435 }
436public:
437 PS3SPUTargetInfo(const std::string& triple)
438 : OSTargetInfo<Target>(triple) {
439 this->UserLabelPrefix = "";
440 }
441};
442
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000443// AuroraUX target
444template<typename Target>
445class AuroraUXTargetInfo : public OSTargetInfo<Target> {
446protected:
447 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000448 MacroBuilder &Builder) const {
449 DefineStd(Builder, "sun", Opts);
450 DefineStd(Builder, "unix", Opts);
451 Builder.defineMacro("__ELF__");
452 Builder.defineMacro("__svr4__");
453 Builder.defineMacro("__SVR4");
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000454 }
455public:
456 AuroraUXTargetInfo(const std::string& triple)
457 : OSTargetInfo<Target>(triple) {
458 this->UserLabelPrefix = "";
459 this->WCharType = this->SignedLong;
460 // FIXME: WIntType should be SignedLong
461 }
462};
463
Torok Edwin5f6c1942009-06-30 17:10:35 +0000464// Solaris target
465template<typename Target>
466class SolarisTargetInfo : public OSTargetInfo<Target> {
467protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000468 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000469 MacroBuilder &Builder) const {
470 DefineStd(Builder, "sun", Opts);
471 DefineStd(Builder, "unix", Opts);
472 Builder.defineMacro("__ELF__");
473 Builder.defineMacro("__svr4__");
474 Builder.defineMacro("__SVR4");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000475 }
476public:
Mike Stump1eb44332009-09-09 15:08:12 +0000477 SolarisTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000478 : OSTargetInfo<Target>(triple) {
479 this->UserLabelPrefix = "";
480 this->WCharType = this->SignedLong;
481 // FIXME: WIntType should be SignedLong
482 }
483};
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000484
485// Windows target
486template<typename Target>
487class WindowsTargetInfo : public OSTargetInfo<Target> {
488protected:
489 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
490 MacroBuilder &Builder) const {
Michael J. Spencera764e832010-10-21 08:22:51 +0000491 Builder.defineMacro("_WIN32");
492 }
493 void getVisualStudioDefines(const LangOptions &Opts,
494 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000495 if (Opts.CPlusPlus) {
496 if (Opts.RTTI)
497 Builder.defineMacro("_CPPRTTI");
498
499 if (Opts.Exceptions)
500 Builder.defineMacro("_CPPUNWIND");
501 }
502
503 if (!Opts.CharIsSigned)
504 Builder.defineMacro("_CHAR_UNSIGNED");
505
506 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
507 // but it works for now.
508 if (Opts.POSIXThreads)
509 Builder.defineMacro("_MT");
Michael J. Spencera764e832010-10-21 08:22:51 +0000510
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000511 if (Opts.MSCVersion != 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000512 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000513
Francois Pichet62ec1f22011-09-17 17:15:52 +0000514 if (Opts.MicrosoftExt) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000515 Builder.defineMacro("_MSC_EXTENSIONS");
516
517 if (Opts.CPlusPlus0x) {
518 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
519 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
520 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
521 }
522 }
523
524 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000525 }
526
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000527public:
528 WindowsTargetInfo(const std::string &triple)
529 : OSTargetInfo<Target>(triple) {}
530};
531
Mike Stump1eb44332009-09-09 15:08:12 +0000532} // end anonymous namespace.
Torok Edwin5f6c1942009-06-30 17:10:35 +0000533
Chris Lattnerd29b6302008-10-05 21:50:58 +0000534//===----------------------------------------------------------------------===//
Eli Friedmane4277982008-08-20 23:11:40 +0000535// Specific target implementations.
536//===----------------------------------------------------------------------===//
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +0000537
Eli Friedmane4277982008-08-20 23:11:40 +0000538namespace {
539// PPC abstract base class
540class PPCTargetInfo : public TargetInfo {
541 static const Builtin::Info BuiltinInfo[];
542 static const char * const GCCRegNames[];
543 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Eli Friedmane4277982008-08-20 23:11:40 +0000544public:
Eli Friedman15b91762009-06-05 07:05:05 +0000545 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
546
Eli Friedmane4277982008-08-20 23:11:40 +0000547 virtual void getTargetBuiltins(const Builtin::Info *&Records,
548 unsigned &NumRecords) const {
Reid Spencer5f016e22007-07-11 17:01:13 +0000549 Records = BuiltinInfo;
Eli Friedmane4277982008-08-20 23:11:40 +0000550 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +0000551 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000552
Chris Lattner33328642009-03-20 15:52:06 +0000553 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000554 MacroBuilder &Builder) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000555
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000556 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000557 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000558 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000559 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000560 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +0000561 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000562 switch (*Name) {
Anders Carlssond04c6e22007-11-27 04:11:28 +0000563 default: return false;
564 case 'O': // Zero
John Thompson8e6065a2010-06-24 22:44:13 +0000565 break;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000566 case 'b': // Base register
567 case 'f': // Floating point register
Chris Lattner44def072009-04-26 07:16:29 +0000568 Info.setAllowsRegister();
John Thompson8e6065a2010-06-24 22:44:13 +0000569 break;
570 // FIXME: The following are added to allow parsing.
571 // I just took a guess at what the actions should be.
572 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer20249a12010-10-21 03:16:25 +0000573 case 'd': // Floating point register (containing 64-bit value)
John Thompson8e6065a2010-06-24 22:44:13 +0000574 case 'v': // Altivec vector register
575 Info.setAllowsRegister();
576 break;
577 case 'w':
578 switch (Name[1]) {
Michael J. Spencer20249a12010-10-21 03:16:25 +0000579 case 'd':// VSX vector register to hold vector double data
580 case 'f':// VSX vector register to hold vector float data
581 case 's':// VSX vector register to hold scalar float data
582 case 'a':// Any VSX register
John Thompson8e6065a2010-06-24 22:44:13 +0000583 break;
584 default:
585 return false;
586 }
587 Info.setAllowsRegister();
588 Name++; // Skip over 'w'.
589 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000590 case 'h': // `MQ', `CTR', or `LINK' register
591 case 'q': // `MQ' register
592 case 'c': // `CTR' register
593 case 'l': // `LINK' register
594 case 'x': // `CR' register (condition register) number 0
595 case 'y': // `CR' register (condition register)
596 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson8e6065a2010-06-24 22:44:13 +0000597 Info.setAllowsRegister();
598 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000599 case 'I': // Signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000600 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer20249a12010-10-21 03:16:25 +0000601 // (use `L' instead for SImode constants)
602 case 'K': // Unsigned 16-bit constant
603 case 'L': // Signed 16-bit constant shifted left 16 bits
604 case 'M': // Constant larger than 31
605 case 'N': // Exact power of 2
606 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000607 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000608 // register with one instruction per word
John Thompson8e6065a2010-06-24 22:44:13 +0000609 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer20249a12010-10-21 03:16:25 +0000610 // into a register using three instructions
John Thompson8e6065a2010-06-24 22:44:13 +0000611 break;
612 case 'm': // Memory operand. Note that on PowerPC targets, m can
613 // include addresses that update the base register. It
614 // is therefore only safe to use `m' in an asm statement
615 // if that asm statement accesses the operand exactly once.
616 // The asm statement must also use `%U<opno>' as a
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000617 // placeholder for the "update" flag in the corresponding
Michael J. Spencer20249a12010-10-21 03:16:25 +0000618 // load or store instruction. For example:
John Thompson8e6065a2010-06-24 22:44:13 +0000619 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000620 // is correct but:
John Thompson8e6065a2010-06-24 22:44:13 +0000621 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
622 // is not. Use es rather than m if you don't want the base
Michael J. Spencer20249a12010-10-21 03:16:25 +0000623 // register to be updated.
624 case 'e':
John Thompson56b6eca2010-06-25 00:02:05 +0000625 if (Name[1] != 's')
626 return false;
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000627 // es: A "stable" memory operand; that is, one which does not
John Thompson8e6065a2010-06-24 22:44:13 +0000628 // include any automodification of the base register. Unlike
629 // `m', this constraint can be used in asm statements that
630 // might access the operand several times, or that might not
John Thompson56b6eca2010-06-25 00:02:05 +0000631 // access it at all.
John Thompson8e6065a2010-06-24 22:44:13 +0000632 Info.setAllowsMemory();
John Thompson56b6eca2010-06-25 00:02:05 +0000633 Name++; // Skip over 'e'.
John Thompson8e6065a2010-06-24 22:44:13 +0000634 break;
635 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer20249a12010-10-21 03:16:25 +0000636 // usually better to use `m' or `es' in asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000637 case 'Z': // Memory operand that is an indexed or indirect from a
638 // register (it is usually better to use `m' or `es' in
Michael J. Spencer20249a12010-10-21 03:16:25 +0000639 // asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000640 Info.setAllowsMemory();
641 Info.setAllowsRegister();
642 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000643 case 'R': // AIX TOC entry
John Thompson8e6065a2010-06-24 22:44:13 +0000644 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000645 // register (`p' is preferable for asm statements)
646 case 'S': // Constant suitable as a 64-bit mask operand
647 case 'T': // Constant suitable as a 32-bit mask operand
648 case 'U': // System V Release 4 small data area reference
John Thompson8e6065a2010-06-24 22:44:13 +0000649 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000650 // instructions
651 case 'W': // Vector constant that does not require memory
652 case 'j': // Vector constant that is all zeros.
John Thompson8e6065a2010-06-24 22:44:13 +0000653 break;
654 // End FIXME.
Anders Carlssond04c6e22007-11-27 04:11:28 +0000655 }
John Thompson8e6065a2010-06-24 22:44:13 +0000656 return true;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000657 }
Eli Friedmane4277982008-08-20 23:11:40 +0000658 virtual const char *getClobbers() const {
659 return "";
Anders Carlssond04c6e22007-11-27 04:11:28 +0000660 }
Eli Friedmane4277982008-08-20 23:11:40 +0000661};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000662
Eli Friedmane4277982008-08-20 23:11:40 +0000663const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000664#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000665#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000666 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000667#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000668};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000669
670
Chris Lattnerc0f59212009-03-02 22:27:17 +0000671/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
672/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000673void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000674 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000675 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000676 Builder.defineMacro("__ppc__");
677 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000678 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000679 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000680 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000681 Builder.defineMacro("_ARCH_PPC64");
682 Builder.defineMacro("_LP64");
683 Builder.defineMacro("__LP64__");
Chris Lattnere03ae302010-02-16 18:14:57 +0000684 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000685 Builder.defineMacro("__ppc64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000686 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +0000687 Builder.defineMacro("__ppc__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000688 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000689
Chris Lattnerc0f59212009-03-02 22:27:17 +0000690 // Target properties.
Joerg Sonnenberger7cd1de52011-07-05 14:56:12 +0000691 if (getTriple().getOS() != llvm::Triple::NetBSD)
692 Builder.defineMacro("_BIG_ENDIAN");
Benjamin Kramera9992772010-01-09 17:55:51 +0000693 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000694
Chris Lattnerc0f59212009-03-02 22:27:17 +0000695 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000696 Builder.defineMacro("__NATURAL_ALIGNMENT__");
697 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000698
Chris Lattnerc0f59212009-03-02 22:27:17 +0000699 // FIXME: Should be controlled by command line option.
Benjamin Kramera9992772010-01-09 17:55:51 +0000700 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000701
John Thompson3f6918a2009-11-19 17:18:50 +0000702 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000703 Builder.defineMacro("__VEC__", "10206");
704 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000705 }
Chris Lattnerc0f59212009-03-02 22:27:17 +0000706}
707
Chris Lattner393ff042008-04-21 18:56:49 +0000708
Eli Friedmane4277982008-08-20 23:11:40 +0000709const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +0000710 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
711 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
712 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
713 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
714 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
715 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
716 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
717 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +0000718 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000719 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +0000720 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000721 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
722 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
723 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
724 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +0000725 "vrsave", "vscr",
726 "spe_acc", "spefscr",
727 "sfp"
728};
Reid Spencer5f016e22007-07-11 17:01:13 +0000729
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000730void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000731 unsigned &NumNames) const {
732 Names = GCCRegNames;
733 NumNames = llvm::array_lengthof(GCCRegNames);
734}
Reid Spencer5f016e22007-07-11 17:01:13 +0000735
Eli Friedmane4277982008-08-20 23:11:40 +0000736const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
737 // While some of these aliases do map to different registers
738 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000739 { { "0" }, "r0" },
740 { { "1"}, "r1" },
741 { { "2" }, "r2" },
742 { { "3" }, "r3" },
743 { { "4" }, "r4" },
744 { { "5" }, "r5" },
745 { { "6" }, "r6" },
746 { { "7" }, "r7" },
747 { { "8" }, "r8" },
748 { { "9" }, "r9" },
749 { { "10" }, "r10" },
750 { { "11" }, "r11" },
751 { { "12" }, "r12" },
752 { { "13" }, "r13" },
753 { { "14" }, "r14" },
754 { { "15" }, "r15" },
755 { { "16" }, "r16" },
756 { { "17" }, "r17" },
757 { { "18" }, "r18" },
758 { { "19" }, "r19" },
759 { { "20" }, "r20" },
760 { { "21" }, "r21" },
761 { { "22" }, "r22" },
762 { { "23" }, "r23" },
763 { { "24" }, "r24" },
764 { { "25" }, "r25" },
765 { { "26" }, "r26" },
766 { { "27" }, "r27" },
767 { { "28" }, "r28" },
768 { { "29" }, "r29" },
769 { { "30" }, "r30" },
770 { { "31" }, "r31" },
771 { { "fr0" }, "f0" },
772 { { "fr1" }, "f1" },
773 { { "fr2" }, "f2" },
774 { { "fr3" }, "f3" },
775 { { "fr4" }, "f4" },
776 { { "fr5" }, "f5" },
777 { { "fr6" }, "f6" },
778 { { "fr7" }, "f7" },
779 { { "fr8" }, "f8" },
780 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +0000781 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000782 { { "fr11" }, "f11" },
783 { { "fr12" }, "f12" },
784 { { "fr13" }, "f13" },
785 { { "fr14" }, "f14" },
786 { { "fr15" }, "f15" },
787 { { "fr16" }, "f16" },
788 { { "fr17" }, "f17" },
789 { { "fr18" }, "f18" },
790 { { "fr19" }, "f19" },
791 { { "fr20" }, "f20" },
792 { { "fr21" }, "f21" },
793 { { "fr22" }, "f22" },
794 { { "fr23" }, "f23" },
795 { { "fr24" }, "f24" },
796 { { "fr25" }, "f25" },
797 { { "fr26" }, "f26" },
798 { { "fr27" }, "f27" },
799 { { "fr28" }, "f28" },
800 { { "fr29" }, "f29" },
801 { { "fr30" }, "f30" },
802 { { "fr31" }, "f31" },
803 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +0000804};
805
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000806void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000807 unsigned &NumAliases) const {
808 Aliases = GCCRegAliases;
809 NumAliases = llvm::array_lengthof(GCCRegAliases);
810}
811} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +0000812
813namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000814class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000815public:
Chris Lattnere03ae302010-02-16 18:14:57 +0000816 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +0000817 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 +0000818 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +0000819
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000820 switch (getTriple().getOS()) {
821 case llvm::Triple::FreeBSD:
822 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000823 SizeType = UnsignedInt;
824 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +0000825 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000826 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000827 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000828 }
829
830 virtual const char *getVAListDeclaration() const {
831 // This is the ELF definition, and is overridden by the Darwin sub-target
832 return "typedef struct __va_list_tag {"
833 " unsigned char gpr;"
834 " unsigned char fpr;"
835 " unsigned short reserved;"
836 " void* overflow_arg_area;"
837 " void* reg_save_area;"
838 "} __builtin_va_list[1];";
Eli Friedmaned855cb2008-08-21 00:13:15 +0000839 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000840};
841} // end anonymous namespace.
842
843namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000844class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000845public:
Eli Friedmane4277982008-08-20 23:11:40 +0000846 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +0000847 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +0000848 IntMaxType = SignedLong;
849 UIntMaxType = UnsignedLong;
850 Int64Type = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +0000851 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 +0000852 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnerf291b102008-05-09 06:17:04 +0000853 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000854 virtual const char *getVAListDeclaration() const {
855 return "typedef char* __builtin_va_list;";
856 }
Eli Friedmane4277982008-08-20 23:11:40 +0000857};
858} // end anonymous namespace.
859
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000860
861namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +0000862class DarwinPPC32TargetInfo :
863 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000864public:
Roman Divackyc81f2a22011-01-06 08:27:10 +0000865 DarwinPPC32TargetInfo(const std::string& triple)
866 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000867 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +0000868 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
869 }
870 virtual const char *getVAListDeclaration() const {
871 return "typedef char* __builtin_va_list;";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000872 }
873};
874
875class DarwinPPC64TargetInfo :
876 public DarwinTargetInfo<PPC64TargetInfo> {
877public:
878 DarwinPPC64TargetInfo(const std::string& triple)
879 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
880 HasAlignMac68kSupport = true;
881 }
882};
883} // end anonymous namespace.
884
Reid Spencer5f016e22007-07-11 17:01:13 +0000885namespace {
Justin Holewinski25bedca2011-10-03 17:28:37 +0000886 static const unsigned PTXAddrSpaceMap[] = {
887 0, // opencl_global
888 4, // opencl_local
889 1 // opencl_constant
890 };
Justin Holewinski285dc652011-04-20 19:34:15 +0000891 class PTXTargetInfo : public TargetInfo {
892 static const char * const GCCRegNames[];
893 static const Builtin::Info BuiltinInfo[];
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000894 std::vector<llvm::StringRef> AvailableFeatures;
Justin Holewinski285dc652011-04-20 19:34:15 +0000895 public:
896 PTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
897 TLSSupported = false;
898 LongWidth = LongAlign = 64;
Justin Holewinski25bedca2011-10-03 17:28:37 +0000899 AddrSpaceMap = &PTXAddrSpaceMap;
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000900 // Define available target features
901 // These must be defined in sorted order!
902 AvailableFeatures.push_back("compute10");
903 AvailableFeatures.push_back("compute11");
904 AvailableFeatures.push_back("compute12");
905 AvailableFeatures.push_back("compute13");
906 AvailableFeatures.push_back("compute20");
907 AvailableFeatures.push_back("double");
908 AvailableFeatures.push_back("no-fma");
909 AvailableFeatures.push_back("ptx20");
910 AvailableFeatures.push_back("ptx21");
911 AvailableFeatures.push_back("ptx22");
912 AvailableFeatures.push_back("ptx23");
913 AvailableFeatures.push_back("sm10");
914 AvailableFeatures.push_back("sm11");
915 AvailableFeatures.push_back("sm12");
916 AvailableFeatures.push_back("sm13");
917 AvailableFeatures.push_back("sm20");
918 AvailableFeatures.push_back("sm21");
919 AvailableFeatures.push_back("sm22");
920 AvailableFeatures.push_back("sm23");
Justin Holewinski285dc652011-04-20 19:34:15 +0000921 }
922 virtual void getTargetDefines(const LangOptions &Opts,
923 MacroBuilder &Builder) const {
924 Builder.defineMacro("__PTX__");
925 }
926 virtual void getTargetBuiltins(const Builtin::Info *&Records,
927 unsigned &NumRecords) const {
928 Records = BuiltinInfo;
929 NumRecords = clang::PTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
930 }
931
932 virtual void getGCCRegNames(const char * const *&Names,
933 unsigned &NumNames) const;
934 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
935 unsigned &NumAliases) const {
936 // No aliases.
937 Aliases = 0;
938 NumAliases = 0;
939 }
940 virtual bool validateAsmConstraint(const char *&Name,
941 TargetInfo::ConstraintInfo &info) const {
942 // FIXME: implement
943 return true;
944 }
945 virtual const char *getClobbers() const {
946 // FIXME: Is this really right?
947 return "";
948 }
949 virtual const char *getVAListDeclaration() const {
950 // FIXME: implement
951 return "typedef char* __builtin_va_list;";
952 }
Justin Holewinski808ef662011-09-15 12:13:38 +0000953
954 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
955 const std::string &Name,
956 bool Enabled) const;
Justin Holewinski285dc652011-04-20 19:34:15 +0000957 };
958
959 const Builtin::Info PTXTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000960#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +0000961#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000962 ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +0000963#include "clang/Basic/BuiltinsPTX.def"
964 };
965
966 const char * const PTXTargetInfo::GCCRegNames[] = {
967 "r0"
968 };
969
970 void PTXTargetInfo::getGCCRegNames(const char * const *&Names,
971 unsigned &NumNames) const {
972 Names = GCCRegNames;
973 NumNames = llvm::array_lengthof(GCCRegNames);
974 }
975
Justin Holewinski808ef662011-09-15 12:13:38 +0000976 bool PTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
977 const std::string &Name,
978 bool Enabled) const {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000979 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
980 Name)) {
981 Features[Name] = Enabled;
982 return true;
Justin Holewinski808ef662011-09-15 12:13:38 +0000983 } else {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000984 return false;
Justin Holewinski808ef662011-09-15 12:13:38 +0000985 }
Justin Holewinski808ef662011-09-15 12:13:38 +0000986 }
Justin Holewinski285dc652011-04-20 19:34:15 +0000987
988 class PTX32TargetInfo : public PTXTargetInfo {
989 public:
990 PTX32TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
991 PointerWidth = PointerAlign = 32;
992 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
993 DescriptionString
994 = "e-p:32:32-i64:64:64-f64:64:64-n1:8:16:32:64";
995 }
996 };
997
998 class PTX64TargetInfo : public PTXTargetInfo {
999 public:
1000 PTX64TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
1001 PointerWidth = PointerAlign = 64;
1002 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
1003 DescriptionString
1004 = "e-p:64:64-i64:64:64-f64:64:64-n1:8:16:32:64";
1005 }
1006 };
1007}
1008
1009namespace {
Chris Lattner9cbeb632010-03-06 21:21:27 +00001010// MBlaze abstract base class
1011class MBlazeTargetInfo : public TargetInfo {
1012 static const char * const GCCRegNames[];
1013 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1014
1015public:
1016 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +00001017 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner9cbeb632010-03-06 21:21:27 +00001018 }
1019
1020 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1021 unsigned &NumRecords) const {
1022 // FIXME: Implement.
1023 Records = 0;
1024 NumRecords = 0;
1025 }
1026
1027 virtual void getTargetDefines(const LangOptions &Opts,
1028 MacroBuilder &Builder) const;
1029
1030 virtual const char *getVAListDeclaration() const {
1031 return "typedef char* __builtin_va_list;";
1032 }
1033 virtual const char *getTargetPrefix() const {
1034 return "mblaze";
1035 }
1036 virtual void getGCCRegNames(const char * const *&Names,
1037 unsigned &NumNames) const;
1038 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1039 unsigned &NumAliases) const;
1040 virtual bool validateAsmConstraint(const char *&Name,
1041 TargetInfo::ConstraintInfo &Info) const {
1042 switch (*Name) {
1043 default: return false;
1044 case 'O': // Zero
1045 return true;
1046 case 'b': // Base register
1047 case 'f': // Floating point register
1048 Info.setAllowsRegister();
1049 return true;
1050 }
1051 }
1052 virtual const char *getClobbers() const {
1053 return "";
1054 }
1055};
1056
1057/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1058/// #defines that are not tied to a specific subtarget.
1059void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1060 MacroBuilder &Builder) const {
1061 // Target identification.
1062 Builder.defineMacro("__microblaze__");
1063 Builder.defineMacro("_ARCH_MICROBLAZE");
1064 Builder.defineMacro("__MICROBLAZE__");
1065
1066 // Target properties.
1067 Builder.defineMacro("_BIG_ENDIAN");
1068 Builder.defineMacro("__BIG_ENDIAN__");
1069
1070 // Subtarget options.
1071 Builder.defineMacro("__REGISTER_PREFIX__", "");
1072}
1073
1074
1075const char * const MBlazeTargetInfo::GCCRegNames[] = {
1076 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1077 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1078 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1079 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1080 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1081 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1082 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1083 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1084 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1085 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1086};
1087
1088void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1089 unsigned &NumNames) const {
1090 Names = GCCRegNames;
1091 NumNames = llvm::array_lengthof(GCCRegNames);
1092}
1093
1094const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1095 { {"f0"}, "r0" },
1096 { {"f1"}, "r1" },
1097 { {"f2"}, "r2" },
1098 { {"f3"}, "r3" },
1099 { {"f4"}, "r4" },
1100 { {"f5"}, "r5" },
1101 { {"f6"}, "r6" },
1102 { {"f7"}, "r7" },
1103 { {"f8"}, "r8" },
1104 { {"f9"}, "r9" },
1105 { {"f10"}, "r10" },
1106 { {"f11"}, "r11" },
1107 { {"f12"}, "r12" },
1108 { {"f13"}, "r13" },
1109 { {"f14"}, "r14" },
1110 { {"f15"}, "r15" },
1111 { {"f16"}, "r16" },
1112 { {"f17"}, "r17" },
1113 { {"f18"}, "r18" },
1114 { {"f19"}, "r19" },
1115 { {"f20"}, "r20" },
1116 { {"f21"}, "r21" },
1117 { {"f22"}, "r22" },
1118 { {"f23"}, "r23" },
1119 { {"f24"}, "r24" },
1120 { {"f25"}, "r25" },
1121 { {"f26"}, "r26" },
1122 { {"f27"}, "r27" },
1123 { {"f28"}, "r28" },
1124 { {"f29"}, "r29" },
1125 { {"f30"}, "r30" },
1126 { {"f31"}, "r31" },
1127};
1128
1129void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1130 unsigned &NumAliases) const {
1131 Aliases = GCCRegAliases;
1132 NumAliases = llvm::array_lengthof(GCCRegAliases);
1133}
1134} // end anonymous namespace.
1135
1136namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001137// Namespace for x86 abstract base class
1138const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001139#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001140#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001141 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001142#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001143};
Eli Friedman61538a72008-05-20 14:21:01 +00001144
Nuno Lopes2550d702009-12-23 17:49:57 +00001145static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001146 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1147 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001148 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001149 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1150 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1151 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001152 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001153};
1154
Eric Christophercfd323d2011-06-21 00:05:20 +00001155const TargetInfo::AddlRegName AddlRegNames[] = {
1156 { { "al", "ah", "eax", "rax" }, 0 },
1157 { { "bl", "bh", "ebx", "rbx" }, 3 },
1158 { { "cl", "ch", "ecx", "rcx" }, 2 },
1159 { { "dl", "dh", "edx", "rdx" }, 1 },
1160 { { "esi", "rsi" }, 4 },
1161 { { "edi", "rdi" }, 5 },
1162 { { "esp", "rsp" }, 7 },
1163 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001164};
1165
1166// X86 target abstract base class; x86-32 and x86-64 are very close, so
1167// most of the implementation can be shared.
1168class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001169 enum X86SSEEnum {
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001170 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
Chris Lattner84f0ea82009-03-02 22:40:39 +00001171 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001172 enum MMX3DNowEnum {
1173 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1174 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001175
Eric Christophereea12d12010-04-02 23:50:19 +00001176 bool HasAES;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001177 bool HasAVX;
1178
Chandler Carruth499d9722011-09-28 08:55:34 +00001179 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1180 ///
1181 /// Each enumeration represents a particular CPU supported by Clang. These
1182 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1183 enum CPUKind {
1184 CK_Generic,
1185
1186 /// \name i386
1187 /// i386-generation processors.
1188 //@{
1189 CK_i386,
1190 //@}
1191
1192 /// \name i486
1193 /// i486-generation processors.
1194 //@{
1195 CK_i486,
1196 CK_WinChipC6,
1197 CK_WinChip2,
1198 CK_C3,
1199 //@}
1200
1201 /// \name i586
1202 /// i586-generation processors, P5 microarchitecture based.
1203 //@{
1204 CK_i586,
1205 CK_Pentium,
1206 CK_PentiumMMX,
1207 //@}
1208
1209 /// \name i686
1210 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1211 //@{
1212 CK_i686,
1213 CK_PentiumPro,
1214 CK_Pentium2,
1215 CK_Pentium3,
1216 CK_Pentium3M,
1217 CK_PentiumM,
1218 CK_C3_2,
1219
1220 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1221 /// Clang however has some logic to suport this.
1222 // FIXME: Warn, deprecate, and potentially remove this.
1223 CK_Yonah,
1224 //@}
1225
1226 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001227 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001228 //@{
1229 CK_Pentium4,
1230 CK_Pentium4M,
1231 CK_Prescott,
1232 CK_Nocona,
1233 //@}
1234
1235 /// \name Core
1236 /// Core microarchitecture based processors.
1237 //@{
1238 CK_Core2,
1239
1240 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1241 /// codename which GCC no longer accepts as an option to -march, but Clang
1242 /// has some logic for recognizing it.
1243 // FIXME: Warn, deprecate, and potentially remove this.
1244 CK_Penryn,
1245 //@}
1246
1247 /// \name Atom
1248 /// Atom processors
1249 //@{
1250 CK_Atom,
1251 //@}
1252
1253 /// \name Nehalem
1254 /// Nehalem microarchitecture based processors.
1255 //@{
1256 CK_Corei7,
1257 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001258 CK_CoreAVXi,
Chandler Carruth499d9722011-09-28 08:55:34 +00001259 //@}
1260
1261 /// \name K6
1262 /// K6 architecture processors.
1263 //@{
1264 CK_K6,
1265 CK_K6_2,
1266 CK_K6_3,
1267 //@}
1268
1269 /// \name K7
1270 /// K7 architecture processors.
1271 //@{
1272 CK_Athlon,
1273 CK_AthlonThunderbird,
1274 CK_Athlon4,
1275 CK_AthlonXP,
1276 CK_AthlonMP,
1277 //@}
1278
1279 /// \name K8
1280 /// K8 architecture processors.
1281 //@{
1282 CK_Athlon64,
1283 CK_Athlon64SSE3,
1284 CK_AthlonFX,
1285 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001286 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001287 CK_Opteron,
1288 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001289 CK_AMDFAM10,
Chandler Carruth499d9722011-09-28 08:55:34 +00001290
1291 /// This specification is deprecated and will be removed in the future.
1292 /// Users should prefer \see CK_K8.
1293 // FIXME: Warn on this when the CPU is set to it.
1294 CK_x86_64,
1295 //@}
1296
1297 /// \name Geode
1298 /// Geode processors.
1299 //@{
1300 CK_Geode
1301 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001302 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001303
Eli Friedman618234a2008-08-20 02:34:37 +00001304public:
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001305 X86TargetInfo(const std::string& triple)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001306 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001307 HasAES(false), HasAVX(false), CPU(CK_Generic) {
Eli Friedman618234a2008-08-20 02:34:37 +00001308 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001309 }
1310 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1311 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001312 Records = BuiltinInfo;
1313 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001314 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001315 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001316 unsigned &NumNames) const {
1317 Names = GCCRegNames;
1318 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001319 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001320 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001321 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001322 Aliases = 0;
1323 NumAliases = 0;
1324 }
1325 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1326 unsigned &NumNames) const {
1327 Names = AddlRegNames;
1328 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001329 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001330 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001331 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001332 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001333 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001334 return "~{dirflag},~{fpsr},~{flags}";
1335 }
Chris Lattner33328642009-03-20 15:52:06 +00001336 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001337 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001338 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1339 const std::string &Name,
1340 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001341 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001342 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001343 virtual const char* getABI() const {
1344 return MMX3DNowLevel == NoMMX3DNow ? "no-mmx" : "";
1345 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001346 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001347 CPU = llvm::StringSwitch<CPUKind>(Name)
1348 .Case("i386", CK_i386)
1349 .Case("i486", CK_i486)
1350 .Case("winchip-c6", CK_WinChipC6)
1351 .Case("winchip2", CK_WinChip2)
1352 .Case("c3", CK_C3)
1353 .Case("i586", CK_i586)
1354 .Case("pentium", CK_Pentium)
1355 .Case("pentium-mmx", CK_PentiumMMX)
1356 .Case("i686", CK_i686)
1357 .Case("pentiumpro", CK_PentiumPro)
1358 .Case("pentium2", CK_Pentium2)
1359 .Case("pentium3", CK_Pentium3)
1360 .Case("pentium3m", CK_Pentium3M)
1361 .Case("pentium-m", CK_PentiumM)
1362 .Case("c3-2", CK_C3_2)
1363 .Case("yonah", CK_Yonah)
1364 .Case("pentium4", CK_Pentium4)
1365 .Case("pentium4m", CK_Pentium4M)
1366 .Case("prescott", CK_Prescott)
1367 .Case("nocona", CK_Nocona)
1368 .Case("core2", CK_Core2)
1369 .Case("penryn", CK_Penryn)
1370 .Case("atom", CK_Atom)
1371 .Case("corei7", CK_Corei7)
1372 .Case("corei7-avx", CK_Corei7AVX)
1373 .Case("core-avx-i", CK_CoreAVXi)
1374 .Case("k6", CK_K6)
1375 .Case("k6-2", CK_K6_2)
1376 .Case("k6-3", CK_K6_3)
1377 .Case("athlon", CK_Athlon)
1378 .Case("athlon-tbird", CK_AthlonThunderbird)
1379 .Case("athlon-4", CK_Athlon4)
1380 .Case("athlon-xp", CK_AthlonXP)
1381 .Case("athlon-mp", CK_AthlonMP)
1382 .Case("athlon64", CK_Athlon64)
1383 .Case("athlon64-sse3", CK_Athlon64SSE3)
1384 .Case("athlon-fx", CK_AthlonFX)
1385 .Case("k8", CK_K8)
1386 .Case("k8-sse3", CK_K8SSE3)
1387 .Case("opteron", CK_Opteron)
1388 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001389 .Case("amdfam10", CK_AMDFAM10)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001390 .Case("x86-64", CK_x86_64)
1391 .Case("geode", CK_Geode)
1392 .Default(CK_Generic);
1393
Chandler Carruth26a39142011-09-28 09:45:08 +00001394 // Perform any per-CPU checks necessary to determine if this CPU is
1395 // acceptable.
1396 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1397 // invalid without explaining *why*.
1398 switch (CPU) {
1399 case CK_Generic:
1400 // No processor selected!
1401 return false;
1402
1403 case CK_i386:
1404 case CK_i486:
1405 case CK_WinChipC6:
1406 case CK_WinChip2:
1407 case CK_C3:
1408 case CK_i586:
1409 case CK_Pentium:
1410 case CK_PentiumMMX:
1411 case CK_i686:
1412 case CK_PentiumPro:
1413 case CK_Pentium2:
1414 case CK_Pentium3:
1415 case CK_Pentium3M:
1416 case CK_PentiumM:
1417 case CK_Yonah:
1418 case CK_C3_2:
1419 case CK_Pentium4:
1420 case CK_Pentium4M:
1421 case CK_Prescott:
1422 case CK_K6:
1423 case CK_K6_2:
1424 case CK_K6_3:
1425 case CK_Athlon:
1426 case CK_AthlonThunderbird:
1427 case CK_Athlon4:
1428 case CK_AthlonXP:
1429 case CK_AthlonMP:
1430 case CK_Geode:
1431 // Only accept certain architectures when compiling in 32-bit mode.
1432 if (PointerWidth != 32)
1433 return false;
1434
1435 // Fallthrough
1436 case CK_Nocona:
1437 case CK_Core2:
1438 case CK_Penryn:
1439 case CK_Atom:
1440 case CK_Corei7:
1441 case CK_Corei7AVX:
1442 case CK_CoreAVXi:
1443 case CK_Athlon64:
1444 case CK_Athlon64SSE3:
1445 case CK_AthlonFX:
1446 case CK_K8:
1447 case CK_K8SSE3:
1448 case CK_Opteron:
1449 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00001450 case CK_AMDFAM10:
Chandler Carruth26a39142011-09-28 09:45:08 +00001451 case CK_x86_64:
1452 return true;
1453 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001454 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001455 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001456};
Chris Lattner3daed522009-03-02 22:20:04 +00001457
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001458void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001459 // FIXME: This should not be here.
1460 Features["3dnow"] = false;
1461 Features["3dnowa"] = false;
1462 Features["mmx"] = false;
1463 Features["sse"] = false;
1464 Features["sse2"] = false;
1465 Features["sse3"] = false;
1466 Features["ssse3"] = false;
1467 Features["sse41"] = false;
1468 Features["sse42"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001469 Features["sse4a"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001470 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001471 Features["avx"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001472
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001473 // FIXME: This *really* should not be here.
1474
1475 // X86_64 always has SSE2.
1476 if (PointerWidth == 64)
1477 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1478
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001479 switch (CPU) {
1480 case CK_Generic:
1481 case CK_i386:
1482 case CK_i486:
1483 case CK_i586:
1484 case CK_Pentium:
1485 case CK_i686:
1486 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001487 break;
1488 case CK_PentiumMMX:
1489 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001490 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001491 break;
1492 case CK_Pentium3:
1493 case CK_Pentium3M:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001494 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001495 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001496 break;
1497 case CK_PentiumM:
1498 case CK_Pentium4:
1499 case CK_Pentium4M:
1500 case CK_x86_64:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001501 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001502 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001503 break;
1504 case CK_Yonah:
1505 case CK_Prescott:
1506 case CK_Nocona:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001507 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001508 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001509 break;
1510 case CK_Core2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001511 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001512 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001513 break;
1514 case CK_Penryn:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001515 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001516 setFeatureEnabled(Features, "sse4", true);
1517 Features["sse42"] = false;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001518 break;
1519 case CK_Atom:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001520 setFeatureEnabled(Features, "mmx", true);
Chandler Carruth49defe62011-09-28 10:36:46 +00001521 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001522 break;
1523 case CK_Corei7:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001524 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001525 setFeatureEnabled(Features, "sse4", true);
Eric Christophereea12d12010-04-02 23:50:19 +00001526 setFeatureEnabled(Features, "aes", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001527 break;
1528 case CK_Corei7AVX:
1529 case CK_CoreAVXi:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001530 setFeatureEnabled(Features, "mmx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00001531 setFeatureEnabled(Features, "sse4", true);
1532 setFeatureEnabled(Features, "aes", true);
Bruno Cardoso Lopese02d3912011-07-11 23:33:46 +00001533 //setFeatureEnabled(Features, "avx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001534 break;
1535 case CK_K6:
1536 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001537 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001538 break;
1539 case CK_K6_2:
1540 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001541 case CK_WinChip2:
1542 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001543 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001544 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00001545 case CK_Athlon:
1546 case CK_AthlonThunderbird:
1547 case CK_Geode:
1548 setFeatureEnabled(Features, "3dnowa", true);
1549 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001550 case CK_Athlon4:
1551 case CK_AthlonXP:
1552 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001553 setFeatureEnabled(Features, "sse", true);
1554 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001555 break;
1556 case CK_K8:
1557 case CK_Opteron:
1558 case CK_Athlon64:
1559 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00001560 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001561 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001562 break;
1563 case CK_K8SSE3:
1564 case CK_OpteronSSE3:
1565 case CK_Athlon64SSE3:
Roman Divacky80b32b82011-10-30 13:47:56 +00001566 setFeatureEnabled(Features, "sse3", true);
1567 setFeatureEnabled(Features, "3dnowa", true);
1568 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00001569 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00001570 setFeatureEnabled(Features, "sse3", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00001571 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00001572 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001573 break;
1574 case CK_C3_2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001575 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001576 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001577 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001578 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001579}
1580
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001581bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump1eb44332009-09-09 15:08:12 +00001582 const std::string &Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001583 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00001584 // FIXME: This *really* should not be here. We need some way of translating
1585 // options into llvm subtarget features.
1586 if (!Features.count(Name) &&
1587 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001588 return false;
1589
1590 if (Enabled) {
1591 if (Name == "mmx")
1592 Features["mmx"] = true;
1593 else if (Name == "sse")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001594 Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001595 else if (Name == "sse2")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001596 Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001597 else if (Name == "sse3")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001598 Features["sse"] = Features["sse2"] = Features["sse3"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001599 else if (Name == "ssse3")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001600 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001601 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001602 else if (Name == "sse4" || Name == "sse4.2")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001603 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001604 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001605 else if (Name == "sse4.1")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001606 Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00001607 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001608 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001609 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001610 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001611 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00001612 else if (Name == "aes")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001613 Features["aes"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001614 else if (Name == "avx")
Bruno Cardoso Lopes292772c2011-08-18 00:07:03 +00001615 Features["avx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1616 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Roman Divacky80b32b82011-10-30 13:47:56 +00001617 else if (Name == "sse4a")
1618 Features["sse4a"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001619 } else {
1620 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001621 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001622 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00001623 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001624 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001625 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00001626 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001627 Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001628 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00001629 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001630 Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001631 else if (Name == "ssse3")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001632 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00001633 else if (Name == "sse4" || Name == "sse4.1")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001634 Features["sse41"] = Features["sse42"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00001635 else if (Name == "sse4.2")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001636 Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001637 else if (Name == "3dnow")
1638 Features["3dnow"] = Features["3dnowa"] = false;
1639 else if (Name == "3dnowa")
1640 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001641 else if (Name == "aes")
1642 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001643 else if (Name == "avx")
1644 Features["avx"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001645 else if (Name == "sse4a")
1646 Features["sse4a"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001647 }
1648
1649 return true;
1650}
1651
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001652/// HandleTargetOptions - Perform initialization based on the user
1653/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001654void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001655 // Remember the maximum enabled sselevel.
1656 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1657 // Ignore disabled features.
1658 if (Features[i][0] == '-')
1659 continue;
1660
Eric Christophereea12d12010-04-02 23:50:19 +00001661 if (Features[i].substr(1) == "aes") {
1662 HasAES = true;
1663 continue;
1664 }
1665
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001666 // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1667 // For now let it be enabled together with other SSE levels.
1668 if (Features[i].substr(1) == "avx") {
1669 HasAVX = true;
1670 continue;
1671 }
1672
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001673 assert(Features[i][0] == '+' && "Invalid target feature!");
1674 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1675 .Case("sse42", SSE42)
1676 .Case("sse41", SSE41)
1677 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00001678 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001679 .Case("sse2", SSE2)
1680 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001681 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001682 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001683
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001684 MMX3DNowEnum ThreeDNowLevel =
1685 llvm::StringSwitch<MMX3DNowEnum>(Features[i].substr(1))
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001686 .Case("3dnowa", AMD3DNowAthlon)
1687 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001688 .Case("mmx", MMX)
1689 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001690
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001691 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001692 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001693
1694 // Don't tell the backend if we're turning off mmx; it will end up disabling
1695 // SSE, which we don't want.
1696 std::vector<std::string>::iterator it;
1697 it = std::find(Features.begin(), Features.end(), "-mmx");
1698 if (it != Features.end())
1699 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00001700}
Chris Lattnerc0f59212009-03-02 22:27:17 +00001701
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001702/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
1703/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00001704void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001705 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00001706 // Target identification.
1707 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00001708 Builder.defineMacro("_LP64");
1709 Builder.defineMacro("__LP64__");
1710 Builder.defineMacro("__amd64__");
1711 Builder.defineMacro("__amd64");
1712 Builder.defineMacro("__x86_64");
1713 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00001714 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00001715 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00001716 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001717
Chris Lattnerc0f59212009-03-02 22:27:17 +00001718 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001719 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
1720 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001721 switch (CPU) {
1722 case CK_Generic:
1723 break;
1724 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001725 // The rest are coming from the i386 define above.
1726 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001727 break;
1728 case CK_i486:
1729 case CK_WinChipC6:
1730 case CK_WinChip2:
1731 case CK_C3:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001732 Builder.defineMacro("__i486");
1733 Builder.defineMacro("__i486__");
1734 Builder.defineMacro("__tune_i486__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001735 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00001736 case CK_PentiumMMX:
1737 Builder.defineMacro("__pentium_mmx__");
1738 Builder.defineMacro("__tune_pentium_mmx__");
1739 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001740 case CK_i586:
1741 case CK_Pentium:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001742 Builder.defineMacro("__i586");
1743 Builder.defineMacro("__i586__");
1744 Builder.defineMacro("__tune_i586__");
1745 Builder.defineMacro("__pentium");
1746 Builder.defineMacro("__pentium__");
1747 Builder.defineMacro("__tune_pentium__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001748 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001749 case CK_Pentium3:
1750 case CK_Pentium3M:
1751 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001752 Builder.defineMacro("__tune_pentium3__");
1753 // Fallthrough
1754 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001755 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001756 Builder.defineMacro("__tune_pentium2__");
1757 // Fallthrough
1758 case CK_PentiumPro:
1759 Builder.defineMacro("__tune_i686__");
1760 Builder.defineMacro("__tune_pentiumpro__");
1761 // Fallthrough
1762 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001763 Builder.defineMacro("__i686");
1764 Builder.defineMacro("__i686__");
1765 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
1766 Builder.defineMacro("__pentiumpro");
1767 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001768 break;
1769 case CK_Pentium4:
1770 case CK_Pentium4M:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001771 Builder.defineMacro("__pentium4");
1772 Builder.defineMacro("__pentium4__");
1773 Builder.defineMacro("__tune_pentium4__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001774 break;
1775 case CK_Yonah:
1776 case CK_Prescott:
1777 case CK_Nocona:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001778 Builder.defineMacro("__nocona");
1779 Builder.defineMacro("__nocona__");
1780 Builder.defineMacro("__tune_nocona__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001781 break;
1782 case CK_Core2:
1783 case CK_Penryn:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001784 Builder.defineMacro("__core2");
1785 Builder.defineMacro("__core2__");
1786 Builder.defineMacro("__tune_core2__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001787 break;
1788 case CK_Atom:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001789 Builder.defineMacro("__atom");
1790 Builder.defineMacro("__atom__");
1791 Builder.defineMacro("__tune_atom__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001792 break;
1793 case CK_Corei7:
1794 case CK_Corei7AVX:
1795 case CK_CoreAVXi:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001796 Builder.defineMacro("__corei7");
1797 Builder.defineMacro("__corei7__");
1798 Builder.defineMacro("__tune_corei7__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001799 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001800 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001801 Builder.defineMacro("__k6_2__");
1802 Builder.defineMacro("__tune_k6_2__");
1803 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001804 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001805 if (CPU != CK_K6_2) { // In case of fallthrough
1806 // FIXME: GCC may be enabling these in cases where some other k6
1807 // architecture is specified but -m3dnow is explicitly provided. The
1808 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001809 Builder.defineMacro("__k6_3__");
1810 Builder.defineMacro("__tune_k6_3__");
1811 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00001812 // Fallthrough
1813 case CK_K6:
1814 Builder.defineMacro("__k6");
1815 Builder.defineMacro("__k6__");
1816 Builder.defineMacro("__tune_k6__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001817 break;
1818 case CK_Athlon:
1819 case CK_AthlonThunderbird:
1820 case CK_Athlon4:
1821 case CK_AthlonXP:
1822 case CK_AthlonMP:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001823 Builder.defineMacro("__athlon");
1824 Builder.defineMacro("__athlon__");
1825 Builder.defineMacro("__tune_athlon__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001826 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001827 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001828 Builder.defineMacro("__tune_athlon_sse__");
1829 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001830 break;
1831 case CK_K8:
1832 case CK_K8SSE3:
1833 case CK_x86_64:
1834 case CK_Opteron:
1835 case CK_OpteronSSE3:
1836 case CK_Athlon64:
1837 case CK_Athlon64SSE3:
1838 case CK_AthlonFX:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001839 Builder.defineMacro("__k8");
1840 Builder.defineMacro("__k8__");
1841 Builder.defineMacro("__tune_k8__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001842 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00001843 case CK_AMDFAM10:
1844 Builder.defineMacro("__amdfam10");
1845 Builder.defineMacro("__amdfam10__");
1846 Builder.defineMacro("__tune_amdfam10__");
1847 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001848 case CK_Geode:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001849 Builder.defineMacro("__geode");
1850 Builder.defineMacro("__geode__");
1851 Builder.defineMacro("__tune_geode__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001852 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001853 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00001854
Chandler Carruth88c75b02011-09-28 09:54:07 +00001855 // Target properties.
1856 Builder.defineMacro("__LITTLE_ENDIAN__");
1857 Builder.defineMacro("__REGISTER_PREFIX__", "");
1858
Chris Lattner54175442009-04-19 17:32:33 +00001859 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1860 // functions in glibc header files that use FP Stack inline asm which the
1861 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00001862 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001863
Chandler Carruth88c75b02011-09-28 09:54:07 +00001864 if (HasAES)
1865 Builder.defineMacro("__AES__");
1866
1867 if (HasAVX)
1868 Builder.defineMacro("__AVX__");
1869
Chris Lattner84f0ea82009-03-02 22:40:39 +00001870 // Each case falls through to the previous one here.
1871 switch (SSELevel) {
1872 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00001873 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001874 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00001875 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001876 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00001877 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001878 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00001879 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001880 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00001881 Builder.defineMacro("__SSE2__");
1882 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00001883 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00001884 Builder.defineMacro("__SSE__");
1885 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001886 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00001887 break;
1888 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00001889
Francois Pichet62ec1f22011-09-17 17:15:52 +00001890 if (Opts.MicrosoftExt && PointerWidth == 32) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001891 switch (SSELevel) {
Michael J. Spencera764e832010-10-21 08:22:51 +00001892 case SSE42:
1893 case SSE41:
1894 case SSSE3:
1895 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001896 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001897 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001898 break;
1899 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001900 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001901 break;
1902 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001903 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001904 }
1905 }
1906
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001907 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001908 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001909 case AMD3DNowAthlon:
1910 Builder.defineMacro("__3dNOW_A__");
1911 case AMD3DNow:
1912 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001913 case MMX:
1914 Builder.defineMacro("__MMX__");
1915 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001916 break;
1917 }
Chris Lattnerc0f59212009-03-02 22:27:17 +00001918}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001919
1920
Eli Friedman618234a2008-08-20 02:34:37 +00001921bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001922X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00001923 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001924 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00001925 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00001926 case 'Y': // first letter of a pair:
1927 switch (*(Name+1)) {
1928 default: return false;
1929 case '0': // First SSE register.
1930 case 't': // Any SSE register, when SSE2 is enabled.
1931 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
1932 case 'm': // any MMX register, when inter-unit moves enabled.
1933 break; // falls through to setAllowsRegister.
1934 }
Eli Friedman618234a2008-08-20 02:34:37 +00001935 case 'a': // eax.
1936 case 'b': // ebx.
1937 case 'c': // ecx.
1938 case 'd': // edx.
1939 case 'S': // esi.
1940 case 'D': // edi.
1941 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00001942 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00001943 case 't': // top of floating point stack.
1944 case 'u': // second from top of floating point stack.
1945 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00001946 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00001947 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00001948 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00001949 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
1950 case 'l': // "Index" registers: any general register that can be used as an
1951 // index in a base+index memory access.
1952 Info.setAllowsRegister();
1953 return true;
1954 case 'C': // SSE floating point constant.
1955 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001956 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00001957 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001958 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00001959 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00001960 return true;
1961 }
Dale Johannesen545be512010-08-24 22:33:12 +00001962 return false;
Eli Friedman618234a2008-08-20 02:34:37 +00001963}
1964
Dale Johannesenf6e2c202010-10-29 23:12:32 +00001965
Eli Friedman618234a2008-08-20 02:34:37 +00001966std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00001967X86TargetInfo::convertConstraint(const char *&Constraint) const {
1968 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00001969 case 'a': return std::string("{ax}");
1970 case 'b': return std::string("{bx}");
1971 case 'c': return std::string("{cx}");
1972 case 'd': return std::string("{dx}");
1973 case 'S': return std::string("{si}");
1974 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00001975 case 'p': // address
1976 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00001977 case 't': // top of floating point stack.
1978 return std::string("{st}");
1979 case 'u': // second from top of floating point stack.
1980 return std::string("{st(1)}"); // second from top of floating point stack.
1981 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00001982 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00001983 }
1984}
Eli Friedman618234a2008-08-20 02:34:37 +00001985} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00001986
1987namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001988// X86-32 generic target
1989class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001990public:
Eli Friedman618234a2008-08-20 02:34:37 +00001991 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1992 DoubleAlign = LongLongAlign = 32;
1993 LongDoubleWidth = 96;
1994 LongDoubleAlign = 32;
Eli Friedmaned855cb2008-08-21 00:13:15 +00001995 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1996 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00001997 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00001998 SizeType = UnsignedInt;
1999 PtrDiffType = SignedInt;
2000 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002001 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002002
2003 // Use fpret for all types.
2004 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2005 (1 << TargetInfo::Double) |
2006 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002007
2008 // x86-32 has atomics up to 8 bytes
2009 // FIXME: Check that we actually have cmpxchg8b before setting
2010 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2011 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002012 }
2013 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002014 return "typedef char* __builtin_va_list;";
Eli Friedman618234a2008-08-20 02:34:37 +00002015 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002016
Chris Lattner21fb98e2009-09-23 06:06:36 +00002017 int getEHDataRegisterNumber(unsigned RegNo) const {
2018 if (RegNo == 0) return 0;
2019 if (RegNo == 1) return 2;
2020 return -1;
2021 }
Eli Friedman618234a2008-08-20 02:34:37 +00002022};
2023} // end anonymous namespace
2024
2025namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002026class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2027public:
2028 OpenBSDI386TargetInfo(const std::string& triple) :
2029 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2030 SizeType = UnsignedLong;
2031 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002032 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002033 }
2034};
2035} // end anonymous namespace
2036
2037namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002038class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002039public:
Torok Edwin5f6c1942009-06-30 17:10:35 +00002040 DarwinI386TargetInfo(const std::string& triple) :
2041 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002042 LongDoubleWidth = 128;
2043 LongDoubleAlign = 128;
Eli Friedman1afabd92009-03-29 20:31:09 +00002044 SizeType = UnsignedLong;
2045 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002046 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2047 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002048 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002049 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002050 }
2051
Eli Friedman618234a2008-08-20 02:34:37 +00002052};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002053} // end anonymous namespace
2054
2055namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002056// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002057class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002058public:
2059 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002060 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002061 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002062 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002063 DoubleAlign = LongLongAlign = 64;
2064 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 +00002065 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002066 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002067 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002068 virtual void getTargetDefines(const LangOptions &Opts,
2069 MacroBuilder &Builder) const {
2070 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2071 }
2072};
2073} // end anonymous namespace
2074
2075namespace {
2076
2077// x86-32 Windows Visual Studio target
2078class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2079public:
2080 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2081 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002082 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002083 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2084 }
2085 virtual void getTargetDefines(const LangOptions &Opts,
2086 MacroBuilder &Builder) const {
2087 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2088 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2089 // The value of the following reflects processor type.
2090 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2091 // We lost the original triple, so we use the default.
2092 Builder.defineMacro("_M_IX86", "600");
2093 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002094};
2095} // end anonymous namespace
2096
2097namespace {
2098// x86-32 MinGW target
2099class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2100public:
2101 MinGWX86_32TargetInfo(const std::string& triple)
2102 : WindowsX86_32TargetInfo(triple) {
2103 }
2104 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002105 MacroBuilder &Builder) const {
2106 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002107 DefineStd(Builder, "WIN32", Opts);
2108 DefineStd(Builder, "WINNT", Opts);
2109 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002110 Builder.defineMacro("__MSVCRT__");
2111 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002112
2113 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2114 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002115 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002116 // Provide "as-is" __declspec.
2117 Builder.defineMacro("__declspec", "__declspec");
2118 else
2119 // Provide alias of __attribute__ like mingw32-gcc.
2120 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002121 }
2122};
2123} // end anonymous namespace
2124
2125namespace {
2126// x86-32 Cygwin target
2127class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2128public:
2129 CygwinX86_32TargetInfo(const std::string& triple)
2130 : X86_32TargetInfo(triple) {
2131 TLSSupported = false;
2132 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002133 DoubleAlign = LongLongAlign = 64;
2134 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2135 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002136 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002137 }
2138 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002139 MacroBuilder &Builder) const {
2140 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2141 Builder.defineMacro("__CYGWIN__");
2142 Builder.defineMacro("__CYGWIN32__");
2143 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00002144 if (Opts.CPlusPlus)
2145 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00002146 }
Eli Friedman29a30502008-08-21 01:40:19 +00002147};
2148} // end anonymous namespace
2149
2150namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002151// x86-32 Haiku target
2152class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2153public:
2154 HaikuX86_32TargetInfo(const std::string& triple)
2155 : X86_32TargetInfo(triple) {
2156 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00002157 IntPtrType = SignedLong;
2158 PtrDiffType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00002159 this->UserLabelPrefix = "";
Eli Friedmana7e68452010-08-22 01:00:03 +00002160 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00002161 virtual void getTargetDefines(const LangOptions &Opts,
2162 MacroBuilder &Builder) const {
2163 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2164 Builder.defineMacro("__INTEL__");
2165 Builder.defineMacro("__HAIKU__");
2166 }
2167};
2168} // end anonymous namespace
2169
Douglas Gregordca52262011-07-01 22:41:14 +00002170// RTEMS Target
2171template<typename Target>
2172class RTEMSTargetInfo : public OSTargetInfo<Target> {
2173protected:
2174 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2175 MacroBuilder &Builder) const {
2176 // RTEMS defines; list based off of gcc output
2177
Douglas Gregordca52262011-07-01 22:41:14 +00002178 Builder.defineMacro("__rtems__");
2179 Builder.defineMacro("__ELF__");
2180 }
2181public:
2182 RTEMSTargetInfo(const std::string &triple)
2183 : OSTargetInfo<Target>(triple) {
2184 this->UserLabelPrefix = "";
2185
2186 llvm::Triple Triple(triple);
2187 switch (Triple.getArch()) {
2188 default:
2189 case llvm::Triple::x86:
2190 // this->MCountName = ".mcount";
2191 break;
2192 case llvm::Triple::mips:
2193 case llvm::Triple::mipsel:
2194 case llvm::Triple::ppc:
2195 case llvm::Triple::ppc64:
2196 // this->MCountName = "_mcount";
2197 break;
2198 case llvm::Triple::arm:
2199 // this->MCountName = "__mcount";
2200 break;
2201 }
2202
2203 }
2204};
2205
2206namespace {
2207// x86-32 RTEMS target
2208class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2209public:
2210 RTEMSX86_32TargetInfo(const std::string& triple)
2211 : X86_32TargetInfo(triple) {
2212 SizeType = UnsignedLong;
2213 IntPtrType = SignedLong;
2214 PtrDiffType = SignedLong;
2215 this->UserLabelPrefix = "";
2216 }
2217 virtual void getTargetDefines(const LangOptions &Opts,
2218 MacroBuilder &Builder) const {
2219 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2220 Builder.defineMacro("__INTEL__");
2221 Builder.defineMacro("__rtems__");
2222 }
2223};
2224} // end anonymous namespace
2225
Chris Lattner86ed3a32010-04-11 19:29:39 +00002226namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002227// x86-64 generic target
2228class X86_64TargetInfo : public X86TargetInfo {
2229public:
Chris Lattner33328642009-03-20 15:52:06 +00002230 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00002231 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002232 LongDoubleWidth = 128;
2233 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00002234 LargeArrayMinWidth = 128;
2235 LargeArrayAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00002236 IntMaxType = SignedLong;
2237 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002238 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002239 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00002240
Eli Friedmaned855cb2008-08-21 00:13:15 +00002241 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2242 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002243 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002244
2245 // Use fpret only for long double.
2246 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00002247
Anders Carlssoneea64802011-10-31 16:27:11 +00002248 // Use fp2ret for _Complex long double.
2249 ComplexLongDoubleUsesFP2Ret = true;
2250
Eli Friedman2be46072011-10-14 20:59:01 +00002251 // x86-64 has atomics up to 16 bytes.
2252 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
2253 // on CPUs with cmpxchg16b
2254 MaxAtomicPromoteWidth = 128;
2255 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00002256 }
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00002257 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002258 return "typedef struct __va_list_tag {"
2259 " unsigned gp_offset;"
2260 " unsigned fp_offset;"
2261 " void* overflow_arg_area;"
2262 " void* reg_save_area;"
John McCall2b7baf02010-05-28 18:25:28 +00002263 "} __va_list_tag;"
Eli Friedmandc043162009-07-03 00:45:06 +00002264 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson3346ae62007-11-24 23:38:12 +00002265 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002266
Chris Lattner21fb98e2009-09-23 06:06:36 +00002267 int getEHDataRegisterNumber(unsigned RegNo) const {
2268 if (RegNo == 0) return 0;
2269 if (RegNo == 1) return 1;
2270 return -1;
2271 }
Eli Friedman618234a2008-08-20 02:34:37 +00002272};
2273} // end anonymous namespace
2274
2275namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002276// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002277class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002278public:
2279 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002280 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002281 TLSSupported = false;
2282 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00002283 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00002284 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00002285 IntMaxType = SignedLongLong;
2286 UIntMaxType = UnsignedLongLong;
2287 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00002288 SizeType = UnsignedLongLong;
2289 PtrDiffType = SignedLongLong;
2290 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00002291 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002292 }
2293 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002294 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002295 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002296 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00002297 }
NAKAMURA Takumi79521992011-01-17 22:56:23 +00002298 virtual const char *getVAListDeclaration() const {
2299 return "typedef char* __builtin_va_list;";
2300 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002301};
2302} // end anonymous namespace
2303
2304namespace {
2305// x86-64 Windows Visual Studio target
2306class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2307public:
2308 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2309 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002310 LongDoubleWidth = LongDoubleAlign = 64;
2311 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00002312 }
2313 virtual void getTargetDefines(const LangOptions &Opts,
2314 MacroBuilder &Builder) const {
2315 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
2316 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00002317 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002318 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002319 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002320};
2321} // end anonymous namespace
2322
2323namespace {
2324// x86-64 MinGW target
2325class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2326public:
2327 MinGWX86_64TargetInfo(const std::string& triple)
2328 : WindowsX86_64TargetInfo(triple) {
2329 }
2330 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002331 MacroBuilder &Builder) const {
2332 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002333 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00002334 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00002335 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00002336 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002337
2338 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2339 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002340 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002341 // Provide "as-is" __declspec.
2342 Builder.defineMacro("__declspec", "__declspec");
2343 else
2344 // Provide alias of __attribute__ like mingw32-gcc.
2345 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002346 }
2347};
2348} // end anonymous namespace
2349
2350namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002351class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2352public:
Mike Stump1eb44332009-09-09 15:08:12 +00002353 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002354 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2355 Int64Type = SignedLongLong;
2356 }
2357};
2358} // end anonymous namespace
2359
2360namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00002361class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
2362public:
Mike Stump1eb44332009-09-09 15:08:12 +00002363 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman6036ebe2009-07-05 22:31:18 +00002364 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
2365 IntMaxType = SignedLongLong;
2366 UIntMaxType = UnsignedLongLong;
2367 Int64Type = SignedLongLong;
2368 }
2369};
2370} // end anonymous namespace
2371
2372namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00002373class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002374 // Possible FPU choices.
2375 enum FPUMode {
2376 NoFPU,
2377 VFP2FPU,
2378 VFP3FPU,
2379 NeonFPU
2380 };
2381
2382 static bool FPUModeIsVFP(FPUMode Mode) {
2383 return Mode >= VFP2FPU && Mode <= NeonFPU;
2384 }
2385
2386 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2387 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002388
Daniel Dunbareac7c532009-12-18 18:42:37 +00002389 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002390
2391 unsigned FPU : 3;
2392
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002393 unsigned IsThumb : 1;
2394
2395 // Initialized via features.
2396 unsigned SoftFloat : 1;
2397 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002398
Chris Lattner2752c012010-03-03 19:03:45 +00002399 static const Builtin::Info BuiltinInfo[];
2400
Chris Lattner393ff042008-04-21 18:56:49 +00002401public:
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002402 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbareac7c532009-12-18 18:42:37 +00002403 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002404 {
Daniel Dunbara2a41612009-09-14 00:02:24 +00002405 SizeType = UnsignedInt;
2406 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00002407 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
2408 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002409
Chris Lattner9bffb072010-04-23 16:29:58 +00002410 // {} in inline assembly are neon specifiers, not assembly variant
2411 // specifiers.
2412 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00002413
Daniel Dunbareac7c532009-12-18 18:42:37 +00002414 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00002415 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002416 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002417 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2418 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002419 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
2420 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002421 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002422 } else {
2423 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2424 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002425 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002426 }
John McCallee79a4c2010-08-21 22:46:04 +00002427
2428 // ARM targets default to using the ARM C++ ABI.
2429 CXXABI = CXXABI_ARM;
Eli Friedman2be46072011-10-14 20:59:01 +00002430
2431 // ARM has atomics up to 8 bytes
2432 // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e
2433 MaxAtomicPromoteWidth = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002434 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002435 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00002436 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002437 ABI = Name;
2438
Daniel Dunbara2a41612009-09-14 00:02:24 +00002439 // The defaults (above) are for AAPCS, check if we need to change them.
2440 //
2441 // FIXME: We need support for -meabi... we could just mangle it into the
2442 // name.
2443 if (Name == "apcs-gnu") {
Daniel Dunbard410fa22010-01-27 20:23:08 +00002444 DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002445 SizeType = UnsignedLong;
2446
James Molloya6d81f92011-11-23 13:35:08 +00002447 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
2448 WCharType = SignedInt;
2449
Daniel Dunbar684de632010-04-22 16:14:54 +00002450 // Do not respect the alignment of bit-field types when laying out
2451 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
2452 UseBitFieldTypeAlignment = false;
2453
Chad Rosier61a62212011-08-04 01:21:14 +00002454 /// Do force alignment of members that follow zero length bitfields. If
2455 /// the alignment of the zero-length bitfield is greater than the member
2456 /// that follows it, `bar', `bar' will be aligned as the type of the
2457 /// zero length bitfield.
2458 UseZeroLengthBitfieldAlignment = true;
2459
2460 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00002461 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
2462 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00002463 ZeroLengthBitfieldBoundary = 32;
2464
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002465 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002466 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2467 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002468 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 +00002469 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002470 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002471 } else {
2472 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 +00002473 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002474 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002475 }
2476
Chad Rosier9f1210c2011-07-26 07:03:04 +00002477 // FIXME: Override "preferred align" for double and long long.
Daniel Dunbara2a41612009-09-14 00:02:24 +00002478 } else if (Name == "aapcs") {
2479 // FIXME: Enumerated types are variable width in straight AAPCS.
2480 } else if (Name == "aapcs-linux") {
Chad Rosier9f1210c2011-07-26 07:03:04 +00002481 ;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002482 } else
2483 return false;
2484
2485 return true;
2486 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002487
Chandler Carruthc3a2e652011-09-28 05:56:05 +00002488 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002489 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
2490 Features["vfp2"] = true;
2491 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
2492 Features["neon"] = true;
2493 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002494
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002495 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2496 const std::string &Name,
2497 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00002498 if (Name == "soft-float" || Name == "soft-float-abi" ||
2499 Name == "vfp2" || Name == "vfp3" || Name == "neon") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002500 Features[Name] = Enabled;
2501 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002502 return false;
2503
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002504 return true;
2505 }
2506
2507 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002508 FPU = NoFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002509 SoftFloat = SoftFloatABI = false;
2510 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
2511 if (Features[i] == "+soft-float")
2512 SoftFloat = true;
2513 else if (Features[i] == "+soft-float-abi")
2514 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002515 else if (Features[i] == "+vfp2")
2516 FPU = VFP2FPU;
2517 else if (Features[i] == "+vfp3")
2518 FPU = VFP3FPU;
2519 else if (Features[i] == "+neon")
2520 FPU = NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002521 }
2522
2523 // Remove front-end specific options which the backend handles differently.
2524 std::vector<std::string>::iterator it;
2525 it = std::find(Features.begin(), Features.end(), "+soft-float");
2526 if (it != Features.end())
2527 Features.erase(it);
2528 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2529 if (it != Features.end())
2530 Features.erase(it);
2531 }
2532
Chris Lattner5f9e2722011-07-23 10:55:15 +00002533 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00002534 return llvm::StringSwitch<const char*>(Name)
2535 .Cases("arm8", "arm810", "4")
2536 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2537 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2538 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2539 .Case("ep9312", "4T")
2540 .Cases("arm10tdmi", "arm1020t", "5T")
2541 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2542 .Case("arm926ej-s", "5TEJ")
2543 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2544 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002545 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002546 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002547 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002548 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2549 .Cases("cortex-a8", "cortex-a9", "7A")
Bob Wilson06f45632011-01-06 16:57:20 +00002550 .Case("cortex-m3", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00002551 .Case("cortex-m0", "6M")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002552 .Default(0);
2553 }
2554 virtual bool setCPU(const std::string &Name) {
2555 if (!getCPUDefineSuffix(Name))
2556 return false;
2557
2558 CPU = Name;
2559 return true;
2560 }
Chris Lattner33328642009-03-20 15:52:06 +00002561 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002562 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002563 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00002564 Builder.defineMacro("__arm");
2565 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002566
Chris Lattnerc0f59212009-03-02 22:27:17 +00002567 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00002568 Builder.defineMacro("__ARMEL__");
2569 Builder.defineMacro("__LITTLE_ENDIAN__");
2570 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002571
Chris Lattner5f9e2722011-07-23 10:55:15 +00002572 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00002573 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002574
Mike Stump437bb4b2009-04-08 02:07:04 +00002575 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002576
Daniel Dunbareac7c532009-12-18 18:42:37 +00002577 // FIXME: It's more complicated than this and we don't really support
2578 // interworking.
2579 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00002580 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002581
Daniel Dunbareac7c532009-12-18 18:42:37 +00002582 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramera9992772010-01-09 17:55:51 +00002583 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002584
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002585 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00002586 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002587
2588 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00002589 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002590
Bob Wilson84f95cf2011-05-13 18:56:03 +00002591 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002592 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002593 Builder.defineMacro("__THUMBEL__");
2594 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00002595 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002596 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002597 }
2598
2599 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00002600 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002601
2602 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramera9992772010-01-09 17:55:51 +00002603 Builder.defineMacro("__VFP_FP__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002604
2605 // This only gets set when Neon instructions are actually available, unlike
2606 // the VFP define, hence the soft float and arch check. This is subtly
2607 // different from gcc, we follow the intent which was that it should be set
2608 // when Neon instructions are actually available.
Bob Wilson84f95cf2011-05-13 18:56:03 +00002609 if (FPU == NeonFPU && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002610 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00002611 }
2612 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2613 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00002614 Records = BuiltinInfo;
2615 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00002616 }
2617 virtual const char *getVAListDeclaration() const {
John McCall0e9972c2011-05-09 02:19:37 +00002618 return "typedef void* __builtin_va_list;";
Chris Lattner393ff042008-04-21 18:56:49 +00002619 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002620 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002621 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002622 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002623 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002624 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002625 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002626 // FIXME: Check if this is complete
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002627 switch (*Name) {
Eli Friedmana9f54962008-08-20 07:44:10 +00002628 default:
Nate Begemanad487f42008-04-22 05:03:19 +00002629 case 'l': // r0-r7
2630 case 'h': // r8-r15
2631 case 'w': // VFP Floating point register single precision
2632 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00002633 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00002634 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00002635 case 'Q': // A memory address that is a single base register.
2636 Info.setAllowsMemory();
2637 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00002638 case 'U': // a memory reference...
2639 switch (Name[1]) {
2640 case 'q': // ...ARMV4 ldrsb
2641 case 'v': // ...VFP load/store (reg+constant offset)
2642 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00002643 case 't': // address valid for load/store opaque types wider
2644 // than 128-bits
2645 case 'n': // valid address for Neon doubleword vector load/store
2646 case 'm': // valid address for Neon element and structure load/store
2647 case 's': // valid address for non-offset loads/stores of quad-word
2648 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00002649 Info.setAllowsMemory();
2650 Name++;
2651 return true;
2652 }
Nate Begemanad487f42008-04-22 05:03:19 +00002653 }
Chris Lattner393ff042008-04-21 18:56:49 +00002654 return false;
2655 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00002656 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00002657 std::string R;
2658 switch (*Constraint) {
2659 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00002660 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00002661 Constraint++;
2662 break;
Eric Christopher283f4472011-06-17 00:40:18 +00002663 case 'p': // 'p' should be translated to 'r' by default.
2664 R = std::string("r");
2665 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00002666 default:
2667 return std::string(1, *Constraint);
2668 }
2669 return R;
2670 }
Chris Lattner393ff042008-04-21 18:56:49 +00002671 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002672 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00002673 return "";
2674 }
2675};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002676
2677const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002678 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002679 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002680 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
2681
2682 // Float registers
2683 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2684 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2685 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002686 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002687
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002688 // Double registers
2689 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
2690 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00002691 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
2692 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002693
2694 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00002695 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
2696 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002697};
2698
2699void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002700 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002701 Names = GCCRegNames;
2702 NumNames = llvm::array_lengthof(GCCRegNames);
2703}
2704
2705const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002706 { { "a1" }, "r0" },
2707 { { "a2" }, "r1" },
2708 { { "a3" }, "r2" },
2709 { { "a4" }, "r3" },
2710 { { "v1" }, "r4" },
2711 { { "v2" }, "r5" },
2712 { { "v3" }, "r6" },
2713 { { "v4" }, "r7" },
2714 { { "v5" }, "r8" },
2715 { { "v6", "rfp" }, "r9" },
2716 { { "sl" }, "r10" },
2717 { { "fp" }, "r11" },
2718 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002719 { { "r13" }, "sp" },
2720 { { "r14" }, "lr" },
2721 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002722 // The S, D and Q registers overlap, but aren't really aliases; we
2723 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002724};
2725
2726void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2727 unsigned &NumAliases) const {
2728 Aliases = GCCRegAliases;
2729 NumAliases = llvm::array_lengthof(GCCRegAliases);
2730}
Chris Lattner2752c012010-03-03 19:03:45 +00002731
2732const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00002733#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00002734#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00002735 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00002736#include "clang/Basic/BuiltinsARM.def"
2737};
Chris Lattner393ff042008-04-21 18:56:49 +00002738} // end anonymous namespace.
2739
Eli Friedmana9f54962008-08-20 07:44:10 +00002740
2741namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00002742class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00002743 public DarwinTargetInfo<ARMTargetInfo> {
2744protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00002745 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00002746 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00002747 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00002748 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002749
Torok Edwin5f6c1942009-06-30 17:10:35 +00002750public:
Mike Stump1eb44332009-09-09 15:08:12 +00002751 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar350b9f32010-05-27 07:00:26 +00002752 : DarwinTargetInfo<ARMTargetInfo>(triple) {
2753 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00002754 // iOS always has 64-bit atomic instructions.
2755 // FIXME: This should be based off of the target features in ARMTargetInfo.
2756 MaxAtomicInlineWidth = 64;
Daniel Dunbar350b9f32010-05-27 07:00:26 +00002757 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002758};
2759} // end anonymous namespace.
2760
Reid Spencer5f016e22007-07-11 17:01:13 +00002761namespace {
Eli Friedman01b86682008-08-20 07:28:14 +00002762class SparcV8TargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00002763 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2764 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002765 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00002766public:
Eli Friedman01b86682008-08-20 07:28:14 +00002767 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
2768 // FIXME: Support Sparc quad-precision long double?
Eli Friedmaned855cb2008-08-21 00:13:15 +00002769 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 +00002770 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedman01b86682008-08-20 07:28:14 +00002771 }
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002772 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2773 const std::string &Name,
2774 bool Enabled) const {
2775 if (Name == "soft-float")
2776 Features[Name] = Enabled;
2777 else
2778 return false;
2779
2780 return true;
2781 }
2782 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
2783 SoftFloat = false;
2784 for (unsigned i = 0, e = Features.size(); i != e; ++i)
2785 if (Features[i] == "+soft-float")
2786 SoftFloat = true;
2787 }
Chris Lattner33328642009-03-20 15:52:06 +00002788 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002789 MacroBuilder &Builder) const {
2790 DefineStd(Builder, "sparc", Opts);
2791 Builder.defineMacro("__sparcv8");
2792 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002793
2794 if (SoftFloat)
2795 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00002796 }
2797 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2798 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00002799 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00002800 }
2801 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002802 return "typedef void* __builtin_va_list;";
Gabor Greif26658672008-02-21 16:29:08 +00002803 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002804 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00002805 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002806 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00002807 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002808 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00002809 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00002810 // FIXME: Implement!
2811 return false;
Gabor Greif26658672008-02-21 16:29:08 +00002812 }
2813 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002814 // FIXME: Implement!
2815 return "";
Gabor Greif26658672008-02-21 16:29:08 +00002816 }
2817};
2818
Chris Lattnere957f532009-01-27 01:58:38 +00002819const char * const SparcV8TargetInfo::GCCRegNames[] = {
2820 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2821 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2822 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2823 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
2824};
2825
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002826void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00002827 unsigned &NumNames) const {
2828 Names = GCCRegNames;
2829 NumNames = llvm::array_lengthof(GCCRegNames);
2830}
2831
2832const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002833 { { "g0" }, "r0" },
2834 { { "g1" }, "r1" },
2835 { { "g2" }, "r2" },
2836 { { "g3" }, "r3" },
2837 { { "g4" }, "r4" },
2838 { { "g5" }, "r5" },
2839 { { "g6" }, "r6" },
2840 { { "g7" }, "r7" },
2841 { { "o0" }, "r8" },
2842 { { "o1" }, "r9" },
2843 { { "o2" }, "r10" },
2844 { { "o3" }, "r11" },
2845 { { "o4" }, "r12" },
2846 { { "o5" }, "r13" },
2847 { { "o6", "sp" }, "r14" },
2848 { { "o7" }, "r15" },
2849 { { "l0" }, "r16" },
2850 { { "l1" }, "r17" },
2851 { { "l2" }, "r18" },
2852 { { "l3" }, "r19" },
2853 { { "l4" }, "r20" },
2854 { { "l5" }, "r21" },
2855 { { "l6" }, "r22" },
2856 { { "l7" }, "r23" },
2857 { { "i0" }, "r24" },
2858 { { "i1" }, "r25" },
2859 { { "i2" }, "r26" },
2860 { { "i3" }, "r27" },
2861 { { "i4" }, "r28" },
2862 { { "i5" }, "r29" },
2863 { { "i6", "fp" }, "r30" },
2864 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00002865};
2866
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002867void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00002868 unsigned &NumAliases) const {
2869 Aliases = GCCRegAliases;
2870 NumAliases = llvm::array_lengthof(GCCRegAliases);
2871}
Gabor Greif26658672008-02-21 16:29:08 +00002872} // end anonymous namespace.
2873
Eli Friedman01b86682008-08-20 07:28:14 +00002874namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00002875class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
2876public:
2877 AuroraUXSparcV8TargetInfo(const std::string& triple) :
2878 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
2879 SizeType = UnsignedInt;
2880 PtrDiffType = SignedInt;
2881 }
2882};
Torok Edwin5f6c1942009-06-30 17:10:35 +00002883class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00002884public:
2885 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwin5f6c1942009-06-30 17:10:35 +00002886 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00002887 SizeType = UnsignedInt;
2888 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00002889 }
2890};
2891} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00002892
Chris Lattner2621fd12008-05-08 05:58:21 +00002893namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002894 class MSP430TargetInfo : public TargetInfo {
2895 static const char * const GCCRegNames[];
2896 public:
2897 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
2898 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00002899 IntWidth = 16; IntAlign = 16;
2900 LongWidth = 32; LongLongWidth = 64;
2901 LongAlign = LongLongAlign = 16;
2902 PointerWidth = 16; PointerAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002903 SizeType = UnsignedInt;
2904 IntMaxType = SignedLong;
2905 UIntMaxType = UnsignedLong;
2906 IntPtrType = SignedShort;
2907 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00002908 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00002909 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002910 }
2911 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002912 MacroBuilder &Builder) const {
2913 Builder.defineMacro("MSP430");
2914 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002915 // FIXME: defines for different 'flavours' of MCU
2916 }
2917 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2918 unsigned &NumRecords) const {
2919 // FIXME: Implement.
2920 Records = 0;
2921 NumRecords = 0;
2922 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002923 virtual void getGCCRegNames(const char * const *&Names,
2924 unsigned &NumNames) const;
2925 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2926 unsigned &NumAliases) const {
2927 // No aliases.
2928 Aliases = 0;
2929 NumAliases = 0;
2930 }
2931 virtual bool validateAsmConstraint(const char *&Name,
2932 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00002933 // No target constraints for now.
2934 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002935 }
2936 virtual const char *getClobbers() const {
2937 // FIXME: Is this really right?
2938 return "";
2939 }
2940 virtual const char *getVAListDeclaration() const {
2941 // FIXME: implement
Anton Korobeynikoveb716852009-05-08 18:24:57 +00002942 return "typedef char* __builtin_va_list;";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00002943 }
2944 };
2945
2946 const char * const MSP430TargetInfo::GCCRegNames[] = {
2947 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2948 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2949 };
2950
2951 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
2952 unsigned &NumNames) const {
2953 Names = GCCRegNames;
2954 NumNames = llvm::array_lengthof(GCCRegNames);
2955 }
2956}
2957
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00002958namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00002959
Mike Stump1eb44332009-09-09 15:08:12 +00002960 // LLVM and Clang cannot be used directly to output native binaries for
2961 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00002962 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00002963 //
2964 // TCE uses the llvm bitcode as input and uses it for generating customized
2965 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00002966 // publicly available in http://tce.cs.tut.fi
2967
Eli Friedman209f5bb2011-10-07 19:51:42 +00002968 static const unsigned TCEOpenCLAddrSpaceMap[] = {
2969 3, // opencl_global
2970 4, // opencl_local
2971 5 // opencl_constant
2972 };
2973
Eli Friedmanb63decf2009-08-19 20:47:07 +00002974 class TCETargetInfo : public TargetInfo{
2975 public:
2976 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
2977 TLSSupported = false;
2978 IntWidth = 32;
2979 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00002980 PointerWidth = 32;
2981 IntAlign = 32;
2982 LongAlign = LongLongAlign = 32;
2983 PointerAlign = 32;
2984 SizeType = UnsignedInt;
2985 IntMaxType = SignedLong;
2986 UIntMaxType = UnsignedLong;
2987 IntPtrType = SignedInt;
2988 PtrDiffType = SignedInt;
2989 FloatWidth = 32;
2990 FloatAlign = 32;
2991 DoubleWidth = 32;
2992 DoubleAlign = 32;
2993 LongDoubleWidth = 32;
2994 LongDoubleAlign = 32;
2995 FloatFormat = &llvm::APFloat::IEEEsingle;
2996 DoubleFormat = &llvm::APFloat::IEEEsingle;
2997 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00002998 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
2999 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00003000 "f32:32:32-f64:32:32-v64:32:32-"
3001 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00003002 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003003 }
3004
3005 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003006 MacroBuilder &Builder) const {
3007 DefineStd(Builder, "tce", Opts);
3008 Builder.defineMacro("__TCE__");
3009 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00003010 }
3011 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3012 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00003013 virtual const char *getClobbers() const {
3014 return "";
3015 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003016 virtual const char *getVAListDeclaration() const {
3017 return "typedef void* __builtin_va_list;";
3018 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003019 virtual void getGCCRegNames(const char * const *&Names,
3020 unsigned &NumNames) const {}
3021 virtual bool validateAsmConstraint(const char *&Name,
3022 TargetInfo::ConstraintInfo &info) const {
3023 return true;
3024 }
3025 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3026 unsigned &NumAliases) const {}
3027 };
3028}
3029
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003030namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003031class MipsTargetInfoBase : public TargetInfo {
3032 std::string CPU;
3033protected:
3034 std::string ABI;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003035public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003036 MipsTargetInfoBase(const std::string& triple, const std::string& ABIStr)
Akira Hatanaka148735e2011-11-05 01:48:34 +00003037 : TargetInfo(triple), ABI(ABIStr) {}
Eric Christophered734732010-03-02 02:41:08 +00003038 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003039 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00003040 virtual bool setCPU(const std::string &Name) {
3041 CPU = Name;
3042 return true;
3043 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003044 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00003045 Features[ABI] = true;
3046 Features[CPU] = true;
3047 }
3048 virtual void getArchDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003049 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003050 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003051 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003052 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3053 unsigned &NumRecords) const {
3054 // FIXME: Implement!
3055 }
3056 virtual const char *getVAListDeclaration() const {
3057 return "typedef void* __builtin_va_list;";
3058 }
3059 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003060 unsigned &NumNames) const {
3061 static const char * const GCCRegNames[] = {
3062 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
3063 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
3064 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
3065 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
3066 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
3067 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
3068 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
3069 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
3070 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
3071 "$fcc5","$fcc6","$fcc7"
3072 };
3073 Names = GCCRegNames;
3074 NumNames = llvm::array_lengthof(GCCRegNames);
3075 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003076 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003077 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003078 virtual bool validateAsmConstraint(const char *&Name,
3079 TargetInfo::ConstraintInfo &Info) const {
3080 switch (*Name) {
3081 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00003082 return false;
3083
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003084 case 'r': // CPU registers.
3085 case 'd': // Equivalent to "r" unless generating MIPS16 code.
3086 case 'y': // Equivalent to "r", backwards compatibility only.
3087 case 'f': // floating-point registers.
3088 Info.setAllowsRegister();
3089 return true;
3090 }
3091 return false;
3092 }
3093
3094 virtual const char *getClobbers() const {
3095 // FIXME: Implement!
3096 return "";
3097 }
3098};
3099
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003100class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003101public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003102 Mips32TargetInfoBase(const std::string& triple) :
Akira Hatanaka148735e2011-11-05 01:48:34 +00003103 MipsTargetInfoBase(triple, "o32") {
3104 SizeType = UnsignedInt;
3105 PtrDiffType = SignedInt;
3106 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003107 virtual bool setABI(const std::string &Name) {
3108 if ((Name == "o32") || (Name == "eabi")) {
3109 ABI = Name;
3110 return true;
3111 } else
3112 return false;
3113 }
3114 virtual void getArchDefines(const LangOptions &Opts,
3115 MacroBuilder &Builder) const {
Douglas Gregorc9a23712011-11-09 15:17:16 +00003116 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
3117 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
3118 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
3119
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003120 if (ABI == "o32") {
3121 Builder.defineMacro("__mips_o32");
3122 Builder.defineMacro("_ABIO32", "1");
3123 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
3124 }
3125 else if (ABI == "eabi")
3126 Builder.defineMacro("__mips_eabi");
3127 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003128 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003129 }
3130 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3131 unsigned &NumAliases) const {
3132 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3133 { { "at" }, "$1" },
3134 { { "v0" }, "$2" },
3135 { { "v1" }, "$3" },
3136 { { "a0" }, "$4" },
3137 { { "a1" }, "$5" },
3138 { { "a2" }, "$6" },
3139 { { "a3" }, "$7" },
3140 { { "t0" }, "$8" },
3141 { { "t1" }, "$9" },
3142 { { "t2" }, "$10" },
3143 { { "t3" }, "$11" },
3144 { { "t4" }, "$12" },
3145 { { "t5" }, "$13" },
3146 { { "t6" }, "$14" },
3147 { { "t7" }, "$15" },
3148 { { "s0" }, "$16" },
3149 { { "s1" }, "$17" },
3150 { { "s2" }, "$18" },
3151 { { "s3" }, "$19" },
3152 { { "s4" }, "$20" },
3153 { { "s5" }, "$21" },
3154 { { "s6" }, "$22" },
3155 { { "s7" }, "$23" },
3156 { { "t8" }, "$24" },
3157 { { "t9" }, "$25" },
3158 { { "k0" }, "$26" },
3159 { { "k1" }, "$27" },
3160 { { "gp" }, "$28" },
3161 { { "sp" }, "$29" },
3162 { { "fp" }, "$30" },
3163 { { "ra" }, "$31" }
3164 };
3165 Aliases = GCCRegAliases;
3166 NumAliases = llvm::array_lengthof(GCCRegAliases);
3167 }
3168};
3169
3170class Mips32EBTargetInfo : public Mips32TargetInfoBase {
3171public:
3172 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
3173 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3174 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3175 }
3176 virtual void getTargetDefines(const LangOptions &Opts,
3177 MacroBuilder &Builder) const {
3178 DefineStd(Builder, "mips", Opts);
3179 Builder.defineMacro("_mips");
3180 DefineStd(Builder, "MIPSEB", Opts);
3181 Builder.defineMacro("_MIPSEB");
3182 Builder.defineMacro("__REGISTER_PREFIX__", "");
3183 getArchDefines(Opts, Builder);
3184 }
3185};
3186
3187class Mips32ELTargetInfo : public Mips32TargetInfoBase {
3188public:
3189 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003190 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 +00003191 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003192 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003193 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003194 MacroBuilder &Builder) const {
3195 DefineStd(Builder, "mips", Opts);
3196 Builder.defineMacro("_mips");
3197 DefineStd(Builder, "MIPSEL", Opts);
3198 Builder.defineMacro("_MIPSEL");
3199 Builder.defineMacro("__REGISTER_PREFIX__", "");
3200 getArchDefines(Opts, Builder);
3201 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003202};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003203
3204class Mips64TargetInfoBase : public MipsTargetInfoBase {
3205 virtual void SetDescriptionString(const std::string &Name) = 0;
3206public:
3207 Mips64TargetInfoBase(const std::string& triple) :
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003208 MipsTargetInfoBase(triple, "n64") {
3209 LongWidth = LongAlign = 64;
3210 PointerWidth = PointerAlign = 64;
3211 LongDoubleWidth = LongDoubleAlign = 128;
3212 LongDoubleFormat = &llvm::APFloat::IEEEquad;
3213 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003214 virtual bool setABI(const std::string &Name) {
3215 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003216
3217 if (Name != "n32" && Name != "n64")
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003218 return false;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003219
3220 ABI = Name;
3221
3222 if (Name == "n32") {
3223 LongWidth = LongAlign = 32;
3224 PointerWidth = PointerAlign = 32;
3225 }
3226
3227 return true;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003228 }
3229 virtual void getArchDefines(const LangOptions &Opts,
3230 MacroBuilder &Builder) const {
3231 if (ABI == "n32") {
3232 Builder.defineMacro("__mips_n32");
3233 Builder.defineMacro("_ABIN32", "2");
3234 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
3235 }
3236 else if (ABI == "n64") {
3237 Builder.defineMacro("__mips_n64");
3238 Builder.defineMacro("_ABI64", "3");
3239 Builder.defineMacro("_MIPS_SIM", "_ABI64");
3240 }
3241 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003242 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003243 }
3244 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3245 unsigned &NumAliases) const {
3246 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3247 { { "at" }, "$1" },
3248 { { "v0" }, "$2" },
3249 { { "v1" }, "$3" },
3250 { { "a0" }, "$4" },
3251 { { "a1" }, "$5" },
3252 { { "a2" }, "$6" },
3253 { { "a3" }, "$7" },
3254 { { "a4" }, "$8" },
3255 { { "a5" }, "$9" },
3256 { { "a6" }, "$10" },
3257 { { "a7" }, "$11" },
3258 { { "t0" }, "$12" },
3259 { { "t1" }, "$13" },
3260 { { "t2" }, "$14" },
3261 { { "t3" }, "$15" },
3262 { { "s0" }, "$16" },
3263 { { "s1" }, "$17" },
3264 { { "s2" }, "$18" },
3265 { { "s3" }, "$19" },
3266 { { "s4" }, "$20" },
3267 { { "s5" }, "$21" },
3268 { { "s6" }, "$22" },
3269 { { "s7" }, "$23" },
3270 { { "t8" }, "$24" },
3271 { { "t9" }, "$25" },
3272 { { "k0" }, "$26" },
3273 { { "k1" }, "$27" },
3274 { { "gp" }, "$28" },
3275 { { "sp" }, "$29" },
3276 { { "fp" }, "$30" },
3277 { { "ra" }, "$31" }
3278 };
3279 Aliases = GCCRegAliases;
3280 NumAliases = llvm::array_lengthof(GCCRegAliases);
3281 }
3282};
3283
3284class Mips64EBTargetInfo : public Mips64TargetInfoBase {
3285 virtual void SetDescriptionString(const std::string &Name) {
3286 // Change DescriptionString only if ABI is n32.
3287 if (Name == "n32")
3288 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003289 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3290 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003291 }
3292public:
3293 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3294 // Default ABI is n64.
3295 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003296 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3297 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003298 }
3299 virtual void getTargetDefines(const LangOptions &Opts,
3300 MacroBuilder &Builder) const {
3301 DefineStd(Builder, "mips", Opts);
3302 Builder.defineMacro("_mips");
3303 DefineStd(Builder, "MIPSEB", Opts);
3304 Builder.defineMacro("_MIPSEB");
3305 Builder.defineMacro("__REGISTER_PREFIX__", "");
3306 getArchDefines(Opts, Builder);
3307 }
3308};
3309
3310class Mips64ELTargetInfo : public Mips64TargetInfoBase {
3311 virtual void SetDescriptionString(const std::string &Name) {
3312 // Change DescriptionString only if ABI is n32.
3313 if (Name == "n32")
3314 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003315 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
3316 "-v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003317 }
3318public:
3319 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3320 // Default ABI is n64.
3321 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003322 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3323 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003324 }
3325 virtual void getTargetDefines(const LangOptions &Opts,
3326 MacroBuilder &Builder) const {
3327 DefineStd(Builder, "mips", Opts);
3328 Builder.defineMacro("_mips");
3329 DefineStd(Builder, "MIPSEL", Opts);
3330 Builder.defineMacro("_MIPSEL");
3331 Builder.defineMacro("__REGISTER_PREFIX__", "");
3332 getArchDefines(Opts, Builder);
3333 }
3334};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003335} // end anonymous namespace.
3336
Ivan Krasinef05abd2011-08-24 20:22:22 +00003337namespace {
3338class PNaClTargetInfo : public TargetInfo {
3339public:
3340 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
3341 this->UserLabelPrefix = "";
3342 this->LongAlign = 32;
3343 this->LongWidth = 32;
3344 this->PointerAlign = 32;
3345 this->PointerWidth = 32;
3346 this->IntMaxType = TargetInfo::SignedLongLong;
3347 this->UIntMaxType = TargetInfo::UnsignedLongLong;
3348 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003349 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003350 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003351 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003352 this->SizeType = TargetInfo::UnsignedInt;
3353 this->PtrDiffType = TargetInfo::SignedInt;
3354 this->IntPtrType = TargetInfo::SignedInt;
David Meyerdd4a8892011-10-11 03:12:01 +00003355 this->RegParmMax = 2;
Ivan Krasinef05abd2011-08-24 20:22:22 +00003356 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
3357 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
3358 }
3359
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003360 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00003361 }
3362 virtual void getArchDefines(const LangOptions &Opts,
3363 MacroBuilder &Builder) const {
3364 Builder.defineMacro("__le32__");
3365 Builder.defineMacro("__pnacl__");
3366 }
3367 virtual void getTargetDefines(const LangOptions &Opts,
3368 MacroBuilder &Builder) const {
Ivan Krasin089ee112011-08-25 23:49:20 +00003369 DefineStd(Builder, "unix", Opts);
3370 Builder.defineMacro("__ELF__");
3371 if (Opts.POSIXThreads)
3372 Builder.defineMacro("_REENTRANT");
3373 if (Opts.CPlusPlus)
3374 Builder.defineMacro("_GNU_SOURCE");
3375
Ivan Krasinef05abd2011-08-24 20:22:22 +00003376 Builder.defineMacro("__native_client__");
3377 getArchDefines(Opts, Builder);
3378 }
3379 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3380 unsigned &NumRecords) const {
3381 }
3382 virtual const char *getVAListDeclaration() const {
Ivan Krasin68018db2011-09-20 14:56:54 +00003383 return "typedef int __builtin_va_list[4];";
Ivan Krasinef05abd2011-08-24 20:22:22 +00003384 }
3385 virtual void getGCCRegNames(const char * const *&Names,
3386 unsigned &NumNames) const;
3387 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3388 unsigned &NumAliases) const;
3389 virtual bool validateAsmConstraint(const char *&Name,
3390 TargetInfo::ConstraintInfo &Info) const {
3391 return false;
3392 }
3393
3394 virtual const char *getClobbers() const {
3395 return "";
3396 }
3397};
3398
3399void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
3400 unsigned &NumNames) const {
3401 Names = NULL;
3402 NumNames = 0;
3403}
3404
3405void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3406 unsigned &NumAliases) const {
3407 Aliases = NULL;
3408 NumAliases = 0;
3409}
3410} // end anonymous namespace.
3411
3412
Reid Spencer5f016e22007-07-11 17:01:13 +00003413//===----------------------------------------------------------------------===//
3414// Driver code
3415//===----------------------------------------------------------------------===//
3416
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003417static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003418 llvm::Triple Triple(T);
3419 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00003420
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003421 switch (Triple.getArch()) {
3422 default:
3423 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00003424
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003425 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00003426 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003427 if (Triple.isOSDarwin())
3428 return new DarwinARMTargetInfo(T);
3429
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003430 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00003431 case llvm::Triple::Linux:
3432 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003433 case llvm::Triple::FreeBSD:
Torok Edwin5f6c1942009-06-30 17:10:35 +00003434 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003435 case llvm::Triple::NetBSD:
3436 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003437 case llvm::Triple::RTEMS:
3438 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003439 default:
3440 return new ARMTargetInfo(T);
3441 }
Eli Friedman61538a72008-05-20 14:21:01 +00003442
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003443 case llvm::Triple::msp430:
3444 return new MSP430TargetInfo(T);
Eli Friedman61538a72008-05-20 14:21:01 +00003445
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003446 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003447 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003448 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003449 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003450 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003451 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003452 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003453 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003454 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003455 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003456 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003457 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003458 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003459
3460 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003461 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003462 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003463 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003464 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003465 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003466 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003467 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003468 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003469 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003470 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003471 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003472 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003473
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003474 case llvm::Triple::mips64:
3475 switch (os) {
3476 case llvm::Triple::Linux:
3477 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
3478 case llvm::Triple::RTEMS:
3479 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
3480 case llvm::Triple::FreeBSD:
3481 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
3482 case llvm::Triple::NetBSD:
3483 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
3484 default:
3485 return new Mips64EBTargetInfo(T);
3486 }
3487
3488 case llvm::Triple::mips64el:
3489 switch (os) {
3490 case llvm::Triple::Linux:
3491 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
3492 case llvm::Triple::RTEMS:
3493 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
3494 case llvm::Triple::FreeBSD:
3495 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
3496 case llvm::Triple::NetBSD:
3497 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
3498 default:
3499 return new Mips64ELTargetInfo(T);
3500 }
3501
Ivan Krasinef05abd2011-08-24 20:22:22 +00003502 case llvm::Triple::le32:
3503 switch (os) {
3504 case llvm::Triple::NativeClient:
3505 return new PNaClTargetInfo(T);
3506 default:
3507 return NULL;
3508 }
3509
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003510 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003511 if (Triple.isOSDarwin())
Roman Divackyc81f2a22011-01-06 08:27:10 +00003512 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003513 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003514 case llvm::Triple::Linux:
3515 return new LinuxTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003516 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00003517 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003518 case llvm::Triple::NetBSD:
3519 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
3520 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003521 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003522 default:
3523 return new PPC32TargetInfo(T);
3524 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003525
3526 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003527 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00003528 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003529 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003530 case llvm::Triple::Linux:
3531 return new LinuxTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003532 case llvm::Triple::Lv2:
John Thompson3f6918a2009-11-19 17:18:50 +00003533 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003534 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00003535 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003536 case llvm::Triple::NetBSD:
3537 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
3538 default:
3539 return new PPC64TargetInfo(T);
3540 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003541
Justin Holewinski285dc652011-04-20 19:34:15 +00003542 case llvm::Triple::ptx32:
3543 return new PTX32TargetInfo(T);
3544 case llvm::Triple::ptx64:
3545 return new PTX64TargetInfo(T);
3546
Chris Lattner9cbeb632010-03-06 21:21:27 +00003547 case llvm::Triple::mblaze:
3548 return new MBlazeTargetInfo(T);
3549
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003550 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003551 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003552 case llvm::Triple::Linux:
3553 return new LinuxTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003554 case llvm::Triple::AuroraUX:
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003555 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003556 case llvm::Triple::Solaris:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003557 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003558 case llvm::Triple::NetBSD:
3559 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
3560 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003561 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003562 default:
3563 return new SparcV8TargetInfo(T);
3564 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003565
John Thompson3f6918a2009-11-19 17:18:50 +00003566 // FIXME: Need a real SPU target.
3567 case llvm::Triple::cellspu:
3568 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
3569
Eli Friedmanb63decf2009-08-19 20:47:07 +00003570 case llvm::Triple::tce:
3571 return new TCETargetInfo(T);
3572
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003573 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003574 if (Triple.isOSDarwin())
3575 return new DarwinI386TargetInfo(T);
3576
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003577 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003578 case llvm::Triple::AuroraUX:
3579 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003580 case llvm::Triple::Linux:
3581 return new LinuxTargetInfo<X86_32TargetInfo>(T);
3582 case llvm::Triple::DragonFly:
3583 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
3584 case llvm::Triple::NetBSD:
3585 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
3586 case llvm::Triple::OpenBSD:
3587 return new OpenBSDI386TargetInfo(T);
3588 case llvm::Triple::FreeBSD:
3589 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner38e317d2010-07-07 16:01:42 +00003590 case llvm::Triple::Minix:
3591 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003592 case llvm::Triple::Solaris:
3593 return new SolarisTargetInfo<X86_32TargetInfo>(T);
3594 case llvm::Triple::Cygwin:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003595 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003596 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003597 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003598 case llvm::Triple::Win32:
Michael J. Spencera764e832010-10-21 08:22:51 +00003599 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattner86ed3a32010-04-11 19:29:39 +00003600 case llvm::Triple::Haiku:
3601 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003602 case llvm::Triple::RTEMS:
3603 return new RTEMSX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003604 default:
3605 return new X86_32TargetInfo(T);
3606 }
3607
3608 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003609 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
3610 return new DarwinX86_64TargetInfo(T);
3611
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003612 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003613 case llvm::Triple::AuroraUX:
3614 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003615 case llvm::Triple::Linux:
3616 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner7a7ca282010-01-09 05:41:14 +00003617 case llvm::Triple::DragonFly:
3618 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003619 case llvm::Triple::NetBSD:
3620 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
3621 case llvm::Triple::OpenBSD:
3622 return new OpenBSDX86_64TargetInfo(T);
3623 case llvm::Triple::FreeBSD:
3624 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
3625 case llvm::Triple::Solaris:
3626 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00003627 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003628 return new MinGWX86_64TargetInfo(T);
3629 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003630 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003631 default:
3632 return new X86_64TargetInfo(T);
3633 }
3634 }
Reid Spencer5f016e22007-07-11 17:01:13 +00003635}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003636
3637/// CreateTargetInfo - Return the target info object for the specified target
3638/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00003639TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003640 TargetOptions &Opts) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003641 llvm::Triple Triple(Opts.Triple);
3642
3643 // Construct the target
3644 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
3645 if (!Target) {
3646 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
3647 return 0;
3648 }
3649
Daniel Dunbareac7c532009-12-18 18:42:37 +00003650 // Set the target CPU if specified.
3651 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
3652 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
3653 return 0;
3654 }
3655
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003656 // Set the target ABI if specified.
3657 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
3658 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
3659 return 0;
3660 }
3661
Charles Davis98b7c5c2010-06-11 01:06:47 +00003662 // Set the target C++ ABI.
John McCallee79a4c2010-08-21 22:46:04 +00003663 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davis98b7c5c2010-06-11 01:06:47 +00003664 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
3665 return 0;
3666 }
3667
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003668 // Compute the default target features, we need the target to handle this
3669 // because features may have dependencies on one another.
3670 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003671 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003672
3673 // Apply the user specified deltas.
3674 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
3675 ie = Opts.Features.end(); it != ie; ++it) {
3676 const char *Name = it->c_str();
3677
3678 // Apply the feature via the target.
3679 if ((Name[0] != '-' && Name[0] != '+') ||
3680 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
3681 Diags.Report(diag::err_target_invalid_feature) << Name;
3682 return 0;
3683 }
3684 }
3685
3686 // Add the features to the compile options.
3687 //
3688 // FIXME: If we are completely confident that we have the right set, we only
3689 // need to pass the minuses.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003690 Opts.Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003691 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
3692 ie = Features.end(); it != ie; ++it)
Chris Lattner1e5f83b2011-07-14 18:24:21 +00003693 Opts.Features.push_back(std::string(it->second ? "+" : "-") +
Chris Lattner48b78bd2011-07-14 18:45:41 +00003694 it->first().str());
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003695 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003696
3697 return Target.take();
3698}