blob: 34ae1d3b16ca1dc5f62f7cfa6b0d28e74dbe2ca3 [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", "");
John McCallf85e1932011-06-15 23:02:42 +0000102 }
Eric Christopher7c9adf92011-07-07 22:55:26 +0000103
Eli Friedman2de4fee2009-06-04 23:00:29 +0000104 if (Opts.Static)
Benjamin Kramera9992772010-01-09 17:55:51 +0000105 Builder.defineMacro("__STATIC__");
Eli Friedman2de4fee2009-06-04 23:00:29 +0000106 else
Benjamin Kramera9992772010-01-09 17:55:51 +0000107 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000108
109 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000110 Builder.defineMacro("_REENTRANT");
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000111
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000112 // Get the platform type and version number from the triple.
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000113 unsigned Maj, Min, Rev;
Mike Stump1eb44332009-09-09 15:08:12 +0000114
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000115 // If no version was given, default to to 10.4.0, for simplifying tests.
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000116 if (Triple.getOSName() == "darwin" || Triple.getOSName() == "osx") {
117 PlatformName = "macosx";
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000118 Min = Rev = 0;
119 Maj = 8;
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000120 } else {
121 // Otherwise, honor all three triple forms ("-darwinNNN[-iphoneos]",
122 // "-osxNNN", and "-iosNNN").
123
124 if (Triple.getOS() == llvm::Triple::Darwin) {
125 // For historical reasons that make little sense, the version passed here
126 // is the "darwin" version, which drops the 10 and offsets by 4.
127 Triple.getOSVersion(Maj, Min, Rev);
128
129 if (Triple.getEnvironmentName() == "iphoneos") {
130 PlatformName = "ios";
131 } else {
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000132 PlatformName = "macosx";
133 Rev = Min;
134 Min = Maj - 4;
135 Maj = 10;
136 }
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000137 } else {
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000138 Triple.getOSVersion(Maj, Min, Rev);
Daniel Dunbara4ff6482011-04-19 23:34:21 +0000139 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000140 }
141 }
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000142
Chad Rosierd9259f32011-07-19 20:00:06 +0000143 // If -ccc-host-triple arch-pc-win32-macho option specified, we're
Eric Christopher895d4222011-07-29 21:20:35 +0000144 // generating code for Win32 ABI. No need to emit
Chad Rosierd9259f32011-07-19 20:00:06 +0000145 // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
146 if (PlatformName == "win32") {
147 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
148 return;
149 }
150
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000151 // Set the appropriate OS version define.
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000152 if (PlatformName == "ios") {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000153 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000154 char Str[6];
155 Str[0] = '0' + Maj;
156 Str[1] = '0' + (Min / 10);
157 Str[2] = '0' + (Min % 10);
158 Str[3] = '0' + (Rev / 10);
159 Str[4] = '0' + (Rev % 10);
160 Str[5] = '\0';
161 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
162 } else {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000163 // Note that the Driver allows versions which aren't representable in the
164 // define (because we only get a single digit for the minor and micro
165 // revision numbers). So, we limit them to the maximum representable
166 // version.
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000167 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000168 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000169 char Str[5];
170 Str[0] = '0' + (Maj / 10);
171 Str[1] = '0' + (Maj % 10);
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000172 Str[2] = '0' + std::min(Min, 9U);
173 Str[3] = '0' + std::min(Rev, 9U);
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000174 Str[4] = '\0';
175 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000176 }
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000177
178 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman618234a2008-08-20 02:34:37 +0000179}
Reid Spencer5f016e22007-07-11 17:01:13 +0000180
Chris Lattner797c3c42009-08-10 19:03:04 +0000181namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000182template<typename Target>
183class DarwinTargetInfo : public OSTargetInfo<Target> {
184protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000185 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000186 MacroBuilder &Builder) const {
Eric Christopher7c9adf92011-07-07 22:55:26 +0000187 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000188 this->PlatformMinVersion);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000189 }
Mike Stump1eb44332009-09-09 15:08:12 +0000190
Torok Edwin5f6c1942009-06-30 17:10:35 +0000191public:
192 DarwinTargetInfo(const std::string& triple) :
193 OSTargetInfo<Target>(triple) {
Eric Christopheraa7333c2011-07-02 00:20:22 +0000194 llvm::Triple T = llvm::Triple(triple);
195 this->TLSSupported = T.isMacOSX() && !T.isMacOSXVersionLT(10,7);
Daniel Dunbare177d3b2011-02-21 23:12:51 +0000196 this->MCountName = "\01mcount";
Torok Edwin5f6c1942009-06-30 17:10:35 +0000197 }
198
Chris Lattner5f9e2722011-07-23 10:55:15 +0000199 virtual std::string isValidSectionSpecifier(StringRef SR) const {
Chris Lattner797c3c42009-08-10 19:03:04 +0000200 // Let MCSectionMachO validate this.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000201 StringRef Segment, Section;
Chris Lattner797c3c42009-08-10 19:03:04 +0000202 unsigned TAA, StubSize;
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000203 bool HasTAA;
Chris Lattner797c3c42009-08-10 19:03:04 +0000204 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000205 TAA, HasTAA, StubSize);
Chris Lattner797c3c42009-08-10 19:03:04 +0000206 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000207
Anders Carlsson18af3682010-06-08 22:47:50 +0000208 virtual const char *getStaticInitSectionSpecifier() const {
209 // FIXME: We should return 0 when building kexts.
210 return "__TEXT,__StaticInit,regular,pure_instructions";
211 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000212
Torok Edwin5f6c1942009-06-30 17:10:35 +0000213};
214
Chris Lattner797c3c42009-08-10 19:03:04 +0000215
Torok Edwin5f6c1942009-06-30 17:10:35 +0000216// DragonFlyBSD Target
217template<typename Target>
218class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
219protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000220 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000221 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000222 // DragonFly defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000223 Builder.defineMacro("__DragonFly__");
224 Builder.defineMacro("__DragonFly_cc_version", "100001");
225 Builder.defineMacro("__ELF__");
226 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
227 Builder.defineMacro("__tune_i386__");
228 DefineStd(Builder, "unix", Opts);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000229 }
230public:
Mike Stump1eb44332009-09-09 15:08:12 +0000231 DragonFlyBSDTargetInfo(const std::string &triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000232 : OSTargetInfo<Target>(triple) {}
233};
234
235// FreeBSD Target
236template<typename Target>
237class FreeBSDTargetInfo : public OSTargetInfo<Target> {
238protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000239 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000240 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000241 // FreeBSD defines; list based off of gcc output
242
Benjamin Kramer474202f2011-10-18 10:10:08 +0000243 unsigned Release = Triple.getOSMajorVersion();
244 if (Release == 0U)
245 Release = 8;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000246
Benjamin Kramer474202f2011-10-18 10:10:08 +0000247 Builder.defineMacro("__FreeBSD__", Twine(Release));
248 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramera9992772010-01-09 17:55:51 +0000249 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
250 DefineStd(Builder, "unix", Opts);
251 Builder.defineMacro("__ELF__");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000252 }
253public:
Mike Stump1eb44332009-09-09 15:08:12 +0000254 FreeBSDTargetInfo(const std::string &triple)
Duncan Sands1e90faf2009-07-08 13:55:08 +0000255 : OSTargetInfo<Target>(triple) {
256 this->UserLabelPrefix = "";
Roman Divackybe4c8702011-02-10 16:52:03 +0000257
258 llvm::Triple Triple(triple);
259 switch (Triple.getArch()) {
260 default:
261 case llvm::Triple::x86:
262 case llvm::Triple::x86_64:
263 this->MCountName = ".mcount";
264 break;
265 case llvm::Triple::mips:
266 case llvm::Triple::mipsel:
267 case llvm::Triple::ppc:
268 case llvm::Triple::ppc64:
269 this->MCountName = "_mcount";
270 break;
271 case llvm::Triple::arm:
272 this->MCountName = "__mcount";
273 break;
274 }
275
Duncan Sands1e90faf2009-07-08 13:55:08 +0000276 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000277};
278
Chris Lattner38e317d2010-07-07 16:01:42 +0000279// Minix Target
280template<typename Target>
281class MinixTargetInfo : public OSTargetInfo<Target> {
282protected:
283 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
284 MacroBuilder &Builder) const {
285 // Minix defines
286
287 Builder.defineMacro("__minix", "3");
288 Builder.defineMacro("_EM_WSIZE", "4");
289 Builder.defineMacro("_EM_PSIZE", "4");
290 Builder.defineMacro("_EM_SSIZE", "2");
291 Builder.defineMacro("_EM_LSIZE", "4");
292 Builder.defineMacro("_EM_FSIZE", "4");
293 Builder.defineMacro("_EM_DSIZE", "8");
Eli Friedman6d402dc2011-12-08 23:54:21 +0000294 Builder.defineMacro("__ELF__");
Chris Lattner38e317d2010-07-07 16:01:42 +0000295 DefineStd(Builder, "unix", Opts);
296 }
297public:
298 MinixTargetInfo(const std::string &triple)
299 : OSTargetInfo<Target>(triple) {
300 this->UserLabelPrefix = "";
301 }
302};
303
Torok Edwin5f6c1942009-06-30 17:10:35 +0000304// Linux target
305template<typename Target>
306class LinuxTargetInfo : public OSTargetInfo<Target> {
307protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000308 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000309 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000310 // Linux defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000311 DefineStd(Builder, "unix", Opts);
312 DefineStd(Builder, "linux", Opts);
313 Builder.defineMacro("__gnu_linux__");
314 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000315 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000316 Builder.defineMacro("_REENTRANT");
Douglas Gregor2b003fd2010-04-21 05:52:38 +0000317 if (Opts.CPlusPlus)
318 Builder.defineMacro("_GNU_SOURCE");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000319 }
320public:
Mike Stump1eb44332009-09-09 15:08:12 +0000321 LinuxTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000322 : OSTargetInfo<Target>(triple) {
323 this->UserLabelPrefix = "";
Douglas Gregor12e84642011-01-12 21:19:25 +0000324 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000325 }
Benjamin Kramer86d18c52011-10-15 17:53:33 +0000326
327 virtual const char *getStaticInitSectionSpecifier() const {
328 return ".text.startup";
329 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000330};
331
Chris Lattnerb62bb282009-07-13 20:29:08 +0000332// NetBSD Target
333template<typename Target>
334class NetBSDTargetInfo : public OSTargetInfo<Target> {
335protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000336 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000337 MacroBuilder &Builder) const {
Chris Lattnerb62bb282009-07-13 20:29:08 +0000338 // NetBSD defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000339 Builder.defineMacro("__NetBSD__");
340 Builder.defineMacro("__unix__");
341 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000342 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000343 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerb62bb282009-07-13 20:29:08 +0000344 }
345public:
Mike Stump1eb44332009-09-09 15:08:12 +0000346 NetBSDTargetInfo(const std::string &triple)
Chris Lattnerb62bb282009-07-13 20:29:08 +0000347 : OSTargetInfo<Target>(triple) {
348 this->UserLabelPrefix = "";
349 }
350};
351
Torok Edwin5f6c1942009-06-30 17:10:35 +0000352// OpenBSD Target
353template<typename Target>
354class OpenBSDTargetInfo : public OSTargetInfo<Target> {
355protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000356 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000357 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000358 // OpenBSD defines; list based off of gcc output
359
Benjamin Kramera9992772010-01-09 17:55:51 +0000360 Builder.defineMacro("__OpenBSD__");
361 DefineStd(Builder, "unix", Opts);
362 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000363 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000364 Builder.defineMacro("_POSIX_THREADS");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000365 }
366public:
Mike Stump1eb44332009-09-09 15:08:12 +0000367 OpenBSDTargetInfo(const std::string &triple)
Eli Friedman62d829a2011-12-15 02:15:56 +0000368 : OSTargetInfo<Target>(triple) {
369 this->UserLabelPrefix = "";
370
371 llvm::Triple Triple(triple);
372 switch (Triple.getArch()) {
373 default:
374 case llvm::Triple::x86:
375 case llvm::Triple::x86_64:
376 case llvm::Triple::arm:
377 case llvm::Triple::sparc:
378 this->MCountName = "__mcount";
379 break;
380 case llvm::Triple::mips64:
381 case llvm::Triple::mips64el:
382 case llvm::Triple::ppc:
383 case llvm::Triple::sparcv9:
384 this->MCountName = "_mcount";
385 break;
386 }
387 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000388};
389
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000390// PSP Target
391template<typename Target>
392class PSPTargetInfo : public OSTargetInfo<Target> {
393protected:
394 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000395 MacroBuilder &Builder) const {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000396 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramera9992772010-01-09 17:55:51 +0000397 Builder.defineMacro("PSP");
398 Builder.defineMacro("_PSP");
399 Builder.defineMacro("__psp__");
400 Builder.defineMacro("__ELF__");
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000401 }
402public:
403 PSPTargetInfo(const std::string& triple)
404 : OSTargetInfo<Target>(triple) {
405 this->UserLabelPrefix = "";
406 }
407};
408
John Thompson3f6918a2009-11-19 17:18:50 +0000409// PS3 PPU Target
410template<typename Target>
411class PS3PPUTargetInfo : public OSTargetInfo<Target> {
412protected:
413 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000414 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000415 // PS3 PPU defines.
John Thompsonfb457972010-03-25 16:18:32 +0000416 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000417 Builder.defineMacro("__PPU__");
418 Builder.defineMacro("__CELLOS_LV2__");
419 Builder.defineMacro("__ELF__");
420 Builder.defineMacro("__LP32__");
John Thompson8e6065a2010-06-24 22:44:13 +0000421 Builder.defineMacro("_ARCH_PPC64");
422 Builder.defineMacro("__powerpc64__");
John Thompson3f6918a2009-11-19 17:18:50 +0000423 }
424public:
425 PS3PPUTargetInfo(const std::string& triple)
426 : OSTargetInfo<Target>(triple) {
427 this->UserLabelPrefix = "";
Nick Lewycky99520702011-12-16 22:32:39 +0000428 this->LongWidth = this->LongAlign = 32;
429 this->PointerWidth = this->PointerAlign = 32;
John Thompson8e6065a2010-06-24 22:44:13 +0000430 this->IntMaxType = TargetInfo::SignedLongLong;
431 this->UIntMaxType = TargetInfo::UnsignedLongLong;
432 this->Int64Type = TargetInfo::SignedLongLong;
John Thompsonec387af2009-12-18 14:21:08 +0000433 this->SizeType = TargetInfo::UnsignedInt;
John Thompson8e6065a2010-06-24 22:44:13 +0000434 this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Nick Lewycky99520702011-12-16 22:32:39 +0000435 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompson3f6918a2009-11-19 17:18:50 +0000436 }
437};
438
439// FIXME: Need a real SPU target.
440// PS3 SPU Target
441template<typename Target>
442class PS3SPUTargetInfo : public OSTargetInfo<Target> {
443protected:
444 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000445 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000446 // PS3 PPU defines.
Benjamin Kramera9992772010-01-09 17:55:51 +0000447 Builder.defineMacro("__SPU__");
448 Builder.defineMacro("__ELF__");
John Thompson3f6918a2009-11-19 17:18:50 +0000449 }
450public:
451 PS3SPUTargetInfo(const std::string& triple)
452 : OSTargetInfo<Target>(triple) {
453 this->UserLabelPrefix = "";
454 }
455};
456
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000457// AuroraUX target
458template<typename Target>
459class AuroraUXTargetInfo : public OSTargetInfo<Target> {
460protected:
461 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000462 MacroBuilder &Builder) const {
463 DefineStd(Builder, "sun", Opts);
464 DefineStd(Builder, "unix", Opts);
465 Builder.defineMacro("__ELF__");
466 Builder.defineMacro("__svr4__");
467 Builder.defineMacro("__SVR4");
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000468 }
469public:
470 AuroraUXTargetInfo(const std::string& triple)
471 : OSTargetInfo<Target>(triple) {
472 this->UserLabelPrefix = "";
473 this->WCharType = this->SignedLong;
474 // FIXME: WIntType should be SignedLong
475 }
476};
477
Torok Edwin5f6c1942009-06-30 17:10:35 +0000478// Solaris target
479template<typename Target>
480class SolarisTargetInfo : public OSTargetInfo<Target> {
481protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000482 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000483 MacroBuilder &Builder) const {
484 DefineStd(Builder, "sun", Opts);
485 DefineStd(Builder, "unix", Opts);
486 Builder.defineMacro("__ELF__");
487 Builder.defineMacro("__svr4__");
488 Builder.defineMacro("__SVR4");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000489 }
490public:
Mike Stump1eb44332009-09-09 15:08:12 +0000491 SolarisTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000492 : OSTargetInfo<Target>(triple) {
493 this->UserLabelPrefix = "";
494 this->WCharType = this->SignedLong;
495 // FIXME: WIntType should be SignedLong
496 }
497};
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000498
499// Windows target
500template<typename Target>
501class WindowsTargetInfo : public OSTargetInfo<Target> {
502protected:
503 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
504 MacroBuilder &Builder) const {
Michael J. Spencera764e832010-10-21 08:22:51 +0000505 Builder.defineMacro("_WIN32");
506 }
507 void getVisualStudioDefines(const LangOptions &Opts,
508 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000509 if (Opts.CPlusPlus) {
510 if (Opts.RTTI)
511 Builder.defineMacro("_CPPRTTI");
512
513 if (Opts.Exceptions)
514 Builder.defineMacro("_CPPUNWIND");
515 }
516
517 if (!Opts.CharIsSigned)
518 Builder.defineMacro("_CHAR_UNSIGNED");
519
520 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
521 // but it works for now.
522 if (Opts.POSIXThreads)
523 Builder.defineMacro("_MT");
Michael J. Spencera764e832010-10-21 08:22:51 +0000524
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000525 if (Opts.MSCVersion != 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000526 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000527
Francois Pichet62ec1f22011-09-17 17:15:52 +0000528 if (Opts.MicrosoftExt) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000529 Builder.defineMacro("_MSC_EXTENSIONS");
530
531 if (Opts.CPlusPlus0x) {
532 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
533 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
534 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
535 }
536 }
537
538 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000539 }
540
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000541public:
542 WindowsTargetInfo(const std::string &triple)
543 : OSTargetInfo<Target>(triple) {}
544};
545
Mike Stump1eb44332009-09-09 15:08:12 +0000546} // end anonymous namespace.
Torok Edwin5f6c1942009-06-30 17:10:35 +0000547
Chris Lattnerd29b6302008-10-05 21:50:58 +0000548//===----------------------------------------------------------------------===//
Eli Friedmane4277982008-08-20 23:11:40 +0000549// Specific target implementations.
550//===----------------------------------------------------------------------===//
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +0000551
Eli Friedmane4277982008-08-20 23:11:40 +0000552namespace {
553// PPC abstract base class
554class PPCTargetInfo : public TargetInfo {
555 static const Builtin::Info BuiltinInfo[];
556 static const char * const GCCRegNames[];
557 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Eli Friedmane4277982008-08-20 23:11:40 +0000558public:
Eli Friedman15b91762009-06-05 07:05:05 +0000559 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
560
Eli Friedmane4277982008-08-20 23:11:40 +0000561 virtual void getTargetBuiltins(const Builtin::Info *&Records,
562 unsigned &NumRecords) const {
Reid Spencer5f016e22007-07-11 17:01:13 +0000563 Records = BuiltinInfo;
Eli Friedmane4277982008-08-20 23:11:40 +0000564 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +0000565 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000566
Chris Lattner33328642009-03-20 15:52:06 +0000567 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000568 MacroBuilder &Builder) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000569
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000570 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000571 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000572 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000573 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000574 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +0000575 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000576 switch (*Name) {
Anders Carlssond04c6e22007-11-27 04:11:28 +0000577 default: return false;
578 case 'O': // Zero
John Thompson8e6065a2010-06-24 22:44:13 +0000579 break;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000580 case 'b': // Base register
581 case 'f': // Floating point register
Chris Lattner44def072009-04-26 07:16:29 +0000582 Info.setAllowsRegister();
John Thompson8e6065a2010-06-24 22:44:13 +0000583 break;
584 // FIXME: The following are added to allow parsing.
585 // I just took a guess at what the actions should be.
586 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer20249a12010-10-21 03:16:25 +0000587 case 'd': // Floating point register (containing 64-bit value)
John Thompson8e6065a2010-06-24 22:44:13 +0000588 case 'v': // Altivec vector register
589 Info.setAllowsRegister();
590 break;
591 case 'w':
592 switch (Name[1]) {
Michael J. Spencer20249a12010-10-21 03:16:25 +0000593 case 'd':// VSX vector register to hold vector double data
594 case 'f':// VSX vector register to hold vector float data
595 case 's':// VSX vector register to hold scalar float data
596 case 'a':// Any VSX register
John Thompson8e6065a2010-06-24 22:44:13 +0000597 break;
598 default:
599 return false;
600 }
601 Info.setAllowsRegister();
602 Name++; // Skip over 'w'.
603 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000604 case 'h': // `MQ', `CTR', or `LINK' register
605 case 'q': // `MQ' register
606 case 'c': // `CTR' register
607 case 'l': // `LINK' register
608 case 'x': // `CR' register (condition register) number 0
609 case 'y': // `CR' register (condition register)
610 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson8e6065a2010-06-24 22:44:13 +0000611 Info.setAllowsRegister();
612 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000613 case 'I': // Signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000614 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer20249a12010-10-21 03:16:25 +0000615 // (use `L' instead for SImode constants)
616 case 'K': // Unsigned 16-bit constant
617 case 'L': // Signed 16-bit constant shifted left 16 bits
618 case 'M': // Constant larger than 31
619 case 'N': // Exact power of 2
620 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000621 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000622 // register with one instruction per word
John Thompson8e6065a2010-06-24 22:44:13 +0000623 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer20249a12010-10-21 03:16:25 +0000624 // into a register using three instructions
John Thompson8e6065a2010-06-24 22:44:13 +0000625 break;
626 case 'm': // Memory operand. Note that on PowerPC targets, m can
627 // include addresses that update the base register. It
628 // is therefore only safe to use `m' in an asm statement
629 // if that asm statement accesses the operand exactly once.
630 // The asm statement must also use `%U<opno>' as a
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000631 // placeholder for the "update" flag in the corresponding
Michael J. Spencer20249a12010-10-21 03:16:25 +0000632 // load or store instruction. For example:
John Thompson8e6065a2010-06-24 22:44:13 +0000633 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000634 // is correct but:
John Thompson8e6065a2010-06-24 22:44:13 +0000635 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
636 // is not. Use es rather than m if you don't want the base
Michael J. Spencer20249a12010-10-21 03:16:25 +0000637 // register to be updated.
638 case 'e':
John Thompson56b6eca2010-06-25 00:02:05 +0000639 if (Name[1] != 's')
640 return false;
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000641 // es: A "stable" memory operand; that is, one which does not
John Thompson8e6065a2010-06-24 22:44:13 +0000642 // include any automodification of the base register. Unlike
643 // `m', this constraint can be used in asm statements that
644 // might access the operand several times, or that might not
John Thompson56b6eca2010-06-25 00:02:05 +0000645 // access it at all.
John Thompson8e6065a2010-06-24 22:44:13 +0000646 Info.setAllowsMemory();
John Thompson56b6eca2010-06-25 00:02:05 +0000647 Name++; // Skip over 'e'.
John Thompson8e6065a2010-06-24 22:44:13 +0000648 break;
649 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer20249a12010-10-21 03:16:25 +0000650 // usually better to use `m' or `es' in asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000651 case 'Z': // Memory operand that is an indexed or indirect from a
652 // register (it is usually better to use `m' or `es' in
Michael J. Spencer20249a12010-10-21 03:16:25 +0000653 // asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000654 Info.setAllowsMemory();
655 Info.setAllowsRegister();
656 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000657 case 'R': // AIX TOC entry
John Thompson8e6065a2010-06-24 22:44:13 +0000658 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000659 // register (`p' is preferable for asm statements)
660 case 'S': // Constant suitable as a 64-bit mask operand
661 case 'T': // Constant suitable as a 32-bit mask operand
662 case 'U': // System V Release 4 small data area reference
John Thompson8e6065a2010-06-24 22:44:13 +0000663 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000664 // instructions
665 case 'W': // Vector constant that does not require memory
666 case 'j': // Vector constant that is all zeros.
John Thompson8e6065a2010-06-24 22:44:13 +0000667 break;
668 // End FIXME.
Anders Carlssond04c6e22007-11-27 04:11:28 +0000669 }
John Thompson8e6065a2010-06-24 22:44:13 +0000670 return true;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000671 }
Eli Friedmane4277982008-08-20 23:11:40 +0000672 virtual const char *getClobbers() const {
673 return "";
Anders Carlssond04c6e22007-11-27 04:11:28 +0000674 }
Eli Friedmane4277982008-08-20 23:11:40 +0000675};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000676
Eli Friedmane4277982008-08-20 23:11:40 +0000677const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000678#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000679#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000680 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000681#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000682};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000683
684
Chris Lattnerc0f59212009-03-02 22:27:17 +0000685/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
686/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000687void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000688 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000689 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000690 Builder.defineMacro("__ppc__");
691 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000692 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000693 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000694 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000695 Builder.defineMacro("_ARCH_PPC64");
696 Builder.defineMacro("_LP64");
697 Builder.defineMacro("__LP64__");
Chris Lattnere03ae302010-02-16 18:14:57 +0000698 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000699 Builder.defineMacro("__ppc64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000700 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +0000701 Builder.defineMacro("__ppc__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000702 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000703
Chris Lattnerc0f59212009-03-02 22:27:17 +0000704 // Target properties.
Joerg Sonnenberger7cd1de52011-07-05 14:56:12 +0000705 if (getTriple().getOS() != llvm::Triple::NetBSD)
706 Builder.defineMacro("_BIG_ENDIAN");
Benjamin Kramera9992772010-01-09 17:55:51 +0000707 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000708
Chris Lattnerc0f59212009-03-02 22:27:17 +0000709 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000710 Builder.defineMacro("__NATURAL_ALIGNMENT__");
711 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000712
Chris Lattnerc0f59212009-03-02 22:27:17 +0000713 // FIXME: Should be controlled by command line option.
Benjamin Kramera9992772010-01-09 17:55:51 +0000714 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000715
John Thompson3f6918a2009-11-19 17:18:50 +0000716 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000717 Builder.defineMacro("__VEC__", "10206");
718 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000719 }
Chris Lattnerc0f59212009-03-02 22:27:17 +0000720}
721
Chris Lattner393ff042008-04-21 18:56:49 +0000722
Eli Friedmane4277982008-08-20 23:11:40 +0000723const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +0000724 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
725 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
726 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
727 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
728 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
729 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
730 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
731 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +0000732 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000733 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +0000734 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000735 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
736 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
737 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
738 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +0000739 "vrsave", "vscr",
740 "spe_acc", "spefscr",
741 "sfp"
742};
Reid Spencer5f016e22007-07-11 17:01:13 +0000743
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000744void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000745 unsigned &NumNames) const {
746 Names = GCCRegNames;
747 NumNames = llvm::array_lengthof(GCCRegNames);
748}
Reid Spencer5f016e22007-07-11 17:01:13 +0000749
Eli Friedmane4277982008-08-20 23:11:40 +0000750const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
751 // While some of these aliases do map to different registers
752 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000753 { { "0" }, "r0" },
754 { { "1"}, "r1" },
755 { { "2" }, "r2" },
756 { { "3" }, "r3" },
757 { { "4" }, "r4" },
758 { { "5" }, "r5" },
759 { { "6" }, "r6" },
760 { { "7" }, "r7" },
761 { { "8" }, "r8" },
762 { { "9" }, "r9" },
763 { { "10" }, "r10" },
764 { { "11" }, "r11" },
765 { { "12" }, "r12" },
766 { { "13" }, "r13" },
767 { { "14" }, "r14" },
768 { { "15" }, "r15" },
769 { { "16" }, "r16" },
770 { { "17" }, "r17" },
771 { { "18" }, "r18" },
772 { { "19" }, "r19" },
773 { { "20" }, "r20" },
774 { { "21" }, "r21" },
775 { { "22" }, "r22" },
776 { { "23" }, "r23" },
777 { { "24" }, "r24" },
778 { { "25" }, "r25" },
779 { { "26" }, "r26" },
780 { { "27" }, "r27" },
781 { { "28" }, "r28" },
782 { { "29" }, "r29" },
783 { { "30" }, "r30" },
784 { { "31" }, "r31" },
785 { { "fr0" }, "f0" },
786 { { "fr1" }, "f1" },
787 { { "fr2" }, "f2" },
788 { { "fr3" }, "f3" },
789 { { "fr4" }, "f4" },
790 { { "fr5" }, "f5" },
791 { { "fr6" }, "f6" },
792 { { "fr7" }, "f7" },
793 { { "fr8" }, "f8" },
794 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +0000795 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000796 { { "fr11" }, "f11" },
797 { { "fr12" }, "f12" },
798 { { "fr13" }, "f13" },
799 { { "fr14" }, "f14" },
800 { { "fr15" }, "f15" },
801 { { "fr16" }, "f16" },
802 { { "fr17" }, "f17" },
803 { { "fr18" }, "f18" },
804 { { "fr19" }, "f19" },
805 { { "fr20" }, "f20" },
806 { { "fr21" }, "f21" },
807 { { "fr22" }, "f22" },
808 { { "fr23" }, "f23" },
809 { { "fr24" }, "f24" },
810 { { "fr25" }, "f25" },
811 { { "fr26" }, "f26" },
812 { { "fr27" }, "f27" },
813 { { "fr28" }, "f28" },
814 { { "fr29" }, "f29" },
815 { { "fr30" }, "f30" },
816 { { "fr31" }, "f31" },
817 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +0000818};
819
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000820void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000821 unsigned &NumAliases) const {
822 Aliases = GCCRegAliases;
823 NumAliases = llvm::array_lengthof(GCCRegAliases);
824}
825} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +0000826
827namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000828class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000829public:
Chris Lattnere03ae302010-02-16 18:14:57 +0000830 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +0000831 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 +0000832 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +0000833
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000834 switch (getTriple().getOS()) {
835 case llvm::Triple::FreeBSD:
836 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000837 SizeType = UnsignedInt;
838 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +0000839 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000840 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000841 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000842 }
843
844 virtual const char *getVAListDeclaration() const {
845 // This is the ELF definition, and is overridden by the Darwin sub-target
846 return "typedef struct __va_list_tag {"
847 " unsigned char gpr;"
848 " unsigned char fpr;"
849 " unsigned short reserved;"
850 " void* overflow_arg_area;"
851 " void* reg_save_area;"
852 "} __builtin_va_list[1];";
Eli Friedmaned855cb2008-08-21 00:13:15 +0000853 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000854};
855} // end anonymous namespace.
856
857namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000858class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000859public:
Eli Friedmane4277982008-08-20 23:11:40 +0000860 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +0000861 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +0000862 IntMaxType = SignedLong;
863 UIntMaxType = UnsignedLong;
864 Int64Type = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +0000865 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 +0000866 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnerf291b102008-05-09 06:17:04 +0000867 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000868 virtual const char *getVAListDeclaration() const {
869 return "typedef char* __builtin_va_list;";
870 }
Eli Friedmane4277982008-08-20 23:11:40 +0000871};
872} // end anonymous namespace.
873
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000874
875namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +0000876class DarwinPPC32TargetInfo :
877 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000878public:
Roman Divackyc81f2a22011-01-06 08:27:10 +0000879 DarwinPPC32TargetInfo(const std::string& triple)
880 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000881 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +0000882 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
883 }
884 virtual const char *getVAListDeclaration() const {
885 return "typedef char* __builtin_va_list;";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000886 }
887};
888
889class DarwinPPC64TargetInfo :
890 public DarwinTargetInfo<PPC64TargetInfo> {
891public:
892 DarwinPPC64TargetInfo(const std::string& triple)
893 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
894 HasAlignMac68kSupport = true;
895 }
896};
897} // end anonymous namespace.
898
Reid Spencer5f016e22007-07-11 17:01:13 +0000899namespace {
Justin Holewinski25bedca2011-10-03 17:28:37 +0000900 static const unsigned PTXAddrSpaceMap[] = {
901 0, // opencl_global
902 4, // opencl_local
903 1 // opencl_constant
904 };
Justin Holewinski285dc652011-04-20 19:34:15 +0000905 class PTXTargetInfo : public TargetInfo {
906 static const char * const GCCRegNames[];
907 static const Builtin::Info BuiltinInfo[];
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000908 std::vector<llvm::StringRef> AvailableFeatures;
Justin Holewinski285dc652011-04-20 19:34:15 +0000909 public:
910 PTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
911 TLSSupported = false;
912 LongWidth = LongAlign = 64;
Justin Holewinski25bedca2011-10-03 17:28:37 +0000913 AddrSpaceMap = &PTXAddrSpaceMap;
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000914 // Define available target features
915 // These must be defined in sorted order!
916 AvailableFeatures.push_back("compute10");
917 AvailableFeatures.push_back("compute11");
918 AvailableFeatures.push_back("compute12");
919 AvailableFeatures.push_back("compute13");
920 AvailableFeatures.push_back("compute20");
921 AvailableFeatures.push_back("double");
922 AvailableFeatures.push_back("no-fma");
923 AvailableFeatures.push_back("ptx20");
924 AvailableFeatures.push_back("ptx21");
925 AvailableFeatures.push_back("ptx22");
926 AvailableFeatures.push_back("ptx23");
927 AvailableFeatures.push_back("sm10");
928 AvailableFeatures.push_back("sm11");
929 AvailableFeatures.push_back("sm12");
930 AvailableFeatures.push_back("sm13");
931 AvailableFeatures.push_back("sm20");
932 AvailableFeatures.push_back("sm21");
933 AvailableFeatures.push_back("sm22");
934 AvailableFeatures.push_back("sm23");
Justin Holewinski285dc652011-04-20 19:34:15 +0000935 }
936 virtual void getTargetDefines(const LangOptions &Opts,
937 MacroBuilder &Builder) const {
938 Builder.defineMacro("__PTX__");
939 }
940 virtual void getTargetBuiltins(const Builtin::Info *&Records,
941 unsigned &NumRecords) const {
942 Records = BuiltinInfo;
943 NumRecords = clang::PTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
944 }
945
946 virtual void getGCCRegNames(const char * const *&Names,
947 unsigned &NumNames) const;
948 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
949 unsigned &NumAliases) const {
950 // No aliases.
951 Aliases = 0;
952 NumAliases = 0;
953 }
954 virtual bool validateAsmConstraint(const char *&Name,
955 TargetInfo::ConstraintInfo &info) const {
956 // FIXME: implement
957 return true;
958 }
959 virtual const char *getClobbers() const {
960 // FIXME: Is this really right?
961 return "";
962 }
963 virtual const char *getVAListDeclaration() const {
964 // FIXME: implement
965 return "typedef char* __builtin_va_list;";
966 }
Justin Holewinski808ef662011-09-15 12:13:38 +0000967
968 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
969 const std::string &Name,
970 bool Enabled) const;
Justin Holewinski285dc652011-04-20 19:34:15 +0000971 };
972
973 const Builtin::Info PTXTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000974#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +0000975#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000976 ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +0000977#include "clang/Basic/BuiltinsPTX.def"
978 };
979
980 const char * const PTXTargetInfo::GCCRegNames[] = {
981 "r0"
982 };
983
984 void PTXTargetInfo::getGCCRegNames(const char * const *&Names,
985 unsigned &NumNames) const {
986 Names = GCCRegNames;
987 NumNames = llvm::array_lengthof(GCCRegNames);
988 }
989
Justin Holewinski808ef662011-09-15 12:13:38 +0000990 bool PTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
991 const std::string &Name,
992 bool Enabled) const {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000993 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
994 Name)) {
995 Features[Name] = Enabled;
996 return true;
Justin Holewinski808ef662011-09-15 12:13:38 +0000997 } else {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000998 return false;
Justin Holewinski808ef662011-09-15 12:13:38 +0000999 }
Justin Holewinski808ef662011-09-15 12:13:38 +00001000 }
Justin Holewinski285dc652011-04-20 19:34:15 +00001001
1002 class PTX32TargetInfo : public PTXTargetInfo {
1003 public:
1004 PTX32TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
1005 PointerWidth = PointerAlign = 32;
1006 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
1007 DescriptionString
1008 = "e-p:32:32-i64:64:64-f64:64:64-n1:8:16:32:64";
1009 }
1010 };
1011
1012 class PTX64TargetInfo : public PTXTargetInfo {
1013 public:
1014 PTX64TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
1015 PointerWidth = PointerAlign = 64;
1016 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
1017 DescriptionString
1018 = "e-p:64:64-i64:64:64-f64:64:64-n1:8:16:32:64";
1019 }
1020 };
1021}
1022
1023namespace {
Chris Lattner9cbeb632010-03-06 21:21:27 +00001024// MBlaze abstract base class
1025class MBlazeTargetInfo : public TargetInfo {
1026 static const char * const GCCRegNames[];
1027 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1028
1029public:
1030 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +00001031 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner9cbeb632010-03-06 21:21:27 +00001032 }
1033
1034 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1035 unsigned &NumRecords) const {
1036 // FIXME: Implement.
1037 Records = 0;
1038 NumRecords = 0;
1039 }
1040
1041 virtual void getTargetDefines(const LangOptions &Opts,
1042 MacroBuilder &Builder) const;
1043
1044 virtual const char *getVAListDeclaration() const {
1045 return "typedef char* __builtin_va_list;";
1046 }
1047 virtual const char *getTargetPrefix() const {
1048 return "mblaze";
1049 }
1050 virtual void getGCCRegNames(const char * const *&Names,
1051 unsigned &NumNames) const;
1052 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1053 unsigned &NumAliases) const;
1054 virtual bool validateAsmConstraint(const char *&Name,
1055 TargetInfo::ConstraintInfo &Info) const {
1056 switch (*Name) {
1057 default: return false;
1058 case 'O': // Zero
1059 return true;
1060 case 'b': // Base register
1061 case 'f': // Floating point register
1062 Info.setAllowsRegister();
1063 return true;
1064 }
1065 }
1066 virtual const char *getClobbers() const {
1067 return "";
1068 }
1069};
1070
1071/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1072/// #defines that are not tied to a specific subtarget.
1073void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1074 MacroBuilder &Builder) const {
1075 // Target identification.
1076 Builder.defineMacro("__microblaze__");
1077 Builder.defineMacro("_ARCH_MICROBLAZE");
1078 Builder.defineMacro("__MICROBLAZE__");
1079
1080 // Target properties.
1081 Builder.defineMacro("_BIG_ENDIAN");
1082 Builder.defineMacro("__BIG_ENDIAN__");
1083
1084 // Subtarget options.
1085 Builder.defineMacro("__REGISTER_PREFIX__", "");
1086}
1087
1088
1089const char * const MBlazeTargetInfo::GCCRegNames[] = {
1090 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1091 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1092 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1093 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1094 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1095 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1096 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1097 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1098 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1099 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1100};
1101
1102void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1103 unsigned &NumNames) const {
1104 Names = GCCRegNames;
1105 NumNames = llvm::array_lengthof(GCCRegNames);
1106}
1107
1108const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1109 { {"f0"}, "r0" },
1110 { {"f1"}, "r1" },
1111 { {"f2"}, "r2" },
1112 { {"f3"}, "r3" },
1113 { {"f4"}, "r4" },
1114 { {"f5"}, "r5" },
1115 { {"f6"}, "r6" },
1116 { {"f7"}, "r7" },
1117 { {"f8"}, "r8" },
1118 { {"f9"}, "r9" },
1119 { {"f10"}, "r10" },
1120 { {"f11"}, "r11" },
1121 { {"f12"}, "r12" },
1122 { {"f13"}, "r13" },
1123 { {"f14"}, "r14" },
1124 { {"f15"}, "r15" },
1125 { {"f16"}, "r16" },
1126 { {"f17"}, "r17" },
1127 { {"f18"}, "r18" },
1128 { {"f19"}, "r19" },
1129 { {"f20"}, "r20" },
1130 { {"f21"}, "r21" },
1131 { {"f22"}, "r22" },
1132 { {"f23"}, "r23" },
1133 { {"f24"}, "r24" },
1134 { {"f25"}, "r25" },
1135 { {"f26"}, "r26" },
1136 { {"f27"}, "r27" },
1137 { {"f28"}, "r28" },
1138 { {"f29"}, "r29" },
1139 { {"f30"}, "r30" },
1140 { {"f31"}, "r31" },
1141};
1142
1143void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1144 unsigned &NumAliases) const {
1145 Aliases = GCCRegAliases;
1146 NumAliases = llvm::array_lengthof(GCCRegAliases);
1147}
1148} // end anonymous namespace.
1149
1150namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001151// Namespace for x86 abstract base class
1152const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001153#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001154#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001155 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001156#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001157};
Eli Friedman61538a72008-05-20 14:21:01 +00001158
Nuno Lopes2550d702009-12-23 17:49:57 +00001159static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001160 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1161 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001162 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001163 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1164 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1165 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001166 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopherc5f9a012011-12-02 02:12:16 +00001167 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1168 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001169};
1170
Eric Christophercfd323d2011-06-21 00:05:20 +00001171const TargetInfo::AddlRegName AddlRegNames[] = {
1172 { { "al", "ah", "eax", "rax" }, 0 },
1173 { { "bl", "bh", "ebx", "rbx" }, 3 },
1174 { { "cl", "ch", "ecx", "rcx" }, 2 },
1175 { { "dl", "dh", "edx", "rdx" }, 1 },
1176 { { "esi", "rsi" }, 4 },
1177 { { "edi", "rdi" }, 5 },
1178 { { "esp", "rsp" }, 7 },
1179 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001180};
1181
1182// X86 target abstract base class; x86-32 and x86-64 are very close, so
1183// most of the implementation can be shared.
1184class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001185 enum X86SSEEnum {
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001186 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
Chris Lattner84f0ea82009-03-02 22:40:39 +00001187 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001188 enum MMX3DNowEnum {
1189 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1190 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001191
Eric Christophereea12d12010-04-02 23:50:19 +00001192 bool HasAES;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001193 bool HasAVX;
Craig Topper2b03bb02011-12-17 19:55:21 +00001194 bool HasAVX2;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001195
Chandler Carruth499d9722011-09-28 08:55:34 +00001196 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1197 ///
1198 /// Each enumeration represents a particular CPU supported by Clang. These
1199 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1200 enum CPUKind {
1201 CK_Generic,
1202
1203 /// \name i386
1204 /// i386-generation processors.
1205 //@{
1206 CK_i386,
1207 //@}
1208
1209 /// \name i486
1210 /// i486-generation processors.
1211 //@{
1212 CK_i486,
1213 CK_WinChipC6,
1214 CK_WinChip2,
1215 CK_C3,
1216 //@}
1217
1218 /// \name i586
1219 /// i586-generation processors, P5 microarchitecture based.
1220 //@{
1221 CK_i586,
1222 CK_Pentium,
1223 CK_PentiumMMX,
1224 //@}
1225
1226 /// \name i686
1227 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1228 //@{
1229 CK_i686,
1230 CK_PentiumPro,
1231 CK_Pentium2,
1232 CK_Pentium3,
1233 CK_Pentium3M,
1234 CK_PentiumM,
1235 CK_C3_2,
1236
1237 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1238 /// Clang however has some logic to suport this.
1239 // FIXME: Warn, deprecate, and potentially remove this.
1240 CK_Yonah,
1241 //@}
1242
1243 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001244 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001245 //@{
1246 CK_Pentium4,
1247 CK_Pentium4M,
1248 CK_Prescott,
1249 CK_Nocona,
1250 //@}
1251
1252 /// \name Core
1253 /// Core microarchitecture based processors.
1254 //@{
1255 CK_Core2,
1256
1257 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1258 /// codename which GCC no longer accepts as an option to -march, but Clang
1259 /// has some logic for recognizing it.
1260 // FIXME: Warn, deprecate, and potentially remove this.
1261 CK_Penryn,
1262 //@}
1263
1264 /// \name Atom
1265 /// Atom processors
1266 //@{
1267 CK_Atom,
1268 //@}
1269
1270 /// \name Nehalem
1271 /// Nehalem microarchitecture based processors.
1272 //@{
1273 CK_Corei7,
1274 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001275 CK_CoreAVXi,
Craig Topper2b03bb02011-12-17 19:55:21 +00001276 CK_CoreAVX2,
Chandler Carruth499d9722011-09-28 08:55:34 +00001277 //@}
1278
1279 /// \name K6
1280 /// K6 architecture processors.
1281 //@{
1282 CK_K6,
1283 CK_K6_2,
1284 CK_K6_3,
1285 //@}
1286
1287 /// \name K7
1288 /// K7 architecture processors.
1289 //@{
1290 CK_Athlon,
1291 CK_AthlonThunderbird,
1292 CK_Athlon4,
1293 CK_AthlonXP,
1294 CK_AthlonMP,
1295 //@}
1296
1297 /// \name K8
1298 /// K8 architecture processors.
1299 //@{
1300 CK_Athlon64,
1301 CK_Athlon64SSE3,
1302 CK_AthlonFX,
1303 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001304 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001305 CK_Opteron,
1306 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001307 CK_AMDFAM10,
Chandler Carruth499d9722011-09-28 08:55:34 +00001308
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001309 /// \name K10
1310 /// K10 architecture processors.
1311 //@{
1312 CK_BDVER1,
1313 CK_BDVER2,
1314
Chandler Carruth499d9722011-09-28 08:55:34 +00001315 /// This specification is deprecated and will be removed in the future.
1316 /// Users should prefer \see CK_K8.
1317 // FIXME: Warn on this when the CPU is set to it.
1318 CK_x86_64,
1319 //@}
1320
1321 /// \name Geode
1322 /// Geode processors.
1323 //@{
1324 CK_Geode
1325 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001326 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001327
Eli Friedman618234a2008-08-20 02:34:37 +00001328public:
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001329 X86TargetInfo(const std::string& triple)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001330 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Craig Topper2b03bb02011-12-17 19:55:21 +00001331 HasAES(false), HasAVX(false), HasAVX2(false), CPU(CK_Generic) {
Eli Friedman618234a2008-08-20 02:34:37 +00001332 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001333 }
1334 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1335 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001336 Records = BuiltinInfo;
1337 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001338 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001339 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001340 unsigned &NumNames) const {
1341 Names = GCCRegNames;
1342 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001343 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001344 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001345 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001346 Aliases = 0;
1347 NumAliases = 0;
1348 }
1349 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1350 unsigned &NumNames) const {
1351 Names = AddlRegNames;
1352 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001353 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001354 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001355 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001356 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001357 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001358 return "~{dirflag},~{fpsr},~{flags}";
1359 }
Chris Lattner33328642009-03-20 15:52:06 +00001360 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001361 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001362 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1363 const std::string &Name,
1364 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001365 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001366 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001367 virtual const char* getABI() const {
Eli Friedmanee1ad992011-12-02 00:11:43 +00001368 if (PointerWidth == 64 && HasAVX)
1369 return "avx";
1370 else if (PointerWidth == 32 && MMX3DNowLevel == NoMMX3DNow)
1371 return "no-mmx";
1372 return "";
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001373 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001374 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001375 CPU = llvm::StringSwitch<CPUKind>(Name)
1376 .Case("i386", CK_i386)
1377 .Case("i486", CK_i486)
1378 .Case("winchip-c6", CK_WinChipC6)
1379 .Case("winchip2", CK_WinChip2)
1380 .Case("c3", CK_C3)
1381 .Case("i586", CK_i586)
1382 .Case("pentium", CK_Pentium)
1383 .Case("pentium-mmx", CK_PentiumMMX)
1384 .Case("i686", CK_i686)
1385 .Case("pentiumpro", CK_PentiumPro)
1386 .Case("pentium2", CK_Pentium2)
1387 .Case("pentium3", CK_Pentium3)
1388 .Case("pentium3m", CK_Pentium3M)
1389 .Case("pentium-m", CK_PentiumM)
1390 .Case("c3-2", CK_C3_2)
1391 .Case("yonah", CK_Yonah)
1392 .Case("pentium4", CK_Pentium4)
1393 .Case("pentium4m", CK_Pentium4M)
1394 .Case("prescott", CK_Prescott)
1395 .Case("nocona", CK_Nocona)
1396 .Case("core2", CK_Core2)
1397 .Case("penryn", CK_Penryn)
1398 .Case("atom", CK_Atom)
1399 .Case("corei7", CK_Corei7)
1400 .Case("corei7-avx", CK_Corei7AVX)
1401 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper2b03bb02011-12-17 19:55:21 +00001402 .Case("core-avx2", CK_CoreAVX2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001403 .Case("k6", CK_K6)
1404 .Case("k6-2", CK_K6_2)
1405 .Case("k6-3", CK_K6_3)
1406 .Case("athlon", CK_Athlon)
1407 .Case("athlon-tbird", CK_AthlonThunderbird)
1408 .Case("athlon-4", CK_Athlon4)
1409 .Case("athlon-xp", CK_AthlonXP)
1410 .Case("athlon-mp", CK_AthlonMP)
1411 .Case("athlon64", CK_Athlon64)
1412 .Case("athlon64-sse3", CK_Athlon64SSE3)
1413 .Case("athlon-fx", CK_AthlonFX)
1414 .Case("k8", CK_K8)
1415 .Case("k8-sse3", CK_K8SSE3)
1416 .Case("opteron", CK_Opteron)
1417 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001418 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001419 .Case("bdver1", CK_BDVER1)
1420 .Case("bdver2", CK_BDVER2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001421 .Case("x86-64", CK_x86_64)
1422 .Case("geode", CK_Geode)
1423 .Default(CK_Generic);
1424
Chandler Carruth26a39142011-09-28 09:45:08 +00001425 // Perform any per-CPU checks necessary to determine if this CPU is
1426 // acceptable.
1427 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1428 // invalid without explaining *why*.
1429 switch (CPU) {
1430 case CK_Generic:
1431 // No processor selected!
1432 return false;
1433
1434 case CK_i386:
1435 case CK_i486:
1436 case CK_WinChipC6:
1437 case CK_WinChip2:
1438 case CK_C3:
1439 case CK_i586:
1440 case CK_Pentium:
1441 case CK_PentiumMMX:
1442 case CK_i686:
1443 case CK_PentiumPro:
1444 case CK_Pentium2:
1445 case CK_Pentium3:
1446 case CK_Pentium3M:
1447 case CK_PentiumM:
1448 case CK_Yonah:
1449 case CK_C3_2:
1450 case CK_Pentium4:
1451 case CK_Pentium4M:
1452 case CK_Prescott:
1453 case CK_K6:
1454 case CK_K6_2:
1455 case CK_K6_3:
1456 case CK_Athlon:
1457 case CK_AthlonThunderbird:
1458 case CK_Athlon4:
1459 case CK_AthlonXP:
1460 case CK_AthlonMP:
1461 case CK_Geode:
1462 // Only accept certain architectures when compiling in 32-bit mode.
1463 if (PointerWidth != 32)
1464 return false;
1465
1466 // Fallthrough
1467 case CK_Nocona:
1468 case CK_Core2:
1469 case CK_Penryn:
1470 case CK_Atom:
1471 case CK_Corei7:
1472 case CK_Corei7AVX:
1473 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001474 case CK_CoreAVX2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001475 case CK_Athlon64:
1476 case CK_Athlon64SSE3:
1477 case CK_AthlonFX:
1478 case CK_K8:
1479 case CK_K8SSE3:
1480 case CK_Opteron:
1481 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00001482 case CK_AMDFAM10:
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001483 case CK_BDVER1:
1484 case CK_BDVER2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001485 case CK_x86_64:
1486 return true;
1487 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001488 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001489 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001490};
Chris Lattner3daed522009-03-02 22:20:04 +00001491
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001492void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001493 // FIXME: This should not be here.
1494 Features["3dnow"] = false;
1495 Features["3dnowa"] = false;
1496 Features["mmx"] = false;
1497 Features["sse"] = false;
1498 Features["sse2"] = false;
1499 Features["sse3"] = false;
1500 Features["ssse3"] = false;
1501 Features["sse41"] = false;
1502 Features["sse42"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001503 Features["sse4a"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001504 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001505 Features["avx"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001506 Features["avx2"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001507
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001508 // FIXME: This *really* should not be here.
1509
1510 // X86_64 always has SSE2.
1511 if (PointerWidth == 64)
1512 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1513
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001514 switch (CPU) {
1515 case CK_Generic:
1516 case CK_i386:
1517 case CK_i486:
1518 case CK_i586:
1519 case CK_Pentium:
1520 case CK_i686:
1521 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001522 break;
1523 case CK_PentiumMMX:
1524 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001525 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001526 break;
1527 case CK_Pentium3:
1528 case CK_Pentium3M:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001529 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001530 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001531 break;
1532 case CK_PentiumM:
1533 case CK_Pentium4:
1534 case CK_Pentium4M:
1535 case CK_x86_64:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001536 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001537 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001538 break;
1539 case CK_Yonah:
1540 case CK_Prescott:
1541 case CK_Nocona:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001542 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001543 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001544 break;
1545 case CK_Core2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001546 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001547 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001548 break;
1549 case CK_Penryn:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001550 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001551 setFeatureEnabled(Features, "sse4", true);
1552 Features["sse42"] = false;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001553 break;
1554 case CK_Atom:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001555 setFeatureEnabled(Features, "mmx", true);
Chandler Carruth49defe62011-09-28 10:36:46 +00001556 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001557 break;
1558 case CK_Corei7:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001559 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001560 setFeatureEnabled(Features, "sse4", true);
Eric Christophereea12d12010-04-02 23:50:19 +00001561 setFeatureEnabled(Features, "aes", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001562 break;
1563 case CK_Corei7AVX:
1564 case CK_CoreAVXi:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001565 setFeatureEnabled(Features, "mmx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00001566 setFeatureEnabled(Features, "sse4", true);
1567 setFeatureEnabled(Features, "aes", true);
Bruno Cardoso Lopese02d3912011-07-11 23:33:46 +00001568 //setFeatureEnabled(Features, "avx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001569 break;
Craig Topper2b03bb02011-12-17 19:55:21 +00001570 case CK_CoreAVX2:
1571 setFeatureEnabled(Features, "mmx", true);
1572 setFeatureEnabled(Features, "sse4", true);
1573 setFeatureEnabled(Features, "aes", true);
1574 //setFeatureEnabled(Features, "avx2", true);
1575 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001576 case CK_K6:
1577 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001578 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001579 break;
1580 case CK_K6_2:
1581 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001582 case CK_WinChip2:
1583 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001584 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001585 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00001586 case CK_Athlon:
1587 case CK_AthlonThunderbird:
1588 case CK_Geode:
1589 setFeatureEnabled(Features, "3dnowa", true);
1590 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001591 case CK_Athlon4:
1592 case CK_AthlonXP:
1593 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001594 setFeatureEnabled(Features, "sse", true);
1595 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001596 break;
1597 case CK_K8:
1598 case CK_Opteron:
1599 case CK_Athlon64:
1600 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00001601 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001602 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001603 break;
1604 case CK_K8SSE3:
1605 case CK_OpteronSSE3:
1606 case CK_Athlon64SSE3:
Roman Divacky80b32b82011-10-30 13:47:56 +00001607 setFeatureEnabled(Features, "sse3", true);
1608 setFeatureEnabled(Features, "3dnowa", true);
1609 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00001610 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00001611 setFeatureEnabled(Features, "sse3", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00001612 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00001613 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001614 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001615 case CK_BDVER1:
1616 case CK_BDVER2:
1617 setFeatureEnabled(Features, "sse4", true);
1618 setFeatureEnabled(Features, "sse4a", true);
1619 setFeatureEnabled(Features, "aes", true);
1620 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001621 case CK_C3_2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001622 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001623 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001624 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001625 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001626}
1627
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001628bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump1eb44332009-09-09 15:08:12 +00001629 const std::string &Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001630 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00001631 // FIXME: This *really* should not be here. We need some way of translating
1632 // options into llvm subtarget features.
1633 if (!Features.count(Name) &&
1634 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001635 return false;
1636
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001637 // FIXME: this should probably use a switch with fall through.
1638
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001639 if (Enabled) {
1640 if (Name == "mmx")
1641 Features["mmx"] = true;
1642 else if (Name == "sse")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001643 Features["mmx"] = Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001644 else if (Name == "sse2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001645 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001646 else if (Name == "sse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001647 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1648 true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001649 else if (Name == "ssse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001650 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001651 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001652 else if (Name == "sse4" || Name == "sse4.2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001653 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001654 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001655 else if (Name == "sse4.1")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001656 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00001657 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001658 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001659 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001660 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001661 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00001662 else if (Name == "aes")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001663 Features["aes"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001664 else if (Name == "avx")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001665 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1666 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1667 Features["avx"] = true;
Craig Topper2b03bb02011-12-17 19:55:21 +00001668 else if (Name == "avx2")
1669 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1670 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1671 Features["avx"] = Features["avx2"] = true;
Roman Divacky80b32b82011-10-30 13:47:56 +00001672 else if (Name == "sse4a")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001673 Features["mmx"] = Features["sse4a"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001674 } else {
1675 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001676 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001677 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00001678 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001679 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001680 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00001681 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001682 Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001683 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00001684 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001685 Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001686 else if (Name == "ssse3")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001687 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00001688 else if (Name == "sse4" || Name == "sse4.1")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001689 Features["sse41"] = Features["sse42"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00001690 else if (Name == "sse4.2")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001691 Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001692 else if (Name == "3dnow")
1693 Features["3dnow"] = Features["3dnowa"] = false;
1694 else if (Name == "3dnowa")
1695 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001696 else if (Name == "aes")
1697 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001698 else if (Name == "avx")
Craig Topper2b03bb02011-12-17 19:55:21 +00001699 Features["avx"] = Features["avx2"] = false;
1700 else if (Name == "avx2")
1701 Features["avx2"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001702 else if (Name == "sse4a")
1703 Features["sse4a"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001704 }
1705
1706 return true;
1707}
1708
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001709/// HandleTargetOptions - Perform initialization based on the user
1710/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001711void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001712 // Remember the maximum enabled sselevel.
1713 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1714 // Ignore disabled features.
1715 if (Features[i][0] == '-')
1716 continue;
1717
Eric Christophereea12d12010-04-02 23:50:19 +00001718 if (Features[i].substr(1) == "aes") {
1719 HasAES = true;
1720 continue;
1721 }
1722
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001723 // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1724 // For now let it be enabled together with other SSE levels.
Craig Topper2b03bb02011-12-17 19:55:21 +00001725 if (Features[i].substr(1) == "avx2") {
1726 HasAVX = true;
1727 HasAVX2 = true;
1728 continue;
1729 }
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001730 if (Features[i].substr(1) == "avx") {
1731 HasAVX = true;
1732 continue;
1733 }
1734
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001735 assert(Features[i][0] == '+' && "Invalid target feature!");
1736 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1737 .Case("sse42", SSE42)
1738 .Case("sse41", SSE41)
1739 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00001740 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001741 .Case("sse2", SSE2)
1742 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001743 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001744 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001745
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001746 MMX3DNowEnum ThreeDNowLevel =
1747 llvm::StringSwitch<MMX3DNowEnum>(Features[i].substr(1))
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001748 .Case("3dnowa", AMD3DNowAthlon)
1749 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001750 .Case("mmx", MMX)
1751 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001752
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001753 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001754 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001755
1756 // Don't tell the backend if we're turning off mmx; it will end up disabling
1757 // SSE, which we don't want.
1758 std::vector<std::string>::iterator it;
1759 it = std::find(Features.begin(), Features.end(), "-mmx");
1760 if (it != Features.end())
1761 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00001762}
Chris Lattnerc0f59212009-03-02 22:27:17 +00001763
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001764/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
1765/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00001766void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001767 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00001768 // Target identification.
1769 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00001770 Builder.defineMacro("_LP64");
1771 Builder.defineMacro("__LP64__");
1772 Builder.defineMacro("__amd64__");
1773 Builder.defineMacro("__amd64");
1774 Builder.defineMacro("__x86_64");
1775 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00001776 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00001777 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00001778 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001779
Chris Lattnerc0f59212009-03-02 22:27:17 +00001780 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001781 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
1782 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001783 switch (CPU) {
1784 case CK_Generic:
1785 break;
1786 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001787 // The rest are coming from the i386 define above.
1788 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001789 break;
1790 case CK_i486:
1791 case CK_WinChipC6:
1792 case CK_WinChip2:
1793 case CK_C3:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001794 Builder.defineMacro("__i486");
1795 Builder.defineMacro("__i486__");
1796 Builder.defineMacro("__tune_i486__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001797 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00001798 case CK_PentiumMMX:
1799 Builder.defineMacro("__pentium_mmx__");
1800 Builder.defineMacro("__tune_pentium_mmx__");
1801 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001802 case CK_i586:
1803 case CK_Pentium:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001804 Builder.defineMacro("__i586");
1805 Builder.defineMacro("__i586__");
1806 Builder.defineMacro("__tune_i586__");
1807 Builder.defineMacro("__pentium");
1808 Builder.defineMacro("__pentium__");
1809 Builder.defineMacro("__tune_pentium__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001810 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001811 case CK_Pentium3:
1812 case CK_Pentium3M:
1813 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001814 Builder.defineMacro("__tune_pentium3__");
1815 // Fallthrough
1816 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001817 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001818 Builder.defineMacro("__tune_pentium2__");
1819 // Fallthrough
1820 case CK_PentiumPro:
1821 Builder.defineMacro("__tune_i686__");
1822 Builder.defineMacro("__tune_pentiumpro__");
1823 // Fallthrough
1824 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001825 Builder.defineMacro("__i686");
1826 Builder.defineMacro("__i686__");
1827 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
1828 Builder.defineMacro("__pentiumpro");
1829 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001830 break;
1831 case CK_Pentium4:
1832 case CK_Pentium4M:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001833 Builder.defineMacro("__pentium4");
1834 Builder.defineMacro("__pentium4__");
1835 Builder.defineMacro("__tune_pentium4__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001836 break;
1837 case CK_Yonah:
1838 case CK_Prescott:
1839 case CK_Nocona:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001840 Builder.defineMacro("__nocona");
1841 Builder.defineMacro("__nocona__");
1842 Builder.defineMacro("__tune_nocona__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001843 break;
1844 case CK_Core2:
1845 case CK_Penryn:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001846 Builder.defineMacro("__core2");
1847 Builder.defineMacro("__core2__");
1848 Builder.defineMacro("__tune_core2__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001849 break;
1850 case CK_Atom:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001851 Builder.defineMacro("__atom");
1852 Builder.defineMacro("__atom__");
1853 Builder.defineMacro("__tune_atom__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001854 break;
1855 case CK_Corei7:
1856 case CK_Corei7AVX:
1857 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001858 case CK_CoreAVX2:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001859 Builder.defineMacro("__corei7");
1860 Builder.defineMacro("__corei7__");
1861 Builder.defineMacro("__tune_corei7__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001862 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001863 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001864 Builder.defineMacro("__k6_2__");
1865 Builder.defineMacro("__tune_k6_2__");
1866 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001867 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001868 if (CPU != CK_K6_2) { // In case of fallthrough
1869 // FIXME: GCC may be enabling these in cases where some other k6
1870 // architecture is specified but -m3dnow is explicitly provided. The
1871 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001872 Builder.defineMacro("__k6_3__");
1873 Builder.defineMacro("__tune_k6_3__");
1874 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00001875 // Fallthrough
1876 case CK_K6:
1877 Builder.defineMacro("__k6");
1878 Builder.defineMacro("__k6__");
1879 Builder.defineMacro("__tune_k6__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001880 break;
1881 case CK_Athlon:
1882 case CK_AthlonThunderbird:
1883 case CK_Athlon4:
1884 case CK_AthlonXP:
1885 case CK_AthlonMP:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001886 Builder.defineMacro("__athlon");
1887 Builder.defineMacro("__athlon__");
1888 Builder.defineMacro("__tune_athlon__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001889 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001890 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001891 Builder.defineMacro("__tune_athlon_sse__");
1892 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001893 break;
1894 case CK_K8:
1895 case CK_K8SSE3:
1896 case CK_x86_64:
1897 case CK_Opteron:
1898 case CK_OpteronSSE3:
1899 case CK_Athlon64:
1900 case CK_Athlon64SSE3:
1901 case CK_AthlonFX:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001902 Builder.defineMacro("__k8");
1903 Builder.defineMacro("__k8__");
1904 Builder.defineMacro("__tune_k8__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001905 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00001906 case CK_AMDFAM10:
1907 Builder.defineMacro("__amdfam10");
1908 Builder.defineMacro("__amdfam10__");
1909 Builder.defineMacro("__tune_amdfam10__");
1910 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001911 case CK_BDVER1:
1912 Builder.defineMacro("__bdver1");
1913 Builder.defineMacro("__bdver1__");
1914 Builder.defineMacro("__tune__bdver1__");
1915 break;
1916 case CK_BDVER2:
1917 Builder.defineMacro("__bdver2");
1918 Builder.defineMacro("__bdver2__");
1919 Builder.defineMacro("__tune__bdver2__");
1920 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001921 case CK_Geode:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001922 Builder.defineMacro("__geode");
1923 Builder.defineMacro("__geode__");
1924 Builder.defineMacro("__tune_geode__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001925 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001926 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00001927
Chandler Carruth88c75b02011-09-28 09:54:07 +00001928 // Target properties.
1929 Builder.defineMacro("__LITTLE_ENDIAN__");
1930 Builder.defineMacro("__REGISTER_PREFIX__", "");
1931
Chris Lattner54175442009-04-19 17:32:33 +00001932 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1933 // functions in glibc header files that use FP Stack inline asm which the
1934 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00001935 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001936
Chandler Carruth88c75b02011-09-28 09:54:07 +00001937 if (HasAES)
1938 Builder.defineMacro("__AES__");
1939
1940 if (HasAVX)
1941 Builder.defineMacro("__AVX__");
Craig Topper2b03bb02011-12-17 19:55:21 +00001942 if (HasAVX2)
1943 Builder.defineMacro("__AVX2__");
Chandler Carruth88c75b02011-09-28 09:54:07 +00001944
Chris Lattner84f0ea82009-03-02 22:40:39 +00001945 // Each case falls through to the previous one here.
1946 switch (SSELevel) {
1947 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00001948 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001949 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00001950 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001951 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00001952 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001953 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00001954 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00001955 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00001956 Builder.defineMacro("__SSE2__");
1957 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00001958 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00001959 Builder.defineMacro("__SSE__");
1960 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001961 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00001962 break;
1963 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00001964
Francois Pichet62ec1f22011-09-17 17:15:52 +00001965 if (Opts.MicrosoftExt && PointerWidth == 32) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001966 switch (SSELevel) {
Michael J. Spencera764e832010-10-21 08:22:51 +00001967 case SSE42:
1968 case SSE41:
1969 case SSSE3:
1970 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001971 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001972 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001973 break;
1974 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001975 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001976 break;
1977 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001978 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001979 }
1980 }
1981
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001982 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001983 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001984 case AMD3DNowAthlon:
1985 Builder.defineMacro("__3dNOW_A__");
1986 case AMD3DNow:
1987 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001988 case MMX:
1989 Builder.defineMacro("__MMX__");
1990 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001991 break;
1992 }
Chris Lattnerc0f59212009-03-02 22:27:17 +00001993}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001994
1995
Eli Friedman618234a2008-08-20 02:34:37 +00001996bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001997X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00001998 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001999 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00002000 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00002001 case 'Y': // first letter of a pair:
2002 switch (*(Name+1)) {
2003 default: return false;
2004 case '0': // First SSE register.
2005 case 't': // Any SSE register, when SSE2 is enabled.
2006 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2007 case 'm': // any MMX register, when inter-unit moves enabled.
2008 break; // falls through to setAllowsRegister.
2009 }
Eli Friedman618234a2008-08-20 02:34:37 +00002010 case 'a': // eax.
2011 case 'b': // ebx.
2012 case 'c': // ecx.
2013 case 'd': // edx.
2014 case 'S': // esi.
2015 case 'D': // edi.
2016 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00002017 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00002018 case 't': // top of floating point stack.
2019 case 'u': // second from top of floating point stack.
2020 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00002021 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00002022 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00002023 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00002024 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2025 case 'l': // "Index" registers: any general register that can be used as an
2026 // index in a base+index memory access.
2027 Info.setAllowsRegister();
2028 return true;
2029 case 'C': // SSE floating point constant.
2030 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002031 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002032 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002033 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002034 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00002035 return true;
2036 }
Dale Johannesen545be512010-08-24 22:33:12 +00002037 return false;
Eli Friedman618234a2008-08-20 02:34:37 +00002038}
2039
Dale Johannesenf6e2c202010-10-29 23:12:32 +00002040
Eli Friedman618234a2008-08-20 02:34:37 +00002041std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00002042X86TargetInfo::convertConstraint(const char *&Constraint) const {
2043 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00002044 case 'a': return std::string("{ax}");
2045 case 'b': return std::string("{bx}");
2046 case 'c': return std::string("{cx}");
2047 case 'd': return std::string("{dx}");
2048 case 'S': return std::string("{si}");
2049 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00002050 case 'p': // address
2051 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00002052 case 't': // top of floating point stack.
2053 return std::string("{st}");
2054 case 'u': // second from top of floating point stack.
2055 return std::string("{st(1)}"); // second from top of floating point stack.
2056 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00002057 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00002058 }
2059}
Eli Friedman618234a2008-08-20 02:34:37 +00002060} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00002061
2062namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002063// X86-32 generic target
2064class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00002065public:
Eli Friedman618234a2008-08-20 02:34:37 +00002066 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
2067 DoubleAlign = LongLongAlign = 32;
2068 LongDoubleWidth = 96;
2069 LongDoubleAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002070 SuitableAlign = 32;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002071 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2072 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00002073 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00002074 SizeType = UnsignedInt;
2075 PtrDiffType = SignedInt;
2076 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002077 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002078
2079 // Use fpret for all types.
2080 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2081 (1 << TargetInfo::Double) |
2082 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002083
2084 // x86-32 has atomics up to 8 bytes
2085 // FIXME: Check that we actually have cmpxchg8b before setting
2086 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2087 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002088 }
2089 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002090 return "typedef char* __builtin_va_list;";
Eli Friedman618234a2008-08-20 02:34:37 +00002091 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002092
Chris Lattner21fb98e2009-09-23 06:06:36 +00002093 int getEHDataRegisterNumber(unsigned RegNo) const {
2094 if (RegNo == 0) return 0;
2095 if (RegNo == 1) return 2;
2096 return -1;
2097 }
Eli Friedman618234a2008-08-20 02:34:37 +00002098};
2099} // end anonymous namespace
2100
2101namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002102class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2103public:
2104 OpenBSDI386TargetInfo(const std::string& triple) :
2105 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2106 SizeType = UnsignedLong;
2107 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002108 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002109 }
2110};
2111} // end anonymous namespace
2112
2113namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002114class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002115public:
Torok Edwin5f6c1942009-06-30 17:10:35 +00002116 DarwinI386TargetInfo(const std::string& triple) :
2117 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002118 LongDoubleWidth = 128;
2119 LongDoubleAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002120 SuitableAlign = 128;
Eli Friedman1afabd92009-03-29 20:31:09 +00002121 SizeType = UnsignedLong;
2122 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002123 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2124 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002125 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002126 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002127 }
2128
Eli Friedman618234a2008-08-20 02:34:37 +00002129};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002130} // end anonymous namespace
2131
2132namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002133// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002134class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002135public:
2136 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002137 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002138 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002139 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002140 DoubleAlign = LongLongAlign = 64;
2141 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 +00002142 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002143 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002144 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002145 virtual void getTargetDefines(const LangOptions &Opts,
2146 MacroBuilder &Builder) const {
2147 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2148 }
2149};
2150} // end anonymous namespace
2151
2152namespace {
2153
2154// x86-32 Windows Visual Studio target
2155class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2156public:
2157 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2158 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002159 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002160 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2161 }
2162 virtual void getTargetDefines(const LangOptions &Opts,
2163 MacroBuilder &Builder) const {
2164 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2165 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2166 // The value of the following reflects processor type.
2167 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2168 // We lost the original triple, so we use the default.
2169 Builder.defineMacro("_M_IX86", "600");
2170 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002171};
2172} // end anonymous namespace
2173
2174namespace {
2175// x86-32 MinGW target
2176class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2177public:
2178 MinGWX86_32TargetInfo(const std::string& triple)
2179 : WindowsX86_32TargetInfo(triple) {
2180 }
2181 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002182 MacroBuilder &Builder) const {
2183 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002184 DefineStd(Builder, "WIN32", Opts);
2185 DefineStd(Builder, "WINNT", Opts);
2186 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002187 Builder.defineMacro("__MSVCRT__");
2188 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002189
2190 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2191 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002192 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002193 // Provide "as-is" __declspec.
2194 Builder.defineMacro("__declspec", "__declspec");
2195 else
2196 // Provide alias of __attribute__ like mingw32-gcc.
2197 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002198 }
2199};
2200} // end anonymous namespace
2201
2202namespace {
2203// x86-32 Cygwin target
2204class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2205public:
2206 CygwinX86_32TargetInfo(const std::string& triple)
2207 : X86_32TargetInfo(triple) {
2208 TLSSupported = false;
2209 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002210 DoubleAlign = LongLongAlign = 64;
2211 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2212 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002213 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002214 }
2215 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002216 MacroBuilder &Builder) const {
2217 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2218 Builder.defineMacro("__CYGWIN__");
2219 Builder.defineMacro("__CYGWIN32__");
2220 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00002221 if (Opts.CPlusPlus)
2222 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00002223 }
Eli Friedman29a30502008-08-21 01:40:19 +00002224};
2225} // end anonymous namespace
2226
2227namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002228// x86-32 Haiku target
2229class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2230public:
2231 HaikuX86_32TargetInfo(const std::string& triple)
2232 : X86_32TargetInfo(triple) {
2233 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00002234 IntPtrType = SignedLong;
2235 PtrDiffType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00002236 this->UserLabelPrefix = "";
Eli Friedmana7e68452010-08-22 01:00:03 +00002237 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00002238 virtual void getTargetDefines(const LangOptions &Opts,
2239 MacroBuilder &Builder) const {
2240 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2241 Builder.defineMacro("__INTEL__");
2242 Builder.defineMacro("__HAIKU__");
2243 }
2244};
2245} // end anonymous namespace
2246
Douglas Gregordca52262011-07-01 22:41:14 +00002247// RTEMS Target
2248template<typename Target>
2249class RTEMSTargetInfo : public OSTargetInfo<Target> {
2250protected:
2251 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2252 MacroBuilder &Builder) const {
2253 // RTEMS defines; list based off of gcc output
2254
Douglas Gregordca52262011-07-01 22:41:14 +00002255 Builder.defineMacro("__rtems__");
2256 Builder.defineMacro("__ELF__");
2257 }
2258public:
2259 RTEMSTargetInfo(const std::string &triple)
2260 : OSTargetInfo<Target>(triple) {
2261 this->UserLabelPrefix = "";
2262
2263 llvm::Triple Triple(triple);
2264 switch (Triple.getArch()) {
2265 default:
2266 case llvm::Triple::x86:
2267 // this->MCountName = ".mcount";
2268 break;
2269 case llvm::Triple::mips:
2270 case llvm::Triple::mipsel:
2271 case llvm::Triple::ppc:
2272 case llvm::Triple::ppc64:
2273 // this->MCountName = "_mcount";
2274 break;
2275 case llvm::Triple::arm:
2276 // this->MCountName = "__mcount";
2277 break;
2278 }
2279
2280 }
2281};
2282
2283namespace {
2284// x86-32 RTEMS target
2285class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2286public:
2287 RTEMSX86_32TargetInfo(const std::string& triple)
2288 : X86_32TargetInfo(triple) {
2289 SizeType = UnsignedLong;
2290 IntPtrType = SignedLong;
2291 PtrDiffType = SignedLong;
2292 this->UserLabelPrefix = "";
2293 }
2294 virtual void getTargetDefines(const LangOptions &Opts,
2295 MacroBuilder &Builder) const {
2296 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2297 Builder.defineMacro("__INTEL__");
2298 Builder.defineMacro("__rtems__");
2299 }
2300};
2301} // end anonymous namespace
2302
Chris Lattner86ed3a32010-04-11 19:29:39 +00002303namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002304// x86-64 generic target
2305class X86_64TargetInfo : public X86TargetInfo {
2306public:
Chris Lattner33328642009-03-20 15:52:06 +00002307 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00002308 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002309 LongDoubleWidth = 128;
2310 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00002311 LargeArrayMinWidth = 128;
2312 LargeArrayAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002313 SuitableAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00002314 IntMaxType = SignedLong;
2315 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002316 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002317 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00002318
Eli Friedmaned855cb2008-08-21 00:13:15 +00002319 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2320 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002321 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002322
2323 // Use fpret only for long double.
2324 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00002325
Anders Carlssoneea64802011-10-31 16:27:11 +00002326 // Use fp2ret for _Complex long double.
2327 ComplexLongDoubleUsesFP2Ret = true;
2328
Eli Friedman2be46072011-10-14 20:59:01 +00002329 // x86-64 has atomics up to 16 bytes.
2330 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
2331 // on CPUs with cmpxchg16b
2332 MaxAtomicPromoteWidth = 128;
2333 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00002334 }
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00002335 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002336 return "typedef struct __va_list_tag {"
2337 " unsigned gp_offset;"
2338 " unsigned fp_offset;"
2339 " void* overflow_arg_area;"
2340 " void* reg_save_area;"
John McCall2b7baf02010-05-28 18:25:28 +00002341 "} __va_list_tag;"
Eli Friedmandc043162009-07-03 00:45:06 +00002342 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson3346ae62007-11-24 23:38:12 +00002343 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002344
Chris Lattner21fb98e2009-09-23 06:06:36 +00002345 int getEHDataRegisterNumber(unsigned RegNo) const {
2346 if (RegNo == 0) return 0;
2347 if (RegNo == 1) return 1;
2348 return -1;
2349 }
Eli Friedman618234a2008-08-20 02:34:37 +00002350};
2351} // end anonymous namespace
2352
2353namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002354// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002355class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002356public:
2357 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002358 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002359 TLSSupported = false;
2360 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00002361 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00002362 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00002363 IntMaxType = SignedLongLong;
2364 UIntMaxType = UnsignedLongLong;
2365 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00002366 SizeType = UnsignedLongLong;
2367 PtrDiffType = SignedLongLong;
2368 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00002369 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002370 }
2371 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002372 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002373 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002374 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00002375 }
NAKAMURA Takumi79521992011-01-17 22:56:23 +00002376 virtual const char *getVAListDeclaration() const {
2377 return "typedef char* __builtin_va_list;";
2378 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002379};
2380} // end anonymous namespace
2381
2382namespace {
2383// x86-64 Windows Visual Studio target
2384class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2385public:
2386 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2387 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002388 LongDoubleWidth = LongDoubleAlign = 64;
2389 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00002390 }
2391 virtual void getTargetDefines(const LangOptions &Opts,
2392 MacroBuilder &Builder) const {
2393 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
2394 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00002395 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002396 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002397 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002398};
2399} // end anonymous namespace
2400
2401namespace {
2402// x86-64 MinGW target
2403class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2404public:
2405 MinGWX86_64TargetInfo(const std::string& triple)
2406 : WindowsX86_64TargetInfo(triple) {
2407 }
2408 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002409 MacroBuilder &Builder) const {
2410 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002411 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00002412 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00002413 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00002414 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002415
2416 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2417 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002418 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002419 // Provide "as-is" __declspec.
2420 Builder.defineMacro("__declspec", "__declspec");
2421 else
2422 // Provide alias of __attribute__ like mingw32-gcc.
2423 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002424 }
2425};
2426} // end anonymous namespace
2427
2428namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002429class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2430public:
Mike Stump1eb44332009-09-09 15:08:12 +00002431 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002432 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2433 Int64Type = SignedLongLong;
2434 }
2435};
2436} // end anonymous namespace
2437
2438namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00002439class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
2440public:
Mike Stump1eb44332009-09-09 15:08:12 +00002441 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman6036ebe2009-07-05 22:31:18 +00002442 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
2443 IntMaxType = SignedLongLong;
2444 UIntMaxType = UnsignedLongLong;
2445 Int64Type = SignedLongLong;
2446 }
2447};
2448} // end anonymous namespace
2449
2450namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00002451class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002452 // Possible FPU choices.
2453 enum FPUMode {
2454 NoFPU,
2455 VFP2FPU,
2456 VFP3FPU,
2457 NeonFPU
2458 };
2459
2460 static bool FPUModeIsVFP(FPUMode Mode) {
2461 return Mode >= VFP2FPU && Mode <= NeonFPU;
2462 }
2463
2464 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2465 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002466
Daniel Dunbareac7c532009-12-18 18:42:37 +00002467 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002468
2469 unsigned FPU : 3;
2470
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002471 unsigned IsThumb : 1;
2472
2473 // Initialized via features.
2474 unsigned SoftFloat : 1;
2475 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002476
Chris Lattner2752c012010-03-03 19:03:45 +00002477 static const Builtin::Info BuiltinInfo[];
2478
Chris Lattner393ff042008-04-21 18:56:49 +00002479public:
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002480 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbareac7c532009-12-18 18:42:37 +00002481 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002482 {
Daniel Dunbara2a41612009-09-14 00:02:24 +00002483 SizeType = UnsignedInt;
2484 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00002485 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
2486 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002487
Chris Lattner9bffb072010-04-23 16:29:58 +00002488 // {} in inline assembly are neon specifiers, not assembly variant
2489 // specifiers.
2490 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00002491
Daniel Dunbareac7c532009-12-18 18:42:37 +00002492 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00002493 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002494 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002495 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2496 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002497 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
2498 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002499 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002500 } else {
2501 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2502 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002503 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002504 }
John McCallee79a4c2010-08-21 22:46:04 +00002505
2506 // ARM targets default to using the ARM C++ ABI.
2507 CXXABI = CXXABI_ARM;
Eli Friedman2be46072011-10-14 20:59:01 +00002508
2509 // ARM has atomics up to 8 bytes
2510 // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e
2511 MaxAtomicPromoteWidth = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002512 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002513 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00002514 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002515 ABI = Name;
2516
Daniel Dunbara2a41612009-09-14 00:02:24 +00002517 // The defaults (above) are for AAPCS, check if we need to change them.
2518 //
2519 // FIXME: We need support for -meabi... we could just mangle it into the
2520 // name.
2521 if (Name == "apcs-gnu") {
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002522 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002523 SizeType = UnsignedLong;
2524
James Molloya6d81f92011-11-23 13:35:08 +00002525 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
2526 WCharType = SignedInt;
2527
Daniel Dunbar684de632010-04-22 16:14:54 +00002528 // Do not respect the alignment of bit-field types when laying out
2529 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
2530 UseBitFieldTypeAlignment = false;
2531
Chad Rosier61a62212011-08-04 01:21:14 +00002532 /// Do force alignment of members that follow zero length bitfields. If
2533 /// the alignment of the zero-length bitfield is greater than the member
2534 /// that follows it, `bar', `bar' will be aligned as the type of the
2535 /// zero length bitfield.
2536 UseZeroLengthBitfieldAlignment = true;
2537
2538 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00002539 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
2540 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00002541 ZeroLengthBitfieldBoundary = 32;
2542
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002543 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002544 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2545 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002546 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 +00002547 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002548 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002549 } else {
2550 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 +00002551 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002552 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002553 }
2554
Chad Rosier9f1210c2011-07-26 07:03:04 +00002555 // FIXME: Override "preferred align" for double and long long.
Daniel Dunbara2a41612009-09-14 00:02:24 +00002556 } else if (Name == "aapcs") {
2557 // FIXME: Enumerated types are variable width in straight AAPCS.
2558 } else if (Name == "aapcs-linux") {
Chad Rosier9f1210c2011-07-26 07:03:04 +00002559 ;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002560 } else
2561 return false;
2562
2563 return true;
2564 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002565
Chandler Carruthc3a2e652011-09-28 05:56:05 +00002566 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002567 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
2568 Features["vfp2"] = true;
2569 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
2570 Features["neon"] = true;
2571 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002572
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002573 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2574 const std::string &Name,
2575 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00002576 if (Name == "soft-float" || Name == "soft-float-abi" ||
2577 Name == "vfp2" || Name == "vfp3" || Name == "neon") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002578 Features[Name] = Enabled;
2579 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002580 return false;
2581
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002582 return true;
2583 }
2584
2585 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002586 FPU = NoFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002587 SoftFloat = SoftFloatABI = false;
2588 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
2589 if (Features[i] == "+soft-float")
2590 SoftFloat = true;
2591 else if (Features[i] == "+soft-float-abi")
2592 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002593 else if (Features[i] == "+vfp2")
2594 FPU = VFP2FPU;
2595 else if (Features[i] == "+vfp3")
2596 FPU = VFP3FPU;
2597 else if (Features[i] == "+neon")
2598 FPU = NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002599 }
2600
2601 // Remove front-end specific options which the backend handles differently.
2602 std::vector<std::string>::iterator it;
2603 it = std::find(Features.begin(), Features.end(), "+soft-float");
2604 if (it != Features.end())
2605 Features.erase(it);
2606 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2607 if (it != Features.end())
2608 Features.erase(it);
2609 }
2610
Chris Lattner5f9e2722011-07-23 10:55:15 +00002611 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00002612 return llvm::StringSwitch<const char*>(Name)
2613 .Cases("arm8", "arm810", "4")
2614 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2615 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2616 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2617 .Case("ep9312", "4T")
2618 .Cases("arm10tdmi", "arm1020t", "5T")
2619 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2620 .Case("arm926ej-s", "5TEJ")
2621 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2622 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002623 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002624 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002625 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002626 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2627 .Cases("cortex-a8", "cortex-a9", "7A")
Bob Wilson06f45632011-01-06 16:57:20 +00002628 .Case("cortex-m3", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00002629 .Case("cortex-m0", "6M")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002630 .Default(0);
2631 }
2632 virtual bool setCPU(const std::string &Name) {
2633 if (!getCPUDefineSuffix(Name))
2634 return false;
2635
2636 CPU = Name;
2637 return true;
2638 }
Chris Lattner33328642009-03-20 15:52:06 +00002639 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002640 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002641 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00002642 Builder.defineMacro("__arm");
2643 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002644
Chris Lattnerc0f59212009-03-02 22:27:17 +00002645 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00002646 Builder.defineMacro("__ARMEL__");
2647 Builder.defineMacro("__LITTLE_ENDIAN__");
2648 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002649
Chris Lattner5f9e2722011-07-23 10:55:15 +00002650 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00002651 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002652
Mike Stump437bb4b2009-04-08 02:07:04 +00002653 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002654
Daniel Dunbareac7c532009-12-18 18:42:37 +00002655 // FIXME: It's more complicated than this and we don't really support
2656 // interworking.
2657 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00002658 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002659
Daniel Dunbareac7c532009-12-18 18:42:37 +00002660 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramera9992772010-01-09 17:55:51 +00002661 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002662
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002663 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00002664 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002665
2666 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00002667 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002668
Bob Wilson84f95cf2011-05-13 18:56:03 +00002669 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002670 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002671 Builder.defineMacro("__THUMBEL__");
2672 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00002673 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002674 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002675 }
2676
2677 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00002678 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002679
2680 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramera9992772010-01-09 17:55:51 +00002681 Builder.defineMacro("__VFP_FP__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002682
2683 // This only gets set when Neon instructions are actually available, unlike
2684 // the VFP define, hence the soft float and arch check. This is subtly
2685 // different from gcc, we follow the intent which was that it should be set
2686 // when Neon instructions are actually available.
Bob Wilson84f95cf2011-05-13 18:56:03 +00002687 if (FPU == NeonFPU && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002688 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00002689 }
2690 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2691 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00002692 Records = BuiltinInfo;
2693 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00002694 }
2695 virtual const char *getVAListDeclaration() const {
John McCall0e9972c2011-05-09 02:19:37 +00002696 return "typedef void* __builtin_va_list;";
Chris Lattner393ff042008-04-21 18:56:49 +00002697 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002698 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002699 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002700 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002701 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002702 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002703 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002704 // FIXME: Check if this is complete
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002705 switch (*Name) {
Eli Friedmana9f54962008-08-20 07:44:10 +00002706 default:
Nate Begemanad487f42008-04-22 05:03:19 +00002707 case 'l': // r0-r7
2708 case 'h': // r8-r15
2709 case 'w': // VFP Floating point register single precision
2710 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00002711 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00002712 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00002713 case 'Q': // A memory address that is a single base register.
2714 Info.setAllowsMemory();
2715 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00002716 case 'U': // a memory reference...
2717 switch (Name[1]) {
2718 case 'q': // ...ARMV4 ldrsb
2719 case 'v': // ...VFP load/store (reg+constant offset)
2720 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00002721 case 't': // address valid for load/store opaque types wider
2722 // than 128-bits
2723 case 'n': // valid address for Neon doubleword vector load/store
2724 case 'm': // valid address for Neon element and structure load/store
2725 case 's': // valid address for non-offset loads/stores of quad-word
2726 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00002727 Info.setAllowsMemory();
2728 Name++;
2729 return true;
2730 }
Nate Begemanad487f42008-04-22 05:03:19 +00002731 }
Chris Lattner393ff042008-04-21 18:56:49 +00002732 return false;
2733 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00002734 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00002735 std::string R;
2736 switch (*Constraint) {
2737 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00002738 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00002739 Constraint++;
2740 break;
Eric Christopher283f4472011-06-17 00:40:18 +00002741 case 'p': // 'p' should be translated to 'r' by default.
2742 R = std::string("r");
2743 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00002744 default:
2745 return std::string(1, *Constraint);
2746 }
2747 return R;
2748 }
Chris Lattner393ff042008-04-21 18:56:49 +00002749 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002750 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00002751 return "";
2752 }
2753};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002754
2755const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002756 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002757 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002758 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
2759
2760 // Float registers
2761 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2762 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2763 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002764 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002765
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002766 // Double registers
2767 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
2768 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00002769 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
2770 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002771
2772 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00002773 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
2774 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002775};
2776
2777void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002778 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002779 Names = GCCRegNames;
2780 NumNames = llvm::array_lengthof(GCCRegNames);
2781}
2782
2783const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002784 { { "a1" }, "r0" },
2785 { { "a2" }, "r1" },
2786 { { "a3" }, "r2" },
2787 { { "a4" }, "r3" },
2788 { { "v1" }, "r4" },
2789 { { "v2" }, "r5" },
2790 { { "v3" }, "r6" },
2791 { { "v4" }, "r7" },
2792 { { "v5" }, "r8" },
2793 { { "v6", "rfp" }, "r9" },
2794 { { "sl" }, "r10" },
2795 { { "fp" }, "r11" },
2796 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002797 { { "r13" }, "sp" },
2798 { { "r14" }, "lr" },
2799 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002800 // The S, D and Q registers overlap, but aren't really aliases; we
2801 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002802};
2803
2804void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2805 unsigned &NumAliases) const {
2806 Aliases = GCCRegAliases;
2807 NumAliases = llvm::array_lengthof(GCCRegAliases);
2808}
Chris Lattner2752c012010-03-03 19:03:45 +00002809
2810const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00002811#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00002812#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00002813 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00002814#include "clang/Basic/BuiltinsARM.def"
2815};
Chris Lattner393ff042008-04-21 18:56:49 +00002816} // end anonymous namespace.
2817
Eli Friedmana9f54962008-08-20 07:44:10 +00002818namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00002819class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00002820 public DarwinTargetInfo<ARMTargetInfo> {
2821protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00002822 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00002823 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00002824 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00002825 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002826
Torok Edwin5f6c1942009-06-30 17:10:35 +00002827public:
Mike Stump1eb44332009-09-09 15:08:12 +00002828 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar350b9f32010-05-27 07:00:26 +00002829 : DarwinTargetInfo<ARMTargetInfo>(triple) {
2830 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00002831 // iOS always has 64-bit atomic instructions.
2832 // FIXME: This should be based off of the target features in ARMTargetInfo.
2833 MaxAtomicInlineWidth = 64;
Daniel Dunbar350b9f32010-05-27 07:00:26 +00002834 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002835};
2836} // end anonymous namespace.
2837
Tony Linthicum96319392011-12-12 21:14:55 +00002838
2839namespace {
2840// Hexagon abstract base class
2841class HexagonTargetInfo : public TargetInfo {
2842 static const Builtin::Info BuiltinInfo[];
2843 static const char * const GCCRegNames[];
2844 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2845 std::string CPU;
2846public:
2847 HexagonTargetInfo(const std::string& triple) : TargetInfo(triple) {
2848 DescriptionString = ("e-p:32:32:32-"
2849 "i64:64:64-i32:32:32-"
2850 "i16:16:16-i1:32:32-a:0:0");
2851
2852 // {} in inline assembly are packet specifiers, not assembly variant
2853 // specifiers.
2854 NoAsmVariants = true;
2855 }
2856
2857 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2858 unsigned &NumRecords) const {
2859 Records = BuiltinInfo;
2860 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
2861 }
2862
2863 virtual bool validateAsmConstraint(const char *&Name,
2864 TargetInfo::ConstraintInfo &Info) const {
2865 return true;
2866 }
2867
2868 virtual void getTargetDefines(const LangOptions &Opts,
2869 MacroBuilder &Builder) const;
2870
2871 virtual const char *getVAListDeclaration() const {
2872 return "typedef char* __builtin_va_list;";
2873 }
2874 virtual void getGCCRegNames(const char * const *&Names,
2875 unsigned &NumNames) const;
2876 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2877 unsigned &NumAliases) const;
2878 virtual const char *getClobbers() const {
2879 return "";
2880 }
2881 virtual bool setCPU(const std::string &Name) {
2882 CPU = Name;
2883 return true;
2884 }
2885};
2886
2887void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
2888 MacroBuilder &Builder) const {
2889 Builder.defineMacro("qdsp6");
2890 Builder.defineMacro("__qdsp6", "1");
2891 Builder.defineMacro("__qdsp6__", "1");
2892
2893 Builder.defineMacro("hexagon");
2894 Builder.defineMacro("__hexagon", "1");
2895 Builder.defineMacro("__hexagon__", "1");
2896
2897 if(CPU == "hexagonv1") {
2898 Builder.defineMacro("__HEXAGON_V1__");
2899 Builder.defineMacro("__HEXAGON_ARCH__", "1");
2900 if(Opts.HexagonQdsp6Compat) {
2901 Builder.defineMacro("__QDSP6_V1__");
2902 Builder.defineMacro("__QDSP6_ARCH__", "1");
2903 }
2904 }
2905 else if(CPU == "hexagonv2") {
2906 Builder.defineMacro("__HEXAGON_V2__");
2907 Builder.defineMacro("__HEXAGON_ARCH__", "2");
2908 if(Opts.HexagonQdsp6Compat) {
2909 Builder.defineMacro("__QDSP6_V2__");
2910 Builder.defineMacro("__QDSP6_ARCH__", "2");
2911 }
2912 }
2913 else if(CPU == "hexagonv3") {
2914 Builder.defineMacro("__HEXAGON_V3__");
2915 Builder.defineMacro("__HEXAGON_ARCH__", "3");
2916 if(Opts.HexagonQdsp6Compat) {
2917 Builder.defineMacro("__QDSP6_V3__");
2918 Builder.defineMacro("__QDSP6_ARCH__", "3");
2919 }
2920 }
2921 else if(CPU == "hexagonv4") {
2922 Builder.defineMacro("__HEXAGON_V4__");
2923 Builder.defineMacro("__HEXAGON_ARCH__", "4");
2924 if(Opts.HexagonQdsp6Compat) {
2925 Builder.defineMacro("__QDSP6_V4__");
2926 Builder.defineMacro("__QDSP6_ARCH__", "4");
2927 }
2928 }
2929}
2930
2931const char * const HexagonTargetInfo::GCCRegNames[] = {
2932 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2933 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2934 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2935 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
2936 "p0", "p1", "p2", "p3",
2937 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
2938};
2939
2940void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
2941 unsigned &NumNames) const {
2942 Names = GCCRegNames;
2943 NumNames = llvm::array_lengthof(GCCRegNames);
2944}
2945
2946
2947const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
2948 { { "sp" }, "r29" },
2949 { { "fp" }, "r30" },
2950 { { "lr" }, "r31" },
2951 };
2952
2953void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2954 unsigned &NumAliases) const {
2955 Aliases = GCCRegAliases;
2956 NumAliases = llvm::array_lengthof(GCCRegAliases);
2957}
2958
2959
2960const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
2961#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
2962#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
2963 ALL_LANGUAGES },
2964#include "clang/Basic/BuiltinsHexagon.def"
2965};
2966}
2967
2968
Reid Spencer5f016e22007-07-11 17:01:13 +00002969namespace {
Eli Friedman01b86682008-08-20 07:28:14 +00002970class SparcV8TargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00002971 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2972 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002973 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00002974public:
Eli Friedman01b86682008-08-20 07:28:14 +00002975 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
2976 // FIXME: Support Sparc quad-precision long double?
Eli Friedmaned855cb2008-08-21 00:13:15 +00002977 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 +00002978 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedman01b86682008-08-20 07:28:14 +00002979 }
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00002980 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2981 const std::string &Name,
2982 bool Enabled) const {
2983 if (Name == "soft-float")
2984 Features[Name] = Enabled;
2985 else
2986 return false;
2987
2988 return true;
2989 }
2990 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
2991 SoftFloat = false;
2992 for (unsigned i = 0, e = Features.size(); i != e; ++i)
2993 if (Features[i] == "+soft-float")
2994 SoftFloat = true;
2995 }
Chris Lattner33328642009-03-20 15:52:06 +00002996 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002997 MacroBuilder &Builder) const {
2998 DefineStd(Builder, "sparc", Opts);
2999 Builder.defineMacro("__sparcv8");
3000 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003001
3002 if (SoftFloat)
3003 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00003004 }
3005 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3006 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003007 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00003008 }
3009 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00003010 return "typedef void* __builtin_va_list;";
Gabor Greif26658672008-02-21 16:29:08 +00003011 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003012 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003013 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003014 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003015 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003016 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00003017 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003018 // FIXME: Implement!
3019 return false;
Gabor Greif26658672008-02-21 16:29:08 +00003020 }
3021 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00003022 // FIXME: Implement!
3023 return "";
Gabor Greif26658672008-02-21 16:29:08 +00003024 }
3025};
3026
Chris Lattnere957f532009-01-27 01:58:38 +00003027const char * const SparcV8TargetInfo::GCCRegNames[] = {
3028 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3029 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3030 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3031 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
3032};
3033
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003034void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003035 unsigned &NumNames) const {
3036 Names = GCCRegNames;
3037 NumNames = llvm::array_lengthof(GCCRegNames);
3038}
3039
3040const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003041 { { "g0" }, "r0" },
3042 { { "g1" }, "r1" },
3043 { { "g2" }, "r2" },
3044 { { "g3" }, "r3" },
3045 { { "g4" }, "r4" },
3046 { { "g5" }, "r5" },
3047 { { "g6" }, "r6" },
3048 { { "g7" }, "r7" },
3049 { { "o0" }, "r8" },
3050 { { "o1" }, "r9" },
3051 { { "o2" }, "r10" },
3052 { { "o3" }, "r11" },
3053 { { "o4" }, "r12" },
3054 { { "o5" }, "r13" },
3055 { { "o6", "sp" }, "r14" },
3056 { { "o7" }, "r15" },
3057 { { "l0" }, "r16" },
3058 { { "l1" }, "r17" },
3059 { { "l2" }, "r18" },
3060 { { "l3" }, "r19" },
3061 { { "l4" }, "r20" },
3062 { { "l5" }, "r21" },
3063 { { "l6" }, "r22" },
3064 { { "l7" }, "r23" },
3065 { { "i0" }, "r24" },
3066 { { "i1" }, "r25" },
3067 { { "i2" }, "r26" },
3068 { { "i3" }, "r27" },
3069 { { "i4" }, "r28" },
3070 { { "i5" }, "r29" },
3071 { { "i6", "fp" }, "r30" },
3072 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00003073};
3074
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003075void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003076 unsigned &NumAliases) const {
3077 Aliases = GCCRegAliases;
3078 NumAliases = llvm::array_lengthof(GCCRegAliases);
3079}
Gabor Greif26658672008-02-21 16:29:08 +00003080} // end anonymous namespace.
3081
Eli Friedman01b86682008-08-20 07:28:14 +00003082namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003083class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
3084public:
3085 AuroraUXSparcV8TargetInfo(const std::string& triple) :
3086 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
3087 SizeType = UnsignedInt;
3088 PtrDiffType = SignedInt;
3089 }
3090};
Torok Edwin5f6c1942009-06-30 17:10:35 +00003091class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00003092public:
3093 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003094 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00003095 SizeType = UnsignedInt;
3096 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00003097 }
3098};
3099} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00003100
Chris Lattner2621fd12008-05-08 05:58:21 +00003101namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003102 class MSP430TargetInfo : public TargetInfo {
3103 static const char * const GCCRegNames[];
3104 public:
3105 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
3106 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00003107 IntWidth = 16; IntAlign = 16;
3108 LongWidth = 32; LongLongWidth = 64;
3109 LongAlign = LongLongAlign = 16;
3110 PointerWidth = 16; PointerAlign = 16;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003111 SuitableAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003112 SizeType = UnsignedInt;
3113 IntMaxType = SignedLong;
3114 UIntMaxType = UnsignedLong;
3115 IntPtrType = SignedShort;
3116 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00003117 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00003118 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003119 }
3120 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003121 MacroBuilder &Builder) const {
3122 Builder.defineMacro("MSP430");
3123 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003124 // FIXME: defines for different 'flavours' of MCU
3125 }
3126 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3127 unsigned &NumRecords) const {
3128 // FIXME: Implement.
3129 Records = 0;
3130 NumRecords = 0;
3131 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003132 virtual void getGCCRegNames(const char * const *&Names,
3133 unsigned &NumNames) const;
3134 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3135 unsigned &NumAliases) const {
3136 // No aliases.
3137 Aliases = 0;
3138 NumAliases = 0;
3139 }
3140 virtual bool validateAsmConstraint(const char *&Name,
3141 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00003142 // No target constraints for now.
3143 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003144 }
3145 virtual const char *getClobbers() const {
3146 // FIXME: Is this really right?
3147 return "";
3148 }
3149 virtual const char *getVAListDeclaration() const {
3150 // FIXME: implement
Anton Korobeynikoveb716852009-05-08 18:24:57 +00003151 return "typedef char* __builtin_va_list;";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003152 }
3153 };
3154
3155 const char * const MSP430TargetInfo::GCCRegNames[] = {
3156 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3157 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3158 };
3159
3160 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
3161 unsigned &NumNames) const {
3162 Names = GCCRegNames;
3163 NumNames = llvm::array_lengthof(GCCRegNames);
3164 }
3165}
3166
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00003167namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00003168
Mike Stump1eb44332009-09-09 15:08:12 +00003169 // LLVM and Clang cannot be used directly to output native binaries for
3170 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00003171 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00003172 //
3173 // TCE uses the llvm bitcode as input and uses it for generating customized
3174 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00003175 // publicly available in http://tce.cs.tut.fi
3176
Eli Friedman209f5bb2011-10-07 19:51:42 +00003177 static const unsigned TCEOpenCLAddrSpaceMap[] = {
3178 3, // opencl_global
3179 4, // opencl_local
3180 5 // opencl_constant
3181 };
3182
Eli Friedmanb63decf2009-08-19 20:47:07 +00003183 class TCETargetInfo : public TargetInfo{
3184 public:
3185 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
3186 TLSSupported = false;
3187 IntWidth = 32;
3188 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003189 PointerWidth = 32;
3190 IntAlign = 32;
3191 LongAlign = LongLongAlign = 32;
3192 PointerAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003193 SuitableAlign = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003194 SizeType = UnsignedInt;
3195 IntMaxType = SignedLong;
3196 UIntMaxType = UnsignedLong;
3197 IntPtrType = SignedInt;
3198 PtrDiffType = SignedInt;
3199 FloatWidth = 32;
3200 FloatAlign = 32;
3201 DoubleWidth = 32;
3202 DoubleAlign = 32;
3203 LongDoubleWidth = 32;
3204 LongDoubleAlign = 32;
3205 FloatFormat = &llvm::APFloat::IEEEsingle;
3206 DoubleFormat = &llvm::APFloat::IEEEsingle;
3207 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00003208 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
3209 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00003210 "f32:32:32-f64:32:32-v64:32:32-"
3211 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00003212 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003213 }
3214
3215 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003216 MacroBuilder &Builder) const {
3217 DefineStd(Builder, "tce", Opts);
3218 Builder.defineMacro("__TCE__");
3219 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00003220 }
3221 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3222 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00003223 virtual const char *getClobbers() const {
3224 return "";
3225 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003226 virtual const char *getVAListDeclaration() const {
3227 return "typedef void* __builtin_va_list;";
3228 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003229 virtual void getGCCRegNames(const char * const *&Names,
3230 unsigned &NumNames) const {}
3231 virtual bool validateAsmConstraint(const char *&Name,
3232 TargetInfo::ConstraintInfo &info) const {
3233 return true;
3234 }
3235 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3236 unsigned &NumAliases) const {}
3237 };
3238}
3239
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003240namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003241class MipsTargetInfoBase : public TargetInfo {
3242 std::string CPU;
3243protected:
3244 std::string ABI;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003245public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003246 MipsTargetInfoBase(const std::string& triple, const std::string& ABIStr)
Akira Hatanaka148735e2011-11-05 01:48:34 +00003247 : TargetInfo(triple), ABI(ABIStr) {}
Eric Christophered734732010-03-02 02:41:08 +00003248 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003249 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00003250 virtual bool setCPU(const std::string &Name) {
3251 CPU = Name;
3252 return true;
3253 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003254 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00003255 Features[ABI] = true;
3256 Features[CPU] = true;
3257 }
3258 virtual void getArchDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003259 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003260 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003261 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003262 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3263 unsigned &NumRecords) const {
3264 // FIXME: Implement!
3265 }
3266 virtual const char *getVAListDeclaration() const {
3267 return "typedef void* __builtin_va_list;";
3268 }
3269 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003270 unsigned &NumNames) const {
3271 static const char * const GCCRegNames[] = {
3272 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
3273 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
3274 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
3275 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
3276 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
3277 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
3278 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
3279 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
3280 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
3281 "$fcc5","$fcc6","$fcc7"
3282 };
3283 Names = GCCRegNames;
3284 NumNames = llvm::array_lengthof(GCCRegNames);
3285 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003286 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003287 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003288 virtual bool validateAsmConstraint(const char *&Name,
3289 TargetInfo::ConstraintInfo &Info) const {
3290 switch (*Name) {
3291 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00003292 return false;
3293
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003294 case 'r': // CPU registers.
3295 case 'd': // Equivalent to "r" unless generating MIPS16 code.
3296 case 'y': // Equivalent to "r", backwards compatibility only.
3297 case 'f': // floating-point registers.
3298 Info.setAllowsRegister();
3299 return true;
3300 }
3301 return false;
3302 }
3303
3304 virtual const char *getClobbers() const {
3305 // FIXME: Implement!
3306 return "";
3307 }
3308};
3309
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003310class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003311public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003312 Mips32TargetInfoBase(const std::string& triple) :
Akira Hatanaka148735e2011-11-05 01:48:34 +00003313 MipsTargetInfoBase(triple, "o32") {
3314 SizeType = UnsignedInt;
3315 PtrDiffType = SignedInt;
3316 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003317 virtual bool setABI(const std::string &Name) {
3318 if ((Name == "o32") || (Name == "eabi")) {
3319 ABI = Name;
3320 return true;
3321 } else
3322 return false;
3323 }
3324 virtual void getArchDefines(const LangOptions &Opts,
3325 MacroBuilder &Builder) const {
Douglas Gregorc9a23712011-11-09 15:17:16 +00003326 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
3327 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
3328 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
3329
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003330 if (ABI == "o32") {
3331 Builder.defineMacro("__mips_o32");
3332 Builder.defineMacro("_ABIO32", "1");
3333 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
3334 }
3335 else if (ABI == "eabi")
3336 Builder.defineMacro("__mips_eabi");
3337 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003338 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003339 }
3340 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3341 unsigned &NumAliases) const {
3342 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3343 { { "at" }, "$1" },
3344 { { "v0" }, "$2" },
3345 { { "v1" }, "$3" },
3346 { { "a0" }, "$4" },
3347 { { "a1" }, "$5" },
3348 { { "a2" }, "$6" },
3349 { { "a3" }, "$7" },
3350 { { "t0" }, "$8" },
3351 { { "t1" }, "$9" },
3352 { { "t2" }, "$10" },
3353 { { "t3" }, "$11" },
3354 { { "t4" }, "$12" },
3355 { { "t5" }, "$13" },
3356 { { "t6" }, "$14" },
3357 { { "t7" }, "$15" },
3358 { { "s0" }, "$16" },
3359 { { "s1" }, "$17" },
3360 { { "s2" }, "$18" },
3361 { { "s3" }, "$19" },
3362 { { "s4" }, "$20" },
3363 { { "s5" }, "$21" },
3364 { { "s6" }, "$22" },
3365 { { "s7" }, "$23" },
3366 { { "t8" }, "$24" },
3367 { { "t9" }, "$25" },
3368 { { "k0" }, "$26" },
3369 { { "k1" }, "$27" },
3370 { { "gp" }, "$28" },
3371 { { "sp" }, "$29" },
3372 { { "fp" }, "$30" },
3373 { { "ra" }, "$31" }
3374 };
3375 Aliases = GCCRegAliases;
3376 NumAliases = llvm::array_lengthof(GCCRegAliases);
3377 }
3378};
3379
3380class Mips32EBTargetInfo : public Mips32TargetInfoBase {
3381public:
3382 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
3383 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3384 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3385 }
3386 virtual void getTargetDefines(const LangOptions &Opts,
3387 MacroBuilder &Builder) const {
3388 DefineStd(Builder, "mips", Opts);
3389 Builder.defineMacro("_mips");
3390 DefineStd(Builder, "MIPSEB", Opts);
3391 Builder.defineMacro("_MIPSEB");
3392 Builder.defineMacro("__REGISTER_PREFIX__", "");
3393 getArchDefines(Opts, Builder);
3394 }
3395};
3396
3397class Mips32ELTargetInfo : public Mips32TargetInfoBase {
3398public:
3399 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003400 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 +00003401 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003402 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003403 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003404 MacroBuilder &Builder) const {
3405 DefineStd(Builder, "mips", Opts);
3406 Builder.defineMacro("_mips");
3407 DefineStd(Builder, "MIPSEL", Opts);
3408 Builder.defineMacro("_MIPSEL");
3409 Builder.defineMacro("__REGISTER_PREFIX__", "");
3410 getArchDefines(Opts, Builder);
3411 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003412};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003413
3414class Mips64TargetInfoBase : public MipsTargetInfoBase {
3415 virtual void SetDescriptionString(const std::string &Name) = 0;
3416public:
3417 Mips64TargetInfoBase(const std::string& triple) :
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003418 MipsTargetInfoBase(triple, "n64") {
3419 LongWidth = LongAlign = 64;
3420 PointerWidth = PointerAlign = 64;
3421 LongDoubleWidth = LongDoubleAlign = 128;
3422 LongDoubleFormat = &llvm::APFloat::IEEEquad;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003423 SuitableAlign = 128;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003424 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003425 virtual bool setABI(const std::string &Name) {
3426 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003427
3428 if (Name != "n32" && Name != "n64")
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003429 return false;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003430
3431 ABI = Name;
3432
3433 if (Name == "n32") {
3434 LongWidth = LongAlign = 32;
3435 PointerWidth = PointerAlign = 32;
3436 }
3437
3438 return true;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003439 }
3440 virtual void getArchDefines(const LangOptions &Opts,
3441 MacroBuilder &Builder) const {
3442 if (ABI == "n32") {
3443 Builder.defineMacro("__mips_n32");
3444 Builder.defineMacro("_ABIN32", "2");
3445 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
3446 }
3447 else if (ABI == "n64") {
3448 Builder.defineMacro("__mips_n64");
3449 Builder.defineMacro("_ABI64", "3");
3450 Builder.defineMacro("_MIPS_SIM", "_ABI64");
3451 }
3452 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003453 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003454 }
3455 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3456 unsigned &NumAliases) const {
3457 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3458 { { "at" }, "$1" },
3459 { { "v0" }, "$2" },
3460 { { "v1" }, "$3" },
3461 { { "a0" }, "$4" },
3462 { { "a1" }, "$5" },
3463 { { "a2" }, "$6" },
3464 { { "a3" }, "$7" },
3465 { { "a4" }, "$8" },
3466 { { "a5" }, "$9" },
3467 { { "a6" }, "$10" },
3468 { { "a7" }, "$11" },
3469 { { "t0" }, "$12" },
3470 { { "t1" }, "$13" },
3471 { { "t2" }, "$14" },
3472 { { "t3" }, "$15" },
3473 { { "s0" }, "$16" },
3474 { { "s1" }, "$17" },
3475 { { "s2" }, "$18" },
3476 { { "s3" }, "$19" },
3477 { { "s4" }, "$20" },
3478 { { "s5" }, "$21" },
3479 { { "s6" }, "$22" },
3480 { { "s7" }, "$23" },
3481 { { "t8" }, "$24" },
3482 { { "t9" }, "$25" },
3483 { { "k0" }, "$26" },
3484 { { "k1" }, "$27" },
3485 { { "gp" }, "$28" },
3486 { { "sp" }, "$29" },
3487 { { "fp" }, "$30" },
3488 { { "ra" }, "$31" }
3489 };
3490 Aliases = GCCRegAliases;
3491 NumAliases = llvm::array_lengthof(GCCRegAliases);
3492 }
3493};
3494
3495class Mips64EBTargetInfo : public Mips64TargetInfoBase {
3496 virtual void SetDescriptionString(const std::string &Name) {
3497 // Change DescriptionString only if ABI is n32.
3498 if (Name == "n32")
3499 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 +00003500 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3501 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003502 }
3503public:
3504 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3505 // Default ABI is n64.
3506 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 +00003507 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3508 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003509 }
3510 virtual void getTargetDefines(const LangOptions &Opts,
3511 MacroBuilder &Builder) const {
3512 DefineStd(Builder, "mips", Opts);
3513 Builder.defineMacro("_mips");
3514 DefineStd(Builder, "MIPSEB", Opts);
3515 Builder.defineMacro("_MIPSEB");
3516 Builder.defineMacro("__REGISTER_PREFIX__", "");
3517 getArchDefines(Opts, Builder);
3518 }
3519};
3520
3521class Mips64ELTargetInfo : public Mips64TargetInfoBase {
3522 virtual void SetDescriptionString(const std::string &Name) {
3523 // Change DescriptionString only if ABI is n32.
3524 if (Name == "n32")
3525 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 +00003526 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
3527 "-v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003528 }
3529public:
3530 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3531 // Default ABI is n64.
3532 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 +00003533 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3534 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003535 }
3536 virtual void getTargetDefines(const LangOptions &Opts,
3537 MacroBuilder &Builder) const {
3538 DefineStd(Builder, "mips", Opts);
3539 Builder.defineMacro("_mips");
3540 DefineStd(Builder, "MIPSEL", Opts);
3541 Builder.defineMacro("_MIPSEL");
3542 Builder.defineMacro("__REGISTER_PREFIX__", "");
3543 getArchDefines(Opts, Builder);
3544 }
3545};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003546} // end anonymous namespace.
3547
Ivan Krasinef05abd2011-08-24 20:22:22 +00003548namespace {
3549class PNaClTargetInfo : public TargetInfo {
3550public:
3551 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
3552 this->UserLabelPrefix = "";
3553 this->LongAlign = 32;
3554 this->LongWidth = 32;
3555 this->PointerAlign = 32;
3556 this->PointerWidth = 32;
3557 this->IntMaxType = TargetInfo::SignedLongLong;
3558 this->UIntMaxType = TargetInfo::UnsignedLongLong;
3559 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003560 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003561 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003562 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003563 this->SizeType = TargetInfo::UnsignedInt;
3564 this->PtrDiffType = TargetInfo::SignedInt;
3565 this->IntPtrType = TargetInfo::SignedInt;
David Meyerdd4a8892011-10-11 03:12:01 +00003566 this->RegParmMax = 2;
Ivan Krasinef05abd2011-08-24 20:22:22 +00003567 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
3568 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
3569 }
3570
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003571 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00003572 }
3573 virtual void getArchDefines(const LangOptions &Opts,
3574 MacroBuilder &Builder) const {
3575 Builder.defineMacro("__le32__");
3576 Builder.defineMacro("__pnacl__");
3577 }
3578 virtual void getTargetDefines(const LangOptions &Opts,
3579 MacroBuilder &Builder) const {
Ivan Krasin089ee112011-08-25 23:49:20 +00003580 DefineStd(Builder, "unix", Opts);
3581 Builder.defineMacro("__ELF__");
3582 if (Opts.POSIXThreads)
3583 Builder.defineMacro("_REENTRANT");
3584 if (Opts.CPlusPlus)
3585 Builder.defineMacro("_GNU_SOURCE");
3586
Ivan Krasinef05abd2011-08-24 20:22:22 +00003587 Builder.defineMacro("__native_client__");
3588 getArchDefines(Opts, Builder);
3589 }
3590 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3591 unsigned &NumRecords) const {
3592 }
3593 virtual const char *getVAListDeclaration() const {
Ivan Krasin68018db2011-09-20 14:56:54 +00003594 return "typedef int __builtin_va_list[4];";
Ivan Krasinef05abd2011-08-24 20:22:22 +00003595 }
3596 virtual void getGCCRegNames(const char * const *&Names,
3597 unsigned &NumNames) const;
3598 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3599 unsigned &NumAliases) const;
3600 virtual bool validateAsmConstraint(const char *&Name,
3601 TargetInfo::ConstraintInfo &Info) const {
3602 return false;
3603 }
3604
3605 virtual const char *getClobbers() const {
3606 return "";
3607 }
3608};
3609
3610void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
3611 unsigned &NumNames) const {
3612 Names = NULL;
3613 NumNames = 0;
3614}
3615
3616void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3617 unsigned &NumAliases) const {
3618 Aliases = NULL;
3619 NumAliases = 0;
3620}
3621} // end anonymous namespace.
3622
3623
Reid Spencer5f016e22007-07-11 17:01:13 +00003624//===----------------------------------------------------------------------===//
3625// Driver code
3626//===----------------------------------------------------------------------===//
3627
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003628static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003629 llvm::Triple Triple(T);
3630 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00003631
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003632 switch (Triple.getArch()) {
3633 default:
3634 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00003635
Tony Linthicum96319392011-12-12 21:14:55 +00003636 case llvm::Triple::hexagon:
3637 return new HexagonTargetInfo(T);
3638
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003639 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00003640 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003641 if (Triple.isOSDarwin())
3642 return new DarwinARMTargetInfo(T);
3643
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003644 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00003645 case llvm::Triple::Linux:
3646 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003647 case llvm::Triple::FreeBSD:
Torok Edwin5f6c1942009-06-30 17:10:35 +00003648 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003649 case llvm::Triple::NetBSD:
3650 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003651 case llvm::Triple::RTEMS:
3652 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003653 default:
3654 return new ARMTargetInfo(T);
3655 }
Eli Friedman61538a72008-05-20 14:21:01 +00003656
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003657 case llvm::Triple::msp430:
3658 return new MSP430TargetInfo(T);
Eli Friedman61538a72008-05-20 14:21:01 +00003659
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003660 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003661 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003662 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003663 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003664 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003665 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003666 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003667 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003668 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003669 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003670 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003671 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003672 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003673
3674 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003675 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003676 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003677 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003678 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003679 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003680 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003681 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003682 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003683 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003684 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003685 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003686 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003687
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003688 case llvm::Triple::mips64:
3689 switch (os) {
3690 case llvm::Triple::Linux:
3691 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
3692 case llvm::Triple::RTEMS:
3693 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
3694 case llvm::Triple::FreeBSD:
3695 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
3696 case llvm::Triple::NetBSD:
3697 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
3698 default:
3699 return new Mips64EBTargetInfo(T);
3700 }
3701
3702 case llvm::Triple::mips64el:
3703 switch (os) {
3704 case llvm::Triple::Linux:
3705 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
3706 case llvm::Triple::RTEMS:
3707 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
3708 case llvm::Triple::FreeBSD:
3709 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
3710 case llvm::Triple::NetBSD:
3711 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
3712 default:
3713 return new Mips64ELTargetInfo(T);
3714 }
3715
Ivan Krasinef05abd2011-08-24 20:22:22 +00003716 case llvm::Triple::le32:
3717 switch (os) {
3718 case llvm::Triple::NativeClient:
3719 return new PNaClTargetInfo(T);
3720 default:
3721 return NULL;
3722 }
3723
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003724 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003725 if (Triple.isOSDarwin())
Roman Divackyc81f2a22011-01-06 08:27:10 +00003726 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003727 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003728 case llvm::Triple::Linux:
3729 return new LinuxTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003730 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00003731 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003732 case llvm::Triple::NetBSD:
3733 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
3734 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003735 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003736 default:
3737 return new PPC32TargetInfo(T);
3738 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003739
3740 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003741 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00003742 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003743 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003744 case llvm::Triple::Linux:
3745 return new LinuxTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003746 case llvm::Triple::Lv2:
John Thompson3f6918a2009-11-19 17:18:50 +00003747 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003748 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00003749 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003750 case llvm::Triple::NetBSD:
3751 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
3752 default:
3753 return new PPC64TargetInfo(T);
3754 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003755
Justin Holewinski285dc652011-04-20 19:34:15 +00003756 case llvm::Triple::ptx32:
3757 return new PTX32TargetInfo(T);
3758 case llvm::Triple::ptx64:
3759 return new PTX64TargetInfo(T);
3760
Chris Lattner9cbeb632010-03-06 21:21:27 +00003761 case llvm::Triple::mblaze:
3762 return new MBlazeTargetInfo(T);
3763
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003764 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003765 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003766 case llvm::Triple::Linux:
3767 return new LinuxTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003768 case llvm::Triple::AuroraUX:
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003769 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003770 case llvm::Triple::Solaris:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003771 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003772 case llvm::Triple::NetBSD:
3773 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
3774 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003775 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003776 default:
3777 return new SparcV8TargetInfo(T);
3778 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003779
John Thompson3f6918a2009-11-19 17:18:50 +00003780 // FIXME: Need a real SPU target.
3781 case llvm::Triple::cellspu:
3782 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
3783
Eli Friedmanb63decf2009-08-19 20:47:07 +00003784 case llvm::Triple::tce:
3785 return new TCETargetInfo(T);
3786
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003787 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003788 if (Triple.isOSDarwin())
3789 return new DarwinI386TargetInfo(T);
3790
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003791 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003792 case llvm::Triple::AuroraUX:
3793 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003794 case llvm::Triple::Linux:
3795 return new LinuxTargetInfo<X86_32TargetInfo>(T);
3796 case llvm::Triple::DragonFly:
3797 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
3798 case llvm::Triple::NetBSD:
3799 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
3800 case llvm::Triple::OpenBSD:
3801 return new OpenBSDI386TargetInfo(T);
3802 case llvm::Triple::FreeBSD:
3803 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner38e317d2010-07-07 16:01:42 +00003804 case llvm::Triple::Minix:
3805 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003806 case llvm::Triple::Solaris:
3807 return new SolarisTargetInfo<X86_32TargetInfo>(T);
3808 case llvm::Triple::Cygwin:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003809 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003810 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003811 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003812 case llvm::Triple::Win32:
Michael J. Spencera764e832010-10-21 08:22:51 +00003813 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattner86ed3a32010-04-11 19:29:39 +00003814 case llvm::Triple::Haiku:
3815 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003816 case llvm::Triple::RTEMS:
3817 return new RTEMSX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003818 default:
3819 return new X86_32TargetInfo(T);
3820 }
3821
3822 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003823 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
3824 return new DarwinX86_64TargetInfo(T);
3825
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003826 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003827 case llvm::Triple::AuroraUX:
3828 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003829 case llvm::Triple::Linux:
3830 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner7a7ca282010-01-09 05:41:14 +00003831 case llvm::Triple::DragonFly:
3832 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003833 case llvm::Triple::NetBSD:
3834 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
3835 case llvm::Triple::OpenBSD:
3836 return new OpenBSDX86_64TargetInfo(T);
3837 case llvm::Triple::FreeBSD:
3838 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
3839 case llvm::Triple::Solaris:
3840 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00003841 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003842 return new MinGWX86_64TargetInfo(T);
3843 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003844 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003845 default:
3846 return new X86_64TargetInfo(T);
3847 }
3848 }
Reid Spencer5f016e22007-07-11 17:01:13 +00003849}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003850
3851/// CreateTargetInfo - Return the target info object for the specified target
3852/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00003853TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003854 TargetOptions &Opts) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003855 llvm::Triple Triple(Opts.Triple);
3856
3857 // Construct the target
3858 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
3859 if (!Target) {
3860 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
3861 return 0;
3862 }
3863
Daniel Dunbareac7c532009-12-18 18:42:37 +00003864 // Set the target CPU if specified.
3865 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
3866 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
3867 return 0;
3868 }
3869
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003870 // Set the target ABI if specified.
3871 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
3872 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
3873 return 0;
3874 }
3875
Charles Davis98b7c5c2010-06-11 01:06:47 +00003876 // Set the target C++ ABI.
John McCallee79a4c2010-08-21 22:46:04 +00003877 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davis98b7c5c2010-06-11 01:06:47 +00003878 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
3879 return 0;
3880 }
3881
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003882 // Compute the default target features, we need the target to handle this
3883 // because features may have dependencies on one another.
3884 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003885 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003886
3887 // Apply the user specified deltas.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00003888 // First the enables.
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003889 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
3890 ie = Opts.Features.end(); it != ie; ++it) {
3891 const char *Name = it->c_str();
3892
Rafael Espindola53ac3d82011-11-27 20:00:43 +00003893 if (Name[0] != '+')
3894 continue;
3895
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003896 // Apply the feature via the target.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00003897 if (!Target->setFeatureEnabled(Features, Name + 1, true)) {
3898 Diags.Report(diag::err_target_invalid_feature) << Name;
3899 return 0;
3900 }
3901 }
3902
3903 // Then the disables.
3904 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
3905 ie = Opts.Features.end(); it != ie; ++it) {
3906 const char *Name = it->c_str();
3907
3908 if (Name[0] == '+')
3909 continue;
3910
3911 // Apply the feature via the target.
3912 if (Name[0] != '-' ||
3913 !Target->setFeatureEnabled(Features, Name + 1, false)) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003914 Diags.Report(diag::err_target_invalid_feature) << Name;
3915 return 0;
3916 }
3917 }
3918
3919 // Add the features to the compile options.
3920 //
3921 // FIXME: If we are completely confident that we have the right set, we only
3922 // need to pass the minuses.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003923 Opts.Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003924 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
3925 ie = Features.end(); it != ie; ++it)
Chris Lattner1e5f83b2011-07-14 18:24:21 +00003926 Opts.Features.push_back(std::string(it->second ? "+" : "-") +
Chris Lattner48b78bd2011-07-14 18:45:41 +00003927 it->first().str());
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003928 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003929
3930 return Target.take();
3931}