blob: 51538f1a775971385e36232ecb89bb1c5786e498 [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?
Nick Lewycky9bddf432011-12-21 04:25:47 +0000883 SuitableAlign = 128;
Roman Divackyc81f2a22011-01-06 08:27:10 +0000884 }
885 virtual const char *getVAListDeclaration() const {
886 return "typedef char* __builtin_va_list;";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000887 }
888};
889
890class DarwinPPC64TargetInfo :
891 public DarwinTargetInfo<PPC64TargetInfo> {
892public:
893 DarwinPPC64TargetInfo(const std::string& triple)
894 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
895 HasAlignMac68kSupport = true;
Nick Lewycky9bddf432011-12-21 04:25:47 +0000896 SuitableAlign = 128;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000897 }
898};
899} // end anonymous namespace.
900
Reid Spencer5f016e22007-07-11 17:01:13 +0000901namespace {
Justin Holewinski25bedca2011-10-03 17:28:37 +0000902 static const unsigned PTXAddrSpaceMap[] = {
903 0, // opencl_global
904 4, // opencl_local
905 1 // opencl_constant
906 };
Justin Holewinski285dc652011-04-20 19:34:15 +0000907 class PTXTargetInfo : public TargetInfo {
908 static const char * const GCCRegNames[];
909 static const Builtin::Info BuiltinInfo[];
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000910 std::vector<llvm::StringRef> AvailableFeatures;
Justin Holewinski285dc652011-04-20 19:34:15 +0000911 public:
912 PTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +0000913 BigEndian = false;
Justin Holewinski285dc652011-04-20 19:34:15 +0000914 TLSSupported = false;
915 LongWidth = LongAlign = 64;
Justin Holewinski25bedca2011-10-03 17:28:37 +0000916 AddrSpaceMap = &PTXAddrSpaceMap;
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000917 // Define available target features
918 // These must be defined in sorted order!
919 AvailableFeatures.push_back("compute10");
920 AvailableFeatures.push_back("compute11");
921 AvailableFeatures.push_back("compute12");
922 AvailableFeatures.push_back("compute13");
923 AvailableFeatures.push_back("compute20");
924 AvailableFeatures.push_back("double");
925 AvailableFeatures.push_back("no-fma");
926 AvailableFeatures.push_back("ptx20");
927 AvailableFeatures.push_back("ptx21");
928 AvailableFeatures.push_back("ptx22");
929 AvailableFeatures.push_back("ptx23");
930 AvailableFeatures.push_back("sm10");
931 AvailableFeatures.push_back("sm11");
932 AvailableFeatures.push_back("sm12");
933 AvailableFeatures.push_back("sm13");
934 AvailableFeatures.push_back("sm20");
935 AvailableFeatures.push_back("sm21");
936 AvailableFeatures.push_back("sm22");
937 AvailableFeatures.push_back("sm23");
Justin Holewinski285dc652011-04-20 19:34:15 +0000938 }
939 virtual void getTargetDefines(const LangOptions &Opts,
940 MacroBuilder &Builder) const {
941 Builder.defineMacro("__PTX__");
942 }
943 virtual void getTargetBuiltins(const Builtin::Info *&Records,
944 unsigned &NumRecords) const {
945 Records = BuiltinInfo;
946 NumRecords = clang::PTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
947 }
948
949 virtual void getGCCRegNames(const char * const *&Names,
950 unsigned &NumNames) const;
951 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
952 unsigned &NumAliases) const {
953 // No aliases.
954 Aliases = 0;
955 NumAliases = 0;
956 }
957 virtual bool validateAsmConstraint(const char *&Name,
958 TargetInfo::ConstraintInfo &info) const {
959 // FIXME: implement
960 return true;
961 }
962 virtual const char *getClobbers() const {
963 // FIXME: Is this really right?
964 return "";
965 }
966 virtual const char *getVAListDeclaration() const {
967 // FIXME: implement
968 return "typedef char* __builtin_va_list;";
969 }
Justin Holewinski808ef662011-09-15 12:13:38 +0000970
971 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
972 const std::string &Name,
973 bool Enabled) const;
Justin Holewinski285dc652011-04-20 19:34:15 +0000974 };
975
976 const Builtin::Info PTXTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000977#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +0000978#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000979 ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +0000980#include "clang/Basic/BuiltinsPTX.def"
981 };
982
983 const char * const PTXTargetInfo::GCCRegNames[] = {
984 "r0"
985 };
986
987 void PTXTargetInfo::getGCCRegNames(const char * const *&Names,
988 unsigned &NumNames) const {
989 Names = GCCRegNames;
990 NumNames = llvm::array_lengthof(GCCRegNames);
991 }
992
Justin Holewinski808ef662011-09-15 12:13:38 +0000993 bool PTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
994 const std::string &Name,
995 bool Enabled) const {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000996 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
997 Name)) {
998 Features[Name] = Enabled;
999 return true;
Justin Holewinski808ef662011-09-15 12:13:38 +00001000 } else {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +00001001 return false;
Justin Holewinski808ef662011-09-15 12:13:38 +00001002 }
Justin Holewinski808ef662011-09-15 12:13:38 +00001003 }
Justin Holewinski285dc652011-04-20 19:34:15 +00001004
1005 class PTX32TargetInfo : public PTXTargetInfo {
1006 public:
1007 PTX32TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
1008 PointerWidth = PointerAlign = 32;
1009 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
1010 DescriptionString
1011 = "e-p:32:32-i64:64:64-f64:64:64-n1:8:16:32:64";
1012 }
1013 };
1014
1015 class PTX64TargetInfo : public PTXTargetInfo {
1016 public:
1017 PTX64TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
1018 PointerWidth = PointerAlign = 64;
1019 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
1020 DescriptionString
1021 = "e-p:64:64-i64:64:64-f64:64:64-n1:8:16:32:64";
1022 }
1023 };
1024}
1025
1026namespace {
Chris Lattner9cbeb632010-03-06 21:21:27 +00001027// MBlaze abstract base class
1028class MBlazeTargetInfo : public TargetInfo {
1029 static const char * const GCCRegNames[];
1030 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1031
1032public:
1033 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +00001034 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner9cbeb632010-03-06 21:21:27 +00001035 }
1036
1037 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1038 unsigned &NumRecords) const {
1039 // FIXME: Implement.
1040 Records = 0;
1041 NumRecords = 0;
1042 }
1043
1044 virtual void getTargetDefines(const LangOptions &Opts,
1045 MacroBuilder &Builder) const;
1046
1047 virtual const char *getVAListDeclaration() const {
1048 return "typedef char* __builtin_va_list;";
1049 }
1050 virtual const char *getTargetPrefix() const {
1051 return "mblaze";
1052 }
1053 virtual void getGCCRegNames(const char * const *&Names,
1054 unsigned &NumNames) const;
1055 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1056 unsigned &NumAliases) const;
1057 virtual bool validateAsmConstraint(const char *&Name,
1058 TargetInfo::ConstraintInfo &Info) const {
1059 switch (*Name) {
1060 default: return false;
1061 case 'O': // Zero
1062 return true;
1063 case 'b': // Base register
1064 case 'f': // Floating point register
1065 Info.setAllowsRegister();
1066 return true;
1067 }
1068 }
1069 virtual const char *getClobbers() const {
1070 return "";
1071 }
1072};
1073
1074/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1075/// #defines that are not tied to a specific subtarget.
1076void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1077 MacroBuilder &Builder) const {
1078 // Target identification.
1079 Builder.defineMacro("__microblaze__");
1080 Builder.defineMacro("_ARCH_MICROBLAZE");
1081 Builder.defineMacro("__MICROBLAZE__");
1082
1083 // Target properties.
1084 Builder.defineMacro("_BIG_ENDIAN");
1085 Builder.defineMacro("__BIG_ENDIAN__");
1086
1087 // Subtarget options.
1088 Builder.defineMacro("__REGISTER_PREFIX__", "");
1089}
1090
1091
1092const char * const MBlazeTargetInfo::GCCRegNames[] = {
1093 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1094 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1095 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1096 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1097 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1098 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1099 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1100 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1101 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1102 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1103};
1104
1105void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1106 unsigned &NumNames) const {
1107 Names = GCCRegNames;
1108 NumNames = llvm::array_lengthof(GCCRegNames);
1109}
1110
1111const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1112 { {"f0"}, "r0" },
1113 { {"f1"}, "r1" },
1114 { {"f2"}, "r2" },
1115 { {"f3"}, "r3" },
1116 { {"f4"}, "r4" },
1117 { {"f5"}, "r5" },
1118 { {"f6"}, "r6" },
1119 { {"f7"}, "r7" },
1120 { {"f8"}, "r8" },
1121 { {"f9"}, "r9" },
1122 { {"f10"}, "r10" },
1123 { {"f11"}, "r11" },
1124 { {"f12"}, "r12" },
1125 { {"f13"}, "r13" },
1126 { {"f14"}, "r14" },
1127 { {"f15"}, "r15" },
1128 { {"f16"}, "r16" },
1129 { {"f17"}, "r17" },
1130 { {"f18"}, "r18" },
1131 { {"f19"}, "r19" },
1132 { {"f20"}, "r20" },
1133 { {"f21"}, "r21" },
1134 { {"f22"}, "r22" },
1135 { {"f23"}, "r23" },
1136 { {"f24"}, "r24" },
1137 { {"f25"}, "r25" },
1138 { {"f26"}, "r26" },
1139 { {"f27"}, "r27" },
1140 { {"f28"}, "r28" },
1141 { {"f29"}, "r29" },
1142 { {"f30"}, "r30" },
1143 { {"f31"}, "r31" },
1144};
1145
1146void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1147 unsigned &NumAliases) const {
1148 Aliases = GCCRegAliases;
1149 NumAliases = llvm::array_lengthof(GCCRegAliases);
1150}
1151} // end anonymous namespace.
1152
1153namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001154// Namespace for x86 abstract base class
1155const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001156#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001157#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001158 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001159#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001160};
Eli Friedman61538a72008-05-20 14:21:01 +00001161
Nuno Lopes2550d702009-12-23 17:49:57 +00001162static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001163 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1164 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001165 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001166 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1167 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1168 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001169 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopherc5f9a012011-12-02 02:12:16 +00001170 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1171 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001172};
1173
Eric Christophercfd323d2011-06-21 00:05:20 +00001174const TargetInfo::AddlRegName AddlRegNames[] = {
1175 { { "al", "ah", "eax", "rax" }, 0 },
1176 { { "bl", "bh", "ebx", "rbx" }, 3 },
1177 { { "cl", "ch", "ecx", "rcx" }, 2 },
1178 { { "dl", "dh", "edx", "rdx" }, 1 },
1179 { { "esi", "rsi" }, 4 },
1180 { { "edi", "rdi" }, 5 },
1181 { { "esp", "rsp" }, 7 },
1182 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001183};
1184
1185// X86 target abstract base class; x86-32 and x86-64 are very close, so
1186// most of the implementation can be shared.
1187class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001188 enum X86SSEEnum {
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001189 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
Chris Lattner84f0ea82009-03-02 22:40:39 +00001190 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001191 enum MMX3DNowEnum {
1192 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1193 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001194
Eric Christophereea12d12010-04-02 23:50:19 +00001195 bool HasAES;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001196 bool HasAVX;
Craig Topper2b03bb02011-12-17 19:55:21 +00001197 bool HasAVX2;
Craig Topper31ceea02011-12-25 05:06:45 +00001198 bool HasLZCNT;
1199 bool HasBMI;
1200 bool HasBMI2;
Craig Toppere14e08b2011-12-29 16:10:46 +00001201 bool HasPOPCNT;
Craig Topper6a511e12011-12-30 07:33:42 +00001202 bool HasFMA4;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001203
Chandler Carruth499d9722011-09-28 08:55:34 +00001204 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1205 ///
1206 /// Each enumeration represents a particular CPU supported by Clang. These
1207 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1208 enum CPUKind {
1209 CK_Generic,
1210
1211 /// \name i386
1212 /// i386-generation processors.
1213 //@{
1214 CK_i386,
1215 //@}
1216
1217 /// \name i486
1218 /// i486-generation processors.
1219 //@{
1220 CK_i486,
1221 CK_WinChipC6,
1222 CK_WinChip2,
1223 CK_C3,
1224 //@}
1225
1226 /// \name i586
1227 /// i586-generation processors, P5 microarchitecture based.
1228 //@{
1229 CK_i586,
1230 CK_Pentium,
1231 CK_PentiumMMX,
1232 //@}
1233
1234 /// \name i686
1235 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1236 //@{
1237 CK_i686,
1238 CK_PentiumPro,
1239 CK_Pentium2,
1240 CK_Pentium3,
1241 CK_Pentium3M,
1242 CK_PentiumM,
1243 CK_C3_2,
1244
1245 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1246 /// Clang however has some logic to suport this.
1247 // FIXME: Warn, deprecate, and potentially remove this.
1248 CK_Yonah,
1249 //@}
1250
1251 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001252 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001253 //@{
1254 CK_Pentium4,
1255 CK_Pentium4M,
1256 CK_Prescott,
1257 CK_Nocona,
1258 //@}
1259
1260 /// \name Core
1261 /// Core microarchitecture based processors.
1262 //@{
1263 CK_Core2,
1264
1265 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1266 /// codename which GCC no longer accepts as an option to -march, but Clang
1267 /// has some logic for recognizing it.
1268 // FIXME: Warn, deprecate, and potentially remove this.
1269 CK_Penryn,
1270 //@}
1271
1272 /// \name Atom
1273 /// Atom processors
1274 //@{
1275 CK_Atom,
1276 //@}
1277
1278 /// \name Nehalem
1279 /// Nehalem microarchitecture based processors.
1280 //@{
1281 CK_Corei7,
1282 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001283 CK_CoreAVXi,
Craig Topper2b03bb02011-12-17 19:55:21 +00001284 CK_CoreAVX2,
Chandler Carruth499d9722011-09-28 08:55:34 +00001285 //@}
1286
1287 /// \name K6
1288 /// K6 architecture processors.
1289 //@{
1290 CK_K6,
1291 CK_K6_2,
1292 CK_K6_3,
1293 //@}
1294
1295 /// \name K7
1296 /// K7 architecture processors.
1297 //@{
1298 CK_Athlon,
1299 CK_AthlonThunderbird,
1300 CK_Athlon4,
1301 CK_AthlonXP,
1302 CK_AthlonMP,
1303 //@}
1304
1305 /// \name K8
1306 /// K8 architecture processors.
1307 //@{
1308 CK_Athlon64,
1309 CK_Athlon64SSE3,
1310 CK_AthlonFX,
1311 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001312 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001313 CK_Opteron,
1314 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001315 CK_AMDFAM10,
Chandler Carruth499d9722011-09-28 08:55:34 +00001316
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001317 /// \name K10
1318 /// K10 architecture processors.
1319 //@{
1320 CK_BDVER1,
1321 CK_BDVER2,
1322
Chandler Carruth499d9722011-09-28 08:55:34 +00001323 /// This specification is deprecated and will be removed in the future.
1324 /// Users should prefer \see CK_K8.
1325 // FIXME: Warn on this when the CPU is set to it.
1326 CK_x86_64,
1327 //@}
1328
1329 /// \name Geode
1330 /// Geode processors.
1331 //@{
1332 CK_Geode
1333 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001334 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001335
Eli Friedman618234a2008-08-20 02:34:37 +00001336public:
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001337 X86TargetInfo(const std::string& triple)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001338 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Craig Topper31ceea02011-12-25 05:06:45 +00001339 HasAES(false), HasAVX(false), HasAVX2(false), HasLZCNT(false),
Craig Topper6a511e12011-12-30 07:33:42 +00001340 HasBMI(false), HasBMI2(false), HasPOPCNT(false), HasFMA4(false),
1341 CPU(CK_Generic) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00001342 BigEndian = false;
Eli Friedman618234a2008-08-20 02:34:37 +00001343 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001344 }
Benjamin Kramerb4066692011-12-28 15:47:06 +00001345 virtual unsigned getFloatEvalMethod() const {
1346 // X87 evaluates with 80 bits "long double" precision.
1347 return SSELevel == NoSSE ? 2 : 0;
1348 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001349 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1350 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001351 Records = BuiltinInfo;
1352 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001353 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001354 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001355 unsigned &NumNames) const {
1356 Names = GCCRegNames;
1357 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001358 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001359 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001360 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001361 Aliases = 0;
1362 NumAliases = 0;
1363 }
1364 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1365 unsigned &NumNames) const {
1366 Names = AddlRegNames;
1367 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001368 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001369 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001370 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001371 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001372 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001373 return "~{dirflag},~{fpsr},~{flags}";
1374 }
Chris Lattner33328642009-03-20 15:52:06 +00001375 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001376 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001377 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1378 const std::string &Name,
1379 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001380 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001381 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001382 virtual const char* getABI() const {
Eli Friedmanee1ad992011-12-02 00:11:43 +00001383 if (PointerWidth == 64 && HasAVX)
1384 return "avx";
1385 else if (PointerWidth == 32 && MMX3DNowLevel == NoMMX3DNow)
1386 return "no-mmx";
1387 return "";
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001388 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001389 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001390 CPU = llvm::StringSwitch<CPUKind>(Name)
1391 .Case("i386", CK_i386)
1392 .Case("i486", CK_i486)
1393 .Case("winchip-c6", CK_WinChipC6)
1394 .Case("winchip2", CK_WinChip2)
1395 .Case("c3", CK_C3)
1396 .Case("i586", CK_i586)
1397 .Case("pentium", CK_Pentium)
1398 .Case("pentium-mmx", CK_PentiumMMX)
1399 .Case("i686", CK_i686)
1400 .Case("pentiumpro", CK_PentiumPro)
1401 .Case("pentium2", CK_Pentium2)
1402 .Case("pentium3", CK_Pentium3)
1403 .Case("pentium3m", CK_Pentium3M)
1404 .Case("pentium-m", CK_PentiumM)
1405 .Case("c3-2", CK_C3_2)
1406 .Case("yonah", CK_Yonah)
1407 .Case("pentium4", CK_Pentium4)
1408 .Case("pentium4m", CK_Pentium4M)
1409 .Case("prescott", CK_Prescott)
1410 .Case("nocona", CK_Nocona)
1411 .Case("core2", CK_Core2)
1412 .Case("penryn", CK_Penryn)
1413 .Case("atom", CK_Atom)
1414 .Case("corei7", CK_Corei7)
1415 .Case("corei7-avx", CK_Corei7AVX)
1416 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper2b03bb02011-12-17 19:55:21 +00001417 .Case("core-avx2", CK_CoreAVX2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001418 .Case("k6", CK_K6)
1419 .Case("k6-2", CK_K6_2)
1420 .Case("k6-3", CK_K6_3)
1421 .Case("athlon", CK_Athlon)
1422 .Case("athlon-tbird", CK_AthlonThunderbird)
1423 .Case("athlon-4", CK_Athlon4)
1424 .Case("athlon-xp", CK_AthlonXP)
1425 .Case("athlon-mp", CK_AthlonMP)
1426 .Case("athlon64", CK_Athlon64)
1427 .Case("athlon64-sse3", CK_Athlon64SSE3)
1428 .Case("athlon-fx", CK_AthlonFX)
1429 .Case("k8", CK_K8)
1430 .Case("k8-sse3", CK_K8SSE3)
1431 .Case("opteron", CK_Opteron)
1432 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001433 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001434 .Case("bdver1", CK_BDVER1)
1435 .Case("bdver2", CK_BDVER2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001436 .Case("x86-64", CK_x86_64)
1437 .Case("geode", CK_Geode)
1438 .Default(CK_Generic);
1439
Chandler Carruth26a39142011-09-28 09:45:08 +00001440 // Perform any per-CPU checks necessary to determine if this CPU is
1441 // acceptable.
1442 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1443 // invalid without explaining *why*.
1444 switch (CPU) {
1445 case CK_Generic:
1446 // No processor selected!
1447 return false;
1448
1449 case CK_i386:
1450 case CK_i486:
1451 case CK_WinChipC6:
1452 case CK_WinChip2:
1453 case CK_C3:
1454 case CK_i586:
1455 case CK_Pentium:
1456 case CK_PentiumMMX:
1457 case CK_i686:
1458 case CK_PentiumPro:
1459 case CK_Pentium2:
1460 case CK_Pentium3:
1461 case CK_Pentium3M:
1462 case CK_PentiumM:
1463 case CK_Yonah:
1464 case CK_C3_2:
1465 case CK_Pentium4:
1466 case CK_Pentium4M:
1467 case CK_Prescott:
1468 case CK_K6:
1469 case CK_K6_2:
1470 case CK_K6_3:
1471 case CK_Athlon:
1472 case CK_AthlonThunderbird:
1473 case CK_Athlon4:
1474 case CK_AthlonXP:
1475 case CK_AthlonMP:
1476 case CK_Geode:
1477 // Only accept certain architectures when compiling in 32-bit mode.
1478 if (PointerWidth != 32)
1479 return false;
1480
1481 // Fallthrough
1482 case CK_Nocona:
1483 case CK_Core2:
1484 case CK_Penryn:
1485 case CK_Atom:
1486 case CK_Corei7:
1487 case CK_Corei7AVX:
1488 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001489 case CK_CoreAVX2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001490 case CK_Athlon64:
1491 case CK_Athlon64SSE3:
1492 case CK_AthlonFX:
1493 case CK_K8:
1494 case CK_K8SSE3:
1495 case CK_Opteron:
1496 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00001497 case CK_AMDFAM10:
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001498 case CK_BDVER1:
1499 case CK_BDVER2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001500 case CK_x86_64:
1501 return true;
1502 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001503 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001504 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001505};
Chris Lattner3daed522009-03-02 22:20:04 +00001506
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001507void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001508 // FIXME: This should not be here.
1509 Features["3dnow"] = false;
1510 Features["3dnowa"] = false;
1511 Features["mmx"] = false;
1512 Features["sse"] = false;
1513 Features["sse2"] = false;
1514 Features["sse3"] = false;
1515 Features["ssse3"] = false;
1516 Features["sse41"] = false;
1517 Features["sse42"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001518 Features["sse4a"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001519 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001520 Features["avx"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001521 Features["avx2"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001522 Features["lzcnt"] = false;
1523 Features["bmi"] = false;
1524 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001525 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001526 Features["fma4"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001527
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001528 // FIXME: This *really* should not be here.
1529
1530 // X86_64 always has SSE2.
1531 if (PointerWidth == 64)
1532 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1533
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001534 switch (CPU) {
1535 case CK_Generic:
1536 case CK_i386:
1537 case CK_i486:
1538 case CK_i586:
1539 case CK_Pentium:
1540 case CK_i686:
1541 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001542 break;
1543 case CK_PentiumMMX:
1544 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001545 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001546 break;
1547 case CK_Pentium3:
1548 case CK_Pentium3M:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001549 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001550 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001551 break;
1552 case CK_PentiumM:
1553 case CK_Pentium4:
1554 case CK_Pentium4M:
1555 case CK_x86_64:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001556 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001557 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001558 break;
1559 case CK_Yonah:
1560 case CK_Prescott:
1561 case CK_Nocona:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001562 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001563 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001564 break;
1565 case CK_Core2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001566 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001567 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001568 break;
1569 case CK_Penryn:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001570 setFeatureEnabled(Features, "mmx", true);
Benjamin Kramerb3453a82012-01-04 14:36:57 +00001571 setFeatureEnabled(Features, "sse4.1", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001572 break;
1573 case CK_Atom:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001574 setFeatureEnabled(Features, "mmx", true);
Chandler Carruth49defe62011-09-28 10:36:46 +00001575 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001576 break;
1577 case CK_Corei7:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001578 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001579 setFeatureEnabled(Features, "sse4", true);
Eric Christophereea12d12010-04-02 23:50:19 +00001580 setFeatureEnabled(Features, "aes", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001581 break;
1582 case CK_Corei7AVX:
1583 case CK_CoreAVXi:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001584 setFeatureEnabled(Features, "mmx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00001585 setFeatureEnabled(Features, "sse4", true);
1586 setFeatureEnabled(Features, "aes", true);
Bruno Cardoso Lopese02d3912011-07-11 23:33:46 +00001587 //setFeatureEnabled(Features, "avx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001588 break;
Craig Topper2b03bb02011-12-17 19:55:21 +00001589 case CK_CoreAVX2:
1590 setFeatureEnabled(Features, "mmx", true);
1591 setFeatureEnabled(Features, "sse4", true);
1592 setFeatureEnabled(Features, "aes", true);
Craig Topper31ceea02011-12-25 05:06:45 +00001593 setFeatureEnabled(Features, "lzcnt", true);
1594 setFeatureEnabled(Features, "bmi", true);
1595 setFeatureEnabled(Features, "bmi2", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00001596 //setFeatureEnabled(Features, "avx2", true);
1597 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001598 case CK_K6:
1599 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001600 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001601 break;
1602 case CK_K6_2:
1603 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001604 case CK_WinChip2:
1605 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001606 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001607 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00001608 case CK_Athlon:
1609 case CK_AthlonThunderbird:
1610 case CK_Geode:
1611 setFeatureEnabled(Features, "3dnowa", true);
1612 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001613 case CK_Athlon4:
1614 case CK_AthlonXP:
1615 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001616 setFeatureEnabled(Features, "sse", true);
1617 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001618 break;
1619 case CK_K8:
1620 case CK_Opteron:
1621 case CK_Athlon64:
1622 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00001623 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001624 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001625 break;
1626 case CK_K8SSE3:
1627 case CK_OpteronSSE3:
1628 case CK_Athlon64SSE3:
Roman Divacky80b32b82011-10-30 13:47:56 +00001629 setFeatureEnabled(Features, "sse3", true);
1630 setFeatureEnabled(Features, "3dnowa", true);
1631 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00001632 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00001633 setFeatureEnabled(Features, "sse3", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00001634 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00001635 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001636 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001637 case CK_BDVER1:
1638 case CK_BDVER2:
1639 setFeatureEnabled(Features, "sse4", true);
1640 setFeatureEnabled(Features, "sse4a", true);
1641 setFeatureEnabled(Features, "aes", true);
1642 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001643 case CK_C3_2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001644 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001645 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001646 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001647 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001648}
1649
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001650bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump1eb44332009-09-09 15:08:12 +00001651 const std::string &Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001652 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00001653 // FIXME: This *really* should not be here. We need some way of translating
1654 // options into llvm subtarget features.
1655 if (!Features.count(Name) &&
1656 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001657 return false;
1658
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001659 // FIXME: this should probably use a switch with fall through.
1660
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001661 if (Enabled) {
1662 if (Name == "mmx")
1663 Features["mmx"] = true;
1664 else if (Name == "sse")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001665 Features["mmx"] = Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001666 else if (Name == "sse2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001667 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001668 else if (Name == "sse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001669 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1670 true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001671 else if (Name == "ssse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001672 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001673 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001674 else if (Name == "sse4" || Name == "sse4.2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001675 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001676 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1677 Features["popcnt"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001678 else if (Name == "sse4.1")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001679 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00001680 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001681 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001682 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001683 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001684 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00001685 else if (Name == "aes")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001686 Features["aes"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001687 else if (Name == "avx")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001688 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1689 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001690 Features["popcnt"] = Features["avx"] = true;
Craig Topper2b03bb02011-12-17 19:55:21 +00001691 else if (Name == "avx2")
1692 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1693 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001694 Features["popcnt"] = Features["avx"] = Features["avx2"] = true;
Craig Topper6a511e12011-12-30 07:33:42 +00001695 else if (Name == "fma4")
1696 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1697 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1698 Features["popcnt"] = Features["avx"] = Features["fma4"] = true;
Roman Divacky80b32b82011-10-30 13:47:56 +00001699 else if (Name == "sse4a")
Craig Topper6a511e12011-12-30 07:33:42 +00001700 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1701 Features["sse4a"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00001702 else if (Name == "lzcnt")
1703 Features["lzcnt"] = true;
1704 else if (Name == "bmi")
1705 Features["bmi"] = true;
1706 else if (Name == "bmi2")
1707 Features["bmi2"] = true;
Craig Toppere14e08b2011-12-29 16:10:46 +00001708 else if (Name == "popcnt")
1709 Features["popcnt"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001710 } else {
1711 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001712 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001713 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00001714 Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00001715 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1716 Features["sse4a"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001717 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00001718 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00001719 Features["sse41"] = Features["sse42"] = Features["sse4a"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001720 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00001721 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Craig Topper6a511e12011-12-30 07:33:42 +00001722 Features["sse42"] = Features["sse4a"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001723 else if (Name == "ssse3")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001724 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00001725 else if (Name == "sse4" || Name == "sse4.1")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001726 Features["sse41"] = Features["sse42"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00001727 else if (Name == "sse4.2")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001728 Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001729 else if (Name == "3dnow")
1730 Features["3dnow"] = Features["3dnowa"] = false;
1731 else if (Name == "3dnowa")
1732 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001733 else if (Name == "aes")
1734 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001735 else if (Name == "avx")
Craig Topper6a511e12011-12-30 07:33:42 +00001736 Features["avx"] = Features["avx2"] = Features["fma4"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001737 else if (Name == "avx2")
1738 Features["avx2"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001739 else if (Name == "sse4a")
1740 Features["sse4a"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001741 else if (Name == "lzcnt")
1742 Features["lzcnt"] = false;
1743 else if (Name == "bmi")
1744 Features["bmi"] = false;
1745 else if (Name == "bmi2")
1746 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001747 else if (Name == "popcnt")
1748 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001749 else if (Name == "fma4")
1750 Features["fma4"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001751 }
1752
1753 return true;
1754}
1755
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001756/// HandleTargetOptions - Perform initialization based on the user
1757/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001758void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001759 // Remember the maximum enabled sselevel.
1760 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1761 // Ignore disabled features.
1762 if (Features[i][0] == '-')
1763 continue;
1764
Eric Christophereea12d12010-04-02 23:50:19 +00001765 if (Features[i].substr(1) == "aes") {
1766 HasAES = true;
1767 continue;
1768 }
1769
Craig Topper31ceea02011-12-25 05:06:45 +00001770 if (Features[i].substr(1) == "lzcnt") {
1771 HasLZCNT = true;
1772 continue;
1773 }
1774
1775 if (Features[i].substr(1) == "bmi") {
1776 HasBMI = true;
1777 continue;
1778 }
1779
1780 if (Features[i].substr(1) == "bmi2") {
1781 HasBMI2 = true;
1782 continue;
1783 }
1784
Craig Toppere14e08b2011-12-29 16:10:46 +00001785 if (Features[i].substr(1) == "popcnt") {
1786 HasPOPCNT = true;
1787 continue;
1788 }
1789
Craig Topper6a511e12011-12-30 07:33:42 +00001790 if (Features[i].substr(1) == "fma4") {
1791 HasFMA4 = true;
1792 continue;
1793 }
1794
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001795 // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1796 // For now let it be enabled together with other SSE levels.
Craig Topper2b03bb02011-12-17 19:55:21 +00001797 if (Features[i].substr(1) == "avx2") {
Craig Topper2b03bb02011-12-17 19:55:21 +00001798 HasAVX2 = true;
1799 continue;
1800 }
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001801 if (Features[i].substr(1) == "avx") {
1802 HasAVX = true;
1803 continue;
1804 }
1805
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001806 assert(Features[i][0] == '+' && "Invalid target feature!");
1807 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1808 .Case("sse42", SSE42)
1809 .Case("sse41", SSE41)
1810 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00001811 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001812 .Case("sse2", SSE2)
1813 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001814 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001815 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001816
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001817 MMX3DNowEnum ThreeDNowLevel =
1818 llvm::StringSwitch<MMX3DNowEnum>(Features[i].substr(1))
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001819 .Case("3dnowa", AMD3DNowAthlon)
1820 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001821 .Case("mmx", MMX)
1822 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001823
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001824 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001825 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001826
1827 // Don't tell the backend if we're turning off mmx; it will end up disabling
1828 // SSE, which we don't want.
1829 std::vector<std::string>::iterator it;
1830 it = std::find(Features.begin(), Features.end(), "-mmx");
1831 if (it != Features.end())
1832 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00001833}
Chris Lattnerc0f59212009-03-02 22:27:17 +00001834
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001835/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
1836/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00001837void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001838 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00001839 // Target identification.
1840 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00001841 Builder.defineMacro("_LP64");
1842 Builder.defineMacro("__LP64__");
1843 Builder.defineMacro("__amd64__");
1844 Builder.defineMacro("__amd64");
1845 Builder.defineMacro("__x86_64");
1846 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00001847 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00001848 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00001849 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001850
Chris Lattnerc0f59212009-03-02 22:27:17 +00001851 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001852 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
1853 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001854 switch (CPU) {
1855 case CK_Generic:
1856 break;
1857 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001858 // The rest are coming from the i386 define above.
1859 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001860 break;
1861 case CK_i486:
1862 case CK_WinChipC6:
1863 case CK_WinChip2:
1864 case CK_C3:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001865 Builder.defineMacro("__i486");
1866 Builder.defineMacro("__i486__");
1867 Builder.defineMacro("__tune_i486__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001868 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00001869 case CK_PentiumMMX:
1870 Builder.defineMacro("__pentium_mmx__");
1871 Builder.defineMacro("__tune_pentium_mmx__");
1872 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001873 case CK_i586:
1874 case CK_Pentium:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001875 Builder.defineMacro("__i586");
1876 Builder.defineMacro("__i586__");
1877 Builder.defineMacro("__tune_i586__");
1878 Builder.defineMacro("__pentium");
1879 Builder.defineMacro("__pentium__");
1880 Builder.defineMacro("__tune_pentium__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001881 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001882 case CK_Pentium3:
1883 case CK_Pentium3M:
1884 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001885 Builder.defineMacro("__tune_pentium3__");
1886 // Fallthrough
1887 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001888 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001889 Builder.defineMacro("__tune_pentium2__");
1890 // Fallthrough
1891 case CK_PentiumPro:
1892 Builder.defineMacro("__tune_i686__");
1893 Builder.defineMacro("__tune_pentiumpro__");
1894 // Fallthrough
1895 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001896 Builder.defineMacro("__i686");
1897 Builder.defineMacro("__i686__");
1898 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
1899 Builder.defineMacro("__pentiumpro");
1900 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001901 break;
1902 case CK_Pentium4:
1903 case CK_Pentium4M:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001904 Builder.defineMacro("__pentium4");
1905 Builder.defineMacro("__pentium4__");
1906 Builder.defineMacro("__tune_pentium4__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001907 break;
1908 case CK_Yonah:
1909 case CK_Prescott:
1910 case CK_Nocona:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001911 Builder.defineMacro("__nocona");
1912 Builder.defineMacro("__nocona__");
1913 Builder.defineMacro("__tune_nocona__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001914 break;
1915 case CK_Core2:
1916 case CK_Penryn:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001917 Builder.defineMacro("__core2");
1918 Builder.defineMacro("__core2__");
1919 Builder.defineMacro("__tune_core2__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001920 break;
1921 case CK_Atom:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001922 Builder.defineMacro("__atom");
1923 Builder.defineMacro("__atom__");
1924 Builder.defineMacro("__tune_atom__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001925 break;
1926 case CK_Corei7:
1927 case CK_Corei7AVX:
1928 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001929 case CK_CoreAVX2:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001930 Builder.defineMacro("__corei7");
1931 Builder.defineMacro("__corei7__");
1932 Builder.defineMacro("__tune_corei7__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001933 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001934 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001935 Builder.defineMacro("__k6_2__");
1936 Builder.defineMacro("__tune_k6_2__");
1937 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001938 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001939 if (CPU != CK_K6_2) { // In case of fallthrough
1940 // FIXME: GCC may be enabling these in cases where some other k6
1941 // architecture is specified but -m3dnow is explicitly provided. The
1942 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001943 Builder.defineMacro("__k6_3__");
1944 Builder.defineMacro("__tune_k6_3__");
1945 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00001946 // Fallthrough
1947 case CK_K6:
1948 Builder.defineMacro("__k6");
1949 Builder.defineMacro("__k6__");
1950 Builder.defineMacro("__tune_k6__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001951 break;
1952 case CK_Athlon:
1953 case CK_AthlonThunderbird:
1954 case CK_Athlon4:
1955 case CK_AthlonXP:
1956 case CK_AthlonMP:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001957 Builder.defineMacro("__athlon");
1958 Builder.defineMacro("__athlon__");
1959 Builder.defineMacro("__tune_athlon__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001960 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001961 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001962 Builder.defineMacro("__tune_athlon_sse__");
1963 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001964 break;
1965 case CK_K8:
1966 case CK_K8SSE3:
1967 case CK_x86_64:
1968 case CK_Opteron:
1969 case CK_OpteronSSE3:
1970 case CK_Athlon64:
1971 case CK_Athlon64SSE3:
1972 case CK_AthlonFX:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001973 Builder.defineMacro("__k8");
1974 Builder.defineMacro("__k8__");
1975 Builder.defineMacro("__tune_k8__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001976 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00001977 case CK_AMDFAM10:
1978 Builder.defineMacro("__amdfam10");
1979 Builder.defineMacro("__amdfam10__");
1980 Builder.defineMacro("__tune_amdfam10__");
1981 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001982 case CK_BDVER1:
1983 Builder.defineMacro("__bdver1");
1984 Builder.defineMacro("__bdver1__");
1985 Builder.defineMacro("__tune__bdver1__");
1986 break;
1987 case CK_BDVER2:
1988 Builder.defineMacro("__bdver2");
1989 Builder.defineMacro("__bdver2__");
1990 Builder.defineMacro("__tune__bdver2__");
1991 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001992 case CK_Geode:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001993 Builder.defineMacro("__geode");
1994 Builder.defineMacro("__geode__");
1995 Builder.defineMacro("__tune_geode__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001996 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001997 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00001998
Chandler Carruth88c75b02011-09-28 09:54:07 +00001999 // Target properties.
2000 Builder.defineMacro("__LITTLE_ENDIAN__");
2001 Builder.defineMacro("__REGISTER_PREFIX__", "");
2002
Chris Lattner54175442009-04-19 17:32:33 +00002003 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2004 // functions in glibc header files that use FP Stack inline asm which the
2005 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00002006 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002007
Chandler Carruth88c75b02011-09-28 09:54:07 +00002008 if (HasAES)
2009 Builder.defineMacro("__AES__");
2010
2011 if (HasAVX)
2012 Builder.defineMacro("__AVX__");
Craig Topper2b03bb02011-12-17 19:55:21 +00002013 if (HasAVX2)
2014 Builder.defineMacro("__AVX2__");
Chandler Carruth88c75b02011-09-28 09:54:07 +00002015
Craig Topper31ceea02011-12-25 05:06:45 +00002016 if (HasLZCNT)
2017 Builder.defineMacro("__LZCNT__");
2018
2019 if (HasBMI)
2020 Builder.defineMacro("__BMI__");
2021
2022 if (HasBMI2)
2023 Builder.defineMacro("__BMI2__");
2024
Craig Toppere14e08b2011-12-29 16:10:46 +00002025 if (HasPOPCNT)
2026 Builder.defineMacro("__POPCNT__");
2027
Craig Topper6a511e12011-12-30 07:33:42 +00002028 if (HasFMA4)
2029 Builder.defineMacro("__FMA4__");
2030
Chris Lattner84f0ea82009-03-02 22:40:39 +00002031 // Each case falls through to the previous one here.
2032 switch (SSELevel) {
2033 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00002034 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002035 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00002036 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002037 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002038 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002039 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002040 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002041 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00002042 Builder.defineMacro("__SSE2__");
2043 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00002044 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00002045 Builder.defineMacro("__SSE__");
2046 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002047 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00002048 break;
2049 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002050
Francois Pichet62ec1f22011-09-17 17:15:52 +00002051 if (Opts.MicrosoftExt && PointerWidth == 32) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002052 switch (SSELevel) {
Michael J. Spencera764e832010-10-21 08:22:51 +00002053 case SSE42:
2054 case SSE41:
2055 case SSSE3:
2056 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002057 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002058 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002059 break;
2060 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002061 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002062 break;
2063 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002064 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002065 }
2066 }
2067
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002068 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002069 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002070 case AMD3DNowAthlon:
2071 Builder.defineMacro("__3dNOW_A__");
2072 case AMD3DNow:
2073 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002074 case MMX:
2075 Builder.defineMacro("__MMX__");
2076 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002077 break;
2078 }
Chris Lattnerc0f59212009-03-02 22:27:17 +00002079}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002080
2081
Eli Friedman618234a2008-08-20 02:34:37 +00002082bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002083X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002084 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002085 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00002086 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00002087 case 'Y': // first letter of a pair:
2088 switch (*(Name+1)) {
2089 default: return false;
2090 case '0': // First SSE register.
2091 case 't': // Any SSE register, when SSE2 is enabled.
2092 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2093 case 'm': // any MMX register, when inter-unit moves enabled.
2094 break; // falls through to setAllowsRegister.
2095 }
Eli Friedman618234a2008-08-20 02:34:37 +00002096 case 'a': // eax.
2097 case 'b': // ebx.
2098 case 'c': // ecx.
2099 case 'd': // edx.
2100 case 'S': // esi.
2101 case 'D': // edi.
2102 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00002103 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00002104 case 't': // top of floating point stack.
2105 case 'u': // second from top of floating point stack.
2106 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00002107 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00002108 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00002109 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00002110 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2111 case 'l': // "Index" registers: any general register that can be used as an
2112 // index in a base+index memory access.
2113 Info.setAllowsRegister();
2114 return true;
2115 case 'C': // SSE floating point constant.
2116 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002117 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002118 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002119 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002120 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00002121 return true;
2122 }
Dale Johannesen545be512010-08-24 22:33:12 +00002123 return false;
Eli Friedman618234a2008-08-20 02:34:37 +00002124}
2125
Dale Johannesenf6e2c202010-10-29 23:12:32 +00002126
Eli Friedman618234a2008-08-20 02:34:37 +00002127std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00002128X86TargetInfo::convertConstraint(const char *&Constraint) const {
2129 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00002130 case 'a': return std::string("{ax}");
2131 case 'b': return std::string("{bx}");
2132 case 'c': return std::string("{cx}");
2133 case 'd': return std::string("{dx}");
2134 case 'S': return std::string("{si}");
2135 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00002136 case 'p': // address
2137 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00002138 case 't': // top of floating point stack.
2139 return std::string("{st}");
2140 case 'u': // second from top of floating point stack.
2141 return std::string("{st(1)}"); // second from top of floating point stack.
2142 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00002143 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00002144 }
2145}
Eli Friedman618234a2008-08-20 02:34:37 +00002146} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00002147
2148namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002149// X86-32 generic target
2150class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00002151public:
Eli Friedman618234a2008-08-20 02:34:37 +00002152 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
2153 DoubleAlign = LongLongAlign = 32;
2154 LongDoubleWidth = 96;
2155 LongDoubleAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00002156 SuitableAlign = 128;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002157 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2158 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00002159 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00002160 SizeType = UnsignedInt;
2161 PtrDiffType = SignedInt;
2162 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002163 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002164
2165 // Use fpret for all types.
2166 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2167 (1 << TargetInfo::Double) |
2168 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002169
2170 // x86-32 has atomics up to 8 bytes
2171 // FIXME: Check that we actually have cmpxchg8b before setting
2172 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2173 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002174 }
2175 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002176 return "typedef char* __builtin_va_list;";
Eli Friedman618234a2008-08-20 02:34:37 +00002177 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002178
Chris Lattner21fb98e2009-09-23 06:06:36 +00002179 int getEHDataRegisterNumber(unsigned RegNo) const {
2180 if (RegNo == 0) return 0;
2181 if (RegNo == 1) return 2;
2182 return -1;
2183 }
Eli Friedman618234a2008-08-20 02:34:37 +00002184};
2185} // end anonymous namespace
2186
2187namespace {
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002188class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
2189public:
2190 NetBSDI386TargetInfo(const std::string &triple) :
2191 NetBSDTargetInfo<X86_32TargetInfo>(triple) {
2192 }
2193
2194 virtual unsigned getFloatEvalMethod() const {
2195 // NetBSD defaults to "double" rounding
2196 return 1;
2197 }
2198};
2199} // end anonymous namespace
2200
2201namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002202class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2203public:
2204 OpenBSDI386TargetInfo(const std::string& triple) :
2205 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2206 SizeType = UnsignedLong;
2207 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002208 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002209 }
2210};
2211} // end anonymous namespace
2212
2213namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002214class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002215public:
Torok Edwin5f6c1942009-06-30 17:10:35 +00002216 DarwinI386TargetInfo(const std::string& triple) :
2217 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002218 LongDoubleWidth = 128;
2219 LongDoubleAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002220 SuitableAlign = 128;
Eli Friedman1afabd92009-03-29 20:31:09 +00002221 SizeType = UnsignedLong;
2222 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002223 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2224 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002225 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002226 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002227 }
2228
Eli Friedman618234a2008-08-20 02:34:37 +00002229};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002230} // end anonymous namespace
2231
2232namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002233// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002234class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002235public:
2236 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002237 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002238 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002239 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002240 DoubleAlign = LongLongAlign = 64;
2241 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 +00002242 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002243 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002244 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002245 virtual void getTargetDefines(const LangOptions &Opts,
2246 MacroBuilder &Builder) const {
2247 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2248 }
2249};
2250} // end anonymous namespace
2251
2252namespace {
2253
2254// x86-32 Windows Visual Studio target
2255class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2256public:
2257 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2258 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002259 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002260 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2261 }
2262 virtual void getTargetDefines(const LangOptions &Opts,
2263 MacroBuilder &Builder) const {
2264 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2265 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2266 // The value of the following reflects processor type.
2267 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2268 // We lost the original triple, so we use the default.
2269 Builder.defineMacro("_M_IX86", "600");
2270 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002271};
2272} // end anonymous namespace
2273
2274namespace {
2275// x86-32 MinGW target
2276class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2277public:
2278 MinGWX86_32TargetInfo(const std::string& triple)
2279 : WindowsX86_32TargetInfo(triple) {
2280 }
2281 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002282 MacroBuilder &Builder) const {
2283 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002284 DefineStd(Builder, "WIN32", Opts);
2285 DefineStd(Builder, "WINNT", Opts);
2286 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002287 Builder.defineMacro("__MSVCRT__");
2288 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002289
2290 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2291 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002292 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002293 // Provide "as-is" __declspec.
2294 Builder.defineMacro("__declspec", "__declspec");
2295 else
2296 // Provide alias of __attribute__ like mingw32-gcc.
2297 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002298 }
2299};
2300} // end anonymous namespace
2301
2302namespace {
2303// x86-32 Cygwin target
2304class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2305public:
2306 CygwinX86_32TargetInfo(const std::string& triple)
2307 : X86_32TargetInfo(triple) {
2308 TLSSupported = false;
2309 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002310 DoubleAlign = LongLongAlign = 64;
2311 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2312 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002313 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002314 }
2315 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002316 MacroBuilder &Builder) const {
2317 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2318 Builder.defineMacro("__CYGWIN__");
2319 Builder.defineMacro("__CYGWIN32__");
2320 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00002321 if (Opts.CPlusPlus)
2322 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00002323 }
Eli Friedman29a30502008-08-21 01:40:19 +00002324};
2325} // end anonymous namespace
2326
2327namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002328// x86-32 Haiku target
2329class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2330public:
2331 HaikuX86_32TargetInfo(const std::string& triple)
2332 : X86_32TargetInfo(triple) {
2333 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00002334 IntPtrType = SignedLong;
2335 PtrDiffType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00002336 this->UserLabelPrefix = "";
Eli Friedmana7e68452010-08-22 01:00:03 +00002337 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00002338 virtual void getTargetDefines(const LangOptions &Opts,
2339 MacroBuilder &Builder) const {
2340 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2341 Builder.defineMacro("__INTEL__");
2342 Builder.defineMacro("__HAIKU__");
2343 }
2344};
2345} // end anonymous namespace
2346
Douglas Gregordca52262011-07-01 22:41:14 +00002347// RTEMS Target
2348template<typename Target>
2349class RTEMSTargetInfo : public OSTargetInfo<Target> {
2350protected:
2351 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2352 MacroBuilder &Builder) const {
2353 // RTEMS defines; list based off of gcc output
2354
Douglas Gregordca52262011-07-01 22:41:14 +00002355 Builder.defineMacro("__rtems__");
2356 Builder.defineMacro("__ELF__");
2357 }
2358public:
2359 RTEMSTargetInfo(const std::string &triple)
2360 : OSTargetInfo<Target>(triple) {
2361 this->UserLabelPrefix = "";
2362
2363 llvm::Triple Triple(triple);
2364 switch (Triple.getArch()) {
2365 default:
2366 case llvm::Triple::x86:
2367 // this->MCountName = ".mcount";
2368 break;
2369 case llvm::Triple::mips:
2370 case llvm::Triple::mipsel:
2371 case llvm::Triple::ppc:
2372 case llvm::Triple::ppc64:
2373 // this->MCountName = "_mcount";
2374 break;
2375 case llvm::Triple::arm:
2376 // this->MCountName = "__mcount";
2377 break;
2378 }
2379
2380 }
2381};
2382
2383namespace {
2384// x86-32 RTEMS target
2385class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2386public:
2387 RTEMSX86_32TargetInfo(const std::string& triple)
2388 : X86_32TargetInfo(triple) {
2389 SizeType = UnsignedLong;
2390 IntPtrType = SignedLong;
2391 PtrDiffType = SignedLong;
2392 this->UserLabelPrefix = "";
2393 }
2394 virtual void getTargetDefines(const LangOptions &Opts,
2395 MacroBuilder &Builder) const {
2396 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2397 Builder.defineMacro("__INTEL__");
2398 Builder.defineMacro("__rtems__");
2399 }
2400};
2401} // end anonymous namespace
2402
Chris Lattner86ed3a32010-04-11 19:29:39 +00002403namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002404// x86-64 generic target
2405class X86_64TargetInfo : public X86TargetInfo {
2406public:
Chris Lattner33328642009-03-20 15:52:06 +00002407 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00002408 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002409 LongDoubleWidth = 128;
2410 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00002411 LargeArrayMinWidth = 128;
2412 LargeArrayAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002413 SuitableAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00002414 IntMaxType = SignedLong;
2415 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002416 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002417 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00002418
Eli Friedmaned855cb2008-08-21 00:13:15 +00002419 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2420 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002421 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002422
2423 // Use fpret only for long double.
2424 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00002425
Anders Carlssoneea64802011-10-31 16:27:11 +00002426 // Use fp2ret for _Complex long double.
2427 ComplexLongDoubleUsesFP2Ret = true;
2428
Eli Friedman2be46072011-10-14 20:59:01 +00002429 // x86-64 has atomics up to 16 bytes.
2430 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
2431 // on CPUs with cmpxchg16b
2432 MaxAtomicPromoteWidth = 128;
2433 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00002434 }
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00002435 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002436 return "typedef struct __va_list_tag {"
2437 " unsigned gp_offset;"
2438 " unsigned fp_offset;"
2439 " void* overflow_arg_area;"
2440 " void* reg_save_area;"
John McCall2b7baf02010-05-28 18:25:28 +00002441 "} __va_list_tag;"
Eli Friedmandc043162009-07-03 00:45:06 +00002442 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson3346ae62007-11-24 23:38:12 +00002443 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002444
Chris Lattner21fb98e2009-09-23 06:06:36 +00002445 int getEHDataRegisterNumber(unsigned RegNo) const {
2446 if (RegNo == 0) return 0;
2447 if (RegNo == 1) return 1;
2448 return -1;
2449 }
Eli Friedman618234a2008-08-20 02:34:37 +00002450};
2451} // end anonymous namespace
2452
2453namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002454// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002455class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002456public:
2457 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002458 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002459 TLSSupported = false;
2460 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00002461 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00002462 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00002463 IntMaxType = SignedLongLong;
2464 UIntMaxType = UnsignedLongLong;
2465 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00002466 SizeType = UnsignedLongLong;
2467 PtrDiffType = SignedLongLong;
2468 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00002469 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002470 }
2471 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002472 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002473 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002474 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00002475 }
NAKAMURA Takumi79521992011-01-17 22:56:23 +00002476 virtual const char *getVAListDeclaration() const {
2477 return "typedef char* __builtin_va_list;";
2478 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002479};
2480} // end anonymous namespace
2481
2482namespace {
2483// x86-64 Windows Visual Studio target
2484class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2485public:
2486 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2487 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002488 LongDoubleWidth = LongDoubleAlign = 64;
2489 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00002490 }
2491 virtual void getTargetDefines(const LangOptions &Opts,
2492 MacroBuilder &Builder) const {
2493 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
2494 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00002495 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002496 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002497 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002498};
2499} // end anonymous namespace
2500
2501namespace {
2502// x86-64 MinGW target
2503class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2504public:
2505 MinGWX86_64TargetInfo(const std::string& triple)
2506 : WindowsX86_64TargetInfo(triple) {
2507 }
2508 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002509 MacroBuilder &Builder) const {
2510 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002511 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00002512 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00002513 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00002514 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002515
2516 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2517 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002518 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002519 // Provide "as-is" __declspec.
2520 Builder.defineMacro("__declspec", "__declspec");
2521 else
2522 // Provide alias of __attribute__ like mingw32-gcc.
2523 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002524 }
2525};
2526} // end anonymous namespace
2527
2528namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002529class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2530public:
Mike Stump1eb44332009-09-09 15:08:12 +00002531 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002532 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2533 Int64Type = SignedLongLong;
2534 }
2535};
2536} // end anonymous namespace
2537
2538namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00002539class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
2540public:
Mike Stump1eb44332009-09-09 15:08:12 +00002541 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman6036ebe2009-07-05 22:31:18 +00002542 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
2543 IntMaxType = SignedLongLong;
2544 UIntMaxType = UnsignedLongLong;
2545 Int64Type = SignedLongLong;
2546 }
2547};
2548} // end anonymous namespace
2549
2550namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00002551class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002552 // Possible FPU choices.
2553 enum FPUMode {
2554 NoFPU,
2555 VFP2FPU,
2556 VFP3FPU,
2557 NeonFPU
2558 };
2559
2560 static bool FPUModeIsVFP(FPUMode Mode) {
2561 return Mode >= VFP2FPU && Mode <= NeonFPU;
2562 }
2563
2564 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2565 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002566
Daniel Dunbareac7c532009-12-18 18:42:37 +00002567 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002568
2569 unsigned FPU : 3;
2570
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002571 unsigned IsThumb : 1;
2572
2573 // Initialized via features.
2574 unsigned SoftFloat : 1;
2575 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002576
Chris Lattner2752c012010-03-03 19:03:45 +00002577 static const Builtin::Info BuiltinInfo[];
2578
Chris Lattner393ff042008-04-21 18:56:49 +00002579public:
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002580 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbareac7c532009-12-18 18:42:37 +00002581 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002582 {
Eli Friedmane6a24e82011-12-22 03:51:45 +00002583 BigEndian = false;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002584 SizeType = UnsignedInt;
2585 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00002586 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
2587 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002588
Chris Lattner9bffb072010-04-23 16:29:58 +00002589 // {} in inline assembly are neon specifiers, not assembly variant
2590 // specifiers.
2591 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00002592
Daniel Dunbareac7c532009-12-18 18:42:37 +00002593 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00002594 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002595 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002596 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2597 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002598 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
2599 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002600 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002601 } else {
2602 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2603 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002604 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002605 }
John McCallee79a4c2010-08-21 22:46:04 +00002606
2607 // ARM targets default to using the ARM C++ ABI.
2608 CXXABI = CXXABI_ARM;
Eli Friedman2be46072011-10-14 20:59:01 +00002609
2610 // ARM has atomics up to 8 bytes
2611 // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e
2612 MaxAtomicPromoteWidth = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002613 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002614 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00002615 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002616 ABI = Name;
2617
Daniel Dunbara2a41612009-09-14 00:02:24 +00002618 // The defaults (above) are for AAPCS, check if we need to change them.
2619 //
2620 // FIXME: We need support for -meabi... we could just mangle it into the
2621 // name.
2622 if (Name == "apcs-gnu") {
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002623 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002624 SizeType = UnsignedLong;
2625
James Molloya6d81f92011-11-23 13:35:08 +00002626 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
2627 WCharType = SignedInt;
2628
Daniel Dunbar684de632010-04-22 16:14:54 +00002629 // Do not respect the alignment of bit-field types when laying out
2630 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
2631 UseBitFieldTypeAlignment = false;
2632
Chad Rosier61a62212011-08-04 01:21:14 +00002633 /// Do force alignment of members that follow zero length bitfields. If
2634 /// the alignment of the zero-length bitfield is greater than the member
2635 /// that follows it, `bar', `bar' will be aligned as the type of the
2636 /// zero length bitfield.
2637 UseZeroLengthBitfieldAlignment = true;
2638
2639 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00002640 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
2641 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00002642 ZeroLengthBitfieldBoundary = 32;
2643
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002644 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002645 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2646 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002647 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 +00002648 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002649 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002650 } else {
2651 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 +00002652 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002653 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002654 }
2655
Chad Rosier9f1210c2011-07-26 07:03:04 +00002656 // FIXME: Override "preferred align" for double and long long.
Daniel Dunbara2a41612009-09-14 00:02:24 +00002657 } else if (Name == "aapcs") {
2658 // FIXME: Enumerated types are variable width in straight AAPCS.
2659 } else if (Name == "aapcs-linux") {
Chad Rosier9f1210c2011-07-26 07:03:04 +00002660 ;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002661 } else
2662 return false;
2663
2664 return true;
2665 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002666
Chandler Carruthc3a2e652011-09-28 05:56:05 +00002667 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002668 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
2669 Features["vfp2"] = true;
2670 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
2671 Features["neon"] = true;
2672 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002673
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002674 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2675 const std::string &Name,
2676 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00002677 if (Name == "soft-float" || Name == "soft-float-abi" ||
2678 Name == "vfp2" || Name == "vfp3" || Name == "neon") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002679 Features[Name] = Enabled;
2680 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002681 return false;
2682
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002683 return true;
2684 }
2685
2686 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002687 FPU = NoFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002688 SoftFloat = SoftFloatABI = false;
2689 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
2690 if (Features[i] == "+soft-float")
2691 SoftFloat = true;
2692 else if (Features[i] == "+soft-float-abi")
2693 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002694 else if (Features[i] == "+vfp2")
2695 FPU = VFP2FPU;
2696 else if (Features[i] == "+vfp3")
2697 FPU = VFP3FPU;
2698 else if (Features[i] == "+neon")
2699 FPU = NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002700 }
2701
2702 // Remove front-end specific options which the backend handles differently.
2703 std::vector<std::string>::iterator it;
2704 it = std::find(Features.begin(), Features.end(), "+soft-float");
2705 if (it != Features.end())
2706 Features.erase(it);
2707 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2708 if (it != Features.end())
2709 Features.erase(it);
2710 }
2711
Chris Lattner5f9e2722011-07-23 10:55:15 +00002712 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00002713 return llvm::StringSwitch<const char*>(Name)
2714 .Cases("arm8", "arm810", "4")
2715 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2716 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2717 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2718 .Case("ep9312", "4T")
2719 .Cases("arm10tdmi", "arm1020t", "5T")
2720 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2721 .Case("arm926ej-s", "5TEJ")
2722 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2723 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002724 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002725 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002726 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002727 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2728 .Cases("cortex-a8", "cortex-a9", "7A")
Bob Wilson06f45632011-01-06 16:57:20 +00002729 .Case("cortex-m3", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00002730 .Case("cortex-m0", "6M")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002731 .Default(0);
2732 }
2733 virtual bool setCPU(const std::string &Name) {
2734 if (!getCPUDefineSuffix(Name))
2735 return false;
2736
2737 CPU = Name;
2738 return true;
2739 }
Chris Lattner33328642009-03-20 15:52:06 +00002740 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002741 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002742 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00002743 Builder.defineMacro("__arm");
2744 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002745
Chris Lattnerc0f59212009-03-02 22:27:17 +00002746 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00002747 Builder.defineMacro("__ARMEL__");
2748 Builder.defineMacro("__LITTLE_ENDIAN__");
2749 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002750
Chris Lattner5f9e2722011-07-23 10:55:15 +00002751 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00002752 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002753
Mike Stump437bb4b2009-04-08 02:07:04 +00002754 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002755
Daniel Dunbareac7c532009-12-18 18:42:37 +00002756 // FIXME: It's more complicated than this and we don't really support
2757 // interworking.
2758 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00002759 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002760
Daniel Dunbareac7c532009-12-18 18:42:37 +00002761 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramera9992772010-01-09 17:55:51 +00002762 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002763
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002764 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00002765 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002766
2767 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00002768 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002769
Bob Wilson84f95cf2011-05-13 18:56:03 +00002770 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002771 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002772 Builder.defineMacro("__THUMBEL__");
2773 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00002774 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002775 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002776 }
2777
2778 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00002779 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002780
2781 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramera9992772010-01-09 17:55:51 +00002782 Builder.defineMacro("__VFP_FP__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002783
2784 // This only gets set when Neon instructions are actually available, unlike
2785 // the VFP define, hence the soft float and arch check. This is subtly
2786 // different from gcc, we follow the intent which was that it should be set
2787 // when Neon instructions are actually available.
Bob Wilson84f95cf2011-05-13 18:56:03 +00002788 if (FPU == NeonFPU && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002789 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00002790 }
2791 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2792 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00002793 Records = BuiltinInfo;
2794 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00002795 }
2796 virtual const char *getVAListDeclaration() const {
John McCall0e9972c2011-05-09 02:19:37 +00002797 return "typedef void* __builtin_va_list;";
Chris Lattner393ff042008-04-21 18:56:49 +00002798 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002799 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002800 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002801 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002802 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002803 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002804 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002805 // FIXME: Check if this is complete
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002806 switch (*Name) {
Eli Friedmana9f54962008-08-20 07:44:10 +00002807 default:
Nate Begemanad487f42008-04-22 05:03:19 +00002808 case 'l': // r0-r7
2809 case 'h': // r8-r15
2810 case 'w': // VFP Floating point register single precision
2811 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00002812 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00002813 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00002814 case 'Q': // A memory address that is a single base register.
2815 Info.setAllowsMemory();
2816 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00002817 case 'U': // a memory reference...
2818 switch (Name[1]) {
2819 case 'q': // ...ARMV4 ldrsb
2820 case 'v': // ...VFP load/store (reg+constant offset)
2821 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00002822 case 't': // address valid for load/store opaque types wider
2823 // than 128-bits
2824 case 'n': // valid address for Neon doubleword vector load/store
2825 case 'm': // valid address for Neon element and structure load/store
2826 case 's': // valid address for non-offset loads/stores of quad-word
2827 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00002828 Info.setAllowsMemory();
2829 Name++;
2830 return true;
2831 }
Nate Begemanad487f42008-04-22 05:03:19 +00002832 }
Chris Lattner393ff042008-04-21 18:56:49 +00002833 return false;
2834 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00002835 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00002836 std::string R;
2837 switch (*Constraint) {
2838 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00002839 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00002840 Constraint++;
2841 break;
Eric Christopher283f4472011-06-17 00:40:18 +00002842 case 'p': // 'p' should be translated to 'r' by default.
2843 R = std::string("r");
2844 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00002845 default:
2846 return std::string(1, *Constraint);
2847 }
2848 return R;
2849 }
Chris Lattner393ff042008-04-21 18:56:49 +00002850 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002851 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00002852 return "";
2853 }
2854};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002855
2856const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002857 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002858 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002859 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
2860
2861 // Float registers
2862 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2863 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2864 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002865 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002866
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002867 // Double registers
2868 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
2869 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00002870 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
2871 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002872
2873 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00002874 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
2875 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002876};
2877
2878void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002879 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002880 Names = GCCRegNames;
2881 NumNames = llvm::array_lengthof(GCCRegNames);
2882}
2883
2884const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002885 { { "a1" }, "r0" },
2886 { { "a2" }, "r1" },
2887 { { "a3" }, "r2" },
2888 { { "a4" }, "r3" },
2889 { { "v1" }, "r4" },
2890 { { "v2" }, "r5" },
2891 { { "v3" }, "r6" },
2892 { { "v4" }, "r7" },
2893 { { "v5" }, "r8" },
2894 { { "v6", "rfp" }, "r9" },
2895 { { "sl" }, "r10" },
2896 { { "fp" }, "r11" },
2897 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002898 { { "r13" }, "sp" },
2899 { { "r14" }, "lr" },
2900 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002901 // The S, D and Q registers overlap, but aren't really aliases; we
2902 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002903};
2904
2905void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2906 unsigned &NumAliases) const {
2907 Aliases = GCCRegAliases;
2908 NumAliases = llvm::array_lengthof(GCCRegAliases);
2909}
Chris Lattner2752c012010-03-03 19:03:45 +00002910
2911const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00002912#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00002913#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00002914 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00002915#include "clang/Basic/BuiltinsARM.def"
2916};
Chris Lattner393ff042008-04-21 18:56:49 +00002917} // end anonymous namespace.
2918
Eli Friedmana9f54962008-08-20 07:44:10 +00002919namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00002920class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00002921 public DarwinTargetInfo<ARMTargetInfo> {
2922protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00002923 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00002924 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00002925 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00002926 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002927
Torok Edwin5f6c1942009-06-30 17:10:35 +00002928public:
Mike Stump1eb44332009-09-09 15:08:12 +00002929 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar350b9f32010-05-27 07:00:26 +00002930 : DarwinTargetInfo<ARMTargetInfo>(triple) {
2931 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00002932 // iOS always has 64-bit atomic instructions.
2933 // FIXME: This should be based off of the target features in ARMTargetInfo.
2934 MaxAtomicInlineWidth = 64;
Daniel Dunbar350b9f32010-05-27 07:00:26 +00002935 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002936};
2937} // end anonymous namespace.
2938
Tony Linthicum96319392011-12-12 21:14:55 +00002939
2940namespace {
2941// Hexagon abstract base class
2942class HexagonTargetInfo : public TargetInfo {
2943 static const Builtin::Info BuiltinInfo[];
2944 static const char * const GCCRegNames[];
2945 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2946 std::string CPU;
2947public:
2948 HexagonTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00002949 BigEndian = false;
Tony Linthicum96319392011-12-12 21:14:55 +00002950 DescriptionString = ("e-p:32:32:32-"
2951 "i64:64:64-i32:32:32-"
2952 "i16:16:16-i1:32:32-a:0:0");
2953
2954 // {} in inline assembly are packet specifiers, not assembly variant
2955 // specifiers.
2956 NoAsmVariants = true;
2957 }
2958
2959 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2960 unsigned &NumRecords) const {
2961 Records = BuiltinInfo;
2962 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
2963 }
2964
2965 virtual bool validateAsmConstraint(const char *&Name,
2966 TargetInfo::ConstraintInfo &Info) const {
2967 return true;
2968 }
2969
2970 virtual void getTargetDefines(const LangOptions &Opts,
2971 MacroBuilder &Builder) const;
2972
2973 virtual const char *getVAListDeclaration() const {
2974 return "typedef char* __builtin_va_list;";
2975 }
2976 virtual void getGCCRegNames(const char * const *&Names,
2977 unsigned &NumNames) const;
2978 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2979 unsigned &NumAliases) const;
2980 virtual const char *getClobbers() const {
2981 return "";
2982 }
2983 virtual bool setCPU(const std::string &Name) {
2984 CPU = Name;
2985 return true;
2986 }
2987};
2988
2989void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
2990 MacroBuilder &Builder) const {
2991 Builder.defineMacro("qdsp6");
2992 Builder.defineMacro("__qdsp6", "1");
2993 Builder.defineMacro("__qdsp6__", "1");
2994
2995 Builder.defineMacro("hexagon");
2996 Builder.defineMacro("__hexagon", "1");
2997 Builder.defineMacro("__hexagon__", "1");
2998
2999 if(CPU == "hexagonv1") {
3000 Builder.defineMacro("__HEXAGON_V1__");
3001 Builder.defineMacro("__HEXAGON_ARCH__", "1");
3002 if(Opts.HexagonQdsp6Compat) {
3003 Builder.defineMacro("__QDSP6_V1__");
3004 Builder.defineMacro("__QDSP6_ARCH__", "1");
3005 }
3006 }
3007 else if(CPU == "hexagonv2") {
3008 Builder.defineMacro("__HEXAGON_V2__");
3009 Builder.defineMacro("__HEXAGON_ARCH__", "2");
3010 if(Opts.HexagonQdsp6Compat) {
3011 Builder.defineMacro("__QDSP6_V2__");
3012 Builder.defineMacro("__QDSP6_ARCH__", "2");
3013 }
3014 }
3015 else if(CPU == "hexagonv3") {
3016 Builder.defineMacro("__HEXAGON_V3__");
3017 Builder.defineMacro("__HEXAGON_ARCH__", "3");
3018 if(Opts.HexagonQdsp6Compat) {
3019 Builder.defineMacro("__QDSP6_V3__");
3020 Builder.defineMacro("__QDSP6_ARCH__", "3");
3021 }
3022 }
3023 else if(CPU == "hexagonv4") {
3024 Builder.defineMacro("__HEXAGON_V4__");
3025 Builder.defineMacro("__HEXAGON_ARCH__", "4");
3026 if(Opts.HexagonQdsp6Compat) {
3027 Builder.defineMacro("__QDSP6_V4__");
3028 Builder.defineMacro("__QDSP6_ARCH__", "4");
3029 }
3030 }
3031}
3032
3033const char * const HexagonTargetInfo::GCCRegNames[] = {
3034 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3035 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3036 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3037 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
3038 "p0", "p1", "p2", "p3",
3039 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
3040};
3041
3042void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
3043 unsigned &NumNames) const {
3044 Names = GCCRegNames;
3045 NumNames = llvm::array_lengthof(GCCRegNames);
3046}
3047
3048
3049const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
3050 { { "sp" }, "r29" },
3051 { { "fp" }, "r30" },
3052 { { "lr" }, "r31" },
3053 };
3054
3055void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3056 unsigned &NumAliases) const {
3057 Aliases = GCCRegAliases;
3058 NumAliases = llvm::array_lengthof(GCCRegAliases);
3059}
3060
3061
3062const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
3063#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3064#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3065 ALL_LANGUAGES },
3066#include "clang/Basic/BuiltinsHexagon.def"
3067};
3068}
3069
3070
Reid Spencer5f016e22007-07-11 17:01:13 +00003071namespace {
Eli Friedman01b86682008-08-20 07:28:14 +00003072class SparcV8TargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00003073 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3074 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003075 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00003076public:
Eli Friedman01b86682008-08-20 07:28:14 +00003077 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
3078 // FIXME: Support Sparc quad-precision long double?
Eli Friedmane6a24e82011-12-22 03:51:45 +00003079 BigEndian = false;
Eli Friedmaned855cb2008-08-21 00:13:15 +00003080 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 +00003081 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedman01b86682008-08-20 07:28:14 +00003082 }
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003083 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
3084 const std::string &Name,
3085 bool Enabled) const {
3086 if (Name == "soft-float")
3087 Features[Name] = Enabled;
3088 else
3089 return false;
3090
3091 return true;
3092 }
3093 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
3094 SoftFloat = false;
3095 for (unsigned i = 0, e = Features.size(); i != e; ++i)
3096 if (Features[i] == "+soft-float")
3097 SoftFloat = true;
3098 }
Chris Lattner33328642009-03-20 15:52:06 +00003099 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003100 MacroBuilder &Builder) const {
3101 DefineStd(Builder, "sparc", Opts);
3102 Builder.defineMacro("__sparcv8");
3103 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003104
3105 if (SoftFloat)
3106 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00003107 }
3108 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3109 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003110 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00003111 }
3112 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00003113 return "typedef void* __builtin_va_list;";
Gabor Greif26658672008-02-21 16:29:08 +00003114 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003115 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003116 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003117 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003118 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003119 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00003120 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003121 // FIXME: Implement!
3122 return false;
Gabor Greif26658672008-02-21 16:29:08 +00003123 }
3124 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00003125 // FIXME: Implement!
3126 return "";
Gabor Greif26658672008-02-21 16:29:08 +00003127 }
3128};
3129
Chris Lattnere957f532009-01-27 01:58:38 +00003130const char * const SparcV8TargetInfo::GCCRegNames[] = {
3131 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3132 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3133 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3134 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
3135};
3136
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003137void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003138 unsigned &NumNames) const {
3139 Names = GCCRegNames;
3140 NumNames = llvm::array_lengthof(GCCRegNames);
3141}
3142
3143const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003144 { { "g0" }, "r0" },
3145 { { "g1" }, "r1" },
3146 { { "g2" }, "r2" },
3147 { { "g3" }, "r3" },
3148 { { "g4" }, "r4" },
3149 { { "g5" }, "r5" },
3150 { { "g6" }, "r6" },
3151 { { "g7" }, "r7" },
3152 { { "o0" }, "r8" },
3153 { { "o1" }, "r9" },
3154 { { "o2" }, "r10" },
3155 { { "o3" }, "r11" },
3156 { { "o4" }, "r12" },
3157 { { "o5" }, "r13" },
3158 { { "o6", "sp" }, "r14" },
3159 { { "o7" }, "r15" },
3160 { { "l0" }, "r16" },
3161 { { "l1" }, "r17" },
3162 { { "l2" }, "r18" },
3163 { { "l3" }, "r19" },
3164 { { "l4" }, "r20" },
3165 { { "l5" }, "r21" },
3166 { { "l6" }, "r22" },
3167 { { "l7" }, "r23" },
3168 { { "i0" }, "r24" },
3169 { { "i1" }, "r25" },
3170 { { "i2" }, "r26" },
3171 { { "i3" }, "r27" },
3172 { { "i4" }, "r28" },
3173 { { "i5" }, "r29" },
3174 { { "i6", "fp" }, "r30" },
3175 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00003176};
3177
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003178void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003179 unsigned &NumAliases) const {
3180 Aliases = GCCRegAliases;
3181 NumAliases = llvm::array_lengthof(GCCRegAliases);
3182}
Gabor Greif26658672008-02-21 16:29:08 +00003183} // end anonymous namespace.
3184
Eli Friedman01b86682008-08-20 07:28:14 +00003185namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003186class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
3187public:
3188 AuroraUXSparcV8TargetInfo(const std::string& triple) :
3189 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
3190 SizeType = UnsignedInt;
3191 PtrDiffType = SignedInt;
3192 }
3193};
Torok Edwin5f6c1942009-06-30 17:10:35 +00003194class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00003195public:
3196 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003197 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00003198 SizeType = UnsignedInt;
3199 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00003200 }
3201};
3202} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00003203
Chris Lattner2621fd12008-05-08 05:58:21 +00003204namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003205 class MSP430TargetInfo : public TargetInfo {
3206 static const char * const GCCRegNames[];
3207 public:
3208 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003209 BigEndian = false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003210 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00003211 IntWidth = 16; IntAlign = 16;
3212 LongWidth = 32; LongLongWidth = 64;
3213 LongAlign = LongLongAlign = 16;
3214 PointerWidth = 16; PointerAlign = 16;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003215 SuitableAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003216 SizeType = UnsignedInt;
3217 IntMaxType = SignedLong;
3218 UIntMaxType = UnsignedLong;
3219 IntPtrType = SignedShort;
3220 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00003221 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00003222 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003223 }
3224 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003225 MacroBuilder &Builder) const {
3226 Builder.defineMacro("MSP430");
3227 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003228 // FIXME: defines for different 'flavours' of MCU
3229 }
3230 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3231 unsigned &NumRecords) const {
3232 // FIXME: Implement.
3233 Records = 0;
3234 NumRecords = 0;
3235 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003236 virtual void getGCCRegNames(const char * const *&Names,
3237 unsigned &NumNames) const;
3238 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3239 unsigned &NumAliases) const {
3240 // No aliases.
3241 Aliases = 0;
3242 NumAliases = 0;
3243 }
3244 virtual bool validateAsmConstraint(const char *&Name,
3245 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00003246 // No target constraints for now.
3247 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003248 }
3249 virtual const char *getClobbers() const {
3250 // FIXME: Is this really right?
3251 return "";
3252 }
3253 virtual const char *getVAListDeclaration() const {
3254 // FIXME: implement
Anton Korobeynikoveb716852009-05-08 18:24:57 +00003255 return "typedef char* __builtin_va_list;";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003256 }
3257 };
3258
3259 const char * const MSP430TargetInfo::GCCRegNames[] = {
3260 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3261 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3262 };
3263
3264 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
3265 unsigned &NumNames) const {
3266 Names = GCCRegNames;
3267 NumNames = llvm::array_lengthof(GCCRegNames);
3268 }
3269}
3270
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00003271namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00003272
Mike Stump1eb44332009-09-09 15:08:12 +00003273 // LLVM and Clang cannot be used directly to output native binaries for
3274 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00003275 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00003276 //
3277 // TCE uses the llvm bitcode as input and uses it for generating customized
3278 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00003279 // publicly available in http://tce.cs.tut.fi
3280
Eli Friedman209f5bb2011-10-07 19:51:42 +00003281 static const unsigned TCEOpenCLAddrSpaceMap[] = {
3282 3, // opencl_global
3283 4, // opencl_local
3284 5 // opencl_constant
3285 };
3286
Eli Friedmanb63decf2009-08-19 20:47:07 +00003287 class TCETargetInfo : public TargetInfo{
3288 public:
3289 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
3290 TLSSupported = false;
3291 IntWidth = 32;
3292 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003293 PointerWidth = 32;
3294 IntAlign = 32;
3295 LongAlign = LongLongAlign = 32;
3296 PointerAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003297 SuitableAlign = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003298 SizeType = UnsignedInt;
3299 IntMaxType = SignedLong;
3300 UIntMaxType = UnsignedLong;
3301 IntPtrType = SignedInt;
3302 PtrDiffType = SignedInt;
3303 FloatWidth = 32;
3304 FloatAlign = 32;
3305 DoubleWidth = 32;
3306 DoubleAlign = 32;
3307 LongDoubleWidth = 32;
3308 LongDoubleAlign = 32;
3309 FloatFormat = &llvm::APFloat::IEEEsingle;
3310 DoubleFormat = &llvm::APFloat::IEEEsingle;
3311 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00003312 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
3313 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00003314 "f32:32:32-f64:32:32-v64:32:32-"
3315 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00003316 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003317 }
3318
3319 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003320 MacroBuilder &Builder) const {
3321 DefineStd(Builder, "tce", Opts);
3322 Builder.defineMacro("__TCE__");
3323 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00003324 }
3325 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3326 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00003327 virtual const char *getClobbers() const {
3328 return "";
3329 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003330 virtual const char *getVAListDeclaration() const {
3331 return "typedef void* __builtin_va_list;";
3332 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003333 virtual void getGCCRegNames(const char * const *&Names,
3334 unsigned &NumNames) const {}
3335 virtual bool validateAsmConstraint(const char *&Name,
3336 TargetInfo::ConstraintInfo &info) const {
3337 return true;
3338 }
3339 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3340 unsigned &NumAliases) const {}
3341 };
3342}
3343
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003344namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003345class MipsTargetInfoBase : public TargetInfo {
3346 std::string CPU;
3347protected:
3348 std::string ABI;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003349public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003350 MipsTargetInfoBase(const std::string& triple, const std::string& ABIStr)
Akira Hatanaka148735e2011-11-05 01:48:34 +00003351 : TargetInfo(triple), ABI(ABIStr) {}
Eric Christophered734732010-03-02 02:41:08 +00003352 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003353 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00003354 virtual bool setCPU(const std::string &Name) {
3355 CPU = Name;
3356 return true;
3357 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003358 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00003359 Features[ABI] = true;
3360 Features[CPU] = true;
3361 }
3362 virtual void getArchDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003363 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003364 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003365 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003366 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3367 unsigned &NumRecords) const {
3368 // FIXME: Implement!
3369 }
3370 virtual const char *getVAListDeclaration() const {
3371 return "typedef void* __builtin_va_list;";
3372 }
3373 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003374 unsigned &NumNames) const {
3375 static const char * const GCCRegNames[] = {
3376 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
3377 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
3378 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
3379 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
3380 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
3381 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
3382 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
3383 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
3384 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
3385 "$fcc5","$fcc6","$fcc7"
3386 };
3387 Names = GCCRegNames;
3388 NumNames = llvm::array_lengthof(GCCRegNames);
3389 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003390 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003391 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003392 virtual bool validateAsmConstraint(const char *&Name,
3393 TargetInfo::ConstraintInfo &Info) const {
3394 switch (*Name) {
3395 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00003396 return false;
3397
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003398 case 'r': // CPU registers.
3399 case 'd': // Equivalent to "r" unless generating MIPS16 code.
3400 case 'y': // Equivalent to "r", backwards compatibility only.
3401 case 'f': // floating-point registers.
3402 Info.setAllowsRegister();
3403 return true;
3404 }
3405 return false;
3406 }
3407
3408 virtual const char *getClobbers() const {
3409 // FIXME: Implement!
3410 return "";
3411 }
3412};
3413
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003414class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003415public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003416 Mips32TargetInfoBase(const std::string& triple) :
Akira Hatanaka148735e2011-11-05 01:48:34 +00003417 MipsTargetInfoBase(triple, "o32") {
3418 SizeType = UnsignedInt;
3419 PtrDiffType = SignedInt;
3420 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003421 virtual bool setABI(const std::string &Name) {
3422 if ((Name == "o32") || (Name == "eabi")) {
3423 ABI = Name;
3424 return true;
3425 } else
3426 return false;
3427 }
3428 virtual void getArchDefines(const LangOptions &Opts,
3429 MacroBuilder &Builder) const {
Douglas Gregorc9a23712011-11-09 15:17:16 +00003430 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
3431 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
3432 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
3433
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003434 if (ABI == "o32") {
3435 Builder.defineMacro("__mips_o32");
3436 Builder.defineMacro("_ABIO32", "1");
3437 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
3438 }
3439 else if (ABI == "eabi")
3440 Builder.defineMacro("__mips_eabi");
3441 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003442 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003443 }
3444 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3445 unsigned &NumAliases) const {
3446 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3447 { { "at" }, "$1" },
3448 { { "v0" }, "$2" },
3449 { { "v1" }, "$3" },
3450 { { "a0" }, "$4" },
3451 { { "a1" }, "$5" },
3452 { { "a2" }, "$6" },
3453 { { "a3" }, "$7" },
3454 { { "t0" }, "$8" },
3455 { { "t1" }, "$9" },
3456 { { "t2" }, "$10" },
3457 { { "t3" }, "$11" },
3458 { { "t4" }, "$12" },
3459 { { "t5" }, "$13" },
3460 { { "t6" }, "$14" },
3461 { { "t7" }, "$15" },
3462 { { "s0" }, "$16" },
3463 { { "s1" }, "$17" },
3464 { { "s2" }, "$18" },
3465 { { "s3" }, "$19" },
3466 { { "s4" }, "$20" },
3467 { { "s5" }, "$21" },
3468 { { "s6" }, "$22" },
3469 { { "s7" }, "$23" },
3470 { { "t8" }, "$24" },
3471 { { "t9" }, "$25" },
3472 { { "k0" }, "$26" },
3473 { { "k1" }, "$27" },
3474 { { "gp" }, "$28" },
3475 { { "sp" }, "$29" },
3476 { { "fp" }, "$30" },
3477 { { "ra" }, "$31" }
3478 };
3479 Aliases = GCCRegAliases;
3480 NumAliases = llvm::array_lengthof(GCCRegAliases);
3481 }
3482};
3483
3484class Mips32EBTargetInfo : public Mips32TargetInfoBase {
3485public:
3486 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
3487 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3488 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3489 }
3490 virtual void getTargetDefines(const LangOptions &Opts,
3491 MacroBuilder &Builder) const {
3492 DefineStd(Builder, "mips", Opts);
3493 Builder.defineMacro("_mips");
3494 DefineStd(Builder, "MIPSEB", Opts);
3495 Builder.defineMacro("_MIPSEB");
3496 Builder.defineMacro("__REGISTER_PREFIX__", "");
3497 getArchDefines(Opts, Builder);
3498 }
3499};
3500
3501class Mips32ELTargetInfo : public Mips32TargetInfoBase {
3502public:
3503 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003504 BigEndian = false;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003505 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 +00003506 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003507 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003508 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003509 MacroBuilder &Builder) const {
3510 DefineStd(Builder, "mips", Opts);
3511 Builder.defineMacro("_mips");
3512 DefineStd(Builder, "MIPSEL", Opts);
3513 Builder.defineMacro("_MIPSEL");
3514 Builder.defineMacro("__REGISTER_PREFIX__", "");
3515 getArchDefines(Opts, Builder);
3516 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003517};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003518
3519class Mips64TargetInfoBase : public MipsTargetInfoBase {
3520 virtual void SetDescriptionString(const std::string &Name) = 0;
3521public:
3522 Mips64TargetInfoBase(const std::string& triple) :
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003523 MipsTargetInfoBase(triple, "n64") {
3524 LongWidth = LongAlign = 64;
3525 PointerWidth = PointerAlign = 64;
3526 LongDoubleWidth = LongDoubleAlign = 128;
3527 LongDoubleFormat = &llvm::APFloat::IEEEquad;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003528 SuitableAlign = 128;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003529 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003530 virtual bool setABI(const std::string &Name) {
3531 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003532
3533 if (Name != "n32" && Name != "n64")
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003534 return false;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003535
3536 ABI = Name;
3537
3538 if (Name == "n32") {
3539 LongWidth = LongAlign = 32;
3540 PointerWidth = PointerAlign = 32;
3541 }
3542
3543 return true;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003544 }
3545 virtual void getArchDefines(const LangOptions &Opts,
3546 MacroBuilder &Builder) const {
3547 if (ABI == "n32") {
3548 Builder.defineMacro("__mips_n32");
3549 Builder.defineMacro("_ABIN32", "2");
3550 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
3551 }
3552 else if (ABI == "n64") {
3553 Builder.defineMacro("__mips_n64");
3554 Builder.defineMacro("_ABI64", "3");
3555 Builder.defineMacro("_MIPS_SIM", "_ABI64");
3556 }
3557 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003558 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003559 }
3560 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3561 unsigned &NumAliases) const {
3562 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3563 { { "at" }, "$1" },
3564 { { "v0" }, "$2" },
3565 { { "v1" }, "$3" },
3566 { { "a0" }, "$4" },
3567 { { "a1" }, "$5" },
3568 { { "a2" }, "$6" },
3569 { { "a3" }, "$7" },
3570 { { "a4" }, "$8" },
3571 { { "a5" }, "$9" },
3572 { { "a6" }, "$10" },
3573 { { "a7" }, "$11" },
3574 { { "t0" }, "$12" },
3575 { { "t1" }, "$13" },
3576 { { "t2" }, "$14" },
3577 { { "t3" }, "$15" },
3578 { { "s0" }, "$16" },
3579 { { "s1" }, "$17" },
3580 { { "s2" }, "$18" },
3581 { { "s3" }, "$19" },
3582 { { "s4" }, "$20" },
3583 { { "s5" }, "$21" },
3584 { { "s6" }, "$22" },
3585 { { "s7" }, "$23" },
3586 { { "t8" }, "$24" },
3587 { { "t9" }, "$25" },
3588 { { "k0" }, "$26" },
3589 { { "k1" }, "$27" },
3590 { { "gp" }, "$28" },
3591 { { "sp" }, "$29" },
3592 { { "fp" }, "$30" },
3593 { { "ra" }, "$31" }
3594 };
3595 Aliases = GCCRegAliases;
3596 NumAliases = llvm::array_lengthof(GCCRegAliases);
3597 }
3598};
3599
3600class Mips64EBTargetInfo : public Mips64TargetInfoBase {
3601 virtual void SetDescriptionString(const std::string &Name) {
3602 // Change DescriptionString only if ABI is n32.
3603 if (Name == "n32")
3604 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 +00003605 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3606 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003607 }
3608public:
3609 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3610 // Default ABI is n64.
3611 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 +00003612 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3613 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003614 }
3615 virtual void getTargetDefines(const LangOptions &Opts,
3616 MacroBuilder &Builder) const {
3617 DefineStd(Builder, "mips", Opts);
3618 Builder.defineMacro("_mips");
3619 DefineStd(Builder, "MIPSEB", Opts);
3620 Builder.defineMacro("_MIPSEB");
3621 Builder.defineMacro("__REGISTER_PREFIX__", "");
3622 getArchDefines(Opts, Builder);
3623 }
3624};
3625
3626class Mips64ELTargetInfo : public Mips64TargetInfoBase {
3627 virtual void SetDescriptionString(const std::string &Name) {
3628 // Change DescriptionString only if ABI is n32.
3629 if (Name == "n32")
3630 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 +00003631 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
3632 "-v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003633 }
3634public:
3635 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003636 // Default ABI is n64.
3637 BigEndian = false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003638 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 +00003639 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3640 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003641 }
3642 virtual void getTargetDefines(const LangOptions &Opts,
3643 MacroBuilder &Builder) const {
3644 DefineStd(Builder, "mips", Opts);
3645 Builder.defineMacro("_mips");
3646 DefineStd(Builder, "MIPSEL", Opts);
3647 Builder.defineMacro("_MIPSEL");
3648 Builder.defineMacro("__REGISTER_PREFIX__", "");
3649 getArchDefines(Opts, Builder);
3650 }
3651};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003652} // end anonymous namespace.
3653
Ivan Krasinef05abd2011-08-24 20:22:22 +00003654namespace {
3655class PNaClTargetInfo : public TargetInfo {
3656public:
3657 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003658 BigEndian = false;
Ivan Krasinef05abd2011-08-24 20:22:22 +00003659 this->UserLabelPrefix = "";
3660 this->LongAlign = 32;
3661 this->LongWidth = 32;
3662 this->PointerAlign = 32;
3663 this->PointerWidth = 32;
3664 this->IntMaxType = TargetInfo::SignedLongLong;
3665 this->UIntMaxType = TargetInfo::UnsignedLongLong;
3666 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003667 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003668 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003669 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003670 this->SizeType = TargetInfo::UnsignedInt;
3671 this->PtrDiffType = TargetInfo::SignedInt;
3672 this->IntPtrType = TargetInfo::SignedInt;
David Meyerdd4a8892011-10-11 03:12:01 +00003673 this->RegParmMax = 2;
Ivan Krasinef05abd2011-08-24 20:22:22 +00003674 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
3675 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
3676 }
3677
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003678 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00003679 }
3680 virtual void getArchDefines(const LangOptions &Opts,
3681 MacroBuilder &Builder) const {
3682 Builder.defineMacro("__le32__");
3683 Builder.defineMacro("__pnacl__");
3684 }
3685 virtual void getTargetDefines(const LangOptions &Opts,
3686 MacroBuilder &Builder) const {
Ivan Krasin089ee112011-08-25 23:49:20 +00003687 DefineStd(Builder, "unix", Opts);
3688 Builder.defineMacro("__ELF__");
3689 if (Opts.POSIXThreads)
3690 Builder.defineMacro("_REENTRANT");
3691 if (Opts.CPlusPlus)
3692 Builder.defineMacro("_GNU_SOURCE");
3693
Ivan Krasinef05abd2011-08-24 20:22:22 +00003694 Builder.defineMacro("__native_client__");
3695 getArchDefines(Opts, Builder);
3696 }
3697 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3698 unsigned &NumRecords) const {
3699 }
3700 virtual const char *getVAListDeclaration() const {
Ivan Krasin68018db2011-09-20 14:56:54 +00003701 return "typedef int __builtin_va_list[4];";
Ivan Krasinef05abd2011-08-24 20:22:22 +00003702 }
3703 virtual void getGCCRegNames(const char * const *&Names,
3704 unsigned &NumNames) const;
3705 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3706 unsigned &NumAliases) const;
3707 virtual bool validateAsmConstraint(const char *&Name,
3708 TargetInfo::ConstraintInfo &Info) const {
3709 return false;
3710 }
3711
3712 virtual const char *getClobbers() const {
3713 return "";
3714 }
3715};
3716
3717void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
3718 unsigned &NumNames) const {
3719 Names = NULL;
3720 NumNames = 0;
3721}
3722
3723void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3724 unsigned &NumAliases) const {
3725 Aliases = NULL;
3726 NumAliases = 0;
3727}
3728} // end anonymous namespace.
3729
3730
Reid Spencer5f016e22007-07-11 17:01:13 +00003731//===----------------------------------------------------------------------===//
3732// Driver code
3733//===----------------------------------------------------------------------===//
3734
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003735static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003736 llvm::Triple Triple(T);
3737 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00003738
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003739 switch (Triple.getArch()) {
3740 default:
3741 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00003742
Tony Linthicum96319392011-12-12 21:14:55 +00003743 case llvm::Triple::hexagon:
3744 return new HexagonTargetInfo(T);
3745
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003746 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00003747 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003748 if (Triple.isOSDarwin())
3749 return new DarwinARMTargetInfo(T);
3750
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003751 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00003752 case llvm::Triple::Linux:
3753 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003754 case llvm::Triple::FreeBSD:
Torok Edwin5f6c1942009-06-30 17:10:35 +00003755 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003756 case llvm::Triple::NetBSD:
3757 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003758 case llvm::Triple::RTEMS:
3759 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003760 default:
3761 return new ARMTargetInfo(T);
3762 }
Eli Friedman61538a72008-05-20 14:21:01 +00003763
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003764 case llvm::Triple::msp430:
3765 return new MSP430TargetInfo(T);
Eli Friedman61538a72008-05-20 14:21:01 +00003766
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003767 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003768 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003769 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003770 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003771 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003772 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003773 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003774 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003775 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003776 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003777 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003778 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003779 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003780
3781 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003782 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003783 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003784 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003785 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003786 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003787 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003788 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003789 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003790 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003791 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003792 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003793 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003794
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003795 case llvm::Triple::mips64:
3796 switch (os) {
3797 case llvm::Triple::Linux:
3798 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
3799 case llvm::Triple::RTEMS:
3800 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
3801 case llvm::Triple::FreeBSD:
3802 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
3803 case llvm::Triple::NetBSD:
3804 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
3805 default:
3806 return new Mips64EBTargetInfo(T);
3807 }
3808
3809 case llvm::Triple::mips64el:
3810 switch (os) {
3811 case llvm::Triple::Linux:
3812 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
3813 case llvm::Triple::RTEMS:
3814 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
3815 case llvm::Triple::FreeBSD:
3816 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
3817 case llvm::Triple::NetBSD:
3818 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
3819 default:
3820 return new Mips64ELTargetInfo(T);
3821 }
3822
Ivan Krasinef05abd2011-08-24 20:22:22 +00003823 case llvm::Triple::le32:
3824 switch (os) {
3825 case llvm::Triple::NativeClient:
3826 return new PNaClTargetInfo(T);
3827 default:
3828 return NULL;
3829 }
3830
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003831 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003832 if (Triple.isOSDarwin())
Roman Divackyc81f2a22011-01-06 08:27:10 +00003833 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003834 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003835 case llvm::Triple::Linux:
3836 return new LinuxTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003837 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00003838 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003839 case llvm::Triple::NetBSD:
3840 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
3841 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003842 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003843 default:
3844 return new PPC32TargetInfo(T);
3845 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003846
3847 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003848 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00003849 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003850 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003851 case llvm::Triple::Linux:
3852 return new LinuxTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003853 case llvm::Triple::Lv2:
John Thompson3f6918a2009-11-19 17:18:50 +00003854 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003855 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00003856 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003857 case llvm::Triple::NetBSD:
3858 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
3859 default:
3860 return new PPC64TargetInfo(T);
3861 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003862
Justin Holewinski285dc652011-04-20 19:34:15 +00003863 case llvm::Triple::ptx32:
3864 return new PTX32TargetInfo(T);
3865 case llvm::Triple::ptx64:
3866 return new PTX64TargetInfo(T);
3867
Chris Lattner9cbeb632010-03-06 21:21:27 +00003868 case llvm::Triple::mblaze:
3869 return new MBlazeTargetInfo(T);
3870
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003871 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003872 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003873 case llvm::Triple::Linux:
3874 return new LinuxTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003875 case llvm::Triple::AuroraUX:
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003876 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003877 case llvm::Triple::Solaris:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003878 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003879 case llvm::Triple::NetBSD:
3880 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
3881 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003882 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003883 default:
3884 return new SparcV8TargetInfo(T);
3885 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003886
John Thompson3f6918a2009-11-19 17:18:50 +00003887 // FIXME: Need a real SPU target.
3888 case llvm::Triple::cellspu:
3889 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
3890
Eli Friedmanb63decf2009-08-19 20:47:07 +00003891 case llvm::Triple::tce:
3892 return new TCETargetInfo(T);
3893
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003894 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003895 if (Triple.isOSDarwin())
3896 return new DarwinI386TargetInfo(T);
3897
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003898 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003899 case llvm::Triple::AuroraUX:
3900 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003901 case llvm::Triple::Linux:
3902 return new LinuxTargetInfo<X86_32TargetInfo>(T);
3903 case llvm::Triple::DragonFly:
3904 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
3905 case llvm::Triple::NetBSD:
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00003906 return new NetBSDI386TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003907 case llvm::Triple::OpenBSD:
3908 return new OpenBSDI386TargetInfo(T);
3909 case llvm::Triple::FreeBSD:
3910 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner38e317d2010-07-07 16:01:42 +00003911 case llvm::Triple::Minix:
3912 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003913 case llvm::Triple::Solaris:
3914 return new SolarisTargetInfo<X86_32TargetInfo>(T);
3915 case llvm::Triple::Cygwin:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003916 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003917 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003918 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003919 case llvm::Triple::Win32:
Michael J. Spencera764e832010-10-21 08:22:51 +00003920 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattner86ed3a32010-04-11 19:29:39 +00003921 case llvm::Triple::Haiku:
3922 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003923 case llvm::Triple::RTEMS:
3924 return new RTEMSX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003925 default:
3926 return new X86_32TargetInfo(T);
3927 }
3928
3929 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003930 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
3931 return new DarwinX86_64TargetInfo(T);
3932
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003933 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003934 case llvm::Triple::AuroraUX:
3935 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003936 case llvm::Triple::Linux:
3937 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner7a7ca282010-01-09 05:41:14 +00003938 case llvm::Triple::DragonFly:
3939 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003940 case llvm::Triple::NetBSD:
3941 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
3942 case llvm::Triple::OpenBSD:
3943 return new OpenBSDX86_64TargetInfo(T);
3944 case llvm::Triple::FreeBSD:
3945 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
3946 case llvm::Triple::Solaris:
3947 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00003948 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003949 return new MinGWX86_64TargetInfo(T);
3950 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003951 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003952 default:
3953 return new X86_64TargetInfo(T);
3954 }
3955 }
Reid Spencer5f016e22007-07-11 17:01:13 +00003956}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003957
3958/// CreateTargetInfo - Return the target info object for the specified target
3959/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00003960TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003961 TargetOptions &Opts) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003962 llvm::Triple Triple(Opts.Triple);
3963
3964 // Construct the target
3965 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
3966 if (!Target) {
3967 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
3968 return 0;
3969 }
3970
Daniel Dunbareac7c532009-12-18 18:42:37 +00003971 // Set the target CPU if specified.
3972 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
3973 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
3974 return 0;
3975 }
3976
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003977 // Set the target ABI if specified.
3978 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
3979 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
3980 return 0;
3981 }
3982
Charles Davis98b7c5c2010-06-11 01:06:47 +00003983 // Set the target C++ ABI.
John McCallee79a4c2010-08-21 22:46:04 +00003984 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davis98b7c5c2010-06-11 01:06:47 +00003985 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
3986 return 0;
3987 }
3988
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003989 // Compute the default target features, we need the target to handle this
3990 // because features may have dependencies on one another.
3991 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003992 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003993
3994 // Apply the user specified deltas.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00003995 // First the enables.
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003996 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
3997 ie = Opts.Features.end(); it != ie; ++it) {
3998 const char *Name = it->c_str();
3999
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004000 if (Name[0] != '+')
4001 continue;
4002
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004003 // Apply the feature via the target.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004004 if (!Target->setFeatureEnabled(Features, Name + 1, true)) {
4005 Diags.Report(diag::err_target_invalid_feature) << Name;
4006 return 0;
4007 }
4008 }
4009
4010 // Then the disables.
4011 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
4012 ie = Opts.Features.end(); it != ie; ++it) {
4013 const char *Name = it->c_str();
4014
4015 if (Name[0] == '+')
4016 continue;
4017
4018 // Apply the feature via the target.
4019 if (Name[0] != '-' ||
4020 !Target->setFeatureEnabled(Features, Name + 1, false)) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004021 Diags.Report(diag::err_target_invalid_feature) << Name;
4022 return 0;
4023 }
4024 }
4025
4026 // Add the features to the compile options.
4027 //
4028 // FIXME: If we are completely confident that we have the right set, we only
4029 // need to pass the minuses.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004030 Opts.Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004031 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
4032 ie = Features.end(); it != ie; ++it)
Chris Lattner1e5f83b2011-07-14 18:24:21 +00004033 Opts.Features.push_back(std::string(it->second ? "+" : "-") +
Chris Lattner48b78bd2011-07-14 18:45:41 +00004034 it->first().str());
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004035 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004036
4037 return Target.take();
4038}