blob: 39bb8697dc5d1b1bb0aa646d70d18d1e56390b96 [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
Benjamin Kramer448f68d2012-01-10 11:50:09 +000057static void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName,
58 bool Tuning = true) {
59 Builder.defineMacro("__" + CPUName);
60 Builder.defineMacro("__" + CPUName + "__");
61 if (Tuning)
62 Builder.defineMacro("__tune_" + CPUName + "__");
63}
64
Chris Lattnerd29b6302008-10-05 21:50:58 +000065//===----------------------------------------------------------------------===//
66// Defines specific to certain operating systems.
67//===----------------------------------------------------------------------===//
Chris Lattner797c3c42009-08-10 19:03:04 +000068
Torok Edwin5f6c1942009-06-30 17:10:35 +000069namespace {
Douglas Gregora3844922009-07-01 15:12:53 +000070template<typename TgtInfo>
71class OSTargetInfo : public TgtInfo {
Torok Edwin5f6c1942009-06-30 17:10:35 +000072protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +000073 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +000074 MacroBuilder &Builder) const=0;
Torok Edwin5f6c1942009-06-30 17:10:35 +000075public:
Douglas Gregora3844922009-07-01 15:12:53 +000076 OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
Torok Edwin5f6c1942009-06-30 17:10:35 +000077 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +000078 MacroBuilder &Builder) const {
79 TgtInfo::getTargetDefines(Opts, Builder);
80 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Torok Edwinb0a5b242009-06-30 17:00:25 +000081 }
Torok Edwin5f6c1942009-06-30 17:10:35 +000082
83};
Chris Lattner4c28b1c2009-08-12 06:24:27 +000084} // end anonymous namespace
Torok Edwinb0a5b242009-06-30 17:00:25 +000085
Chris Lattner797c3c42009-08-10 19:03:04 +000086
Daniel Dunbar21ae3192010-01-26 01:44:04 +000087static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +000088 const llvm::Triple &Triple,
Chris Lattner5f9e2722011-07-23 10:55:15 +000089 StringRef &PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +000090 VersionTuple &PlatformMinVersion) {
Benjamin Kramera9992772010-01-09 17:55:51 +000091 Builder.defineMacro("__APPLE_CC__", "5621");
92 Builder.defineMacro("__APPLE__");
93 Builder.defineMacro("__MACH__");
94 Builder.defineMacro("OBJC_NEW_PROPERTIES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000095
John McCall098df7f2011-06-16 00:03:19 +000096 if (!Opts.ObjCAutoRefCount) {
John McCallf85e1932011-06-15 23:02:42 +000097 // __weak is always defined, for use in blocks and with objc pointers.
98 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000099
John McCallf85e1932011-06-15 23:02:42 +0000100 // Darwin defines __strong even in C mode (just to nothing).
Douglas Gregore289d812011-09-13 17:21:33 +0000101 if (Opts.getGC() != LangOptions::NonGC)
John McCallf85e1932011-06-15 23:02:42 +0000102 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
103 else
104 Builder.defineMacro("__strong", "");
Eric Christopher7c9adf92011-07-07 22:55:26 +0000105
John McCallf85e1932011-06-15 23:02:42 +0000106 // __unsafe_unretained is defined to nothing in non-ARC mode. We even
107 // allow this in C, since one might have block pointers in structs that
108 // are used in pure C code and in Objective-C ARC.
109 Builder.defineMacro("__unsafe_unretained", "");
John McCallf85e1932011-06-15 23:02:42 +0000110 }
Eric Christopher7c9adf92011-07-07 22:55:26 +0000111
Eli Friedman2de4fee2009-06-04 23:00:29 +0000112 if (Opts.Static)
Benjamin Kramera9992772010-01-09 17:55:51 +0000113 Builder.defineMacro("__STATIC__");
Eli Friedman2de4fee2009-06-04 23:00:29 +0000114 else
Benjamin Kramera9992772010-01-09 17:55:51 +0000115 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000116
117 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000118 Builder.defineMacro("_REENTRANT");
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000119
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000120 // Get the platform type and version number from the triple.
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000121 unsigned Maj, Min, Rev;
Mike Stump1eb44332009-09-09 15:08:12 +0000122
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000123 // If no version was given, default to to 10.4.0, for simplifying tests.
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000124 if (Triple.getOSName() == "darwin" || Triple.getOSName() == "osx") {
125 PlatformName = "macosx";
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000126 Min = Rev = 0;
127 Maj = 8;
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000128 } else {
129 // Otherwise, honor all three triple forms ("-darwinNNN[-iphoneos]",
130 // "-osxNNN", and "-iosNNN").
131
132 if (Triple.getOS() == llvm::Triple::Darwin) {
133 // For historical reasons that make little sense, the version passed here
134 // is the "darwin" version, which drops the 10 and offsets by 4.
135 Triple.getOSVersion(Maj, Min, Rev);
136
137 if (Triple.getEnvironmentName() == "iphoneos") {
138 PlatformName = "ios";
139 } else {
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000140 PlatformName = "macosx";
141 Rev = Min;
142 Min = Maj - 4;
143 Maj = 10;
144 }
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000145 } else {
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000146 Triple.getOSVersion(Maj, Min, Rev);
Daniel Dunbara4ff6482011-04-19 23:34:21 +0000147 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000148 }
149 }
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000150
Sebastian Pop9ec60df2012-01-20 22:01:23 +0000151 // If -target arch-pc-win32-macho option specified, we're
Eric Christopher895d4222011-07-29 21:20:35 +0000152 // generating code for Win32 ABI. No need to emit
Chad Rosierd9259f32011-07-19 20:00:06 +0000153 // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
154 if (PlatformName == "win32") {
155 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
156 return;
157 }
158
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000159 // Set the appropriate OS version define.
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000160 if (PlatformName == "ios") {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000161 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000162 char Str[6];
163 Str[0] = '0' + Maj;
164 Str[1] = '0' + (Min / 10);
165 Str[2] = '0' + (Min % 10);
166 Str[3] = '0' + (Rev / 10);
167 Str[4] = '0' + (Rev % 10);
168 Str[5] = '\0';
169 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
170 } else {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000171 // Note that the Driver allows versions which aren't representable in the
172 // define (because we only get a single digit for the minor and micro
173 // revision numbers). So, we limit them to the maximum representable
174 // version.
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000175 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000176 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000177 char Str[5];
178 Str[0] = '0' + (Maj / 10);
179 Str[1] = '0' + (Maj % 10);
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000180 Str[2] = '0' + std::min(Min, 9U);
181 Str[3] = '0' + std::min(Rev, 9U);
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000182 Str[4] = '\0';
183 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000184 }
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000185
186 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman618234a2008-08-20 02:34:37 +0000187}
Reid Spencer5f016e22007-07-11 17:01:13 +0000188
Chris Lattner797c3c42009-08-10 19:03:04 +0000189namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000190template<typename Target>
191class DarwinTargetInfo : public OSTargetInfo<Target> {
192protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000193 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000194 MacroBuilder &Builder) const {
Eric Christopher7c9adf92011-07-07 22:55:26 +0000195 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000196 this->PlatformMinVersion);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000197 }
Mike Stump1eb44332009-09-09 15:08:12 +0000198
Torok Edwin5f6c1942009-06-30 17:10:35 +0000199public:
200 DarwinTargetInfo(const std::string& triple) :
201 OSTargetInfo<Target>(triple) {
Eric Christopheraa7333c2011-07-02 00:20:22 +0000202 llvm::Triple T = llvm::Triple(triple);
203 this->TLSSupported = T.isMacOSX() && !T.isMacOSXVersionLT(10,7);
Daniel Dunbare177d3b2011-02-21 23:12:51 +0000204 this->MCountName = "\01mcount";
Torok Edwin5f6c1942009-06-30 17:10:35 +0000205 }
206
Chris Lattner5f9e2722011-07-23 10:55:15 +0000207 virtual std::string isValidSectionSpecifier(StringRef SR) const {
Chris Lattner797c3c42009-08-10 19:03:04 +0000208 // Let MCSectionMachO validate this.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000209 StringRef Segment, Section;
Chris Lattner797c3c42009-08-10 19:03:04 +0000210 unsigned TAA, StubSize;
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000211 bool HasTAA;
Chris Lattner797c3c42009-08-10 19:03:04 +0000212 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000213 TAA, HasTAA, StubSize);
Chris Lattner797c3c42009-08-10 19:03:04 +0000214 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000215
Anders Carlsson18af3682010-06-08 22:47:50 +0000216 virtual const char *getStaticInitSectionSpecifier() const {
217 // FIXME: We should return 0 when building kexts.
218 return "__TEXT,__StaticInit,regular,pure_instructions";
219 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000220
John McCall41887602012-01-29 01:20:30 +0000221 /// Darwin does not support protected visibility. Darwin's "default"
222 /// is very similar to ELF's "protected"; Darwin requires a "weak"
223 /// attribute on declarations that can be dynamically replaced.
224 virtual bool hasProtectedVisibility() const {
225 return false;
226 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000227};
228
Chris Lattner797c3c42009-08-10 19:03:04 +0000229
Torok Edwin5f6c1942009-06-30 17:10:35 +0000230// DragonFlyBSD Target
231template<typename Target>
232class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
233protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000234 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000235 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000236 // DragonFly defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000237 Builder.defineMacro("__DragonFly__");
238 Builder.defineMacro("__DragonFly_cc_version", "100001");
239 Builder.defineMacro("__ELF__");
240 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
241 Builder.defineMacro("__tune_i386__");
242 DefineStd(Builder, "unix", Opts);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000243 }
244public:
Mike Stump1eb44332009-09-09 15:08:12 +0000245 DragonFlyBSDTargetInfo(const std::string &triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000246 : OSTargetInfo<Target>(triple) {}
247};
248
249// FreeBSD Target
250template<typename Target>
251class FreeBSDTargetInfo : public OSTargetInfo<Target> {
252protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000253 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000254 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000255 // FreeBSD defines; list based off of gcc output
256
Benjamin Kramer474202f2011-10-18 10:10:08 +0000257 unsigned Release = Triple.getOSMajorVersion();
258 if (Release == 0U)
259 Release = 8;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000260
Benjamin Kramer474202f2011-10-18 10:10:08 +0000261 Builder.defineMacro("__FreeBSD__", Twine(Release));
262 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramera9992772010-01-09 17:55:51 +0000263 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
264 DefineStd(Builder, "unix", Opts);
265 Builder.defineMacro("__ELF__");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000266 }
267public:
Mike Stump1eb44332009-09-09 15:08:12 +0000268 FreeBSDTargetInfo(const std::string &triple)
Duncan Sands1e90faf2009-07-08 13:55:08 +0000269 : OSTargetInfo<Target>(triple) {
270 this->UserLabelPrefix = "";
Roman Divackybe4c8702011-02-10 16:52:03 +0000271
272 llvm::Triple Triple(triple);
273 switch (Triple.getArch()) {
274 default:
275 case llvm::Triple::x86:
276 case llvm::Triple::x86_64:
277 this->MCountName = ".mcount";
278 break;
279 case llvm::Triple::mips:
280 case llvm::Triple::mipsel:
281 case llvm::Triple::ppc:
282 case llvm::Triple::ppc64:
283 this->MCountName = "_mcount";
284 break;
285 case llvm::Triple::arm:
286 this->MCountName = "__mcount";
287 break;
288 }
289
Duncan Sands1e90faf2009-07-08 13:55:08 +0000290 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000291};
292
Chris Lattner38e317d2010-07-07 16:01:42 +0000293// Minix Target
294template<typename Target>
295class MinixTargetInfo : public OSTargetInfo<Target> {
296protected:
297 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
298 MacroBuilder &Builder) const {
299 // Minix defines
300
301 Builder.defineMacro("__minix", "3");
302 Builder.defineMacro("_EM_WSIZE", "4");
303 Builder.defineMacro("_EM_PSIZE", "4");
304 Builder.defineMacro("_EM_SSIZE", "2");
305 Builder.defineMacro("_EM_LSIZE", "4");
306 Builder.defineMacro("_EM_FSIZE", "4");
307 Builder.defineMacro("_EM_DSIZE", "8");
Eli Friedman6d402dc2011-12-08 23:54:21 +0000308 Builder.defineMacro("__ELF__");
Chris Lattner38e317d2010-07-07 16:01:42 +0000309 DefineStd(Builder, "unix", Opts);
310 }
311public:
312 MinixTargetInfo(const std::string &triple)
313 : OSTargetInfo<Target>(triple) {
314 this->UserLabelPrefix = "";
315 }
316};
317
Torok Edwin5f6c1942009-06-30 17:10:35 +0000318// Linux target
319template<typename Target>
320class LinuxTargetInfo : public OSTargetInfo<Target> {
321protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000322 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000323 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000324 // Linux defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000325 DefineStd(Builder, "unix", Opts);
326 DefineStd(Builder, "linux", Opts);
327 Builder.defineMacro("__gnu_linux__");
328 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000329 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000330 Builder.defineMacro("_REENTRANT");
Douglas Gregor2b003fd2010-04-21 05:52:38 +0000331 if (Opts.CPlusPlus)
332 Builder.defineMacro("_GNU_SOURCE");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000333 }
334public:
Mike Stump1eb44332009-09-09 15:08:12 +0000335 LinuxTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000336 : OSTargetInfo<Target>(triple) {
337 this->UserLabelPrefix = "";
Douglas Gregor12e84642011-01-12 21:19:25 +0000338 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000339 }
Benjamin Kramer86d18c52011-10-15 17:53:33 +0000340
341 virtual const char *getStaticInitSectionSpecifier() const {
342 return ".text.startup";
343 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000344};
345
Chris Lattnerb62bb282009-07-13 20:29:08 +0000346// NetBSD Target
347template<typename Target>
348class NetBSDTargetInfo : public OSTargetInfo<Target> {
349protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000350 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000351 MacroBuilder &Builder) const {
Chris Lattnerb62bb282009-07-13 20:29:08 +0000352 // NetBSD defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000353 Builder.defineMacro("__NetBSD__");
354 Builder.defineMacro("__unix__");
355 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000356 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000357 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerb62bb282009-07-13 20:29:08 +0000358 }
359public:
Mike Stump1eb44332009-09-09 15:08:12 +0000360 NetBSDTargetInfo(const std::string &triple)
Chris Lattnerb62bb282009-07-13 20:29:08 +0000361 : OSTargetInfo<Target>(triple) {
362 this->UserLabelPrefix = "";
363 }
364};
365
Torok Edwin5f6c1942009-06-30 17:10:35 +0000366// OpenBSD Target
367template<typename Target>
368class OpenBSDTargetInfo : public OSTargetInfo<Target> {
369protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000370 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000371 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000372 // OpenBSD defines; list based off of gcc output
373
Benjamin Kramera9992772010-01-09 17:55:51 +0000374 Builder.defineMacro("__OpenBSD__");
375 DefineStd(Builder, "unix", Opts);
376 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000377 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000378 Builder.defineMacro("_POSIX_THREADS");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000379 }
380public:
Mike Stump1eb44332009-09-09 15:08:12 +0000381 OpenBSDTargetInfo(const std::string &triple)
Eli Friedman62d829a2011-12-15 02:15:56 +0000382 : OSTargetInfo<Target>(triple) {
383 this->UserLabelPrefix = "";
384
385 llvm::Triple Triple(triple);
386 switch (Triple.getArch()) {
387 default:
388 case llvm::Triple::x86:
389 case llvm::Triple::x86_64:
390 case llvm::Triple::arm:
391 case llvm::Triple::sparc:
392 this->MCountName = "__mcount";
393 break;
394 case llvm::Triple::mips64:
395 case llvm::Triple::mips64el:
396 case llvm::Triple::ppc:
397 case llvm::Triple::sparcv9:
398 this->MCountName = "_mcount";
399 break;
400 }
401 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000402};
403
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000404// PSP Target
405template<typename Target>
406class PSPTargetInfo : public OSTargetInfo<Target> {
407protected:
408 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000409 MacroBuilder &Builder) const {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000410 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramera9992772010-01-09 17:55:51 +0000411 Builder.defineMacro("PSP");
412 Builder.defineMacro("_PSP");
413 Builder.defineMacro("__psp__");
414 Builder.defineMacro("__ELF__");
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000415 }
416public:
417 PSPTargetInfo(const std::string& triple)
418 : OSTargetInfo<Target>(triple) {
419 this->UserLabelPrefix = "";
420 }
421};
422
John Thompson3f6918a2009-11-19 17:18:50 +0000423// PS3 PPU Target
424template<typename Target>
425class PS3PPUTargetInfo : public OSTargetInfo<Target> {
426protected:
427 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000428 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000429 // PS3 PPU defines.
John Thompsonfb457972010-03-25 16:18:32 +0000430 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000431 Builder.defineMacro("__PPU__");
432 Builder.defineMacro("__CELLOS_LV2__");
433 Builder.defineMacro("__ELF__");
434 Builder.defineMacro("__LP32__");
John Thompson8e6065a2010-06-24 22:44:13 +0000435 Builder.defineMacro("_ARCH_PPC64");
436 Builder.defineMacro("__powerpc64__");
John Thompson3f6918a2009-11-19 17:18:50 +0000437 }
438public:
439 PS3PPUTargetInfo(const std::string& triple)
440 : OSTargetInfo<Target>(triple) {
441 this->UserLabelPrefix = "";
Nick Lewycky99520702011-12-16 22:32:39 +0000442 this->LongWidth = this->LongAlign = 32;
443 this->PointerWidth = this->PointerAlign = 32;
John Thompson8e6065a2010-06-24 22:44:13 +0000444 this->IntMaxType = TargetInfo::SignedLongLong;
445 this->UIntMaxType = TargetInfo::UnsignedLongLong;
446 this->Int64Type = TargetInfo::SignedLongLong;
John Thompsonec387af2009-12-18 14:21:08 +0000447 this->SizeType = TargetInfo::UnsignedInt;
John Thompson8e6065a2010-06-24 22:44:13 +0000448 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 +0000449 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompson3f6918a2009-11-19 17:18:50 +0000450 }
451};
452
453// FIXME: Need a real SPU target.
454// PS3 SPU Target
455template<typename Target>
456class PS3SPUTargetInfo : public OSTargetInfo<Target> {
457protected:
458 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000459 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000460 // PS3 PPU defines.
Benjamin Kramera9992772010-01-09 17:55:51 +0000461 Builder.defineMacro("__SPU__");
462 Builder.defineMacro("__ELF__");
John Thompson3f6918a2009-11-19 17:18:50 +0000463 }
464public:
465 PS3SPUTargetInfo(const std::string& triple)
466 : OSTargetInfo<Target>(triple) {
467 this->UserLabelPrefix = "";
468 }
469};
470
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000471// AuroraUX target
472template<typename Target>
473class AuroraUXTargetInfo : public OSTargetInfo<Target> {
474protected:
475 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000476 MacroBuilder &Builder) const {
477 DefineStd(Builder, "sun", Opts);
478 DefineStd(Builder, "unix", Opts);
479 Builder.defineMacro("__ELF__");
480 Builder.defineMacro("__svr4__");
481 Builder.defineMacro("__SVR4");
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000482 }
483public:
484 AuroraUXTargetInfo(const std::string& triple)
485 : OSTargetInfo<Target>(triple) {
486 this->UserLabelPrefix = "";
487 this->WCharType = this->SignedLong;
488 // FIXME: WIntType should be SignedLong
489 }
490};
491
Torok Edwin5f6c1942009-06-30 17:10:35 +0000492// Solaris target
493template<typename Target>
494class SolarisTargetInfo : public OSTargetInfo<Target> {
495protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000496 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000497 MacroBuilder &Builder) const {
498 DefineStd(Builder, "sun", Opts);
499 DefineStd(Builder, "unix", Opts);
500 Builder.defineMacro("__ELF__");
501 Builder.defineMacro("__svr4__");
502 Builder.defineMacro("__SVR4");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000503 }
504public:
Mike Stump1eb44332009-09-09 15:08:12 +0000505 SolarisTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000506 : OSTargetInfo<Target>(triple) {
507 this->UserLabelPrefix = "";
508 this->WCharType = this->SignedLong;
509 // FIXME: WIntType should be SignedLong
510 }
511};
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000512
513// Windows target
514template<typename Target>
515class WindowsTargetInfo : public OSTargetInfo<Target> {
516protected:
517 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
518 MacroBuilder &Builder) const {
Michael J. Spencera764e832010-10-21 08:22:51 +0000519 Builder.defineMacro("_WIN32");
520 }
521 void getVisualStudioDefines(const LangOptions &Opts,
522 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000523 if (Opts.CPlusPlus) {
524 if (Opts.RTTI)
525 Builder.defineMacro("_CPPRTTI");
526
527 if (Opts.Exceptions)
528 Builder.defineMacro("_CPPUNWIND");
529 }
530
531 if (!Opts.CharIsSigned)
532 Builder.defineMacro("_CHAR_UNSIGNED");
533
534 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
535 // but it works for now.
536 if (Opts.POSIXThreads)
537 Builder.defineMacro("_MT");
Michael J. Spencera764e832010-10-21 08:22:51 +0000538
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000539 if (Opts.MSCVersion != 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000540 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000541
Francois Pichet62ec1f22011-09-17 17:15:52 +0000542 if (Opts.MicrosoftExt) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000543 Builder.defineMacro("_MSC_EXTENSIONS");
544
545 if (Opts.CPlusPlus0x) {
546 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
547 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
548 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
549 }
550 }
551
552 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000553 }
554
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000555public:
556 WindowsTargetInfo(const std::string &triple)
557 : OSTargetInfo<Target>(triple) {}
558};
559
Mike Stump1eb44332009-09-09 15:08:12 +0000560} // end anonymous namespace.
Torok Edwin5f6c1942009-06-30 17:10:35 +0000561
Chris Lattnerd29b6302008-10-05 21:50:58 +0000562//===----------------------------------------------------------------------===//
Eli Friedmane4277982008-08-20 23:11:40 +0000563// Specific target implementations.
564//===----------------------------------------------------------------------===//
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +0000565
Eli Friedmane4277982008-08-20 23:11:40 +0000566namespace {
567// PPC abstract base class
568class PPCTargetInfo : public TargetInfo {
569 static const Builtin::Info BuiltinInfo[];
570 static const char * const GCCRegNames[];
571 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Eli Friedmane4277982008-08-20 23:11:40 +0000572public:
Eli Friedman15b91762009-06-05 07:05:05 +0000573 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
574
Eli Friedmane4277982008-08-20 23:11:40 +0000575 virtual void getTargetBuiltins(const Builtin::Info *&Records,
576 unsigned &NumRecords) const {
Reid Spencer5f016e22007-07-11 17:01:13 +0000577 Records = BuiltinInfo;
Eli Friedmane4277982008-08-20 23:11:40 +0000578 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +0000579 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000580
Bob Wilson9f1c49c2012-01-28 18:02:29 +0000581 virtual bool isCLZForZeroUndef() const { return false; }
582
Chris Lattner33328642009-03-20 15:52:06 +0000583 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000584 MacroBuilder &Builder) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000585
Douglas Gregore727d212012-01-30 06:38:25 +0000586 virtual bool hasFeature(StringRef Feature) const;
587
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000588 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000589 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000590 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000591 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000592 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +0000593 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000594 switch (*Name) {
Anders Carlssond04c6e22007-11-27 04:11:28 +0000595 default: return false;
596 case 'O': // Zero
John Thompson8e6065a2010-06-24 22:44:13 +0000597 break;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000598 case 'b': // Base register
599 case 'f': // Floating point register
Chris Lattner44def072009-04-26 07:16:29 +0000600 Info.setAllowsRegister();
John Thompson8e6065a2010-06-24 22:44:13 +0000601 break;
602 // FIXME: The following are added to allow parsing.
603 // I just took a guess at what the actions should be.
604 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer20249a12010-10-21 03:16:25 +0000605 case 'd': // Floating point register (containing 64-bit value)
John Thompson8e6065a2010-06-24 22:44:13 +0000606 case 'v': // Altivec vector register
607 Info.setAllowsRegister();
608 break;
609 case 'w':
610 switch (Name[1]) {
Michael J. Spencer20249a12010-10-21 03:16:25 +0000611 case 'd':// VSX vector register to hold vector double data
612 case 'f':// VSX vector register to hold vector float data
613 case 's':// VSX vector register to hold scalar float data
614 case 'a':// Any VSX register
John Thompson8e6065a2010-06-24 22:44:13 +0000615 break;
616 default:
617 return false;
618 }
619 Info.setAllowsRegister();
620 Name++; // Skip over 'w'.
621 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000622 case 'h': // `MQ', `CTR', or `LINK' register
623 case 'q': // `MQ' register
624 case 'c': // `CTR' register
625 case 'l': // `LINK' register
626 case 'x': // `CR' register (condition register) number 0
627 case 'y': // `CR' register (condition register)
628 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson8e6065a2010-06-24 22:44:13 +0000629 Info.setAllowsRegister();
630 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000631 case 'I': // Signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000632 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer20249a12010-10-21 03:16:25 +0000633 // (use `L' instead for SImode constants)
634 case 'K': // Unsigned 16-bit constant
635 case 'L': // Signed 16-bit constant shifted left 16 bits
636 case 'M': // Constant larger than 31
637 case 'N': // Exact power of 2
638 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000639 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000640 // register with one instruction per word
John Thompson8e6065a2010-06-24 22:44:13 +0000641 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer20249a12010-10-21 03:16:25 +0000642 // into a register using three instructions
John Thompson8e6065a2010-06-24 22:44:13 +0000643 break;
644 case 'm': // Memory operand. Note that on PowerPC targets, m can
645 // include addresses that update the base register. It
646 // is therefore only safe to use `m' in an asm statement
647 // if that asm statement accesses the operand exactly once.
648 // The asm statement must also use `%U<opno>' as a
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000649 // placeholder for the "update" flag in the corresponding
Michael J. Spencer20249a12010-10-21 03:16:25 +0000650 // load or store instruction. For example:
John Thompson8e6065a2010-06-24 22:44:13 +0000651 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000652 // is correct but:
John Thompson8e6065a2010-06-24 22:44:13 +0000653 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
654 // is not. Use es rather than m if you don't want the base
Michael J. Spencer20249a12010-10-21 03:16:25 +0000655 // register to be updated.
656 case 'e':
John Thompson56b6eca2010-06-25 00:02:05 +0000657 if (Name[1] != 's')
658 return false;
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000659 // es: A "stable" memory operand; that is, one which does not
John Thompson8e6065a2010-06-24 22:44:13 +0000660 // include any automodification of the base register. Unlike
661 // `m', this constraint can be used in asm statements that
662 // might access the operand several times, or that might not
John Thompson56b6eca2010-06-25 00:02:05 +0000663 // access it at all.
John Thompson8e6065a2010-06-24 22:44:13 +0000664 Info.setAllowsMemory();
John Thompson56b6eca2010-06-25 00:02:05 +0000665 Name++; // Skip over 'e'.
John Thompson8e6065a2010-06-24 22:44:13 +0000666 break;
667 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer20249a12010-10-21 03:16:25 +0000668 // usually better to use `m' or `es' in asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000669 case 'Z': // Memory operand that is an indexed or indirect from a
670 // register (it is usually better to use `m' or `es' in
Michael J. Spencer20249a12010-10-21 03:16:25 +0000671 // asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000672 Info.setAllowsMemory();
673 Info.setAllowsRegister();
674 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000675 case 'R': // AIX TOC entry
John Thompson8e6065a2010-06-24 22:44:13 +0000676 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000677 // register (`p' is preferable for asm statements)
678 case 'S': // Constant suitable as a 64-bit mask operand
679 case 'T': // Constant suitable as a 32-bit mask operand
680 case 'U': // System V Release 4 small data area reference
John Thompson8e6065a2010-06-24 22:44:13 +0000681 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000682 // instructions
683 case 'W': // Vector constant that does not require memory
684 case 'j': // Vector constant that is all zeros.
John Thompson8e6065a2010-06-24 22:44:13 +0000685 break;
686 // End FIXME.
Anders Carlssond04c6e22007-11-27 04:11:28 +0000687 }
John Thompson8e6065a2010-06-24 22:44:13 +0000688 return true;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000689 }
Eli Friedmane4277982008-08-20 23:11:40 +0000690 virtual const char *getClobbers() const {
691 return "";
Anders Carlssond04c6e22007-11-27 04:11:28 +0000692 }
Eli Friedmane4277982008-08-20 23:11:40 +0000693};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000694
Eli Friedmane4277982008-08-20 23:11:40 +0000695const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000696#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000697#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000698 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000699#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000700};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000701
702
Chris Lattnerc0f59212009-03-02 22:27:17 +0000703/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
704/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000705void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000706 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000707 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000708 Builder.defineMacro("__ppc__");
709 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000710 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000711 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000712 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000713 Builder.defineMacro("_ARCH_PPC64");
714 Builder.defineMacro("_LP64");
715 Builder.defineMacro("__LP64__");
Chris Lattnere03ae302010-02-16 18:14:57 +0000716 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000717 Builder.defineMacro("__ppc64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000718 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +0000719 Builder.defineMacro("__ppc__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000720 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000721
Chris Lattnerc0f59212009-03-02 22:27:17 +0000722 // Target properties.
Joerg Sonnenberger7cd1de52011-07-05 14:56:12 +0000723 if (getTriple().getOS() != llvm::Triple::NetBSD)
724 Builder.defineMacro("_BIG_ENDIAN");
Benjamin Kramera9992772010-01-09 17:55:51 +0000725 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000726
Chris Lattnerc0f59212009-03-02 22:27:17 +0000727 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000728 Builder.defineMacro("__NATURAL_ALIGNMENT__");
729 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000730
Chris Lattnerc0f59212009-03-02 22:27:17 +0000731 // FIXME: Should be controlled by command line option.
Benjamin Kramera9992772010-01-09 17:55:51 +0000732 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000733
John Thompson3f6918a2009-11-19 17:18:50 +0000734 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000735 Builder.defineMacro("__VEC__", "10206");
736 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000737 }
Chris Lattnerc0f59212009-03-02 22:27:17 +0000738}
739
Douglas Gregore727d212012-01-30 06:38:25 +0000740bool PPCTargetInfo::hasFeature(StringRef Feature) const {
741 return Feature == "powerpc";
742}
Chris Lattner393ff042008-04-21 18:56:49 +0000743
Douglas Gregore727d212012-01-30 06:38:25 +0000744
Eli Friedmane4277982008-08-20 23:11:40 +0000745const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +0000746 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
747 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
748 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
749 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
750 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
751 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
752 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
753 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +0000754 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000755 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +0000756 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000757 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
758 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
759 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
760 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +0000761 "vrsave", "vscr",
762 "spe_acc", "spefscr",
763 "sfp"
764};
Reid Spencer5f016e22007-07-11 17:01:13 +0000765
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000766void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000767 unsigned &NumNames) const {
768 Names = GCCRegNames;
769 NumNames = llvm::array_lengthof(GCCRegNames);
770}
Reid Spencer5f016e22007-07-11 17:01:13 +0000771
Eli Friedmane4277982008-08-20 23:11:40 +0000772const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
773 // While some of these aliases do map to different registers
774 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000775 { { "0" }, "r0" },
776 { { "1"}, "r1" },
777 { { "2" }, "r2" },
778 { { "3" }, "r3" },
779 { { "4" }, "r4" },
780 { { "5" }, "r5" },
781 { { "6" }, "r6" },
782 { { "7" }, "r7" },
783 { { "8" }, "r8" },
784 { { "9" }, "r9" },
785 { { "10" }, "r10" },
786 { { "11" }, "r11" },
787 { { "12" }, "r12" },
788 { { "13" }, "r13" },
789 { { "14" }, "r14" },
790 { { "15" }, "r15" },
791 { { "16" }, "r16" },
792 { { "17" }, "r17" },
793 { { "18" }, "r18" },
794 { { "19" }, "r19" },
795 { { "20" }, "r20" },
796 { { "21" }, "r21" },
797 { { "22" }, "r22" },
798 { { "23" }, "r23" },
799 { { "24" }, "r24" },
800 { { "25" }, "r25" },
801 { { "26" }, "r26" },
802 { { "27" }, "r27" },
803 { { "28" }, "r28" },
804 { { "29" }, "r29" },
805 { { "30" }, "r30" },
806 { { "31" }, "r31" },
807 { { "fr0" }, "f0" },
808 { { "fr1" }, "f1" },
809 { { "fr2" }, "f2" },
810 { { "fr3" }, "f3" },
811 { { "fr4" }, "f4" },
812 { { "fr5" }, "f5" },
813 { { "fr6" }, "f6" },
814 { { "fr7" }, "f7" },
815 { { "fr8" }, "f8" },
816 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +0000817 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000818 { { "fr11" }, "f11" },
819 { { "fr12" }, "f12" },
820 { { "fr13" }, "f13" },
821 { { "fr14" }, "f14" },
822 { { "fr15" }, "f15" },
823 { { "fr16" }, "f16" },
824 { { "fr17" }, "f17" },
825 { { "fr18" }, "f18" },
826 { { "fr19" }, "f19" },
827 { { "fr20" }, "f20" },
828 { { "fr21" }, "f21" },
829 { { "fr22" }, "f22" },
830 { { "fr23" }, "f23" },
831 { { "fr24" }, "f24" },
832 { { "fr25" }, "f25" },
833 { { "fr26" }, "f26" },
834 { { "fr27" }, "f27" },
835 { { "fr28" }, "f28" },
836 { { "fr29" }, "f29" },
837 { { "fr30" }, "f30" },
838 { { "fr31" }, "f31" },
839 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +0000840};
841
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000842void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000843 unsigned &NumAliases) const {
844 Aliases = GCCRegAliases;
845 NumAliases = llvm::array_lengthof(GCCRegAliases);
846}
847} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +0000848
849namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000850class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000851public:
Chris Lattnere03ae302010-02-16 18:14:57 +0000852 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +0000853 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 +0000854 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +0000855
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000856 switch (getTriple().getOS()) {
857 case llvm::Triple::FreeBSD:
858 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000859 SizeType = UnsignedInt;
860 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +0000861 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000862 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000863 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000864 }
865
866 virtual const char *getVAListDeclaration() const {
867 // This is the ELF definition, and is overridden by the Darwin sub-target
868 return "typedef struct __va_list_tag {"
869 " unsigned char gpr;"
870 " unsigned char fpr;"
871 " unsigned short reserved;"
872 " void* overflow_arg_area;"
873 " void* reg_save_area;"
874 "} __builtin_va_list[1];";
Eli Friedmaned855cb2008-08-21 00:13:15 +0000875 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000876};
877} // end anonymous namespace.
878
879namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000880class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000881public:
Eli Friedmane4277982008-08-20 23:11:40 +0000882 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +0000883 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +0000884 IntMaxType = SignedLong;
885 UIntMaxType = UnsignedLong;
886 Int64Type = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +0000887 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 +0000888 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnerf291b102008-05-09 06:17:04 +0000889 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000890 virtual const char *getVAListDeclaration() const {
891 return "typedef char* __builtin_va_list;";
892 }
Eli Friedmane4277982008-08-20 23:11:40 +0000893};
894} // end anonymous namespace.
895
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000896
897namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +0000898class DarwinPPC32TargetInfo :
899 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000900public:
Roman Divackyc81f2a22011-01-06 08:27:10 +0000901 DarwinPPC32TargetInfo(const std::string& triple)
902 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000903 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +0000904 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
Anton Yartsev9bc23ba2012-01-17 22:40:00 +0000905 LongLongAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +0000906 SuitableAlign = 128;
Anton Yartsev9bc23ba2012-01-17 22:40:00 +0000907 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
908 "i64:32:64-f32:32:32-f64:64:64-v128:128:128-n32";
Roman Divackyc81f2a22011-01-06 08:27:10 +0000909 }
910 virtual const char *getVAListDeclaration() const {
911 return "typedef char* __builtin_va_list;";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000912 }
913};
914
915class DarwinPPC64TargetInfo :
916 public DarwinTargetInfo<PPC64TargetInfo> {
917public:
918 DarwinPPC64TargetInfo(const std::string& triple)
919 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
920 HasAlignMac68kSupport = true;
Nick Lewycky9bddf432011-12-21 04:25:47 +0000921 SuitableAlign = 128;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000922 }
923};
924} // end anonymous namespace.
925
Reid Spencer5f016e22007-07-11 17:01:13 +0000926namespace {
Justin Holewinski25bedca2011-10-03 17:28:37 +0000927 static const unsigned PTXAddrSpaceMap[] = {
928 0, // opencl_global
929 4, // opencl_local
930 1 // opencl_constant
931 };
Justin Holewinski285dc652011-04-20 19:34:15 +0000932 class PTXTargetInfo : public TargetInfo {
933 static const char * const GCCRegNames[];
934 static const Builtin::Info BuiltinInfo[];
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000935 std::vector<llvm::StringRef> AvailableFeatures;
Justin Holewinski285dc652011-04-20 19:34:15 +0000936 public:
937 PTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +0000938 BigEndian = false;
Justin Holewinski285dc652011-04-20 19:34:15 +0000939 TLSSupported = false;
940 LongWidth = LongAlign = 64;
Justin Holewinski25bedca2011-10-03 17:28:37 +0000941 AddrSpaceMap = &PTXAddrSpaceMap;
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000942 // Define available target features
943 // These must be defined in sorted order!
944 AvailableFeatures.push_back("compute10");
945 AvailableFeatures.push_back("compute11");
946 AvailableFeatures.push_back("compute12");
947 AvailableFeatures.push_back("compute13");
948 AvailableFeatures.push_back("compute20");
949 AvailableFeatures.push_back("double");
950 AvailableFeatures.push_back("no-fma");
951 AvailableFeatures.push_back("ptx20");
952 AvailableFeatures.push_back("ptx21");
953 AvailableFeatures.push_back("ptx22");
954 AvailableFeatures.push_back("ptx23");
955 AvailableFeatures.push_back("sm10");
956 AvailableFeatures.push_back("sm11");
957 AvailableFeatures.push_back("sm12");
958 AvailableFeatures.push_back("sm13");
959 AvailableFeatures.push_back("sm20");
960 AvailableFeatures.push_back("sm21");
961 AvailableFeatures.push_back("sm22");
962 AvailableFeatures.push_back("sm23");
Justin Holewinski285dc652011-04-20 19:34:15 +0000963 }
964 virtual void getTargetDefines(const LangOptions &Opts,
965 MacroBuilder &Builder) const {
966 Builder.defineMacro("__PTX__");
967 }
968 virtual void getTargetBuiltins(const Builtin::Info *&Records,
969 unsigned &NumRecords) const {
970 Records = BuiltinInfo;
971 NumRecords = clang::PTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
972 }
Douglas Gregore727d212012-01-30 06:38:25 +0000973 virtual bool hasFeature(StringRef Feature) const {
974 return Feature == "ptx";
975 }
976
Justin Holewinski285dc652011-04-20 19:34:15 +0000977 virtual void getGCCRegNames(const char * const *&Names,
978 unsigned &NumNames) const;
979 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
980 unsigned &NumAliases) const {
981 // No aliases.
982 Aliases = 0;
983 NumAliases = 0;
984 }
985 virtual bool validateAsmConstraint(const char *&Name,
986 TargetInfo::ConstraintInfo &info) const {
987 // FIXME: implement
988 return true;
989 }
990 virtual const char *getClobbers() const {
991 // FIXME: Is this really right?
992 return "";
993 }
994 virtual const char *getVAListDeclaration() const {
995 // FIXME: implement
996 return "typedef char* __builtin_va_list;";
997 }
Justin Holewinski808ef662011-09-15 12:13:38 +0000998
999 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1000 const std::string &Name,
1001 bool Enabled) const;
Justin Holewinski285dc652011-04-20 19:34:15 +00001002 };
1003
1004 const Builtin::Info PTXTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001005#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +00001006#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001007 ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +00001008#include "clang/Basic/BuiltinsPTX.def"
1009 };
1010
1011 const char * const PTXTargetInfo::GCCRegNames[] = {
1012 "r0"
1013 };
1014
1015 void PTXTargetInfo::getGCCRegNames(const char * const *&Names,
1016 unsigned &NumNames) const {
1017 Names = GCCRegNames;
1018 NumNames = llvm::array_lengthof(GCCRegNames);
1019 }
1020
Justin Holewinski808ef662011-09-15 12:13:38 +00001021 bool PTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1022 const std::string &Name,
1023 bool Enabled) const {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +00001024 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
1025 Name)) {
1026 Features[Name] = Enabled;
1027 return true;
Justin Holewinski808ef662011-09-15 12:13:38 +00001028 } else {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +00001029 return false;
Justin Holewinski808ef662011-09-15 12:13:38 +00001030 }
Justin Holewinski808ef662011-09-15 12:13:38 +00001031 }
Justin Holewinski285dc652011-04-20 19:34:15 +00001032
1033 class PTX32TargetInfo : public PTXTargetInfo {
1034 public:
1035 PTX32TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
1036 PointerWidth = PointerAlign = 32;
1037 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
1038 DescriptionString
1039 = "e-p:32:32-i64:64:64-f64:64:64-n1:8:16:32:64";
1040 }
1041 };
1042
1043 class PTX64TargetInfo : public PTXTargetInfo {
1044 public:
1045 PTX64TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
1046 PointerWidth = PointerAlign = 64;
1047 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
1048 DescriptionString
1049 = "e-p:64:64-i64:64:64-f64:64:64-n1:8:16:32:64";
1050 }
1051 };
1052}
1053
1054namespace {
Chris Lattner9cbeb632010-03-06 21:21:27 +00001055// MBlaze abstract base class
1056class MBlazeTargetInfo : public TargetInfo {
1057 static const char * const GCCRegNames[];
1058 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1059
1060public:
1061 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +00001062 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner9cbeb632010-03-06 21:21:27 +00001063 }
1064
1065 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1066 unsigned &NumRecords) const {
1067 // FIXME: Implement.
1068 Records = 0;
1069 NumRecords = 0;
1070 }
1071
1072 virtual void getTargetDefines(const LangOptions &Opts,
1073 MacroBuilder &Builder) const;
1074
Douglas Gregore727d212012-01-30 06:38:25 +00001075 virtual bool hasFeature(StringRef Feature) const {
1076 return Feature == "mblaze";
1077 }
1078
Chris Lattner9cbeb632010-03-06 21:21:27 +00001079 virtual const char *getVAListDeclaration() const {
1080 return "typedef char* __builtin_va_list;";
1081 }
1082 virtual const char *getTargetPrefix() const {
1083 return "mblaze";
1084 }
1085 virtual void getGCCRegNames(const char * const *&Names,
1086 unsigned &NumNames) const;
1087 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1088 unsigned &NumAliases) const;
1089 virtual bool validateAsmConstraint(const char *&Name,
1090 TargetInfo::ConstraintInfo &Info) const {
1091 switch (*Name) {
1092 default: return false;
1093 case 'O': // Zero
1094 return true;
1095 case 'b': // Base register
1096 case 'f': // Floating point register
1097 Info.setAllowsRegister();
1098 return true;
1099 }
1100 }
1101 virtual const char *getClobbers() const {
1102 return "";
1103 }
1104};
1105
1106/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1107/// #defines that are not tied to a specific subtarget.
1108void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1109 MacroBuilder &Builder) const {
1110 // Target identification.
1111 Builder.defineMacro("__microblaze__");
1112 Builder.defineMacro("_ARCH_MICROBLAZE");
1113 Builder.defineMacro("__MICROBLAZE__");
1114
1115 // Target properties.
1116 Builder.defineMacro("_BIG_ENDIAN");
1117 Builder.defineMacro("__BIG_ENDIAN__");
1118
1119 // Subtarget options.
1120 Builder.defineMacro("__REGISTER_PREFIX__", "");
1121}
1122
1123
1124const char * const MBlazeTargetInfo::GCCRegNames[] = {
1125 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1126 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1127 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1128 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1129 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1130 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1131 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1132 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1133 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1134 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1135};
1136
1137void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1138 unsigned &NumNames) const {
1139 Names = GCCRegNames;
1140 NumNames = llvm::array_lengthof(GCCRegNames);
1141}
1142
1143const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1144 { {"f0"}, "r0" },
1145 { {"f1"}, "r1" },
1146 { {"f2"}, "r2" },
1147 { {"f3"}, "r3" },
1148 { {"f4"}, "r4" },
1149 { {"f5"}, "r5" },
1150 { {"f6"}, "r6" },
1151 { {"f7"}, "r7" },
1152 { {"f8"}, "r8" },
1153 { {"f9"}, "r9" },
1154 { {"f10"}, "r10" },
1155 { {"f11"}, "r11" },
1156 { {"f12"}, "r12" },
1157 { {"f13"}, "r13" },
1158 { {"f14"}, "r14" },
1159 { {"f15"}, "r15" },
1160 { {"f16"}, "r16" },
1161 { {"f17"}, "r17" },
1162 { {"f18"}, "r18" },
1163 { {"f19"}, "r19" },
1164 { {"f20"}, "r20" },
1165 { {"f21"}, "r21" },
1166 { {"f22"}, "r22" },
1167 { {"f23"}, "r23" },
1168 { {"f24"}, "r24" },
1169 { {"f25"}, "r25" },
1170 { {"f26"}, "r26" },
1171 { {"f27"}, "r27" },
1172 { {"f28"}, "r28" },
1173 { {"f29"}, "r29" },
1174 { {"f30"}, "r30" },
1175 { {"f31"}, "r31" },
1176};
1177
1178void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1179 unsigned &NumAliases) const {
1180 Aliases = GCCRegAliases;
1181 NumAliases = llvm::array_lengthof(GCCRegAliases);
1182}
1183} // end anonymous namespace.
1184
1185namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001186// Namespace for x86 abstract base class
1187const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001188#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001189#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001190 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001191#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001192};
Eli Friedman61538a72008-05-20 14:21:01 +00001193
Nuno Lopes2550d702009-12-23 17:49:57 +00001194static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001195 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1196 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001197 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001198 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1199 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1200 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001201 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopherc5f9a012011-12-02 02:12:16 +00001202 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1203 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001204};
1205
Eric Christophercfd323d2011-06-21 00:05:20 +00001206const TargetInfo::AddlRegName AddlRegNames[] = {
1207 { { "al", "ah", "eax", "rax" }, 0 },
1208 { { "bl", "bh", "ebx", "rbx" }, 3 },
1209 { { "cl", "ch", "ecx", "rcx" }, 2 },
1210 { { "dl", "dh", "edx", "rdx" }, 1 },
1211 { { "esi", "rsi" }, 4 },
1212 { { "edi", "rdi" }, 5 },
1213 { { "esp", "rsp" }, 7 },
1214 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001215};
1216
1217// X86 target abstract base class; x86-32 and x86-64 are very close, so
1218// most of the implementation can be shared.
1219class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001220 enum X86SSEEnum {
Craig Topper05fe4b52012-01-09 09:19:09 +00001221 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2
Chris Lattner84f0ea82009-03-02 22:40:39 +00001222 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001223 enum MMX3DNowEnum {
1224 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1225 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001226
Eric Christophereea12d12010-04-02 23:50:19 +00001227 bool HasAES;
Craig Topper31ceea02011-12-25 05:06:45 +00001228 bool HasLZCNT;
1229 bool HasBMI;
1230 bool HasBMI2;
Craig Toppere14e08b2011-12-29 16:10:46 +00001231 bool HasPOPCNT;
Craig Topper6a511e12011-12-30 07:33:42 +00001232 bool HasFMA4;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001233
Chandler Carruth499d9722011-09-28 08:55:34 +00001234 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1235 ///
1236 /// Each enumeration represents a particular CPU supported by Clang. These
1237 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1238 enum CPUKind {
1239 CK_Generic,
1240
1241 /// \name i386
1242 /// i386-generation processors.
1243 //@{
1244 CK_i386,
1245 //@}
1246
1247 /// \name i486
1248 /// i486-generation processors.
1249 //@{
1250 CK_i486,
1251 CK_WinChipC6,
1252 CK_WinChip2,
1253 CK_C3,
1254 //@}
1255
1256 /// \name i586
1257 /// i586-generation processors, P5 microarchitecture based.
1258 //@{
1259 CK_i586,
1260 CK_Pentium,
1261 CK_PentiumMMX,
1262 //@}
1263
1264 /// \name i686
1265 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1266 //@{
1267 CK_i686,
1268 CK_PentiumPro,
1269 CK_Pentium2,
1270 CK_Pentium3,
1271 CK_Pentium3M,
1272 CK_PentiumM,
1273 CK_C3_2,
1274
1275 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1276 /// Clang however has some logic to suport this.
1277 // FIXME: Warn, deprecate, and potentially remove this.
1278 CK_Yonah,
1279 //@}
1280
1281 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001282 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001283 //@{
1284 CK_Pentium4,
1285 CK_Pentium4M,
1286 CK_Prescott,
1287 CK_Nocona,
1288 //@}
1289
1290 /// \name Core
1291 /// Core microarchitecture based processors.
1292 //@{
1293 CK_Core2,
1294
1295 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1296 /// codename which GCC no longer accepts as an option to -march, but Clang
1297 /// has some logic for recognizing it.
1298 // FIXME: Warn, deprecate, and potentially remove this.
1299 CK_Penryn,
1300 //@}
1301
1302 /// \name Atom
1303 /// Atom processors
1304 //@{
1305 CK_Atom,
1306 //@}
1307
1308 /// \name Nehalem
1309 /// Nehalem microarchitecture based processors.
1310 //@{
1311 CK_Corei7,
1312 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001313 CK_CoreAVXi,
Craig Topper2b03bb02011-12-17 19:55:21 +00001314 CK_CoreAVX2,
Chandler Carruth499d9722011-09-28 08:55:34 +00001315 //@}
1316
1317 /// \name K6
1318 /// K6 architecture processors.
1319 //@{
1320 CK_K6,
1321 CK_K6_2,
1322 CK_K6_3,
1323 //@}
1324
1325 /// \name K7
1326 /// K7 architecture processors.
1327 //@{
1328 CK_Athlon,
1329 CK_AthlonThunderbird,
1330 CK_Athlon4,
1331 CK_AthlonXP,
1332 CK_AthlonMP,
1333 //@}
1334
1335 /// \name K8
1336 /// K8 architecture processors.
1337 //@{
1338 CK_Athlon64,
1339 CK_Athlon64SSE3,
1340 CK_AthlonFX,
1341 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001342 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001343 CK_Opteron,
1344 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001345 CK_AMDFAM10,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001346 //@}
Chandler Carruth499d9722011-09-28 08:55:34 +00001347
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001348 /// \name Bobcat
1349 /// Bobcat architecture processors.
1350 //@{
1351 CK_BTVER1,
1352 //@}
1353
1354 /// \name Bulldozer
1355 /// Bulldozer architecture processors.
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001356 //@{
1357 CK_BDVER1,
1358 CK_BDVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001359 //@}
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001360
Chandler Carruth499d9722011-09-28 08:55:34 +00001361 /// This specification is deprecated and will be removed in the future.
1362 /// Users should prefer \see CK_K8.
1363 // FIXME: Warn on this when the CPU is set to it.
1364 CK_x86_64,
1365 //@}
1366
1367 /// \name Geode
1368 /// Geode processors.
1369 //@{
1370 CK_Geode
1371 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001372 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001373
Eli Friedman618234a2008-08-20 02:34:37 +00001374public:
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001375 X86TargetInfo(const std::string& triple)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001376 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Craig Topper05fe4b52012-01-09 09:19:09 +00001377 HasAES(false), HasLZCNT(false), HasBMI(false), HasBMI2(false),
1378 HasPOPCNT(false), HasFMA4(false), CPU(CK_Generic) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00001379 BigEndian = false;
Eli Friedman618234a2008-08-20 02:34:37 +00001380 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001381 }
Benjamin Kramerb4066692011-12-28 15:47:06 +00001382 virtual unsigned getFloatEvalMethod() const {
1383 // X87 evaluates with 80 bits "long double" precision.
1384 return SSELevel == NoSSE ? 2 : 0;
1385 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001386 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1387 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001388 Records = BuiltinInfo;
1389 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001390 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001391 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001392 unsigned &NumNames) const {
1393 Names = GCCRegNames;
1394 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001395 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001396 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001397 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001398 Aliases = 0;
1399 NumAliases = 0;
1400 }
1401 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1402 unsigned &NumNames) const {
1403 Names = AddlRegNames;
1404 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001405 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001406 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001407 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001408 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001409 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001410 return "~{dirflag},~{fpsr},~{flags}";
1411 }
Chris Lattner33328642009-03-20 15:52:06 +00001412 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001413 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001414 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1415 const std::string &Name,
1416 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001417 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Douglas Gregore727d212012-01-30 06:38:25 +00001418 virtual bool hasFeature(StringRef Feature) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001419 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001420 virtual const char* getABI() const {
Craig Topper05fe4b52012-01-09 09:19:09 +00001421 if (PointerWidth == 64 && SSELevel >= AVX)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001422 return "avx";
1423 else if (PointerWidth == 32 && MMX3DNowLevel == NoMMX3DNow)
1424 return "no-mmx";
1425 return "";
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001426 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001427 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001428 CPU = llvm::StringSwitch<CPUKind>(Name)
1429 .Case("i386", CK_i386)
1430 .Case("i486", CK_i486)
1431 .Case("winchip-c6", CK_WinChipC6)
1432 .Case("winchip2", CK_WinChip2)
1433 .Case("c3", CK_C3)
1434 .Case("i586", CK_i586)
1435 .Case("pentium", CK_Pentium)
1436 .Case("pentium-mmx", CK_PentiumMMX)
1437 .Case("i686", CK_i686)
1438 .Case("pentiumpro", CK_PentiumPro)
1439 .Case("pentium2", CK_Pentium2)
1440 .Case("pentium3", CK_Pentium3)
1441 .Case("pentium3m", CK_Pentium3M)
1442 .Case("pentium-m", CK_PentiumM)
1443 .Case("c3-2", CK_C3_2)
1444 .Case("yonah", CK_Yonah)
1445 .Case("pentium4", CK_Pentium4)
1446 .Case("pentium4m", CK_Pentium4M)
1447 .Case("prescott", CK_Prescott)
1448 .Case("nocona", CK_Nocona)
1449 .Case("core2", CK_Core2)
1450 .Case("penryn", CK_Penryn)
1451 .Case("atom", CK_Atom)
1452 .Case("corei7", CK_Corei7)
1453 .Case("corei7-avx", CK_Corei7AVX)
1454 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper2b03bb02011-12-17 19:55:21 +00001455 .Case("core-avx2", CK_CoreAVX2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001456 .Case("k6", CK_K6)
1457 .Case("k6-2", CK_K6_2)
1458 .Case("k6-3", CK_K6_3)
1459 .Case("athlon", CK_Athlon)
1460 .Case("athlon-tbird", CK_AthlonThunderbird)
1461 .Case("athlon-4", CK_Athlon4)
1462 .Case("athlon-xp", CK_AthlonXP)
1463 .Case("athlon-mp", CK_AthlonMP)
1464 .Case("athlon64", CK_Athlon64)
1465 .Case("athlon64-sse3", CK_Athlon64SSE3)
1466 .Case("athlon-fx", CK_AthlonFX)
1467 .Case("k8", CK_K8)
1468 .Case("k8-sse3", CK_K8SSE3)
1469 .Case("opteron", CK_Opteron)
1470 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001471 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001472 .Case("btver1", CK_BTVER1)
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001473 .Case("bdver1", CK_BDVER1)
1474 .Case("bdver2", CK_BDVER2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001475 .Case("x86-64", CK_x86_64)
1476 .Case("geode", CK_Geode)
1477 .Default(CK_Generic);
1478
Chandler Carruth26a39142011-09-28 09:45:08 +00001479 // Perform any per-CPU checks necessary to determine if this CPU is
1480 // acceptable.
1481 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1482 // invalid without explaining *why*.
1483 switch (CPU) {
1484 case CK_Generic:
1485 // No processor selected!
1486 return false;
1487
1488 case CK_i386:
1489 case CK_i486:
1490 case CK_WinChipC6:
1491 case CK_WinChip2:
1492 case CK_C3:
1493 case CK_i586:
1494 case CK_Pentium:
1495 case CK_PentiumMMX:
1496 case CK_i686:
1497 case CK_PentiumPro:
1498 case CK_Pentium2:
1499 case CK_Pentium3:
1500 case CK_Pentium3M:
1501 case CK_PentiumM:
1502 case CK_Yonah:
1503 case CK_C3_2:
1504 case CK_Pentium4:
1505 case CK_Pentium4M:
1506 case CK_Prescott:
1507 case CK_K6:
1508 case CK_K6_2:
1509 case CK_K6_3:
1510 case CK_Athlon:
1511 case CK_AthlonThunderbird:
1512 case CK_Athlon4:
1513 case CK_AthlonXP:
1514 case CK_AthlonMP:
1515 case CK_Geode:
1516 // Only accept certain architectures when compiling in 32-bit mode.
1517 if (PointerWidth != 32)
1518 return false;
1519
1520 // Fallthrough
1521 case CK_Nocona:
1522 case CK_Core2:
1523 case CK_Penryn:
1524 case CK_Atom:
1525 case CK_Corei7:
1526 case CK_Corei7AVX:
1527 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001528 case CK_CoreAVX2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001529 case CK_Athlon64:
1530 case CK_Athlon64SSE3:
1531 case CK_AthlonFX:
1532 case CK_K8:
1533 case CK_K8SSE3:
1534 case CK_Opteron:
1535 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00001536 case CK_AMDFAM10:
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001537 case CK_BTVER1:
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001538 case CK_BDVER1:
1539 case CK_BDVER2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001540 case CK_x86_64:
1541 return true;
1542 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001543 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001544 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001545};
Chris Lattner3daed522009-03-02 22:20:04 +00001546
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001547void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001548 // FIXME: This should not be here.
1549 Features["3dnow"] = false;
1550 Features["3dnowa"] = false;
1551 Features["mmx"] = false;
1552 Features["sse"] = false;
1553 Features["sse2"] = false;
1554 Features["sse3"] = false;
1555 Features["ssse3"] = false;
1556 Features["sse41"] = false;
1557 Features["sse42"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001558 Features["sse4a"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001559 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001560 Features["avx"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001561 Features["avx2"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001562 Features["lzcnt"] = false;
1563 Features["bmi"] = false;
1564 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001565 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001566 Features["fma4"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001567
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001568 // FIXME: This *really* should not be here.
1569
1570 // X86_64 always has SSE2.
1571 if (PointerWidth == 64)
1572 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1573
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001574 switch (CPU) {
1575 case CK_Generic:
1576 case CK_i386:
1577 case CK_i486:
1578 case CK_i586:
1579 case CK_Pentium:
1580 case CK_i686:
1581 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001582 break;
1583 case CK_PentiumMMX:
1584 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001585 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001586 break;
1587 case CK_Pentium3:
1588 case CK_Pentium3M:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001589 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001590 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001591 break;
1592 case CK_PentiumM:
1593 case CK_Pentium4:
1594 case CK_Pentium4M:
1595 case CK_x86_64:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001596 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001597 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001598 break;
1599 case CK_Yonah:
1600 case CK_Prescott:
1601 case CK_Nocona:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001602 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001603 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001604 break;
1605 case CK_Core2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001606 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001607 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001608 break;
1609 case CK_Penryn:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001610 setFeatureEnabled(Features, "mmx", true);
Benjamin Kramerb3453a82012-01-04 14:36:57 +00001611 setFeatureEnabled(Features, "sse4.1", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001612 break;
1613 case CK_Atom:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001614 setFeatureEnabled(Features, "mmx", true);
Chandler Carruth49defe62011-09-28 10:36:46 +00001615 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001616 break;
1617 case CK_Corei7:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001618 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001619 setFeatureEnabled(Features, "sse4", true);
Eric Christophereea12d12010-04-02 23:50:19 +00001620 setFeatureEnabled(Features, "aes", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001621 break;
1622 case CK_Corei7AVX:
1623 case CK_CoreAVXi:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001624 setFeatureEnabled(Features, "mmx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00001625 setFeatureEnabled(Features, "sse4", true);
1626 setFeatureEnabled(Features, "aes", true);
Bruno Cardoso Lopese02d3912011-07-11 23:33:46 +00001627 //setFeatureEnabled(Features, "avx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001628 break;
Craig Topper2b03bb02011-12-17 19:55:21 +00001629 case CK_CoreAVX2:
1630 setFeatureEnabled(Features, "mmx", true);
1631 setFeatureEnabled(Features, "sse4", true);
1632 setFeatureEnabled(Features, "aes", true);
Craig Topper31ceea02011-12-25 05:06:45 +00001633 setFeatureEnabled(Features, "lzcnt", true);
1634 setFeatureEnabled(Features, "bmi", true);
1635 setFeatureEnabled(Features, "bmi2", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00001636 //setFeatureEnabled(Features, "avx2", true);
1637 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001638 case CK_K6:
1639 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001640 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001641 break;
1642 case CK_K6_2:
1643 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001644 case CK_WinChip2:
1645 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001646 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001647 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00001648 case CK_Athlon:
1649 case CK_AthlonThunderbird:
1650 case CK_Geode:
1651 setFeatureEnabled(Features, "3dnowa", true);
1652 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001653 case CK_Athlon4:
1654 case CK_AthlonXP:
1655 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001656 setFeatureEnabled(Features, "sse", true);
1657 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001658 break;
1659 case CK_K8:
1660 case CK_Opteron:
1661 case CK_Athlon64:
1662 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00001663 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001664 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001665 break;
1666 case CK_K8SSE3:
1667 case CK_OpteronSSE3:
1668 case CK_Athlon64SSE3:
Roman Divacky80b32b82011-10-30 13:47:56 +00001669 setFeatureEnabled(Features, "sse3", true);
1670 setFeatureEnabled(Features, "3dnowa", true);
1671 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00001672 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00001673 setFeatureEnabled(Features, "sse3", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00001674 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00001675 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001676 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001677 case CK_BTVER1:
1678 setFeatureEnabled(Features, "ssse3", true);
1679 setFeatureEnabled(Features, "sse4a", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001680 case CK_BDVER1:
1681 case CK_BDVER2:
1682 setFeatureEnabled(Features, "sse4", true);
1683 setFeatureEnabled(Features, "sse4a", true);
1684 setFeatureEnabled(Features, "aes", true);
1685 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001686 case CK_C3_2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001687 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001688 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001689 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001690 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001691}
1692
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001693bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump1eb44332009-09-09 15:08:12 +00001694 const std::string &Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001695 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00001696 // FIXME: This *really* should not be here. We need some way of translating
1697 // options into llvm subtarget features.
1698 if (!Features.count(Name) &&
1699 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001700 return false;
1701
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001702 // FIXME: this should probably use a switch with fall through.
1703
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001704 if (Enabled) {
1705 if (Name == "mmx")
1706 Features["mmx"] = true;
1707 else if (Name == "sse")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001708 Features["mmx"] = Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001709 else if (Name == "sse2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001710 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001711 else if (Name == "sse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001712 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1713 true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001714 else if (Name == "ssse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001715 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001716 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001717 else if (Name == "sse4" || Name == "sse4.2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001718 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001719 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1720 Features["popcnt"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001721 else if (Name == "sse4.1")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001722 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00001723 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001724 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001725 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001726 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001727 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00001728 else if (Name == "aes")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001729 Features["aes"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001730 else if (Name == "avx")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001731 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1732 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001733 Features["popcnt"] = Features["avx"] = true;
Craig Topper2b03bb02011-12-17 19:55:21 +00001734 else if (Name == "avx2")
1735 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1736 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001737 Features["popcnt"] = Features["avx"] = Features["avx2"] = true;
Craig Topper6a511e12011-12-30 07:33:42 +00001738 else if (Name == "fma4")
1739 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1740 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1741 Features["popcnt"] = Features["avx"] = Features["fma4"] = true;
Roman Divacky80b32b82011-10-30 13:47:56 +00001742 else if (Name == "sse4a")
Craig Topper6a511e12011-12-30 07:33:42 +00001743 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Benjamin Kramer5c65e4f2012-01-10 11:50:13 +00001744 Features["lzcnt"] = Features["popcnt"] = Features["sse4a"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00001745 else if (Name == "lzcnt")
1746 Features["lzcnt"] = true;
1747 else if (Name == "bmi")
1748 Features["bmi"] = true;
1749 else if (Name == "bmi2")
1750 Features["bmi2"] = true;
Craig Toppere14e08b2011-12-29 16:10:46 +00001751 else if (Name == "popcnt")
1752 Features["popcnt"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001753 } else {
1754 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001755 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001756 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00001757 Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00001758 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1759 Features["sse4a"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001760 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00001761 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00001762 Features["sse41"] = Features["sse42"] = Features["sse4a"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001763 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00001764 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Craig Topper6a511e12011-12-30 07:33:42 +00001765 Features["sse42"] = Features["sse4a"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001766 else if (Name == "ssse3")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001767 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00001768 else if (Name == "sse4" || Name == "sse4.1")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001769 Features["sse41"] = Features["sse42"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00001770 else if (Name == "sse4.2")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001771 Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001772 else if (Name == "3dnow")
1773 Features["3dnow"] = Features["3dnowa"] = false;
1774 else if (Name == "3dnowa")
1775 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001776 else if (Name == "aes")
1777 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001778 else if (Name == "avx")
Craig Topper6a511e12011-12-30 07:33:42 +00001779 Features["avx"] = Features["avx2"] = Features["fma4"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001780 else if (Name == "avx2")
1781 Features["avx2"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001782 else if (Name == "sse4a")
1783 Features["sse4a"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001784 else if (Name == "lzcnt")
1785 Features["lzcnt"] = false;
1786 else if (Name == "bmi")
1787 Features["bmi"] = false;
1788 else if (Name == "bmi2")
1789 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001790 else if (Name == "popcnt")
1791 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001792 else if (Name == "fma4")
1793 Features["fma4"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001794 }
1795
1796 return true;
1797}
1798
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001799/// HandleTargetOptions - Perform initialization based on the user
1800/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001801void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001802 // Remember the maximum enabled sselevel.
1803 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1804 // Ignore disabled features.
1805 if (Features[i][0] == '-')
1806 continue;
1807
Eric Christophereea12d12010-04-02 23:50:19 +00001808 if (Features[i].substr(1) == "aes") {
1809 HasAES = true;
1810 continue;
1811 }
1812
Craig Topper31ceea02011-12-25 05:06:45 +00001813 if (Features[i].substr(1) == "lzcnt") {
1814 HasLZCNT = true;
1815 continue;
1816 }
1817
1818 if (Features[i].substr(1) == "bmi") {
1819 HasBMI = true;
1820 continue;
1821 }
1822
1823 if (Features[i].substr(1) == "bmi2") {
1824 HasBMI2 = true;
1825 continue;
1826 }
1827
Craig Toppere14e08b2011-12-29 16:10:46 +00001828 if (Features[i].substr(1) == "popcnt") {
1829 HasPOPCNT = true;
1830 continue;
1831 }
1832
Craig Topper6a511e12011-12-30 07:33:42 +00001833 if (Features[i].substr(1) == "fma4") {
1834 HasFMA4 = true;
1835 continue;
1836 }
1837
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001838 assert(Features[i][0] == '+' && "Invalid target feature!");
1839 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
Craig Topper05fe4b52012-01-09 09:19:09 +00001840 .Case("avx2", AVX2)
1841 .Case("avx", AVX)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001842 .Case("sse42", SSE42)
1843 .Case("sse41", SSE41)
1844 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00001845 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001846 .Case("sse2", SSE2)
1847 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001848 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001849 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001850
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001851 MMX3DNowEnum ThreeDNowLevel =
1852 llvm::StringSwitch<MMX3DNowEnum>(Features[i].substr(1))
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001853 .Case("3dnowa", AMD3DNowAthlon)
1854 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001855 .Case("mmx", MMX)
1856 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001857
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001858 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001859 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001860
1861 // Don't tell the backend if we're turning off mmx; it will end up disabling
1862 // SSE, which we don't want.
1863 std::vector<std::string>::iterator it;
1864 it = std::find(Features.begin(), Features.end(), "-mmx");
1865 if (it != Features.end())
1866 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00001867}
Chris Lattnerc0f59212009-03-02 22:27:17 +00001868
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001869/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
1870/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00001871void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001872 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00001873 // Target identification.
1874 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00001875 Builder.defineMacro("_LP64");
1876 Builder.defineMacro("__LP64__");
1877 Builder.defineMacro("__amd64__");
1878 Builder.defineMacro("__amd64");
1879 Builder.defineMacro("__x86_64");
1880 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00001881 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00001882 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00001883 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001884
Chris Lattnerc0f59212009-03-02 22:27:17 +00001885 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001886 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
1887 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001888 switch (CPU) {
1889 case CK_Generic:
1890 break;
1891 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001892 // The rest are coming from the i386 define above.
1893 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001894 break;
1895 case CK_i486:
1896 case CK_WinChipC6:
1897 case CK_WinChip2:
1898 case CK_C3:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001899 defineCPUMacros(Builder, "i486");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001900 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00001901 case CK_PentiumMMX:
1902 Builder.defineMacro("__pentium_mmx__");
1903 Builder.defineMacro("__tune_pentium_mmx__");
1904 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001905 case CK_i586:
1906 case CK_Pentium:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001907 defineCPUMacros(Builder, "i586");
1908 defineCPUMacros(Builder, "pentium");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001909 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001910 case CK_Pentium3:
1911 case CK_Pentium3M:
1912 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001913 Builder.defineMacro("__tune_pentium3__");
1914 // Fallthrough
1915 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001916 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001917 Builder.defineMacro("__tune_pentium2__");
1918 // Fallthrough
1919 case CK_PentiumPro:
1920 Builder.defineMacro("__tune_i686__");
1921 Builder.defineMacro("__tune_pentiumpro__");
1922 // Fallthrough
1923 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001924 Builder.defineMacro("__i686");
1925 Builder.defineMacro("__i686__");
1926 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
1927 Builder.defineMacro("__pentiumpro");
1928 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001929 break;
1930 case CK_Pentium4:
1931 case CK_Pentium4M:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001932 defineCPUMacros(Builder, "pentium4");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001933 break;
1934 case CK_Yonah:
1935 case CK_Prescott:
1936 case CK_Nocona:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001937 defineCPUMacros(Builder, "nocona");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001938 break;
1939 case CK_Core2:
1940 case CK_Penryn:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001941 defineCPUMacros(Builder, "core2");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001942 break;
1943 case CK_Atom:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001944 defineCPUMacros(Builder, "atom");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001945 break;
1946 case CK_Corei7:
1947 case CK_Corei7AVX:
1948 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001949 case CK_CoreAVX2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001950 defineCPUMacros(Builder, "corei7");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001951 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001952 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001953 Builder.defineMacro("__k6_2__");
1954 Builder.defineMacro("__tune_k6_2__");
1955 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001956 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001957 if (CPU != CK_K6_2) { // In case of fallthrough
1958 // FIXME: GCC may be enabling these in cases where some other k6
1959 // architecture is specified but -m3dnow is explicitly provided. The
1960 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001961 Builder.defineMacro("__k6_3__");
1962 Builder.defineMacro("__tune_k6_3__");
1963 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00001964 // Fallthrough
1965 case CK_K6:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001966 defineCPUMacros(Builder, "k6");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001967 break;
1968 case CK_Athlon:
1969 case CK_AthlonThunderbird:
1970 case CK_Athlon4:
1971 case CK_AthlonXP:
1972 case CK_AthlonMP:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001973 defineCPUMacros(Builder, "athlon");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001974 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001975 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001976 Builder.defineMacro("__tune_athlon_sse__");
1977 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001978 break;
1979 case CK_K8:
1980 case CK_K8SSE3:
1981 case CK_x86_64:
1982 case CK_Opteron:
1983 case CK_OpteronSSE3:
1984 case CK_Athlon64:
1985 case CK_Athlon64SSE3:
1986 case CK_AthlonFX:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001987 defineCPUMacros(Builder, "k8");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001988 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00001989 case CK_AMDFAM10:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001990 defineCPUMacros(Builder, "amdfam10");
Roman Divacky01c770d2011-10-30 07:48:46 +00001991 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001992 case CK_BTVER1:
1993 defineCPUMacros(Builder, "btver1");
1994 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001995 case CK_BDVER1:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001996 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001997 break;
1998 case CK_BDVER2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001999 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002000 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002001 case CK_Geode:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002002 defineCPUMacros(Builder, "geode");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002003 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002004 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00002005
Chandler Carruth88c75b02011-09-28 09:54:07 +00002006 // Target properties.
2007 Builder.defineMacro("__LITTLE_ENDIAN__");
2008 Builder.defineMacro("__REGISTER_PREFIX__", "");
2009
Chris Lattner54175442009-04-19 17:32:33 +00002010 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2011 // functions in glibc header files that use FP Stack inline asm which the
2012 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00002013 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002014
Chandler Carruth88c75b02011-09-28 09:54:07 +00002015 if (HasAES)
2016 Builder.defineMacro("__AES__");
2017
Craig Topper31ceea02011-12-25 05:06:45 +00002018 if (HasLZCNT)
2019 Builder.defineMacro("__LZCNT__");
2020
2021 if (HasBMI)
2022 Builder.defineMacro("__BMI__");
2023
2024 if (HasBMI2)
2025 Builder.defineMacro("__BMI2__");
2026
Craig Toppere14e08b2011-12-29 16:10:46 +00002027 if (HasPOPCNT)
2028 Builder.defineMacro("__POPCNT__");
2029
Craig Topper6a511e12011-12-30 07:33:42 +00002030 if (HasFMA4)
2031 Builder.defineMacro("__FMA4__");
2032
Chris Lattner84f0ea82009-03-02 22:40:39 +00002033 // Each case falls through to the previous one here.
2034 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002035 case AVX2:
2036 Builder.defineMacro("__AVX2__");
2037 case AVX:
2038 Builder.defineMacro("__AVX__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002039 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00002040 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002041 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00002042 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002043 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002044 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002045 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002046 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002047 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00002048 Builder.defineMacro("__SSE2__");
2049 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00002050 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00002051 Builder.defineMacro("__SSE__");
2052 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002053 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00002054 break;
2055 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002056
Francois Pichet62ec1f22011-09-17 17:15:52 +00002057 if (Opts.MicrosoftExt && PointerWidth == 32) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002058 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002059 case AVX2:
2060 case AVX:
Michael J. Spencera764e832010-10-21 08:22:51 +00002061 case SSE42:
2062 case SSE41:
2063 case SSSE3:
2064 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002065 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002066 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002067 break;
2068 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002069 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002070 break;
2071 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002072 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002073 }
2074 }
2075
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002076 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002077 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002078 case AMD3DNowAthlon:
2079 Builder.defineMacro("__3dNOW_A__");
2080 case AMD3DNow:
2081 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002082 case MMX:
2083 Builder.defineMacro("__MMX__");
2084 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002085 break;
2086 }
Chris Lattnerc0f59212009-03-02 22:27:17 +00002087}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002088
Douglas Gregore727d212012-01-30 06:38:25 +00002089bool X86TargetInfo::hasFeature(StringRef Feature) const {
2090 return llvm::StringSwitch<bool>(Feature)
2091 .Case("aes", HasAES)
2092 .Case("avx", SSELevel >= AVX)
2093 .Case("avx2", SSELevel >= AVX2)
2094 .Case("bmi", HasBMI)
2095 .Case("bmi2", HasBMI2)
2096 .Case("fma4", HasFMA4)
2097 .Case("lzcnt", HasLZCNT)
2098 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
2099 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
2100 .Case("mmx", MMX3DNowLevel >= MMX)
2101 .Case("popcnt", HasPOPCNT)
2102 .Case("sse", SSELevel >= SSE1)
2103 .Case("sse2", SSELevel >= SSE2)
2104 .Case("sse3", SSELevel >= SSE3)
2105 .Case("ssse3", SSELevel >= SSSE3)
2106 .Case("sse41", SSELevel >= SSE41)
2107 .Case("sse42", SSELevel >= SSE42)
2108 .Case("x86", true)
2109 .Case("x86_32", PointerWidth == 32)
2110 .Case("x86_64", PointerWidth == 64)
2111 .Default(false);
2112}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002113
Eli Friedman618234a2008-08-20 02:34:37 +00002114bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002115X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002116 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002117 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00002118 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00002119 case 'Y': // first letter of a pair:
2120 switch (*(Name+1)) {
2121 default: return false;
2122 case '0': // First SSE register.
2123 case 't': // Any SSE register, when SSE2 is enabled.
2124 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2125 case 'm': // any MMX register, when inter-unit moves enabled.
2126 break; // falls through to setAllowsRegister.
2127 }
Eli Friedman618234a2008-08-20 02:34:37 +00002128 case 'a': // eax.
2129 case 'b': // ebx.
2130 case 'c': // ecx.
2131 case 'd': // edx.
2132 case 'S': // esi.
2133 case 'D': // edi.
2134 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00002135 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00002136 case 't': // top of floating point stack.
2137 case 'u': // second from top of floating point stack.
2138 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00002139 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00002140 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00002141 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00002142 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2143 case 'l': // "Index" registers: any general register that can be used as an
2144 // index in a base+index memory access.
2145 Info.setAllowsRegister();
2146 return true;
2147 case 'C': // SSE floating point constant.
2148 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002149 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002150 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002151 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002152 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00002153 return true;
2154 }
2155}
2156
Dale Johannesenf6e2c202010-10-29 23:12:32 +00002157
Eli Friedman618234a2008-08-20 02:34:37 +00002158std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00002159X86TargetInfo::convertConstraint(const char *&Constraint) const {
2160 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00002161 case 'a': return std::string("{ax}");
2162 case 'b': return std::string("{bx}");
2163 case 'c': return std::string("{cx}");
2164 case 'd': return std::string("{dx}");
2165 case 'S': return std::string("{si}");
2166 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00002167 case 'p': // address
2168 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00002169 case 't': // top of floating point stack.
2170 return std::string("{st}");
2171 case 'u': // second from top of floating point stack.
2172 return std::string("{st(1)}"); // second from top of floating point stack.
2173 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00002174 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00002175 }
2176}
Eli Friedman618234a2008-08-20 02:34:37 +00002177} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00002178
2179namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002180// X86-32 generic target
2181class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00002182public:
Eli Friedman618234a2008-08-20 02:34:37 +00002183 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
2184 DoubleAlign = LongLongAlign = 32;
2185 LongDoubleWidth = 96;
2186 LongDoubleAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00002187 SuitableAlign = 128;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002188 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2189 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00002190 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00002191 SizeType = UnsignedInt;
2192 PtrDiffType = SignedInt;
2193 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002194 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002195
2196 // Use fpret for all types.
2197 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2198 (1 << TargetInfo::Double) |
2199 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002200
2201 // x86-32 has atomics up to 8 bytes
2202 // FIXME: Check that we actually have cmpxchg8b before setting
2203 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2204 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002205 }
2206 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002207 return "typedef char* __builtin_va_list;";
Eli Friedman618234a2008-08-20 02:34:37 +00002208 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002209
Chris Lattner21fb98e2009-09-23 06:06:36 +00002210 int getEHDataRegisterNumber(unsigned RegNo) const {
2211 if (RegNo == 0) return 0;
2212 if (RegNo == 1) return 2;
2213 return -1;
2214 }
Eli Friedman618234a2008-08-20 02:34:37 +00002215};
2216} // end anonymous namespace
2217
2218namespace {
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002219class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
2220public:
2221 NetBSDI386TargetInfo(const std::string &triple) :
2222 NetBSDTargetInfo<X86_32TargetInfo>(triple) {
2223 }
2224
2225 virtual unsigned getFloatEvalMethod() const {
2226 // NetBSD defaults to "double" rounding
2227 return 1;
2228 }
2229};
2230} // end anonymous namespace
2231
2232namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002233class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2234public:
2235 OpenBSDI386TargetInfo(const std::string& triple) :
2236 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2237 SizeType = UnsignedLong;
2238 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002239 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002240 }
2241};
2242} // end anonymous namespace
2243
2244namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002245class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002246public:
Torok Edwin5f6c1942009-06-30 17:10:35 +00002247 DarwinI386TargetInfo(const std::string& triple) :
2248 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002249 LongDoubleWidth = 128;
2250 LongDoubleAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002251 SuitableAlign = 128;
Eli Friedman1afabd92009-03-29 20:31:09 +00002252 SizeType = UnsignedLong;
2253 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002254 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2255 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002256 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002257 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002258 }
2259
Eli Friedman618234a2008-08-20 02:34:37 +00002260};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002261} // end anonymous namespace
2262
2263namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002264// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002265class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002266public:
2267 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002268 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002269 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002270 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002271 DoubleAlign = LongLongAlign = 64;
2272 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 +00002273 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002274 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002275 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002276 virtual void getTargetDefines(const LangOptions &Opts,
2277 MacroBuilder &Builder) const {
2278 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2279 }
2280};
2281} // end anonymous namespace
2282
2283namespace {
2284
2285// x86-32 Windows Visual Studio target
2286class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2287public:
2288 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2289 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002290 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002291 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2292 }
2293 virtual void getTargetDefines(const LangOptions &Opts,
2294 MacroBuilder &Builder) const {
2295 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2296 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2297 // The value of the following reflects processor type.
2298 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2299 // We lost the original triple, so we use the default.
2300 Builder.defineMacro("_M_IX86", "600");
2301 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002302};
2303} // end anonymous namespace
2304
2305namespace {
2306// x86-32 MinGW target
2307class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2308public:
2309 MinGWX86_32TargetInfo(const std::string& triple)
2310 : WindowsX86_32TargetInfo(triple) {
2311 }
2312 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002313 MacroBuilder &Builder) const {
2314 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002315 DefineStd(Builder, "WIN32", Opts);
2316 DefineStd(Builder, "WINNT", Opts);
2317 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002318 Builder.defineMacro("__MSVCRT__");
2319 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002320
2321 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2322 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002323 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002324 // Provide "as-is" __declspec.
2325 Builder.defineMacro("__declspec", "__declspec");
2326 else
2327 // Provide alias of __attribute__ like mingw32-gcc.
2328 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002329 }
2330};
2331} // end anonymous namespace
2332
2333namespace {
2334// x86-32 Cygwin target
2335class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2336public:
2337 CygwinX86_32TargetInfo(const std::string& triple)
2338 : X86_32TargetInfo(triple) {
2339 TLSSupported = false;
2340 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002341 DoubleAlign = LongLongAlign = 64;
2342 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2343 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002344 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002345 }
2346 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002347 MacroBuilder &Builder) const {
2348 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2349 Builder.defineMacro("__CYGWIN__");
2350 Builder.defineMacro("__CYGWIN32__");
2351 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00002352 if (Opts.CPlusPlus)
2353 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00002354 }
Eli Friedman29a30502008-08-21 01:40:19 +00002355};
2356} // end anonymous namespace
2357
2358namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002359// x86-32 Haiku target
2360class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2361public:
2362 HaikuX86_32TargetInfo(const std::string& triple)
2363 : X86_32TargetInfo(triple) {
2364 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00002365 IntPtrType = SignedLong;
2366 PtrDiffType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00002367 this->UserLabelPrefix = "";
Eli Friedmana7e68452010-08-22 01:00:03 +00002368 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00002369 virtual void getTargetDefines(const LangOptions &Opts,
2370 MacroBuilder &Builder) const {
2371 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2372 Builder.defineMacro("__INTEL__");
2373 Builder.defineMacro("__HAIKU__");
2374 }
2375};
2376} // end anonymous namespace
2377
Douglas Gregordca52262011-07-01 22:41:14 +00002378// RTEMS Target
2379template<typename Target>
2380class RTEMSTargetInfo : public OSTargetInfo<Target> {
2381protected:
2382 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2383 MacroBuilder &Builder) const {
2384 // RTEMS defines; list based off of gcc output
2385
Douglas Gregordca52262011-07-01 22:41:14 +00002386 Builder.defineMacro("__rtems__");
2387 Builder.defineMacro("__ELF__");
2388 }
2389public:
2390 RTEMSTargetInfo(const std::string &triple)
2391 : OSTargetInfo<Target>(triple) {
2392 this->UserLabelPrefix = "";
2393
2394 llvm::Triple Triple(triple);
2395 switch (Triple.getArch()) {
2396 default:
2397 case llvm::Triple::x86:
2398 // this->MCountName = ".mcount";
2399 break;
2400 case llvm::Triple::mips:
2401 case llvm::Triple::mipsel:
2402 case llvm::Triple::ppc:
2403 case llvm::Triple::ppc64:
2404 // this->MCountName = "_mcount";
2405 break;
2406 case llvm::Triple::arm:
2407 // this->MCountName = "__mcount";
2408 break;
2409 }
2410
2411 }
2412};
2413
2414namespace {
2415// x86-32 RTEMS target
2416class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2417public:
2418 RTEMSX86_32TargetInfo(const std::string& triple)
2419 : X86_32TargetInfo(triple) {
2420 SizeType = UnsignedLong;
2421 IntPtrType = SignedLong;
2422 PtrDiffType = SignedLong;
2423 this->UserLabelPrefix = "";
2424 }
2425 virtual void getTargetDefines(const LangOptions &Opts,
2426 MacroBuilder &Builder) const {
2427 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2428 Builder.defineMacro("__INTEL__");
2429 Builder.defineMacro("__rtems__");
2430 }
2431};
2432} // end anonymous namespace
2433
Chris Lattner86ed3a32010-04-11 19:29:39 +00002434namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002435// x86-64 generic target
2436class X86_64TargetInfo : public X86TargetInfo {
2437public:
Chris Lattner33328642009-03-20 15:52:06 +00002438 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00002439 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002440 LongDoubleWidth = 128;
2441 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00002442 LargeArrayMinWidth = 128;
2443 LargeArrayAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002444 SuitableAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00002445 IntMaxType = SignedLong;
2446 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002447 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002448 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00002449
Eli Friedmaned855cb2008-08-21 00:13:15 +00002450 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2451 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002452 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002453
2454 // Use fpret only for long double.
2455 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00002456
Anders Carlssoneea64802011-10-31 16:27:11 +00002457 // Use fp2ret for _Complex long double.
2458 ComplexLongDoubleUsesFP2Ret = true;
2459
Eli Friedman2be46072011-10-14 20:59:01 +00002460 // x86-64 has atomics up to 16 bytes.
2461 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
2462 // on CPUs with cmpxchg16b
2463 MaxAtomicPromoteWidth = 128;
2464 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00002465 }
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00002466 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002467 return "typedef struct __va_list_tag {"
2468 " unsigned gp_offset;"
2469 " unsigned fp_offset;"
2470 " void* overflow_arg_area;"
2471 " void* reg_save_area;"
John McCall2b7baf02010-05-28 18:25:28 +00002472 "} __va_list_tag;"
Eli Friedmandc043162009-07-03 00:45:06 +00002473 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson3346ae62007-11-24 23:38:12 +00002474 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002475
Chris Lattner21fb98e2009-09-23 06:06:36 +00002476 int getEHDataRegisterNumber(unsigned RegNo) const {
2477 if (RegNo == 0) return 0;
2478 if (RegNo == 1) return 1;
2479 return -1;
2480 }
Eli Friedman618234a2008-08-20 02:34:37 +00002481};
2482} // end anonymous namespace
2483
2484namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002485// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002486class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002487public:
2488 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002489 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002490 TLSSupported = false;
2491 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00002492 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00002493 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00002494 IntMaxType = SignedLongLong;
2495 UIntMaxType = UnsignedLongLong;
2496 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00002497 SizeType = UnsignedLongLong;
2498 PtrDiffType = SignedLongLong;
2499 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00002500 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002501 }
2502 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002503 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002504 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002505 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00002506 }
NAKAMURA Takumi79521992011-01-17 22:56:23 +00002507 virtual const char *getVAListDeclaration() const {
2508 return "typedef char* __builtin_va_list;";
2509 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002510};
2511} // end anonymous namespace
2512
2513namespace {
2514// x86-64 Windows Visual Studio target
2515class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2516public:
2517 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2518 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002519 LongDoubleWidth = LongDoubleAlign = 64;
2520 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00002521 }
2522 virtual void getTargetDefines(const LangOptions &Opts,
2523 MacroBuilder &Builder) const {
2524 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
2525 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00002526 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002527 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002528 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002529};
2530} // end anonymous namespace
2531
2532namespace {
2533// x86-64 MinGW target
2534class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2535public:
2536 MinGWX86_64TargetInfo(const std::string& triple)
2537 : WindowsX86_64TargetInfo(triple) {
2538 }
2539 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002540 MacroBuilder &Builder) const {
2541 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002542 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00002543 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00002544 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00002545 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002546
2547 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2548 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002549 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002550 // Provide "as-is" __declspec.
2551 Builder.defineMacro("__declspec", "__declspec");
2552 else
2553 // Provide alias of __attribute__ like mingw32-gcc.
2554 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002555 }
2556};
2557} // end anonymous namespace
2558
2559namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002560class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2561public:
Mike Stump1eb44332009-09-09 15:08:12 +00002562 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002563 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2564 Int64Type = SignedLongLong;
2565 }
2566};
2567} // end anonymous namespace
2568
2569namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00002570class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
2571public:
Mike Stump1eb44332009-09-09 15:08:12 +00002572 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman6036ebe2009-07-05 22:31:18 +00002573 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
2574 IntMaxType = SignedLongLong;
2575 UIntMaxType = UnsignedLongLong;
2576 Int64Type = SignedLongLong;
2577 }
2578};
2579} // end anonymous namespace
2580
2581namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00002582class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002583 // Possible FPU choices.
2584 enum FPUMode {
2585 NoFPU,
2586 VFP2FPU,
2587 VFP3FPU,
2588 NeonFPU
2589 };
2590
2591 static bool FPUModeIsVFP(FPUMode Mode) {
2592 return Mode >= VFP2FPU && Mode <= NeonFPU;
2593 }
2594
2595 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2596 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002597
Daniel Dunbareac7c532009-12-18 18:42:37 +00002598 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002599
2600 unsigned FPU : 3;
2601
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002602 unsigned IsThumb : 1;
2603
2604 // Initialized via features.
2605 unsigned SoftFloat : 1;
2606 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002607
Chris Lattner2752c012010-03-03 19:03:45 +00002608 static const Builtin::Info BuiltinInfo[];
2609
Chris Lattner393ff042008-04-21 18:56:49 +00002610public:
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002611 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbareac7c532009-12-18 18:42:37 +00002612 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002613 {
Eli Friedmane6a24e82011-12-22 03:51:45 +00002614 BigEndian = false;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002615 SizeType = UnsignedInt;
2616 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00002617 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
2618 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002619
Chris Lattner9bffb072010-04-23 16:29:58 +00002620 // {} in inline assembly are neon specifiers, not assembly variant
2621 // specifiers.
2622 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00002623
Daniel Dunbareac7c532009-12-18 18:42:37 +00002624 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00002625 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002626 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002627 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2628 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002629 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
2630 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002631 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002632 } else {
2633 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2634 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002635 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002636 }
John McCallee79a4c2010-08-21 22:46:04 +00002637
2638 // ARM targets default to using the ARM C++ ABI.
2639 CXXABI = CXXABI_ARM;
Eli Friedman2be46072011-10-14 20:59:01 +00002640
2641 // ARM has atomics up to 8 bytes
2642 // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e
2643 MaxAtomicPromoteWidth = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002644 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002645 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00002646 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002647 ABI = Name;
2648
Daniel Dunbara2a41612009-09-14 00:02:24 +00002649 // The defaults (above) are for AAPCS, check if we need to change them.
2650 //
2651 // FIXME: We need support for -meabi... we could just mangle it into the
2652 // name.
2653 if (Name == "apcs-gnu") {
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002654 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002655 SizeType = UnsignedLong;
2656
James Molloya6d81f92011-11-23 13:35:08 +00002657 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
2658 WCharType = SignedInt;
2659
Daniel Dunbar684de632010-04-22 16:14:54 +00002660 // Do not respect the alignment of bit-field types when laying out
2661 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
2662 UseBitFieldTypeAlignment = false;
2663
Chad Rosier61a62212011-08-04 01:21:14 +00002664 /// Do force alignment of members that follow zero length bitfields. If
2665 /// the alignment of the zero-length bitfield is greater than the member
2666 /// that follows it, `bar', `bar' will be aligned as the type of the
2667 /// zero length bitfield.
2668 UseZeroLengthBitfieldAlignment = true;
2669
2670 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00002671 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
2672 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00002673 ZeroLengthBitfieldBoundary = 32;
2674
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002675 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002676 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2677 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002678 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 +00002679 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002680 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002681 } else {
2682 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 +00002683 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002684 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002685 }
2686
Chad Rosier9f1210c2011-07-26 07:03:04 +00002687 // FIXME: Override "preferred align" for double and long long.
Daniel Dunbara2a41612009-09-14 00:02:24 +00002688 } else if (Name == "aapcs") {
2689 // FIXME: Enumerated types are variable width in straight AAPCS.
2690 } else if (Name == "aapcs-linux") {
Chad Rosier9f1210c2011-07-26 07:03:04 +00002691 ;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002692 } else
2693 return false;
2694
2695 return true;
2696 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002697
Chandler Carruthc3a2e652011-09-28 05:56:05 +00002698 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002699 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
2700 Features["vfp2"] = true;
2701 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
2702 Features["neon"] = true;
2703 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002704
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002705 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2706 const std::string &Name,
2707 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00002708 if (Name == "soft-float" || Name == "soft-float-abi" ||
Evgeniy Stepanov35dd7322012-01-11 11:21:31 +00002709 Name == "vfp2" || Name == "vfp3" || Name == "neon" || Name == "d16") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002710 Features[Name] = Enabled;
2711 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002712 return false;
2713
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002714 return true;
2715 }
2716
2717 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002718 FPU = NoFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002719 SoftFloat = SoftFloatABI = false;
2720 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
2721 if (Features[i] == "+soft-float")
2722 SoftFloat = true;
2723 else if (Features[i] == "+soft-float-abi")
2724 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002725 else if (Features[i] == "+vfp2")
2726 FPU = VFP2FPU;
2727 else if (Features[i] == "+vfp3")
2728 FPU = VFP3FPU;
2729 else if (Features[i] == "+neon")
2730 FPU = NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002731 }
2732
2733 // Remove front-end specific options which the backend handles differently.
2734 std::vector<std::string>::iterator it;
2735 it = std::find(Features.begin(), Features.end(), "+soft-float");
2736 if (it != Features.end())
2737 Features.erase(it);
2738 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2739 if (it != Features.end())
2740 Features.erase(it);
2741 }
2742
Douglas Gregore727d212012-01-30 06:38:25 +00002743 virtual bool hasFeature(StringRef Feature) const {
2744 return llvm::StringSwitch<bool>(Feature)
2745 .Case("arm", true)
2746 .Case("softfloat", SoftFloat)
2747 .Case("thumb", IsThumb)
2748 .Case("neon", FPU == NeonFPU && !SoftFloat &&
2749 StringRef(getCPUDefineSuffix(CPU)).startswith("7"))
2750 .Default(false);
2751 }
Chris Lattner5f9e2722011-07-23 10:55:15 +00002752 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00002753 return llvm::StringSwitch<const char*>(Name)
2754 .Cases("arm8", "arm810", "4")
2755 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2756 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2757 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2758 .Case("ep9312", "4T")
2759 .Cases("arm10tdmi", "arm1020t", "5T")
2760 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2761 .Case("arm926ej-s", "5TEJ")
2762 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2763 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002764 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002765 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002766 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002767 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2768 .Cases("cortex-a8", "cortex-a9", "7A")
Bob Wilson06f45632011-01-06 16:57:20 +00002769 .Case("cortex-m3", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00002770 .Case("cortex-m0", "6M")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002771 .Default(0);
2772 }
2773 virtual bool setCPU(const std::string &Name) {
2774 if (!getCPUDefineSuffix(Name))
2775 return false;
2776
2777 CPU = Name;
2778 return true;
2779 }
Chris Lattner33328642009-03-20 15:52:06 +00002780 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002781 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002782 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00002783 Builder.defineMacro("__arm");
2784 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002785
Chris Lattnerc0f59212009-03-02 22:27:17 +00002786 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00002787 Builder.defineMacro("__ARMEL__");
2788 Builder.defineMacro("__LITTLE_ENDIAN__");
2789 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002790
Chris Lattner5f9e2722011-07-23 10:55:15 +00002791 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00002792 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002793
Mike Stump437bb4b2009-04-08 02:07:04 +00002794 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002795
Daniel Dunbareac7c532009-12-18 18:42:37 +00002796 // FIXME: It's more complicated than this and we don't really support
2797 // interworking.
2798 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00002799 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002800
Daniel Dunbareac7c532009-12-18 18:42:37 +00002801 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramera9992772010-01-09 17:55:51 +00002802 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002803
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002804 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00002805 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002806
2807 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00002808 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002809
Bob Wilson84f95cf2011-05-13 18:56:03 +00002810 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002811 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002812 Builder.defineMacro("__THUMBEL__");
2813 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00002814 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002815 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002816 }
2817
2818 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00002819 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002820
2821 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramera9992772010-01-09 17:55:51 +00002822 Builder.defineMacro("__VFP_FP__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002823
2824 // This only gets set when Neon instructions are actually available, unlike
2825 // the VFP define, hence the soft float and arch check. This is subtly
2826 // different from gcc, we follow the intent which was that it should be set
2827 // when Neon instructions are actually available.
Bob Wilson84f95cf2011-05-13 18:56:03 +00002828 if (FPU == NeonFPU && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002829 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00002830 }
2831 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2832 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00002833 Records = BuiltinInfo;
2834 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00002835 }
Bob Wilson8b30a932012-01-26 22:14:27 +00002836 virtual bool isCLZForZeroUndef() const { return false; }
Chris Lattner393ff042008-04-21 18:56:49 +00002837 virtual const char *getVAListDeclaration() const {
John McCall0e9972c2011-05-09 02:19:37 +00002838 return "typedef void* __builtin_va_list;";
Chris Lattner393ff042008-04-21 18:56:49 +00002839 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002840 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002841 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002842 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002843 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002844 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002845 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002846 // FIXME: Check if this is complete
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002847 switch (*Name) {
Eli Friedmana9f54962008-08-20 07:44:10 +00002848 default:
Nate Begemanad487f42008-04-22 05:03:19 +00002849 case 'l': // r0-r7
2850 case 'h': // r8-r15
2851 case 'w': // VFP Floating point register single precision
2852 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00002853 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00002854 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00002855 case 'Q': // A memory address that is a single base register.
2856 Info.setAllowsMemory();
2857 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00002858 case 'U': // a memory reference...
2859 switch (Name[1]) {
2860 case 'q': // ...ARMV4 ldrsb
2861 case 'v': // ...VFP load/store (reg+constant offset)
2862 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00002863 case 't': // address valid for load/store opaque types wider
2864 // than 128-bits
2865 case 'n': // valid address for Neon doubleword vector load/store
2866 case 'm': // valid address for Neon element and structure load/store
2867 case 's': // valid address for non-offset loads/stores of quad-word
2868 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00002869 Info.setAllowsMemory();
2870 Name++;
2871 return true;
2872 }
Nate Begemanad487f42008-04-22 05:03:19 +00002873 }
Chris Lattner393ff042008-04-21 18:56:49 +00002874 return false;
2875 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00002876 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00002877 std::string R;
2878 switch (*Constraint) {
2879 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00002880 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00002881 Constraint++;
2882 break;
Eric Christopher283f4472011-06-17 00:40:18 +00002883 case 'p': // 'p' should be translated to 'r' by default.
2884 R = std::string("r");
2885 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00002886 default:
2887 return std::string(1, *Constraint);
2888 }
2889 return R;
2890 }
Chris Lattner393ff042008-04-21 18:56:49 +00002891 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002892 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00002893 return "";
2894 }
2895};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002896
2897const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002898 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002899 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002900 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
2901
2902 // Float registers
2903 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2904 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2905 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002906 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002907
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002908 // Double registers
2909 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
2910 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00002911 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
2912 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002913
2914 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00002915 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
2916 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002917};
2918
2919void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002920 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002921 Names = GCCRegNames;
2922 NumNames = llvm::array_lengthof(GCCRegNames);
2923}
2924
2925const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002926 { { "a1" }, "r0" },
2927 { { "a2" }, "r1" },
2928 { { "a3" }, "r2" },
2929 { { "a4" }, "r3" },
2930 { { "v1" }, "r4" },
2931 { { "v2" }, "r5" },
2932 { { "v3" }, "r6" },
2933 { { "v4" }, "r7" },
2934 { { "v5" }, "r8" },
2935 { { "v6", "rfp" }, "r9" },
2936 { { "sl" }, "r10" },
2937 { { "fp" }, "r11" },
2938 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002939 { { "r13" }, "sp" },
2940 { { "r14" }, "lr" },
2941 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002942 // The S, D and Q registers overlap, but aren't really aliases; we
2943 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002944};
2945
2946void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2947 unsigned &NumAliases) const {
2948 Aliases = GCCRegAliases;
2949 NumAliases = llvm::array_lengthof(GCCRegAliases);
2950}
Chris Lattner2752c012010-03-03 19:03:45 +00002951
2952const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00002953#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00002954#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00002955 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00002956#include "clang/Basic/BuiltinsARM.def"
2957};
Chris Lattner393ff042008-04-21 18:56:49 +00002958} // end anonymous namespace.
2959
Eli Friedmana9f54962008-08-20 07:44:10 +00002960namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00002961class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00002962 public DarwinTargetInfo<ARMTargetInfo> {
2963protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00002964 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00002965 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00002966 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00002967 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002968
Torok Edwin5f6c1942009-06-30 17:10:35 +00002969public:
Mike Stump1eb44332009-09-09 15:08:12 +00002970 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar350b9f32010-05-27 07:00:26 +00002971 : DarwinTargetInfo<ARMTargetInfo>(triple) {
2972 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00002973 // iOS always has 64-bit atomic instructions.
2974 // FIXME: This should be based off of the target features in ARMTargetInfo.
2975 MaxAtomicInlineWidth = 64;
Daniel Dunbar350b9f32010-05-27 07:00:26 +00002976 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002977};
2978} // end anonymous namespace.
2979
Tony Linthicum96319392011-12-12 21:14:55 +00002980
2981namespace {
2982// Hexagon abstract base class
2983class HexagonTargetInfo : public TargetInfo {
2984 static const Builtin::Info BuiltinInfo[];
2985 static const char * const GCCRegNames[];
2986 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2987 std::string CPU;
2988public:
2989 HexagonTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00002990 BigEndian = false;
Tony Linthicum96319392011-12-12 21:14:55 +00002991 DescriptionString = ("e-p:32:32:32-"
2992 "i64:64:64-i32:32:32-"
2993 "i16:16:16-i1:32:32-a:0:0");
2994
2995 // {} in inline assembly are packet specifiers, not assembly variant
2996 // specifiers.
2997 NoAsmVariants = true;
2998 }
2999
3000 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3001 unsigned &NumRecords) const {
3002 Records = BuiltinInfo;
3003 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
3004 }
3005
3006 virtual bool validateAsmConstraint(const char *&Name,
3007 TargetInfo::ConstraintInfo &Info) const {
3008 return true;
3009 }
3010
3011 virtual void getTargetDefines(const LangOptions &Opts,
3012 MacroBuilder &Builder) const;
3013
Douglas Gregore727d212012-01-30 06:38:25 +00003014 virtual bool hasFeature(StringRef Feature) const {
3015 return Feature == "hexagon";
3016 }
3017
Tony Linthicum96319392011-12-12 21:14:55 +00003018 virtual const char *getVAListDeclaration() const {
3019 return "typedef char* __builtin_va_list;";
3020 }
3021 virtual void getGCCRegNames(const char * const *&Names,
3022 unsigned &NumNames) const;
3023 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3024 unsigned &NumAliases) const;
3025 virtual const char *getClobbers() const {
3026 return "";
3027 }
Sebastian Pop43115d42012-01-13 20:37:10 +00003028
3029 static const char *getHexagonCPUSuffix(StringRef Name) {
3030 return llvm::StringSwitch<const char*>(Name)
3031 .Case("hexagonv2", "2")
3032 .Case("hexagonv3", "3")
3033 .Case("hexagonv4", "4")
3034 .Default(0);
3035 }
3036
Tony Linthicum96319392011-12-12 21:14:55 +00003037 virtual bool setCPU(const std::string &Name) {
Sebastian Pop43115d42012-01-13 20:37:10 +00003038 if (!getHexagonCPUSuffix(Name))
3039 return false;
3040
Tony Linthicum96319392011-12-12 21:14:55 +00003041 CPU = Name;
3042 return true;
3043 }
3044};
3045
3046void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
3047 MacroBuilder &Builder) const {
3048 Builder.defineMacro("qdsp6");
3049 Builder.defineMacro("__qdsp6", "1");
3050 Builder.defineMacro("__qdsp6__", "1");
3051
3052 Builder.defineMacro("hexagon");
3053 Builder.defineMacro("__hexagon", "1");
3054 Builder.defineMacro("__hexagon__", "1");
3055
3056 if(CPU == "hexagonv1") {
3057 Builder.defineMacro("__HEXAGON_V1__");
3058 Builder.defineMacro("__HEXAGON_ARCH__", "1");
3059 if(Opts.HexagonQdsp6Compat) {
3060 Builder.defineMacro("__QDSP6_V1__");
3061 Builder.defineMacro("__QDSP6_ARCH__", "1");
3062 }
3063 }
3064 else if(CPU == "hexagonv2") {
3065 Builder.defineMacro("__HEXAGON_V2__");
3066 Builder.defineMacro("__HEXAGON_ARCH__", "2");
3067 if(Opts.HexagonQdsp6Compat) {
3068 Builder.defineMacro("__QDSP6_V2__");
3069 Builder.defineMacro("__QDSP6_ARCH__", "2");
3070 }
3071 }
3072 else if(CPU == "hexagonv3") {
3073 Builder.defineMacro("__HEXAGON_V3__");
3074 Builder.defineMacro("__HEXAGON_ARCH__", "3");
3075 if(Opts.HexagonQdsp6Compat) {
3076 Builder.defineMacro("__QDSP6_V3__");
3077 Builder.defineMacro("__QDSP6_ARCH__", "3");
3078 }
3079 }
3080 else if(CPU == "hexagonv4") {
3081 Builder.defineMacro("__HEXAGON_V4__");
3082 Builder.defineMacro("__HEXAGON_ARCH__", "4");
3083 if(Opts.HexagonQdsp6Compat) {
3084 Builder.defineMacro("__QDSP6_V4__");
3085 Builder.defineMacro("__QDSP6_ARCH__", "4");
3086 }
3087 }
3088}
3089
3090const char * const HexagonTargetInfo::GCCRegNames[] = {
3091 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3092 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3093 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3094 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
3095 "p0", "p1", "p2", "p3",
3096 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
3097};
3098
3099void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
3100 unsigned &NumNames) const {
3101 Names = GCCRegNames;
3102 NumNames = llvm::array_lengthof(GCCRegNames);
3103}
3104
3105
3106const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
3107 { { "sp" }, "r29" },
3108 { { "fp" }, "r30" },
3109 { { "lr" }, "r31" },
3110 };
3111
3112void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3113 unsigned &NumAliases) const {
3114 Aliases = GCCRegAliases;
3115 NumAliases = llvm::array_lengthof(GCCRegAliases);
3116}
3117
3118
3119const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
3120#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3121#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3122 ALL_LANGUAGES },
3123#include "clang/Basic/BuiltinsHexagon.def"
3124};
3125}
3126
3127
Reid Spencer5f016e22007-07-11 17:01:13 +00003128namespace {
Eli Friedman01b86682008-08-20 07:28:14 +00003129class SparcV8TargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00003130 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3131 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003132 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00003133public:
Eli Friedman01b86682008-08-20 07:28:14 +00003134 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
3135 // FIXME: Support Sparc quad-precision long double?
Eli Friedmane6a24e82011-12-22 03:51:45 +00003136 BigEndian = false;
Eli Friedmaned855cb2008-08-21 00:13:15 +00003137 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 +00003138 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedman01b86682008-08-20 07:28:14 +00003139 }
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003140 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
3141 const std::string &Name,
3142 bool Enabled) const {
3143 if (Name == "soft-float")
3144 Features[Name] = Enabled;
3145 else
3146 return false;
3147
3148 return true;
3149 }
3150 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
3151 SoftFloat = false;
3152 for (unsigned i = 0, e = Features.size(); i != e; ++i)
3153 if (Features[i] == "+soft-float")
3154 SoftFloat = true;
3155 }
Chris Lattner33328642009-03-20 15:52:06 +00003156 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003157 MacroBuilder &Builder) const {
3158 DefineStd(Builder, "sparc", Opts);
3159 Builder.defineMacro("__sparcv8");
3160 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003161
3162 if (SoftFloat)
3163 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00003164 }
Douglas Gregore727d212012-01-30 06:38:25 +00003165
3166 virtual bool hasFeature(StringRef Feature) const {
3167 return llvm::StringSwitch<bool>(Feature)
3168 .Case("softfloat", SoftFloat)
3169 .Case("sparc", true)
3170 .Default(false);
3171 }
3172
Gabor Greif26658672008-02-21 16:29:08 +00003173 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3174 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003175 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00003176 }
3177 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00003178 return "typedef void* __builtin_va_list;";
Gabor Greif26658672008-02-21 16:29:08 +00003179 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003180 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003181 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003182 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003183 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003184 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00003185 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003186 // FIXME: Implement!
3187 return false;
Gabor Greif26658672008-02-21 16:29:08 +00003188 }
3189 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00003190 // FIXME: Implement!
3191 return "";
Gabor Greif26658672008-02-21 16:29:08 +00003192 }
3193};
3194
Chris Lattnere957f532009-01-27 01:58:38 +00003195const char * const SparcV8TargetInfo::GCCRegNames[] = {
3196 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3197 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3198 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3199 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
3200};
3201
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003202void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003203 unsigned &NumNames) const {
3204 Names = GCCRegNames;
3205 NumNames = llvm::array_lengthof(GCCRegNames);
3206}
3207
3208const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003209 { { "g0" }, "r0" },
3210 { { "g1" }, "r1" },
3211 { { "g2" }, "r2" },
3212 { { "g3" }, "r3" },
3213 { { "g4" }, "r4" },
3214 { { "g5" }, "r5" },
3215 { { "g6" }, "r6" },
3216 { { "g7" }, "r7" },
3217 { { "o0" }, "r8" },
3218 { { "o1" }, "r9" },
3219 { { "o2" }, "r10" },
3220 { { "o3" }, "r11" },
3221 { { "o4" }, "r12" },
3222 { { "o5" }, "r13" },
3223 { { "o6", "sp" }, "r14" },
3224 { { "o7" }, "r15" },
3225 { { "l0" }, "r16" },
3226 { { "l1" }, "r17" },
3227 { { "l2" }, "r18" },
3228 { { "l3" }, "r19" },
3229 { { "l4" }, "r20" },
3230 { { "l5" }, "r21" },
3231 { { "l6" }, "r22" },
3232 { { "l7" }, "r23" },
3233 { { "i0" }, "r24" },
3234 { { "i1" }, "r25" },
3235 { { "i2" }, "r26" },
3236 { { "i3" }, "r27" },
3237 { { "i4" }, "r28" },
3238 { { "i5" }, "r29" },
3239 { { "i6", "fp" }, "r30" },
3240 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00003241};
3242
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003243void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003244 unsigned &NumAliases) const {
3245 Aliases = GCCRegAliases;
3246 NumAliases = llvm::array_lengthof(GCCRegAliases);
3247}
Gabor Greif26658672008-02-21 16:29:08 +00003248} // end anonymous namespace.
3249
Eli Friedman01b86682008-08-20 07:28:14 +00003250namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003251class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
3252public:
3253 AuroraUXSparcV8TargetInfo(const std::string& triple) :
3254 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
3255 SizeType = UnsignedInt;
3256 PtrDiffType = SignedInt;
3257 }
3258};
Torok Edwin5f6c1942009-06-30 17:10:35 +00003259class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00003260public:
3261 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003262 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00003263 SizeType = UnsignedInt;
3264 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00003265 }
3266};
3267} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00003268
Chris Lattner2621fd12008-05-08 05:58:21 +00003269namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003270 class MSP430TargetInfo : public TargetInfo {
3271 static const char * const GCCRegNames[];
3272 public:
3273 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003274 BigEndian = false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003275 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00003276 IntWidth = 16; IntAlign = 16;
3277 LongWidth = 32; LongLongWidth = 64;
3278 LongAlign = LongLongAlign = 16;
3279 PointerWidth = 16; PointerAlign = 16;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003280 SuitableAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003281 SizeType = UnsignedInt;
3282 IntMaxType = SignedLong;
3283 UIntMaxType = UnsignedLong;
3284 IntPtrType = SignedShort;
3285 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00003286 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00003287 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003288 }
3289 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003290 MacroBuilder &Builder) const {
3291 Builder.defineMacro("MSP430");
3292 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003293 // FIXME: defines for different 'flavours' of MCU
3294 }
3295 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3296 unsigned &NumRecords) const {
3297 // FIXME: Implement.
3298 Records = 0;
3299 NumRecords = 0;
3300 }
Douglas Gregore727d212012-01-30 06:38:25 +00003301 virtual bool hasFeature(StringRef Feature) const {
3302 return Feature == "msp430";
3303 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003304 virtual void getGCCRegNames(const char * const *&Names,
3305 unsigned &NumNames) const;
3306 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3307 unsigned &NumAliases) const {
3308 // No aliases.
3309 Aliases = 0;
3310 NumAliases = 0;
3311 }
3312 virtual bool validateAsmConstraint(const char *&Name,
3313 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00003314 // No target constraints for now.
3315 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003316 }
3317 virtual const char *getClobbers() const {
3318 // FIXME: Is this really right?
3319 return "";
3320 }
3321 virtual const char *getVAListDeclaration() const {
3322 // FIXME: implement
Anton Korobeynikoveb716852009-05-08 18:24:57 +00003323 return "typedef char* __builtin_va_list;";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003324 }
3325 };
3326
3327 const char * const MSP430TargetInfo::GCCRegNames[] = {
3328 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3329 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3330 };
3331
3332 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
3333 unsigned &NumNames) const {
3334 Names = GCCRegNames;
3335 NumNames = llvm::array_lengthof(GCCRegNames);
3336 }
3337}
3338
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00003339namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00003340
Mike Stump1eb44332009-09-09 15:08:12 +00003341 // LLVM and Clang cannot be used directly to output native binaries for
3342 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00003343 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00003344 //
3345 // TCE uses the llvm bitcode as input and uses it for generating customized
3346 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00003347 // publicly available in http://tce.cs.tut.fi
3348
Eli Friedman209f5bb2011-10-07 19:51:42 +00003349 static const unsigned TCEOpenCLAddrSpaceMap[] = {
3350 3, // opencl_global
3351 4, // opencl_local
3352 5 // opencl_constant
3353 };
3354
Eli Friedmanb63decf2009-08-19 20:47:07 +00003355 class TCETargetInfo : public TargetInfo{
3356 public:
3357 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
3358 TLSSupported = false;
3359 IntWidth = 32;
3360 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003361 PointerWidth = 32;
3362 IntAlign = 32;
3363 LongAlign = LongLongAlign = 32;
3364 PointerAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003365 SuitableAlign = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003366 SizeType = UnsignedInt;
3367 IntMaxType = SignedLong;
3368 UIntMaxType = UnsignedLong;
3369 IntPtrType = SignedInt;
3370 PtrDiffType = SignedInt;
3371 FloatWidth = 32;
3372 FloatAlign = 32;
3373 DoubleWidth = 32;
3374 DoubleAlign = 32;
3375 LongDoubleWidth = 32;
3376 LongDoubleAlign = 32;
3377 FloatFormat = &llvm::APFloat::IEEEsingle;
3378 DoubleFormat = &llvm::APFloat::IEEEsingle;
3379 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00003380 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
3381 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00003382 "f32:32:32-f64:32:32-v64:32:32-"
3383 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00003384 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003385 }
3386
3387 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003388 MacroBuilder &Builder) const {
3389 DefineStd(Builder, "tce", Opts);
3390 Builder.defineMacro("__TCE__");
3391 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00003392 }
Douglas Gregore727d212012-01-30 06:38:25 +00003393 virtual bool hasFeature(StringRef Feature) const {
3394 return Feature == "tce";
3395 }
3396
Eli Friedmanb63decf2009-08-19 20:47:07 +00003397 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3398 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00003399 virtual const char *getClobbers() const {
3400 return "";
3401 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003402 virtual const char *getVAListDeclaration() const {
3403 return "typedef void* __builtin_va_list;";
3404 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003405 virtual void getGCCRegNames(const char * const *&Names,
3406 unsigned &NumNames) const {}
3407 virtual bool validateAsmConstraint(const char *&Name,
3408 TargetInfo::ConstraintInfo &info) const {
3409 return true;
3410 }
3411 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3412 unsigned &NumAliases) const {}
3413 };
3414}
3415
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003416namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003417class MipsTargetInfoBase : public TargetInfo {
3418 std::string CPU;
3419protected:
3420 std::string ABI;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003421public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003422 MipsTargetInfoBase(const std::string& triple, const std::string& ABIStr)
Akira Hatanaka148735e2011-11-05 01:48:34 +00003423 : TargetInfo(triple), ABI(ABIStr) {}
Eric Christophered734732010-03-02 02:41:08 +00003424 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003425 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00003426 virtual bool setCPU(const std::string &Name) {
3427 CPU = Name;
3428 return true;
3429 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003430 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00003431 Features[ABI] = true;
3432 Features[CPU] = true;
3433 }
3434 virtual void getArchDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003435 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003436 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003437 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003438 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3439 unsigned &NumRecords) const {
3440 // FIXME: Implement!
3441 }
Douglas Gregore727d212012-01-30 06:38:25 +00003442 virtual bool hasFeature(StringRef Feature) const {
3443 return Feature == "mips";
3444 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003445 virtual const char *getVAListDeclaration() const {
3446 return "typedef void* __builtin_va_list;";
3447 }
3448 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003449 unsigned &NumNames) const {
3450 static const char * const GCCRegNames[] = {
3451 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
3452 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
3453 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
3454 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
3455 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
3456 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
3457 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
3458 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
3459 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
3460 "$fcc5","$fcc6","$fcc7"
3461 };
3462 Names = GCCRegNames;
3463 NumNames = llvm::array_lengthof(GCCRegNames);
3464 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003465 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003466 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003467 virtual bool validateAsmConstraint(const char *&Name,
3468 TargetInfo::ConstraintInfo &Info) const {
3469 switch (*Name) {
3470 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00003471 return false;
3472
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003473 case 'r': // CPU registers.
3474 case 'd': // Equivalent to "r" unless generating MIPS16 code.
3475 case 'y': // Equivalent to "r", backwards compatibility only.
3476 case 'f': // floating-point registers.
3477 Info.setAllowsRegister();
3478 return true;
3479 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003480 }
3481
3482 virtual const char *getClobbers() const {
3483 // FIXME: Implement!
3484 return "";
3485 }
3486};
3487
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003488class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003489public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003490 Mips32TargetInfoBase(const std::string& triple) :
Akira Hatanaka148735e2011-11-05 01:48:34 +00003491 MipsTargetInfoBase(triple, "o32") {
3492 SizeType = UnsignedInt;
3493 PtrDiffType = SignedInt;
3494 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003495 virtual bool setABI(const std::string &Name) {
3496 if ((Name == "o32") || (Name == "eabi")) {
3497 ABI = Name;
3498 return true;
3499 } else
3500 return false;
3501 }
3502 virtual void getArchDefines(const LangOptions &Opts,
3503 MacroBuilder &Builder) const {
Douglas Gregorc9a23712011-11-09 15:17:16 +00003504 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
3505 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
3506 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
3507
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003508 if (ABI == "o32") {
3509 Builder.defineMacro("__mips_o32");
3510 Builder.defineMacro("_ABIO32", "1");
3511 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
3512 }
3513 else if (ABI == "eabi")
3514 Builder.defineMacro("__mips_eabi");
3515 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003516 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003517 }
3518 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3519 unsigned &NumAliases) const {
3520 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3521 { { "at" }, "$1" },
3522 { { "v0" }, "$2" },
3523 { { "v1" }, "$3" },
3524 { { "a0" }, "$4" },
3525 { { "a1" }, "$5" },
3526 { { "a2" }, "$6" },
3527 { { "a3" }, "$7" },
3528 { { "t0" }, "$8" },
3529 { { "t1" }, "$9" },
3530 { { "t2" }, "$10" },
3531 { { "t3" }, "$11" },
3532 { { "t4" }, "$12" },
3533 { { "t5" }, "$13" },
3534 { { "t6" }, "$14" },
3535 { { "t7" }, "$15" },
3536 { { "s0" }, "$16" },
3537 { { "s1" }, "$17" },
3538 { { "s2" }, "$18" },
3539 { { "s3" }, "$19" },
3540 { { "s4" }, "$20" },
3541 { { "s5" }, "$21" },
3542 { { "s6" }, "$22" },
3543 { { "s7" }, "$23" },
3544 { { "t8" }, "$24" },
3545 { { "t9" }, "$25" },
3546 { { "k0" }, "$26" },
3547 { { "k1" }, "$27" },
3548 { { "gp" }, "$28" },
3549 { { "sp" }, "$29" },
3550 { { "fp" }, "$30" },
3551 { { "ra" }, "$31" }
3552 };
3553 Aliases = GCCRegAliases;
3554 NumAliases = llvm::array_lengthof(GCCRegAliases);
3555 }
3556};
3557
3558class Mips32EBTargetInfo : public Mips32TargetInfoBase {
3559public:
3560 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
3561 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3562 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3563 }
3564 virtual void getTargetDefines(const LangOptions &Opts,
3565 MacroBuilder &Builder) const {
3566 DefineStd(Builder, "mips", Opts);
3567 Builder.defineMacro("_mips");
3568 DefineStd(Builder, "MIPSEB", Opts);
3569 Builder.defineMacro("_MIPSEB");
3570 Builder.defineMacro("__REGISTER_PREFIX__", "");
3571 getArchDefines(Opts, Builder);
3572 }
3573};
3574
3575class Mips32ELTargetInfo : public Mips32TargetInfoBase {
3576public:
3577 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003578 BigEndian = false;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003579 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 +00003580 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003581 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003582 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003583 MacroBuilder &Builder) const {
3584 DefineStd(Builder, "mips", Opts);
3585 Builder.defineMacro("_mips");
3586 DefineStd(Builder, "MIPSEL", Opts);
3587 Builder.defineMacro("_MIPSEL");
3588 Builder.defineMacro("__REGISTER_PREFIX__", "");
3589 getArchDefines(Opts, Builder);
3590 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003591};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003592
3593class Mips64TargetInfoBase : public MipsTargetInfoBase {
3594 virtual void SetDescriptionString(const std::string &Name) = 0;
3595public:
3596 Mips64TargetInfoBase(const std::string& triple) :
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003597 MipsTargetInfoBase(triple, "n64") {
3598 LongWidth = LongAlign = 64;
3599 PointerWidth = PointerAlign = 64;
3600 LongDoubleWidth = LongDoubleAlign = 128;
3601 LongDoubleFormat = &llvm::APFloat::IEEEquad;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003602 SuitableAlign = 128;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003603 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003604 virtual bool setABI(const std::string &Name) {
3605 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003606
3607 if (Name != "n32" && Name != "n64")
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003608 return false;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003609
3610 ABI = Name;
3611
3612 if (Name == "n32") {
3613 LongWidth = LongAlign = 32;
3614 PointerWidth = PointerAlign = 32;
3615 }
3616
3617 return true;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003618 }
3619 virtual void getArchDefines(const LangOptions &Opts,
3620 MacroBuilder &Builder) const {
3621 if (ABI == "n32") {
3622 Builder.defineMacro("__mips_n32");
3623 Builder.defineMacro("_ABIN32", "2");
3624 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
3625 }
3626 else if (ABI == "n64") {
3627 Builder.defineMacro("__mips_n64");
3628 Builder.defineMacro("_ABI64", "3");
3629 Builder.defineMacro("_MIPS_SIM", "_ABI64");
3630 }
3631 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003632 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003633 }
3634 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3635 unsigned &NumAliases) const {
3636 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3637 { { "at" }, "$1" },
3638 { { "v0" }, "$2" },
3639 { { "v1" }, "$3" },
3640 { { "a0" }, "$4" },
3641 { { "a1" }, "$5" },
3642 { { "a2" }, "$6" },
3643 { { "a3" }, "$7" },
3644 { { "a4" }, "$8" },
3645 { { "a5" }, "$9" },
3646 { { "a6" }, "$10" },
3647 { { "a7" }, "$11" },
3648 { { "t0" }, "$12" },
3649 { { "t1" }, "$13" },
3650 { { "t2" }, "$14" },
3651 { { "t3" }, "$15" },
3652 { { "s0" }, "$16" },
3653 { { "s1" }, "$17" },
3654 { { "s2" }, "$18" },
3655 { { "s3" }, "$19" },
3656 { { "s4" }, "$20" },
3657 { { "s5" }, "$21" },
3658 { { "s6" }, "$22" },
3659 { { "s7" }, "$23" },
3660 { { "t8" }, "$24" },
3661 { { "t9" }, "$25" },
3662 { { "k0" }, "$26" },
3663 { { "k1" }, "$27" },
3664 { { "gp" }, "$28" },
3665 { { "sp" }, "$29" },
3666 { { "fp" }, "$30" },
3667 { { "ra" }, "$31" }
3668 };
3669 Aliases = GCCRegAliases;
3670 NumAliases = llvm::array_lengthof(GCCRegAliases);
3671 }
3672};
3673
3674class Mips64EBTargetInfo : public Mips64TargetInfoBase {
3675 virtual void SetDescriptionString(const std::string &Name) {
3676 // Change DescriptionString only if ABI is n32.
3677 if (Name == "n32")
3678 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 +00003679 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3680 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003681 }
3682public:
3683 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3684 // Default ABI is n64.
3685 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 +00003686 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3687 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003688 }
3689 virtual void getTargetDefines(const LangOptions &Opts,
3690 MacroBuilder &Builder) const {
3691 DefineStd(Builder, "mips", Opts);
3692 Builder.defineMacro("_mips");
3693 DefineStd(Builder, "MIPSEB", Opts);
3694 Builder.defineMacro("_MIPSEB");
3695 Builder.defineMacro("__REGISTER_PREFIX__", "");
3696 getArchDefines(Opts, Builder);
3697 }
3698};
3699
3700class Mips64ELTargetInfo : public Mips64TargetInfoBase {
3701 virtual void SetDescriptionString(const std::string &Name) {
3702 // Change DescriptionString only if ABI is n32.
3703 if (Name == "n32")
3704 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 +00003705 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
3706 "-v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003707 }
3708public:
3709 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003710 // Default ABI is n64.
3711 BigEndian = false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003712 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 +00003713 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3714 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003715 }
3716 virtual void getTargetDefines(const LangOptions &Opts,
3717 MacroBuilder &Builder) const {
3718 DefineStd(Builder, "mips", Opts);
3719 Builder.defineMacro("_mips");
3720 DefineStd(Builder, "MIPSEL", Opts);
3721 Builder.defineMacro("_MIPSEL");
3722 Builder.defineMacro("__REGISTER_PREFIX__", "");
3723 getArchDefines(Opts, Builder);
3724 }
3725};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003726} // end anonymous namespace.
3727
Ivan Krasinef05abd2011-08-24 20:22:22 +00003728namespace {
3729class PNaClTargetInfo : public TargetInfo {
3730public:
3731 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003732 BigEndian = false;
Ivan Krasinef05abd2011-08-24 20:22:22 +00003733 this->UserLabelPrefix = "";
3734 this->LongAlign = 32;
3735 this->LongWidth = 32;
3736 this->PointerAlign = 32;
3737 this->PointerWidth = 32;
3738 this->IntMaxType = TargetInfo::SignedLongLong;
3739 this->UIntMaxType = TargetInfo::UnsignedLongLong;
3740 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003741 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003742 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003743 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003744 this->SizeType = TargetInfo::UnsignedInt;
3745 this->PtrDiffType = TargetInfo::SignedInt;
3746 this->IntPtrType = TargetInfo::SignedInt;
David Meyerdd4a8892011-10-11 03:12:01 +00003747 this->RegParmMax = 2;
Ivan Krasinef05abd2011-08-24 20:22:22 +00003748 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
3749 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
3750 }
3751
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003752 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00003753 }
3754 virtual void getArchDefines(const LangOptions &Opts,
3755 MacroBuilder &Builder) const {
3756 Builder.defineMacro("__le32__");
3757 Builder.defineMacro("__pnacl__");
3758 }
3759 virtual void getTargetDefines(const LangOptions &Opts,
3760 MacroBuilder &Builder) const {
Ivan Krasin089ee112011-08-25 23:49:20 +00003761 DefineStd(Builder, "unix", Opts);
3762 Builder.defineMacro("__ELF__");
3763 if (Opts.POSIXThreads)
3764 Builder.defineMacro("_REENTRANT");
3765 if (Opts.CPlusPlus)
3766 Builder.defineMacro("_GNU_SOURCE");
3767
Ivan Krasinef05abd2011-08-24 20:22:22 +00003768 Builder.defineMacro("__native_client__");
3769 getArchDefines(Opts, Builder);
3770 }
Douglas Gregore727d212012-01-30 06:38:25 +00003771 virtual bool hasFeature(StringRef Feature) const {
3772 return Feature == "pnacl";
3773 }
Ivan Krasinef05abd2011-08-24 20:22:22 +00003774 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3775 unsigned &NumRecords) const {
3776 }
3777 virtual const char *getVAListDeclaration() const {
Ivan Krasin68018db2011-09-20 14:56:54 +00003778 return "typedef int __builtin_va_list[4];";
Ivan Krasinef05abd2011-08-24 20:22:22 +00003779 }
3780 virtual void getGCCRegNames(const char * const *&Names,
3781 unsigned &NumNames) const;
3782 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3783 unsigned &NumAliases) const;
3784 virtual bool validateAsmConstraint(const char *&Name,
3785 TargetInfo::ConstraintInfo &Info) const {
3786 return false;
3787 }
3788
3789 virtual const char *getClobbers() const {
3790 return "";
3791 }
3792};
3793
3794void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
3795 unsigned &NumNames) const {
3796 Names = NULL;
3797 NumNames = 0;
3798}
3799
3800void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3801 unsigned &NumAliases) const {
3802 Aliases = NULL;
3803 NumAliases = 0;
3804}
3805} // end anonymous namespace.
3806
3807
Reid Spencer5f016e22007-07-11 17:01:13 +00003808//===----------------------------------------------------------------------===//
3809// Driver code
3810//===----------------------------------------------------------------------===//
3811
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003812static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003813 llvm::Triple Triple(T);
3814 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00003815
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003816 switch (Triple.getArch()) {
3817 default:
3818 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00003819
Tony Linthicum96319392011-12-12 21:14:55 +00003820 case llvm::Triple::hexagon:
3821 return new HexagonTargetInfo(T);
3822
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003823 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00003824 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003825 if (Triple.isOSDarwin())
3826 return new DarwinARMTargetInfo(T);
3827
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003828 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00003829 case llvm::Triple::Linux:
3830 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003831 case llvm::Triple::FreeBSD:
Torok Edwin5f6c1942009-06-30 17:10:35 +00003832 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003833 case llvm::Triple::NetBSD:
3834 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003835 case llvm::Triple::RTEMS:
3836 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003837 default:
3838 return new ARMTargetInfo(T);
3839 }
Eli Friedman61538a72008-05-20 14:21:01 +00003840
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003841 case llvm::Triple::msp430:
3842 return new MSP430TargetInfo(T);
Eli Friedman61538a72008-05-20 14:21:01 +00003843
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003844 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003845 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003846 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003847 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003848 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003849 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003850 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003851 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003852 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003853 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003854 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003855 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003856 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003857
3858 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003859 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003860 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003861 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003862 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003863 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003864 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003865 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003866 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003867 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003868 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003869 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003870 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003871
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003872 case llvm::Triple::mips64:
3873 switch (os) {
3874 case llvm::Triple::Linux:
3875 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
3876 case llvm::Triple::RTEMS:
3877 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
3878 case llvm::Triple::FreeBSD:
3879 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
3880 case llvm::Triple::NetBSD:
3881 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
3882 default:
3883 return new Mips64EBTargetInfo(T);
3884 }
3885
3886 case llvm::Triple::mips64el:
3887 switch (os) {
3888 case llvm::Triple::Linux:
3889 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
3890 case llvm::Triple::RTEMS:
3891 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
3892 case llvm::Triple::FreeBSD:
3893 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
3894 case llvm::Triple::NetBSD:
3895 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
3896 default:
3897 return new Mips64ELTargetInfo(T);
3898 }
3899
Ivan Krasinef05abd2011-08-24 20:22:22 +00003900 case llvm::Triple::le32:
3901 switch (os) {
3902 case llvm::Triple::NativeClient:
3903 return new PNaClTargetInfo(T);
3904 default:
3905 return NULL;
3906 }
3907
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003908 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003909 if (Triple.isOSDarwin())
Roman Divackyc81f2a22011-01-06 08:27:10 +00003910 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003911 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003912 case llvm::Triple::Linux:
3913 return new LinuxTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003914 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00003915 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003916 case llvm::Triple::NetBSD:
3917 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
3918 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003919 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003920 default:
3921 return new PPC32TargetInfo(T);
3922 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003923
3924 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003925 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00003926 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003927 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003928 case llvm::Triple::Linux:
3929 return new LinuxTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003930 case llvm::Triple::Lv2:
John Thompson3f6918a2009-11-19 17:18:50 +00003931 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003932 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00003933 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003934 case llvm::Triple::NetBSD:
3935 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
3936 default:
3937 return new PPC64TargetInfo(T);
3938 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003939
Justin Holewinski285dc652011-04-20 19:34:15 +00003940 case llvm::Triple::ptx32:
3941 return new PTX32TargetInfo(T);
3942 case llvm::Triple::ptx64:
3943 return new PTX64TargetInfo(T);
3944
Chris Lattner9cbeb632010-03-06 21:21:27 +00003945 case llvm::Triple::mblaze:
3946 return new MBlazeTargetInfo(T);
3947
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003948 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003949 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003950 case llvm::Triple::Linux:
3951 return new LinuxTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003952 case llvm::Triple::AuroraUX:
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003953 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003954 case llvm::Triple::Solaris:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003955 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003956 case llvm::Triple::NetBSD:
3957 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
3958 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003959 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003960 default:
3961 return new SparcV8TargetInfo(T);
3962 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003963
John Thompson3f6918a2009-11-19 17:18:50 +00003964 // FIXME: Need a real SPU target.
3965 case llvm::Triple::cellspu:
3966 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
3967
Eli Friedmanb63decf2009-08-19 20:47:07 +00003968 case llvm::Triple::tce:
3969 return new TCETargetInfo(T);
3970
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003971 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003972 if (Triple.isOSDarwin())
3973 return new DarwinI386TargetInfo(T);
3974
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003975 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003976 case llvm::Triple::AuroraUX:
3977 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003978 case llvm::Triple::Linux:
3979 return new LinuxTargetInfo<X86_32TargetInfo>(T);
3980 case llvm::Triple::DragonFly:
3981 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
3982 case llvm::Triple::NetBSD:
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00003983 return new NetBSDI386TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003984 case llvm::Triple::OpenBSD:
3985 return new OpenBSDI386TargetInfo(T);
3986 case llvm::Triple::FreeBSD:
3987 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner38e317d2010-07-07 16:01:42 +00003988 case llvm::Triple::Minix:
3989 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003990 case llvm::Triple::Solaris:
3991 return new SolarisTargetInfo<X86_32TargetInfo>(T);
3992 case llvm::Triple::Cygwin:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003993 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003994 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003995 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003996 case llvm::Triple::Win32:
Michael J. Spencera764e832010-10-21 08:22:51 +00003997 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattner86ed3a32010-04-11 19:29:39 +00003998 case llvm::Triple::Haiku:
3999 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00004000 case llvm::Triple::RTEMS:
4001 return new RTEMSX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004002 default:
4003 return new X86_32TargetInfo(T);
4004 }
4005
4006 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004007 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
4008 return new DarwinX86_64TargetInfo(T);
4009
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004010 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004011 case llvm::Triple::AuroraUX:
4012 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004013 case llvm::Triple::Linux:
4014 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner7a7ca282010-01-09 05:41:14 +00004015 case llvm::Triple::DragonFly:
4016 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004017 case llvm::Triple::NetBSD:
4018 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
4019 case llvm::Triple::OpenBSD:
4020 return new OpenBSDX86_64TargetInfo(T);
4021 case llvm::Triple::FreeBSD:
4022 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
4023 case llvm::Triple::Solaris:
4024 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00004025 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004026 return new MinGWX86_64TargetInfo(T);
4027 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004028 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004029 default:
4030 return new X86_64TargetInfo(T);
4031 }
4032 }
Reid Spencer5f016e22007-07-11 17:01:13 +00004033}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004034
4035/// CreateTargetInfo - Return the target info object for the specified target
4036/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00004037TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004038 TargetOptions &Opts) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004039 llvm::Triple Triple(Opts.Triple);
4040
4041 // Construct the target
4042 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
4043 if (!Target) {
4044 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
4045 return 0;
4046 }
4047
Daniel Dunbareac7c532009-12-18 18:42:37 +00004048 // Set the target CPU if specified.
4049 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
4050 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
4051 return 0;
4052 }
4053
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004054 // Set the target ABI if specified.
4055 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
4056 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
4057 return 0;
4058 }
4059
Charles Davis98b7c5c2010-06-11 01:06:47 +00004060 // Set the target C++ ABI.
John McCallee79a4c2010-08-21 22:46:04 +00004061 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davis98b7c5c2010-06-11 01:06:47 +00004062 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
4063 return 0;
4064 }
4065
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004066 // Compute the default target features, we need the target to handle this
4067 // because features may have dependencies on one another.
4068 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004069 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004070
4071 // Apply the user specified deltas.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004072 // First the enables.
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004073 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
4074 ie = Opts.Features.end(); it != ie; ++it) {
4075 const char *Name = it->c_str();
4076
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004077 if (Name[0] != '+')
4078 continue;
4079
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004080 // Apply the feature via the target.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004081 if (!Target->setFeatureEnabled(Features, Name + 1, true)) {
4082 Diags.Report(diag::err_target_invalid_feature) << Name;
4083 return 0;
4084 }
4085 }
4086
4087 // Then the disables.
4088 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
4089 ie = Opts.Features.end(); it != ie; ++it) {
4090 const char *Name = it->c_str();
4091
4092 if (Name[0] == '+')
4093 continue;
4094
4095 // Apply the feature via the target.
4096 if (Name[0] != '-' ||
4097 !Target->setFeatureEnabled(Features, Name + 1, false)) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004098 Diags.Report(diag::err_target_invalid_feature) << Name;
4099 return 0;
4100 }
4101 }
4102
4103 // Add the features to the compile options.
4104 //
4105 // FIXME: If we are completely confident that we have the right set, we only
4106 // need to pass the minuses.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004107 Opts.Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004108 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
4109 ie = Features.end(); it != ie; ++it)
Chris Lattner1e5f83b2011-07-14 18:24:21 +00004110 Opts.Features.push_back(std::string(it->second ? "+" : "-") +
Chris Lattner48b78bd2011-07-14 18:45:41 +00004111 it->first().str());
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004112 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004113
4114 return Target.take();
4115}