blob: 5dc63e79cf8e5013f51cdb66e979b703fc1142a8 [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
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000586 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000587 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000588 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000589 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000590 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +0000591 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000592 switch (*Name) {
Anders Carlssond04c6e22007-11-27 04:11:28 +0000593 default: return false;
594 case 'O': // Zero
John Thompson8e6065a2010-06-24 22:44:13 +0000595 break;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000596 case 'b': // Base register
597 case 'f': // Floating point register
Chris Lattner44def072009-04-26 07:16:29 +0000598 Info.setAllowsRegister();
John Thompson8e6065a2010-06-24 22:44:13 +0000599 break;
600 // FIXME: The following are added to allow parsing.
601 // I just took a guess at what the actions should be.
602 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer20249a12010-10-21 03:16:25 +0000603 case 'd': // Floating point register (containing 64-bit value)
John Thompson8e6065a2010-06-24 22:44:13 +0000604 case 'v': // Altivec vector register
605 Info.setAllowsRegister();
606 break;
607 case 'w':
608 switch (Name[1]) {
Michael J. Spencer20249a12010-10-21 03:16:25 +0000609 case 'd':// VSX vector register to hold vector double data
610 case 'f':// VSX vector register to hold vector float data
611 case 's':// VSX vector register to hold scalar float data
612 case 'a':// Any VSX register
John Thompson8e6065a2010-06-24 22:44:13 +0000613 break;
614 default:
615 return false;
616 }
617 Info.setAllowsRegister();
618 Name++; // Skip over 'w'.
619 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000620 case 'h': // `MQ', `CTR', or `LINK' register
621 case 'q': // `MQ' register
622 case 'c': // `CTR' register
623 case 'l': // `LINK' register
624 case 'x': // `CR' register (condition register) number 0
625 case 'y': // `CR' register (condition register)
626 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson8e6065a2010-06-24 22:44:13 +0000627 Info.setAllowsRegister();
628 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000629 case 'I': // Signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000630 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer20249a12010-10-21 03:16:25 +0000631 // (use `L' instead for SImode constants)
632 case 'K': // Unsigned 16-bit constant
633 case 'L': // Signed 16-bit constant shifted left 16 bits
634 case 'M': // Constant larger than 31
635 case 'N': // Exact power of 2
636 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000637 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000638 // register with one instruction per word
John Thompson8e6065a2010-06-24 22:44:13 +0000639 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer20249a12010-10-21 03:16:25 +0000640 // into a register using three instructions
John Thompson8e6065a2010-06-24 22:44:13 +0000641 break;
642 case 'm': // Memory operand. Note that on PowerPC targets, m can
643 // include addresses that update the base register. It
644 // is therefore only safe to use `m' in an asm statement
645 // if that asm statement accesses the operand exactly once.
646 // The asm statement must also use `%U<opno>' as a
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000647 // placeholder for the "update" flag in the corresponding
Michael J. Spencer20249a12010-10-21 03:16:25 +0000648 // load or store instruction. For example:
John Thompson8e6065a2010-06-24 22:44:13 +0000649 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000650 // is correct but:
John Thompson8e6065a2010-06-24 22:44:13 +0000651 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
652 // is not. Use es rather than m if you don't want the base
Michael J. Spencer20249a12010-10-21 03:16:25 +0000653 // register to be updated.
654 case 'e':
John Thompson56b6eca2010-06-25 00:02:05 +0000655 if (Name[1] != 's')
656 return false;
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000657 // es: A "stable" memory operand; that is, one which does not
John Thompson8e6065a2010-06-24 22:44:13 +0000658 // include any automodification of the base register. Unlike
659 // `m', this constraint can be used in asm statements that
660 // might access the operand several times, or that might not
John Thompson56b6eca2010-06-25 00:02:05 +0000661 // access it at all.
John Thompson8e6065a2010-06-24 22:44:13 +0000662 Info.setAllowsMemory();
John Thompson56b6eca2010-06-25 00:02:05 +0000663 Name++; // Skip over 'e'.
John Thompson8e6065a2010-06-24 22:44:13 +0000664 break;
665 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer20249a12010-10-21 03:16:25 +0000666 // usually better to use `m' or `es' in asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000667 case 'Z': // Memory operand that is an indexed or indirect from a
668 // register (it is usually better to use `m' or `es' in
Michael J. Spencer20249a12010-10-21 03:16:25 +0000669 // asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000670 Info.setAllowsMemory();
671 Info.setAllowsRegister();
672 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000673 case 'R': // AIX TOC entry
John Thompson8e6065a2010-06-24 22:44:13 +0000674 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000675 // register (`p' is preferable for asm statements)
676 case 'S': // Constant suitable as a 64-bit mask operand
677 case 'T': // Constant suitable as a 32-bit mask operand
678 case 'U': // System V Release 4 small data area reference
John Thompson8e6065a2010-06-24 22:44:13 +0000679 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000680 // instructions
681 case 'W': // Vector constant that does not require memory
682 case 'j': // Vector constant that is all zeros.
John Thompson8e6065a2010-06-24 22:44:13 +0000683 break;
684 // End FIXME.
Anders Carlssond04c6e22007-11-27 04:11:28 +0000685 }
John Thompson8e6065a2010-06-24 22:44:13 +0000686 return true;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000687 }
Eli Friedmane4277982008-08-20 23:11:40 +0000688 virtual const char *getClobbers() const {
689 return "";
Anders Carlssond04c6e22007-11-27 04:11:28 +0000690 }
Eli Friedmane4277982008-08-20 23:11:40 +0000691};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000692
Eli Friedmane4277982008-08-20 23:11:40 +0000693const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000694#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000695#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000696 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000697#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000698};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000699
700
Chris Lattnerc0f59212009-03-02 22:27:17 +0000701/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
702/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000703void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000704 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000705 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000706 Builder.defineMacro("__ppc__");
707 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000708 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000709 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000710 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000711 Builder.defineMacro("_ARCH_PPC64");
712 Builder.defineMacro("_LP64");
713 Builder.defineMacro("__LP64__");
Chris Lattnere03ae302010-02-16 18:14:57 +0000714 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000715 Builder.defineMacro("__ppc64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000716 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +0000717 Builder.defineMacro("__ppc__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000718 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000719
Chris Lattnerc0f59212009-03-02 22:27:17 +0000720 // Target properties.
Joerg Sonnenberger7cd1de52011-07-05 14:56:12 +0000721 if (getTriple().getOS() != llvm::Triple::NetBSD)
722 Builder.defineMacro("_BIG_ENDIAN");
Benjamin Kramera9992772010-01-09 17:55:51 +0000723 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000724
Chris Lattnerc0f59212009-03-02 22:27:17 +0000725 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000726 Builder.defineMacro("__NATURAL_ALIGNMENT__");
727 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000728
Chris Lattnerc0f59212009-03-02 22:27:17 +0000729 // FIXME: Should be controlled by command line option.
Benjamin Kramera9992772010-01-09 17:55:51 +0000730 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000731
John Thompson3f6918a2009-11-19 17:18:50 +0000732 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000733 Builder.defineMacro("__VEC__", "10206");
734 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000735 }
Chris Lattnerc0f59212009-03-02 22:27:17 +0000736}
737
Chris Lattner393ff042008-04-21 18:56:49 +0000738
Eli Friedmane4277982008-08-20 23:11:40 +0000739const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +0000740 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
741 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
742 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
743 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
744 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
745 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
746 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
747 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +0000748 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000749 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +0000750 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000751 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
752 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
753 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
754 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +0000755 "vrsave", "vscr",
756 "spe_acc", "spefscr",
757 "sfp"
758};
Reid Spencer5f016e22007-07-11 17:01:13 +0000759
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000760void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000761 unsigned &NumNames) const {
762 Names = GCCRegNames;
763 NumNames = llvm::array_lengthof(GCCRegNames);
764}
Reid Spencer5f016e22007-07-11 17:01:13 +0000765
Eli Friedmane4277982008-08-20 23:11:40 +0000766const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
767 // While some of these aliases do map to different registers
768 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000769 { { "0" }, "r0" },
770 { { "1"}, "r1" },
771 { { "2" }, "r2" },
772 { { "3" }, "r3" },
773 { { "4" }, "r4" },
774 { { "5" }, "r5" },
775 { { "6" }, "r6" },
776 { { "7" }, "r7" },
777 { { "8" }, "r8" },
778 { { "9" }, "r9" },
779 { { "10" }, "r10" },
780 { { "11" }, "r11" },
781 { { "12" }, "r12" },
782 { { "13" }, "r13" },
783 { { "14" }, "r14" },
784 { { "15" }, "r15" },
785 { { "16" }, "r16" },
786 { { "17" }, "r17" },
787 { { "18" }, "r18" },
788 { { "19" }, "r19" },
789 { { "20" }, "r20" },
790 { { "21" }, "r21" },
791 { { "22" }, "r22" },
792 { { "23" }, "r23" },
793 { { "24" }, "r24" },
794 { { "25" }, "r25" },
795 { { "26" }, "r26" },
796 { { "27" }, "r27" },
797 { { "28" }, "r28" },
798 { { "29" }, "r29" },
799 { { "30" }, "r30" },
800 { { "31" }, "r31" },
801 { { "fr0" }, "f0" },
802 { { "fr1" }, "f1" },
803 { { "fr2" }, "f2" },
804 { { "fr3" }, "f3" },
805 { { "fr4" }, "f4" },
806 { { "fr5" }, "f5" },
807 { { "fr6" }, "f6" },
808 { { "fr7" }, "f7" },
809 { { "fr8" }, "f8" },
810 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +0000811 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000812 { { "fr11" }, "f11" },
813 { { "fr12" }, "f12" },
814 { { "fr13" }, "f13" },
815 { { "fr14" }, "f14" },
816 { { "fr15" }, "f15" },
817 { { "fr16" }, "f16" },
818 { { "fr17" }, "f17" },
819 { { "fr18" }, "f18" },
820 { { "fr19" }, "f19" },
821 { { "fr20" }, "f20" },
822 { { "fr21" }, "f21" },
823 { { "fr22" }, "f22" },
824 { { "fr23" }, "f23" },
825 { { "fr24" }, "f24" },
826 { { "fr25" }, "f25" },
827 { { "fr26" }, "f26" },
828 { { "fr27" }, "f27" },
829 { { "fr28" }, "f28" },
830 { { "fr29" }, "f29" },
831 { { "fr30" }, "f30" },
832 { { "fr31" }, "f31" },
833 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +0000834};
835
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000836void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000837 unsigned &NumAliases) const {
838 Aliases = GCCRegAliases;
839 NumAliases = llvm::array_lengthof(GCCRegAliases);
840}
841} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +0000842
843namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000844class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000845public:
Chris Lattnere03ae302010-02-16 18:14:57 +0000846 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +0000847 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 +0000848 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +0000849
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000850 switch (getTriple().getOS()) {
851 case llvm::Triple::FreeBSD:
852 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000853 SizeType = UnsignedInt;
854 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +0000855 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000856 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000857 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000858 }
859
860 virtual const char *getVAListDeclaration() const {
861 // This is the ELF definition, and is overridden by the Darwin sub-target
862 return "typedef struct __va_list_tag {"
863 " unsigned char gpr;"
864 " unsigned char fpr;"
865 " unsigned short reserved;"
866 " void* overflow_arg_area;"
867 " void* reg_save_area;"
868 "} __builtin_va_list[1];";
Eli Friedmaned855cb2008-08-21 00:13:15 +0000869 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000870};
871} // end anonymous namespace.
872
873namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000874class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000875public:
Eli Friedmane4277982008-08-20 23:11:40 +0000876 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +0000877 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +0000878 IntMaxType = SignedLong;
879 UIntMaxType = UnsignedLong;
880 Int64Type = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +0000881 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 +0000882 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnerf291b102008-05-09 06:17:04 +0000883 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000884 virtual const char *getVAListDeclaration() const {
885 return "typedef char* __builtin_va_list;";
886 }
Eli Friedmane4277982008-08-20 23:11:40 +0000887};
888} // end anonymous namespace.
889
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000890
891namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +0000892class DarwinPPC32TargetInfo :
893 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000894public:
Roman Divackyc81f2a22011-01-06 08:27:10 +0000895 DarwinPPC32TargetInfo(const std::string& triple)
896 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000897 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +0000898 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
Anton Yartsev9bc23ba2012-01-17 22:40:00 +0000899 LongLongAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +0000900 SuitableAlign = 128;
Anton Yartsev9bc23ba2012-01-17 22:40:00 +0000901 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
902 "i64:32:64-f32:32:32-f64:64:64-v128:128:128-n32";
Roman Divackyc81f2a22011-01-06 08:27:10 +0000903 }
904 virtual const char *getVAListDeclaration() const {
905 return "typedef char* __builtin_va_list;";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000906 }
907};
908
909class DarwinPPC64TargetInfo :
910 public DarwinTargetInfo<PPC64TargetInfo> {
911public:
912 DarwinPPC64TargetInfo(const std::string& triple)
913 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
914 HasAlignMac68kSupport = true;
Nick Lewycky9bddf432011-12-21 04:25:47 +0000915 SuitableAlign = 128;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000916 }
917};
918} // end anonymous namespace.
919
Reid Spencer5f016e22007-07-11 17:01:13 +0000920namespace {
Justin Holewinski25bedca2011-10-03 17:28:37 +0000921 static const unsigned PTXAddrSpaceMap[] = {
922 0, // opencl_global
923 4, // opencl_local
924 1 // opencl_constant
925 };
Justin Holewinski285dc652011-04-20 19:34:15 +0000926 class PTXTargetInfo : public TargetInfo {
927 static const char * const GCCRegNames[];
928 static const Builtin::Info BuiltinInfo[];
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000929 std::vector<llvm::StringRef> AvailableFeatures;
Justin Holewinski285dc652011-04-20 19:34:15 +0000930 public:
931 PTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +0000932 BigEndian = false;
Justin Holewinski285dc652011-04-20 19:34:15 +0000933 TLSSupported = false;
934 LongWidth = LongAlign = 64;
Justin Holewinski25bedca2011-10-03 17:28:37 +0000935 AddrSpaceMap = &PTXAddrSpaceMap;
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000936 // Define available target features
937 // These must be defined in sorted order!
938 AvailableFeatures.push_back("compute10");
939 AvailableFeatures.push_back("compute11");
940 AvailableFeatures.push_back("compute12");
941 AvailableFeatures.push_back("compute13");
942 AvailableFeatures.push_back("compute20");
943 AvailableFeatures.push_back("double");
944 AvailableFeatures.push_back("no-fma");
945 AvailableFeatures.push_back("ptx20");
946 AvailableFeatures.push_back("ptx21");
947 AvailableFeatures.push_back("ptx22");
948 AvailableFeatures.push_back("ptx23");
949 AvailableFeatures.push_back("sm10");
950 AvailableFeatures.push_back("sm11");
951 AvailableFeatures.push_back("sm12");
952 AvailableFeatures.push_back("sm13");
953 AvailableFeatures.push_back("sm20");
954 AvailableFeatures.push_back("sm21");
955 AvailableFeatures.push_back("sm22");
956 AvailableFeatures.push_back("sm23");
Justin Holewinski285dc652011-04-20 19:34:15 +0000957 }
958 virtual void getTargetDefines(const LangOptions &Opts,
959 MacroBuilder &Builder) const {
960 Builder.defineMacro("__PTX__");
961 }
962 virtual void getTargetBuiltins(const Builtin::Info *&Records,
963 unsigned &NumRecords) const {
964 Records = BuiltinInfo;
965 NumRecords = clang::PTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
966 }
967
968 virtual void getGCCRegNames(const char * const *&Names,
969 unsigned &NumNames) const;
970 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
971 unsigned &NumAliases) const {
972 // No aliases.
973 Aliases = 0;
974 NumAliases = 0;
975 }
976 virtual bool validateAsmConstraint(const char *&Name,
977 TargetInfo::ConstraintInfo &info) const {
978 // FIXME: implement
979 return true;
980 }
981 virtual const char *getClobbers() const {
982 // FIXME: Is this really right?
983 return "";
984 }
985 virtual const char *getVAListDeclaration() const {
986 // FIXME: implement
987 return "typedef char* __builtin_va_list;";
988 }
Justin Holewinski808ef662011-09-15 12:13:38 +0000989
990 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
991 const std::string &Name,
992 bool Enabled) const;
Justin Holewinski285dc652011-04-20 19:34:15 +0000993 };
994
995 const Builtin::Info PTXTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000996#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +0000997#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000998 ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +0000999#include "clang/Basic/BuiltinsPTX.def"
1000 };
1001
1002 const char * const PTXTargetInfo::GCCRegNames[] = {
1003 "r0"
1004 };
1005
1006 void PTXTargetInfo::getGCCRegNames(const char * const *&Names,
1007 unsigned &NumNames) const {
1008 Names = GCCRegNames;
1009 NumNames = llvm::array_lengthof(GCCRegNames);
1010 }
1011
Justin Holewinski808ef662011-09-15 12:13:38 +00001012 bool PTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1013 const std::string &Name,
1014 bool Enabled) const {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +00001015 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
1016 Name)) {
1017 Features[Name] = Enabled;
1018 return true;
Justin Holewinski808ef662011-09-15 12:13:38 +00001019 } else {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +00001020 return false;
Justin Holewinski808ef662011-09-15 12:13:38 +00001021 }
Justin Holewinski808ef662011-09-15 12:13:38 +00001022 }
Justin Holewinski285dc652011-04-20 19:34:15 +00001023
1024 class PTX32TargetInfo : public PTXTargetInfo {
1025 public:
1026 PTX32TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
1027 PointerWidth = PointerAlign = 32;
1028 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
1029 DescriptionString
1030 = "e-p:32:32-i64:64:64-f64:64:64-n1:8:16:32:64";
1031 }
1032 };
1033
1034 class PTX64TargetInfo : public PTXTargetInfo {
1035 public:
1036 PTX64TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
1037 PointerWidth = PointerAlign = 64;
1038 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
1039 DescriptionString
1040 = "e-p:64:64-i64:64:64-f64:64:64-n1:8:16:32:64";
1041 }
1042 };
1043}
1044
1045namespace {
Chris Lattner9cbeb632010-03-06 21:21:27 +00001046// MBlaze abstract base class
1047class MBlazeTargetInfo : public TargetInfo {
1048 static const char * const GCCRegNames[];
1049 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1050
1051public:
1052 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +00001053 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner9cbeb632010-03-06 21:21:27 +00001054 }
1055
1056 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1057 unsigned &NumRecords) const {
1058 // FIXME: Implement.
1059 Records = 0;
1060 NumRecords = 0;
1061 }
1062
1063 virtual void getTargetDefines(const LangOptions &Opts,
1064 MacroBuilder &Builder) const;
1065
1066 virtual const char *getVAListDeclaration() const {
1067 return "typedef char* __builtin_va_list;";
1068 }
1069 virtual const char *getTargetPrefix() const {
1070 return "mblaze";
1071 }
1072 virtual void getGCCRegNames(const char * const *&Names,
1073 unsigned &NumNames) const;
1074 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1075 unsigned &NumAliases) const;
1076 virtual bool validateAsmConstraint(const char *&Name,
1077 TargetInfo::ConstraintInfo &Info) const {
1078 switch (*Name) {
1079 default: return false;
1080 case 'O': // Zero
1081 return true;
1082 case 'b': // Base register
1083 case 'f': // Floating point register
1084 Info.setAllowsRegister();
1085 return true;
1086 }
1087 }
1088 virtual const char *getClobbers() const {
1089 return "";
1090 }
1091};
1092
1093/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1094/// #defines that are not tied to a specific subtarget.
1095void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1096 MacroBuilder &Builder) const {
1097 // Target identification.
1098 Builder.defineMacro("__microblaze__");
1099 Builder.defineMacro("_ARCH_MICROBLAZE");
1100 Builder.defineMacro("__MICROBLAZE__");
1101
1102 // Target properties.
1103 Builder.defineMacro("_BIG_ENDIAN");
1104 Builder.defineMacro("__BIG_ENDIAN__");
1105
1106 // Subtarget options.
1107 Builder.defineMacro("__REGISTER_PREFIX__", "");
1108}
1109
1110
1111const char * const MBlazeTargetInfo::GCCRegNames[] = {
1112 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1113 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1114 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1115 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1116 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1117 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1118 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1119 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1120 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1121 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1122};
1123
1124void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1125 unsigned &NumNames) const {
1126 Names = GCCRegNames;
1127 NumNames = llvm::array_lengthof(GCCRegNames);
1128}
1129
1130const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1131 { {"f0"}, "r0" },
1132 { {"f1"}, "r1" },
1133 { {"f2"}, "r2" },
1134 { {"f3"}, "r3" },
1135 { {"f4"}, "r4" },
1136 { {"f5"}, "r5" },
1137 { {"f6"}, "r6" },
1138 { {"f7"}, "r7" },
1139 { {"f8"}, "r8" },
1140 { {"f9"}, "r9" },
1141 { {"f10"}, "r10" },
1142 { {"f11"}, "r11" },
1143 { {"f12"}, "r12" },
1144 { {"f13"}, "r13" },
1145 { {"f14"}, "r14" },
1146 { {"f15"}, "r15" },
1147 { {"f16"}, "r16" },
1148 { {"f17"}, "r17" },
1149 { {"f18"}, "r18" },
1150 { {"f19"}, "r19" },
1151 { {"f20"}, "r20" },
1152 { {"f21"}, "r21" },
1153 { {"f22"}, "r22" },
1154 { {"f23"}, "r23" },
1155 { {"f24"}, "r24" },
1156 { {"f25"}, "r25" },
1157 { {"f26"}, "r26" },
1158 { {"f27"}, "r27" },
1159 { {"f28"}, "r28" },
1160 { {"f29"}, "r29" },
1161 { {"f30"}, "r30" },
1162 { {"f31"}, "r31" },
1163};
1164
1165void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1166 unsigned &NumAliases) const {
1167 Aliases = GCCRegAliases;
1168 NumAliases = llvm::array_lengthof(GCCRegAliases);
1169}
1170} // end anonymous namespace.
1171
1172namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001173// Namespace for x86 abstract base class
1174const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001175#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001176#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001177 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001178#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001179};
Eli Friedman61538a72008-05-20 14:21:01 +00001180
Nuno Lopes2550d702009-12-23 17:49:57 +00001181static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001182 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1183 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001184 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001185 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1186 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1187 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001188 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopherc5f9a012011-12-02 02:12:16 +00001189 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1190 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001191};
1192
Eric Christophercfd323d2011-06-21 00:05:20 +00001193const TargetInfo::AddlRegName AddlRegNames[] = {
1194 { { "al", "ah", "eax", "rax" }, 0 },
1195 { { "bl", "bh", "ebx", "rbx" }, 3 },
1196 { { "cl", "ch", "ecx", "rcx" }, 2 },
1197 { { "dl", "dh", "edx", "rdx" }, 1 },
1198 { { "esi", "rsi" }, 4 },
1199 { { "edi", "rdi" }, 5 },
1200 { { "esp", "rsp" }, 7 },
1201 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001202};
1203
1204// X86 target abstract base class; x86-32 and x86-64 are very close, so
1205// most of the implementation can be shared.
1206class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001207 enum X86SSEEnum {
Craig Topper05fe4b52012-01-09 09:19:09 +00001208 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2
Chris Lattner84f0ea82009-03-02 22:40:39 +00001209 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001210 enum MMX3DNowEnum {
1211 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1212 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001213
Eric Christophereea12d12010-04-02 23:50:19 +00001214 bool HasAES;
Craig Topper31ceea02011-12-25 05:06:45 +00001215 bool HasLZCNT;
1216 bool HasBMI;
1217 bool HasBMI2;
Craig Toppere14e08b2011-12-29 16:10:46 +00001218 bool HasPOPCNT;
Craig Topper6a511e12011-12-30 07:33:42 +00001219 bool HasFMA4;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001220
Chandler Carruth499d9722011-09-28 08:55:34 +00001221 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1222 ///
1223 /// Each enumeration represents a particular CPU supported by Clang. These
1224 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1225 enum CPUKind {
1226 CK_Generic,
1227
1228 /// \name i386
1229 /// i386-generation processors.
1230 //@{
1231 CK_i386,
1232 //@}
1233
1234 /// \name i486
1235 /// i486-generation processors.
1236 //@{
1237 CK_i486,
1238 CK_WinChipC6,
1239 CK_WinChip2,
1240 CK_C3,
1241 //@}
1242
1243 /// \name i586
1244 /// i586-generation processors, P5 microarchitecture based.
1245 //@{
1246 CK_i586,
1247 CK_Pentium,
1248 CK_PentiumMMX,
1249 //@}
1250
1251 /// \name i686
1252 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1253 //@{
1254 CK_i686,
1255 CK_PentiumPro,
1256 CK_Pentium2,
1257 CK_Pentium3,
1258 CK_Pentium3M,
1259 CK_PentiumM,
1260 CK_C3_2,
1261
1262 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1263 /// Clang however has some logic to suport this.
1264 // FIXME: Warn, deprecate, and potentially remove this.
1265 CK_Yonah,
1266 //@}
1267
1268 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001269 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001270 //@{
1271 CK_Pentium4,
1272 CK_Pentium4M,
1273 CK_Prescott,
1274 CK_Nocona,
1275 //@}
1276
1277 /// \name Core
1278 /// Core microarchitecture based processors.
1279 //@{
1280 CK_Core2,
1281
1282 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1283 /// codename which GCC no longer accepts as an option to -march, but Clang
1284 /// has some logic for recognizing it.
1285 // FIXME: Warn, deprecate, and potentially remove this.
1286 CK_Penryn,
1287 //@}
1288
1289 /// \name Atom
1290 /// Atom processors
1291 //@{
1292 CK_Atom,
1293 //@}
1294
1295 /// \name Nehalem
1296 /// Nehalem microarchitecture based processors.
1297 //@{
1298 CK_Corei7,
1299 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001300 CK_CoreAVXi,
Craig Topper2b03bb02011-12-17 19:55:21 +00001301 CK_CoreAVX2,
Chandler Carruth499d9722011-09-28 08:55:34 +00001302 //@}
1303
1304 /// \name K6
1305 /// K6 architecture processors.
1306 //@{
1307 CK_K6,
1308 CK_K6_2,
1309 CK_K6_3,
1310 //@}
1311
1312 /// \name K7
1313 /// K7 architecture processors.
1314 //@{
1315 CK_Athlon,
1316 CK_AthlonThunderbird,
1317 CK_Athlon4,
1318 CK_AthlonXP,
1319 CK_AthlonMP,
1320 //@}
1321
1322 /// \name K8
1323 /// K8 architecture processors.
1324 //@{
1325 CK_Athlon64,
1326 CK_Athlon64SSE3,
1327 CK_AthlonFX,
1328 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001329 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001330 CK_Opteron,
1331 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001332 CK_AMDFAM10,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001333 //@}
Chandler Carruth499d9722011-09-28 08:55:34 +00001334
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001335 /// \name Bobcat
1336 /// Bobcat architecture processors.
1337 //@{
1338 CK_BTVER1,
1339 //@}
1340
1341 /// \name Bulldozer
1342 /// Bulldozer architecture processors.
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001343 //@{
1344 CK_BDVER1,
1345 CK_BDVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001346 //@}
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001347
Chandler Carruth499d9722011-09-28 08:55:34 +00001348 /// This specification is deprecated and will be removed in the future.
1349 /// Users should prefer \see CK_K8.
1350 // FIXME: Warn on this when the CPU is set to it.
1351 CK_x86_64,
1352 //@}
1353
1354 /// \name Geode
1355 /// Geode processors.
1356 //@{
1357 CK_Geode
1358 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001359 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001360
Eli Friedman618234a2008-08-20 02:34:37 +00001361public:
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001362 X86TargetInfo(const std::string& triple)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001363 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Craig Topper05fe4b52012-01-09 09:19:09 +00001364 HasAES(false), HasLZCNT(false), HasBMI(false), HasBMI2(false),
1365 HasPOPCNT(false), HasFMA4(false), CPU(CK_Generic) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00001366 BigEndian = false;
Eli Friedman618234a2008-08-20 02:34:37 +00001367 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001368 }
Benjamin Kramerb4066692011-12-28 15:47:06 +00001369 virtual unsigned getFloatEvalMethod() const {
1370 // X87 evaluates with 80 bits "long double" precision.
1371 return SSELevel == NoSSE ? 2 : 0;
1372 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001373 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1374 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001375 Records = BuiltinInfo;
1376 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001377 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001378 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001379 unsigned &NumNames) const {
1380 Names = GCCRegNames;
1381 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001382 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001383 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001384 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001385 Aliases = 0;
1386 NumAliases = 0;
1387 }
1388 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1389 unsigned &NumNames) const {
1390 Names = AddlRegNames;
1391 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001392 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001393 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001394 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001395 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001396 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001397 return "~{dirflag},~{fpsr},~{flags}";
1398 }
Chris Lattner33328642009-03-20 15:52:06 +00001399 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001400 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001401 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1402 const std::string &Name,
1403 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001404 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001405 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001406 virtual const char* getABI() const {
Craig Topper05fe4b52012-01-09 09:19:09 +00001407 if (PointerWidth == 64 && SSELevel >= AVX)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001408 return "avx";
1409 else if (PointerWidth == 32 && MMX3DNowLevel == NoMMX3DNow)
1410 return "no-mmx";
1411 return "";
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001412 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001413 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001414 CPU = llvm::StringSwitch<CPUKind>(Name)
1415 .Case("i386", CK_i386)
1416 .Case("i486", CK_i486)
1417 .Case("winchip-c6", CK_WinChipC6)
1418 .Case("winchip2", CK_WinChip2)
1419 .Case("c3", CK_C3)
1420 .Case("i586", CK_i586)
1421 .Case("pentium", CK_Pentium)
1422 .Case("pentium-mmx", CK_PentiumMMX)
1423 .Case("i686", CK_i686)
1424 .Case("pentiumpro", CK_PentiumPro)
1425 .Case("pentium2", CK_Pentium2)
1426 .Case("pentium3", CK_Pentium3)
1427 .Case("pentium3m", CK_Pentium3M)
1428 .Case("pentium-m", CK_PentiumM)
1429 .Case("c3-2", CK_C3_2)
1430 .Case("yonah", CK_Yonah)
1431 .Case("pentium4", CK_Pentium4)
1432 .Case("pentium4m", CK_Pentium4M)
1433 .Case("prescott", CK_Prescott)
1434 .Case("nocona", CK_Nocona)
1435 .Case("core2", CK_Core2)
1436 .Case("penryn", CK_Penryn)
1437 .Case("atom", CK_Atom)
1438 .Case("corei7", CK_Corei7)
1439 .Case("corei7-avx", CK_Corei7AVX)
1440 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper2b03bb02011-12-17 19:55:21 +00001441 .Case("core-avx2", CK_CoreAVX2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001442 .Case("k6", CK_K6)
1443 .Case("k6-2", CK_K6_2)
1444 .Case("k6-3", CK_K6_3)
1445 .Case("athlon", CK_Athlon)
1446 .Case("athlon-tbird", CK_AthlonThunderbird)
1447 .Case("athlon-4", CK_Athlon4)
1448 .Case("athlon-xp", CK_AthlonXP)
1449 .Case("athlon-mp", CK_AthlonMP)
1450 .Case("athlon64", CK_Athlon64)
1451 .Case("athlon64-sse3", CK_Athlon64SSE3)
1452 .Case("athlon-fx", CK_AthlonFX)
1453 .Case("k8", CK_K8)
1454 .Case("k8-sse3", CK_K8SSE3)
1455 .Case("opteron", CK_Opteron)
1456 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001457 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001458 .Case("btver1", CK_BTVER1)
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001459 .Case("bdver1", CK_BDVER1)
1460 .Case("bdver2", CK_BDVER2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001461 .Case("x86-64", CK_x86_64)
1462 .Case("geode", CK_Geode)
1463 .Default(CK_Generic);
1464
Chandler Carruth26a39142011-09-28 09:45:08 +00001465 // Perform any per-CPU checks necessary to determine if this CPU is
1466 // acceptable.
1467 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1468 // invalid without explaining *why*.
1469 switch (CPU) {
1470 case CK_Generic:
1471 // No processor selected!
1472 return false;
1473
1474 case CK_i386:
1475 case CK_i486:
1476 case CK_WinChipC6:
1477 case CK_WinChip2:
1478 case CK_C3:
1479 case CK_i586:
1480 case CK_Pentium:
1481 case CK_PentiumMMX:
1482 case CK_i686:
1483 case CK_PentiumPro:
1484 case CK_Pentium2:
1485 case CK_Pentium3:
1486 case CK_Pentium3M:
1487 case CK_PentiumM:
1488 case CK_Yonah:
1489 case CK_C3_2:
1490 case CK_Pentium4:
1491 case CK_Pentium4M:
1492 case CK_Prescott:
1493 case CK_K6:
1494 case CK_K6_2:
1495 case CK_K6_3:
1496 case CK_Athlon:
1497 case CK_AthlonThunderbird:
1498 case CK_Athlon4:
1499 case CK_AthlonXP:
1500 case CK_AthlonMP:
1501 case CK_Geode:
1502 // Only accept certain architectures when compiling in 32-bit mode.
1503 if (PointerWidth != 32)
1504 return false;
1505
1506 // Fallthrough
1507 case CK_Nocona:
1508 case CK_Core2:
1509 case CK_Penryn:
1510 case CK_Atom:
1511 case CK_Corei7:
1512 case CK_Corei7AVX:
1513 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001514 case CK_CoreAVX2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001515 case CK_Athlon64:
1516 case CK_Athlon64SSE3:
1517 case CK_AthlonFX:
1518 case CK_K8:
1519 case CK_K8SSE3:
1520 case CK_Opteron:
1521 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00001522 case CK_AMDFAM10:
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001523 case CK_BTVER1:
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001524 case CK_BDVER1:
1525 case CK_BDVER2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001526 case CK_x86_64:
1527 return true;
1528 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001529 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001530 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001531};
Chris Lattner3daed522009-03-02 22:20:04 +00001532
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001533void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001534 // FIXME: This should not be here.
1535 Features["3dnow"] = false;
1536 Features["3dnowa"] = false;
1537 Features["mmx"] = false;
1538 Features["sse"] = false;
1539 Features["sse2"] = false;
1540 Features["sse3"] = false;
1541 Features["ssse3"] = false;
1542 Features["sse41"] = false;
1543 Features["sse42"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001544 Features["sse4a"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001545 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001546 Features["avx"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001547 Features["avx2"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001548 Features["lzcnt"] = false;
1549 Features["bmi"] = false;
1550 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001551 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001552 Features["fma4"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001553
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001554 // FIXME: This *really* should not be here.
1555
1556 // X86_64 always has SSE2.
1557 if (PointerWidth == 64)
1558 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1559
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001560 switch (CPU) {
1561 case CK_Generic:
1562 case CK_i386:
1563 case CK_i486:
1564 case CK_i586:
1565 case CK_Pentium:
1566 case CK_i686:
1567 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001568 break;
1569 case CK_PentiumMMX:
1570 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001571 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001572 break;
1573 case CK_Pentium3:
1574 case CK_Pentium3M:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001575 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001576 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001577 break;
1578 case CK_PentiumM:
1579 case CK_Pentium4:
1580 case CK_Pentium4M:
1581 case CK_x86_64:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001582 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001583 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001584 break;
1585 case CK_Yonah:
1586 case CK_Prescott:
1587 case CK_Nocona:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001588 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001589 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001590 break;
1591 case CK_Core2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001592 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001593 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001594 break;
1595 case CK_Penryn:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001596 setFeatureEnabled(Features, "mmx", true);
Benjamin Kramerb3453a82012-01-04 14:36:57 +00001597 setFeatureEnabled(Features, "sse4.1", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001598 break;
1599 case CK_Atom:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001600 setFeatureEnabled(Features, "mmx", true);
Chandler Carruth49defe62011-09-28 10:36:46 +00001601 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001602 break;
1603 case CK_Corei7:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001604 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001605 setFeatureEnabled(Features, "sse4", true);
Eric Christophereea12d12010-04-02 23:50:19 +00001606 setFeatureEnabled(Features, "aes", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001607 break;
1608 case CK_Corei7AVX:
1609 case CK_CoreAVXi:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001610 setFeatureEnabled(Features, "mmx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00001611 setFeatureEnabled(Features, "sse4", true);
1612 setFeatureEnabled(Features, "aes", true);
Bruno Cardoso Lopese02d3912011-07-11 23:33:46 +00001613 //setFeatureEnabled(Features, "avx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001614 break;
Craig Topper2b03bb02011-12-17 19:55:21 +00001615 case CK_CoreAVX2:
1616 setFeatureEnabled(Features, "mmx", true);
1617 setFeatureEnabled(Features, "sse4", true);
1618 setFeatureEnabled(Features, "aes", true);
Craig Topper31ceea02011-12-25 05:06:45 +00001619 setFeatureEnabled(Features, "lzcnt", true);
1620 setFeatureEnabled(Features, "bmi", true);
1621 setFeatureEnabled(Features, "bmi2", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00001622 //setFeatureEnabled(Features, "avx2", true);
1623 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001624 case CK_K6:
1625 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001626 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001627 break;
1628 case CK_K6_2:
1629 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001630 case CK_WinChip2:
1631 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001632 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001633 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00001634 case CK_Athlon:
1635 case CK_AthlonThunderbird:
1636 case CK_Geode:
1637 setFeatureEnabled(Features, "3dnowa", true);
1638 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001639 case CK_Athlon4:
1640 case CK_AthlonXP:
1641 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001642 setFeatureEnabled(Features, "sse", true);
1643 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001644 break;
1645 case CK_K8:
1646 case CK_Opteron:
1647 case CK_Athlon64:
1648 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00001649 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001650 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001651 break;
1652 case CK_K8SSE3:
1653 case CK_OpteronSSE3:
1654 case CK_Athlon64SSE3:
Roman Divacky80b32b82011-10-30 13:47:56 +00001655 setFeatureEnabled(Features, "sse3", true);
1656 setFeatureEnabled(Features, "3dnowa", true);
1657 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00001658 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00001659 setFeatureEnabled(Features, "sse3", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00001660 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00001661 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001662 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001663 case CK_BTVER1:
1664 setFeatureEnabled(Features, "ssse3", true);
1665 setFeatureEnabled(Features, "sse4a", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001666 case CK_BDVER1:
1667 case CK_BDVER2:
1668 setFeatureEnabled(Features, "sse4", true);
1669 setFeatureEnabled(Features, "sse4a", true);
1670 setFeatureEnabled(Features, "aes", true);
1671 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001672 case CK_C3_2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001673 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001674 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001675 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001676 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001677}
1678
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001679bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump1eb44332009-09-09 15:08:12 +00001680 const std::string &Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001681 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00001682 // FIXME: This *really* should not be here. We need some way of translating
1683 // options into llvm subtarget features.
1684 if (!Features.count(Name) &&
1685 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001686 return false;
1687
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001688 // FIXME: this should probably use a switch with fall through.
1689
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001690 if (Enabled) {
1691 if (Name == "mmx")
1692 Features["mmx"] = true;
1693 else if (Name == "sse")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001694 Features["mmx"] = Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001695 else if (Name == "sse2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001696 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001697 else if (Name == "sse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001698 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1699 true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001700 else if (Name == "ssse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001701 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001702 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001703 else if (Name == "sse4" || Name == "sse4.2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001704 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001705 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1706 Features["popcnt"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001707 else if (Name == "sse4.1")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001708 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00001709 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001710 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001711 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001712 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001713 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00001714 else if (Name == "aes")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001715 Features["aes"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001716 else if (Name == "avx")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001717 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1718 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001719 Features["popcnt"] = Features["avx"] = true;
Craig Topper2b03bb02011-12-17 19:55:21 +00001720 else if (Name == "avx2")
1721 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1722 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001723 Features["popcnt"] = Features["avx"] = Features["avx2"] = true;
Craig Topper6a511e12011-12-30 07:33:42 +00001724 else if (Name == "fma4")
1725 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1726 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1727 Features["popcnt"] = Features["avx"] = Features["fma4"] = true;
Roman Divacky80b32b82011-10-30 13:47:56 +00001728 else if (Name == "sse4a")
Craig Topper6a511e12011-12-30 07:33:42 +00001729 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Benjamin Kramer5c65e4f2012-01-10 11:50:13 +00001730 Features["lzcnt"] = Features["popcnt"] = Features["sse4a"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00001731 else if (Name == "lzcnt")
1732 Features["lzcnt"] = true;
1733 else if (Name == "bmi")
1734 Features["bmi"] = true;
1735 else if (Name == "bmi2")
1736 Features["bmi2"] = true;
Craig Toppere14e08b2011-12-29 16:10:46 +00001737 else if (Name == "popcnt")
1738 Features["popcnt"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001739 } else {
1740 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001741 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001742 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00001743 Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00001744 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1745 Features["sse4a"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001746 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00001747 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00001748 Features["sse41"] = Features["sse42"] = Features["sse4a"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001749 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00001750 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Craig Topper6a511e12011-12-30 07:33:42 +00001751 Features["sse42"] = Features["sse4a"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001752 else if (Name == "ssse3")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001753 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00001754 else if (Name == "sse4" || Name == "sse4.1")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001755 Features["sse41"] = Features["sse42"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00001756 else if (Name == "sse4.2")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001757 Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001758 else if (Name == "3dnow")
1759 Features["3dnow"] = Features["3dnowa"] = false;
1760 else if (Name == "3dnowa")
1761 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001762 else if (Name == "aes")
1763 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001764 else if (Name == "avx")
Craig Topper6a511e12011-12-30 07:33:42 +00001765 Features["avx"] = Features["avx2"] = Features["fma4"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001766 else if (Name == "avx2")
1767 Features["avx2"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001768 else if (Name == "sse4a")
1769 Features["sse4a"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001770 else if (Name == "lzcnt")
1771 Features["lzcnt"] = false;
1772 else if (Name == "bmi")
1773 Features["bmi"] = false;
1774 else if (Name == "bmi2")
1775 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001776 else if (Name == "popcnt")
1777 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001778 else if (Name == "fma4")
1779 Features["fma4"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001780 }
1781
1782 return true;
1783}
1784
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001785/// HandleTargetOptions - Perform initialization based on the user
1786/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001787void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001788 // Remember the maximum enabled sselevel.
1789 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1790 // Ignore disabled features.
1791 if (Features[i][0] == '-')
1792 continue;
1793
Eric Christophereea12d12010-04-02 23:50:19 +00001794 if (Features[i].substr(1) == "aes") {
1795 HasAES = true;
1796 continue;
1797 }
1798
Craig Topper31ceea02011-12-25 05:06:45 +00001799 if (Features[i].substr(1) == "lzcnt") {
1800 HasLZCNT = true;
1801 continue;
1802 }
1803
1804 if (Features[i].substr(1) == "bmi") {
1805 HasBMI = true;
1806 continue;
1807 }
1808
1809 if (Features[i].substr(1) == "bmi2") {
1810 HasBMI2 = true;
1811 continue;
1812 }
1813
Craig Toppere14e08b2011-12-29 16:10:46 +00001814 if (Features[i].substr(1) == "popcnt") {
1815 HasPOPCNT = true;
1816 continue;
1817 }
1818
Craig Topper6a511e12011-12-30 07:33:42 +00001819 if (Features[i].substr(1) == "fma4") {
1820 HasFMA4 = true;
1821 continue;
1822 }
1823
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001824 assert(Features[i][0] == '+' && "Invalid target feature!");
1825 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
Craig Topper05fe4b52012-01-09 09:19:09 +00001826 .Case("avx2", AVX2)
1827 .Case("avx", AVX)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001828 .Case("sse42", SSE42)
1829 .Case("sse41", SSE41)
1830 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00001831 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001832 .Case("sse2", SSE2)
1833 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001834 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001835 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001836
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001837 MMX3DNowEnum ThreeDNowLevel =
1838 llvm::StringSwitch<MMX3DNowEnum>(Features[i].substr(1))
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001839 .Case("3dnowa", AMD3DNowAthlon)
1840 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001841 .Case("mmx", MMX)
1842 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001843
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001844 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001845 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001846
1847 // Don't tell the backend if we're turning off mmx; it will end up disabling
1848 // SSE, which we don't want.
1849 std::vector<std::string>::iterator it;
1850 it = std::find(Features.begin(), Features.end(), "-mmx");
1851 if (it != Features.end())
1852 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00001853}
Chris Lattnerc0f59212009-03-02 22:27:17 +00001854
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001855/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
1856/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00001857void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001858 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00001859 // Target identification.
1860 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00001861 Builder.defineMacro("_LP64");
1862 Builder.defineMacro("__LP64__");
1863 Builder.defineMacro("__amd64__");
1864 Builder.defineMacro("__amd64");
1865 Builder.defineMacro("__x86_64");
1866 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00001867 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00001868 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00001869 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001870
Chris Lattnerc0f59212009-03-02 22:27:17 +00001871 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001872 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
1873 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001874 switch (CPU) {
1875 case CK_Generic:
1876 break;
1877 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001878 // The rest are coming from the i386 define above.
1879 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001880 break;
1881 case CK_i486:
1882 case CK_WinChipC6:
1883 case CK_WinChip2:
1884 case CK_C3:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001885 defineCPUMacros(Builder, "i486");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001886 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00001887 case CK_PentiumMMX:
1888 Builder.defineMacro("__pentium_mmx__");
1889 Builder.defineMacro("__tune_pentium_mmx__");
1890 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001891 case CK_i586:
1892 case CK_Pentium:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001893 defineCPUMacros(Builder, "i586");
1894 defineCPUMacros(Builder, "pentium");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001895 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001896 case CK_Pentium3:
1897 case CK_Pentium3M:
1898 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001899 Builder.defineMacro("__tune_pentium3__");
1900 // Fallthrough
1901 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001902 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001903 Builder.defineMacro("__tune_pentium2__");
1904 // Fallthrough
1905 case CK_PentiumPro:
1906 Builder.defineMacro("__tune_i686__");
1907 Builder.defineMacro("__tune_pentiumpro__");
1908 // Fallthrough
1909 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001910 Builder.defineMacro("__i686");
1911 Builder.defineMacro("__i686__");
1912 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
1913 Builder.defineMacro("__pentiumpro");
1914 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001915 break;
1916 case CK_Pentium4:
1917 case CK_Pentium4M:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001918 defineCPUMacros(Builder, "pentium4");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001919 break;
1920 case CK_Yonah:
1921 case CK_Prescott:
1922 case CK_Nocona:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001923 defineCPUMacros(Builder, "nocona");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001924 break;
1925 case CK_Core2:
1926 case CK_Penryn:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001927 defineCPUMacros(Builder, "core2");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001928 break;
1929 case CK_Atom:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001930 defineCPUMacros(Builder, "atom");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001931 break;
1932 case CK_Corei7:
1933 case CK_Corei7AVX:
1934 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001935 case CK_CoreAVX2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001936 defineCPUMacros(Builder, "corei7");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001937 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001938 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001939 Builder.defineMacro("__k6_2__");
1940 Builder.defineMacro("__tune_k6_2__");
1941 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001942 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001943 if (CPU != CK_K6_2) { // In case of fallthrough
1944 // FIXME: GCC may be enabling these in cases where some other k6
1945 // architecture is specified but -m3dnow is explicitly provided. The
1946 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001947 Builder.defineMacro("__k6_3__");
1948 Builder.defineMacro("__tune_k6_3__");
1949 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00001950 // Fallthrough
1951 case CK_K6:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001952 defineCPUMacros(Builder, "k6");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001953 break;
1954 case CK_Athlon:
1955 case CK_AthlonThunderbird:
1956 case CK_Athlon4:
1957 case CK_AthlonXP:
1958 case CK_AthlonMP:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001959 defineCPUMacros(Builder, "athlon");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001960 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001961 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001962 Builder.defineMacro("__tune_athlon_sse__");
1963 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001964 break;
1965 case CK_K8:
1966 case CK_K8SSE3:
1967 case CK_x86_64:
1968 case CK_Opteron:
1969 case CK_OpteronSSE3:
1970 case CK_Athlon64:
1971 case CK_Athlon64SSE3:
1972 case CK_AthlonFX:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001973 defineCPUMacros(Builder, "k8");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001974 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00001975 case CK_AMDFAM10:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001976 defineCPUMacros(Builder, "amdfam10");
Roman Divacky01c770d2011-10-30 07:48:46 +00001977 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001978 case CK_BTVER1:
1979 defineCPUMacros(Builder, "btver1");
1980 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001981 case CK_BDVER1:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001982 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001983 break;
1984 case CK_BDVER2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001985 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001986 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001987 case CK_Geode:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001988 defineCPUMacros(Builder, "geode");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001989 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001990 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00001991
Chandler Carruth88c75b02011-09-28 09:54:07 +00001992 // Target properties.
1993 Builder.defineMacro("__LITTLE_ENDIAN__");
1994 Builder.defineMacro("__REGISTER_PREFIX__", "");
1995
Chris Lattner54175442009-04-19 17:32:33 +00001996 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1997 // functions in glibc header files that use FP Stack inline asm which the
1998 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00001999 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002000
Chandler Carruth88c75b02011-09-28 09:54:07 +00002001 if (HasAES)
2002 Builder.defineMacro("__AES__");
2003
Craig Topper31ceea02011-12-25 05:06:45 +00002004 if (HasLZCNT)
2005 Builder.defineMacro("__LZCNT__");
2006
2007 if (HasBMI)
2008 Builder.defineMacro("__BMI__");
2009
2010 if (HasBMI2)
2011 Builder.defineMacro("__BMI2__");
2012
Craig Toppere14e08b2011-12-29 16:10:46 +00002013 if (HasPOPCNT)
2014 Builder.defineMacro("__POPCNT__");
2015
Craig Topper6a511e12011-12-30 07:33:42 +00002016 if (HasFMA4)
2017 Builder.defineMacro("__FMA4__");
2018
Chris Lattner84f0ea82009-03-02 22:40:39 +00002019 // Each case falls through to the previous one here.
2020 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002021 case AVX2:
2022 Builder.defineMacro("__AVX2__");
2023 case AVX:
2024 Builder.defineMacro("__AVX__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002025 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00002026 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002027 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00002028 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002029 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002030 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002031 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002032 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002033 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00002034 Builder.defineMacro("__SSE2__");
2035 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00002036 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00002037 Builder.defineMacro("__SSE__");
2038 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002039 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00002040 break;
2041 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002042
Francois Pichet62ec1f22011-09-17 17:15:52 +00002043 if (Opts.MicrosoftExt && PointerWidth == 32) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002044 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002045 case AVX2:
2046 case AVX:
Michael J. Spencera764e832010-10-21 08:22:51 +00002047 case SSE42:
2048 case SSE41:
2049 case SSSE3:
2050 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002051 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002052 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002053 break;
2054 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002055 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002056 break;
2057 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002058 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002059 }
2060 }
2061
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002062 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002063 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002064 case AMD3DNowAthlon:
2065 Builder.defineMacro("__3dNOW_A__");
2066 case AMD3DNow:
2067 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002068 case MMX:
2069 Builder.defineMacro("__MMX__");
2070 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002071 break;
2072 }
Chris Lattnerc0f59212009-03-02 22:27:17 +00002073}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002074
2075
Eli Friedman618234a2008-08-20 02:34:37 +00002076bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002077X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002078 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002079 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00002080 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00002081 case 'Y': // first letter of a pair:
2082 switch (*(Name+1)) {
2083 default: return false;
2084 case '0': // First SSE register.
2085 case 't': // Any SSE register, when SSE2 is enabled.
2086 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2087 case 'm': // any MMX register, when inter-unit moves enabled.
2088 break; // falls through to setAllowsRegister.
2089 }
Eli Friedman618234a2008-08-20 02:34:37 +00002090 case 'a': // eax.
2091 case 'b': // ebx.
2092 case 'c': // ecx.
2093 case 'd': // edx.
2094 case 'S': // esi.
2095 case 'D': // edi.
2096 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00002097 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00002098 case 't': // top of floating point stack.
2099 case 'u': // second from top of floating point stack.
2100 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00002101 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00002102 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00002103 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00002104 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2105 case 'l': // "Index" registers: any general register that can be used as an
2106 // index in a base+index memory access.
2107 Info.setAllowsRegister();
2108 return true;
2109 case 'C': // SSE floating point constant.
2110 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002111 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002112 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002113 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002114 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00002115 return true;
2116 }
2117}
2118
Dale Johannesenf6e2c202010-10-29 23:12:32 +00002119
Eli Friedman618234a2008-08-20 02:34:37 +00002120std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00002121X86TargetInfo::convertConstraint(const char *&Constraint) const {
2122 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00002123 case 'a': return std::string("{ax}");
2124 case 'b': return std::string("{bx}");
2125 case 'c': return std::string("{cx}");
2126 case 'd': return std::string("{dx}");
2127 case 'S': return std::string("{si}");
2128 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00002129 case 'p': // address
2130 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00002131 case 't': // top of floating point stack.
2132 return std::string("{st}");
2133 case 'u': // second from top of floating point stack.
2134 return std::string("{st(1)}"); // second from top of floating point stack.
2135 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00002136 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00002137 }
2138}
Eli Friedman618234a2008-08-20 02:34:37 +00002139} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00002140
2141namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002142// X86-32 generic target
2143class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00002144public:
Eli Friedman618234a2008-08-20 02:34:37 +00002145 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
2146 DoubleAlign = LongLongAlign = 32;
2147 LongDoubleWidth = 96;
2148 LongDoubleAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00002149 SuitableAlign = 128;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002150 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2151 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00002152 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00002153 SizeType = UnsignedInt;
2154 PtrDiffType = SignedInt;
2155 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002156 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002157
2158 // Use fpret for all types.
2159 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2160 (1 << TargetInfo::Double) |
2161 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002162
2163 // x86-32 has atomics up to 8 bytes
2164 // FIXME: Check that we actually have cmpxchg8b before setting
2165 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2166 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002167 }
2168 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002169 return "typedef char* __builtin_va_list;";
Eli Friedman618234a2008-08-20 02:34:37 +00002170 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002171
Chris Lattner21fb98e2009-09-23 06:06:36 +00002172 int getEHDataRegisterNumber(unsigned RegNo) const {
2173 if (RegNo == 0) return 0;
2174 if (RegNo == 1) return 2;
2175 return -1;
2176 }
Eli Friedman618234a2008-08-20 02:34:37 +00002177};
2178} // end anonymous namespace
2179
2180namespace {
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002181class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
2182public:
2183 NetBSDI386TargetInfo(const std::string &triple) :
2184 NetBSDTargetInfo<X86_32TargetInfo>(triple) {
2185 }
2186
2187 virtual unsigned getFloatEvalMethod() const {
2188 // NetBSD defaults to "double" rounding
2189 return 1;
2190 }
2191};
2192} // end anonymous namespace
2193
2194namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002195class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2196public:
2197 OpenBSDI386TargetInfo(const std::string& triple) :
2198 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2199 SizeType = UnsignedLong;
2200 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002201 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002202 }
2203};
2204} // end anonymous namespace
2205
2206namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002207class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002208public:
Torok Edwin5f6c1942009-06-30 17:10:35 +00002209 DarwinI386TargetInfo(const std::string& triple) :
2210 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002211 LongDoubleWidth = 128;
2212 LongDoubleAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002213 SuitableAlign = 128;
Eli Friedman1afabd92009-03-29 20:31:09 +00002214 SizeType = UnsignedLong;
2215 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002216 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2217 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002218 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002219 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002220 }
2221
Eli Friedman618234a2008-08-20 02:34:37 +00002222};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002223} // end anonymous namespace
2224
2225namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002226// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002227class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002228public:
2229 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002230 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002231 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002232 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002233 DoubleAlign = LongLongAlign = 64;
2234 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 +00002235 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002236 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002237 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002238 virtual void getTargetDefines(const LangOptions &Opts,
2239 MacroBuilder &Builder) const {
2240 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2241 }
2242};
2243} // end anonymous namespace
2244
2245namespace {
2246
2247// x86-32 Windows Visual Studio target
2248class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2249public:
2250 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2251 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002252 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002253 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2254 }
2255 virtual void getTargetDefines(const LangOptions &Opts,
2256 MacroBuilder &Builder) const {
2257 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2258 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2259 // The value of the following reflects processor type.
2260 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2261 // We lost the original triple, so we use the default.
2262 Builder.defineMacro("_M_IX86", "600");
2263 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002264};
2265} // end anonymous namespace
2266
2267namespace {
2268// x86-32 MinGW target
2269class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2270public:
2271 MinGWX86_32TargetInfo(const std::string& triple)
2272 : WindowsX86_32TargetInfo(triple) {
2273 }
2274 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002275 MacroBuilder &Builder) const {
2276 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002277 DefineStd(Builder, "WIN32", Opts);
2278 DefineStd(Builder, "WINNT", Opts);
2279 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002280 Builder.defineMacro("__MSVCRT__");
2281 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002282
2283 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2284 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002285 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002286 // Provide "as-is" __declspec.
2287 Builder.defineMacro("__declspec", "__declspec");
2288 else
2289 // Provide alias of __attribute__ like mingw32-gcc.
2290 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002291 }
2292};
2293} // end anonymous namespace
2294
2295namespace {
2296// x86-32 Cygwin target
2297class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2298public:
2299 CygwinX86_32TargetInfo(const std::string& triple)
2300 : X86_32TargetInfo(triple) {
2301 TLSSupported = false;
2302 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002303 DoubleAlign = LongLongAlign = 64;
2304 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2305 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002306 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002307 }
2308 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002309 MacroBuilder &Builder) const {
2310 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2311 Builder.defineMacro("__CYGWIN__");
2312 Builder.defineMacro("__CYGWIN32__");
2313 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00002314 if (Opts.CPlusPlus)
2315 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00002316 }
Eli Friedman29a30502008-08-21 01:40:19 +00002317};
2318} // end anonymous namespace
2319
2320namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002321// x86-32 Haiku target
2322class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2323public:
2324 HaikuX86_32TargetInfo(const std::string& triple)
2325 : X86_32TargetInfo(triple) {
2326 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00002327 IntPtrType = SignedLong;
2328 PtrDiffType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00002329 this->UserLabelPrefix = "";
Eli Friedmana7e68452010-08-22 01:00:03 +00002330 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00002331 virtual void getTargetDefines(const LangOptions &Opts,
2332 MacroBuilder &Builder) const {
2333 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2334 Builder.defineMacro("__INTEL__");
2335 Builder.defineMacro("__HAIKU__");
2336 }
2337};
2338} // end anonymous namespace
2339
Douglas Gregordca52262011-07-01 22:41:14 +00002340// RTEMS Target
2341template<typename Target>
2342class RTEMSTargetInfo : public OSTargetInfo<Target> {
2343protected:
2344 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2345 MacroBuilder &Builder) const {
2346 // RTEMS defines; list based off of gcc output
2347
Douglas Gregordca52262011-07-01 22:41:14 +00002348 Builder.defineMacro("__rtems__");
2349 Builder.defineMacro("__ELF__");
2350 }
2351public:
2352 RTEMSTargetInfo(const std::string &triple)
2353 : OSTargetInfo<Target>(triple) {
2354 this->UserLabelPrefix = "";
2355
2356 llvm::Triple Triple(triple);
2357 switch (Triple.getArch()) {
2358 default:
2359 case llvm::Triple::x86:
2360 // this->MCountName = ".mcount";
2361 break;
2362 case llvm::Triple::mips:
2363 case llvm::Triple::mipsel:
2364 case llvm::Triple::ppc:
2365 case llvm::Triple::ppc64:
2366 // this->MCountName = "_mcount";
2367 break;
2368 case llvm::Triple::arm:
2369 // this->MCountName = "__mcount";
2370 break;
2371 }
2372
2373 }
2374};
2375
2376namespace {
2377// x86-32 RTEMS target
2378class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2379public:
2380 RTEMSX86_32TargetInfo(const std::string& triple)
2381 : X86_32TargetInfo(triple) {
2382 SizeType = UnsignedLong;
2383 IntPtrType = SignedLong;
2384 PtrDiffType = SignedLong;
2385 this->UserLabelPrefix = "";
2386 }
2387 virtual void getTargetDefines(const LangOptions &Opts,
2388 MacroBuilder &Builder) const {
2389 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2390 Builder.defineMacro("__INTEL__");
2391 Builder.defineMacro("__rtems__");
2392 }
2393};
2394} // end anonymous namespace
2395
Chris Lattner86ed3a32010-04-11 19:29:39 +00002396namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002397// x86-64 generic target
2398class X86_64TargetInfo : public X86TargetInfo {
2399public:
Chris Lattner33328642009-03-20 15:52:06 +00002400 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00002401 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002402 LongDoubleWidth = 128;
2403 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00002404 LargeArrayMinWidth = 128;
2405 LargeArrayAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002406 SuitableAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00002407 IntMaxType = SignedLong;
2408 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002409 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002410 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00002411
Eli Friedmaned855cb2008-08-21 00:13:15 +00002412 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2413 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002414 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002415
2416 // Use fpret only for long double.
2417 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00002418
Anders Carlssoneea64802011-10-31 16:27:11 +00002419 // Use fp2ret for _Complex long double.
2420 ComplexLongDoubleUsesFP2Ret = true;
2421
Eli Friedman2be46072011-10-14 20:59:01 +00002422 // x86-64 has atomics up to 16 bytes.
2423 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
2424 // on CPUs with cmpxchg16b
2425 MaxAtomicPromoteWidth = 128;
2426 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00002427 }
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00002428 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002429 return "typedef struct __va_list_tag {"
2430 " unsigned gp_offset;"
2431 " unsigned fp_offset;"
2432 " void* overflow_arg_area;"
2433 " void* reg_save_area;"
John McCall2b7baf02010-05-28 18:25:28 +00002434 "} __va_list_tag;"
Eli Friedmandc043162009-07-03 00:45:06 +00002435 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson3346ae62007-11-24 23:38:12 +00002436 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002437
Chris Lattner21fb98e2009-09-23 06:06:36 +00002438 int getEHDataRegisterNumber(unsigned RegNo) const {
2439 if (RegNo == 0) return 0;
2440 if (RegNo == 1) return 1;
2441 return -1;
2442 }
Eli Friedman618234a2008-08-20 02:34:37 +00002443};
2444} // end anonymous namespace
2445
2446namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002447// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002448class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002449public:
2450 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002451 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002452 TLSSupported = false;
2453 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00002454 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00002455 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00002456 IntMaxType = SignedLongLong;
2457 UIntMaxType = UnsignedLongLong;
2458 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00002459 SizeType = UnsignedLongLong;
2460 PtrDiffType = SignedLongLong;
2461 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00002462 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002463 }
2464 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002465 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002466 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002467 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00002468 }
NAKAMURA Takumi79521992011-01-17 22:56:23 +00002469 virtual const char *getVAListDeclaration() const {
2470 return "typedef char* __builtin_va_list;";
2471 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002472};
2473} // end anonymous namespace
2474
2475namespace {
2476// x86-64 Windows Visual Studio target
2477class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2478public:
2479 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2480 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002481 LongDoubleWidth = LongDoubleAlign = 64;
2482 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00002483 }
2484 virtual void getTargetDefines(const LangOptions &Opts,
2485 MacroBuilder &Builder) const {
2486 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
2487 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00002488 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002489 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002490 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002491};
2492} // end anonymous namespace
2493
2494namespace {
2495// x86-64 MinGW target
2496class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2497public:
2498 MinGWX86_64TargetInfo(const std::string& triple)
2499 : WindowsX86_64TargetInfo(triple) {
2500 }
2501 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002502 MacroBuilder &Builder) const {
2503 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002504 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00002505 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00002506 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00002507 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002508
2509 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2510 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002511 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002512 // Provide "as-is" __declspec.
2513 Builder.defineMacro("__declspec", "__declspec");
2514 else
2515 // Provide alias of __attribute__ like mingw32-gcc.
2516 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002517 }
2518};
2519} // end anonymous namespace
2520
2521namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002522class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2523public:
Mike Stump1eb44332009-09-09 15:08:12 +00002524 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002525 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2526 Int64Type = SignedLongLong;
2527 }
2528};
2529} // end anonymous namespace
2530
2531namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00002532class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
2533public:
Mike Stump1eb44332009-09-09 15:08:12 +00002534 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman6036ebe2009-07-05 22:31:18 +00002535 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
2536 IntMaxType = SignedLongLong;
2537 UIntMaxType = UnsignedLongLong;
2538 Int64Type = SignedLongLong;
2539 }
2540};
2541} // end anonymous namespace
2542
2543namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00002544class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002545 // Possible FPU choices.
2546 enum FPUMode {
2547 NoFPU,
2548 VFP2FPU,
2549 VFP3FPU,
2550 NeonFPU
2551 };
2552
2553 static bool FPUModeIsVFP(FPUMode Mode) {
2554 return Mode >= VFP2FPU && Mode <= NeonFPU;
2555 }
2556
2557 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2558 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002559
Daniel Dunbareac7c532009-12-18 18:42:37 +00002560 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002561
2562 unsigned FPU : 3;
2563
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002564 unsigned IsThumb : 1;
2565
2566 // Initialized via features.
2567 unsigned SoftFloat : 1;
2568 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002569
Chris Lattner2752c012010-03-03 19:03:45 +00002570 static const Builtin::Info BuiltinInfo[];
2571
Chris Lattner393ff042008-04-21 18:56:49 +00002572public:
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002573 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbareac7c532009-12-18 18:42:37 +00002574 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002575 {
Eli Friedmane6a24e82011-12-22 03:51:45 +00002576 BigEndian = false;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002577 SizeType = UnsignedInt;
2578 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00002579 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
2580 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002581
Chris Lattner9bffb072010-04-23 16:29:58 +00002582 // {} in inline assembly are neon specifiers, not assembly variant
2583 // specifiers.
2584 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00002585
Daniel Dunbareac7c532009-12-18 18:42:37 +00002586 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00002587 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002588 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002589 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2590 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002591 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
2592 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002593 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002594 } else {
2595 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2596 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002597 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002598 }
John McCallee79a4c2010-08-21 22:46:04 +00002599
2600 // ARM targets default to using the ARM C++ ABI.
2601 CXXABI = CXXABI_ARM;
Eli Friedman2be46072011-10-14 20:59:01 +00002602
2603 // ARM has atomics up to 8 bytes
2604 // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e
2605 MaxAtomicPromoteWidth = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002606 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002607 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00002608 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002609 ABI = Name;
2610
Daniel Dunbara2a41612009-09-14 00:02:24 +00002611 // The defaults (above) are for AAPCS, check if we need to change them.
2612 //
2613 // FIXME: We need support for -meabi... we could just mangle it into the
2614 // name.
2615 if (Name == "apcs-gnu") {
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002616 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002617 SizeType = UnsignedLong;
2618
James Molloya6d81f92011-11-23 13:35:08 +00002619 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
2620 WCharType = SignedInt;
2621
Daniel Dunbar684de632010-04-22 16:14:54 +00002622 // Do not respect the alignment of bit-field types when laying out
2623 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
2624 UseBitFieldTypeAlignment = false;
2625
Chad Rosier61a62212011-08-04 01:21:14 +00002626 /// Do force alignment of members that follow zero length bitfields. If
2627 /// the alignment of the zero-length bitfield is greater than the member
2628 /// that follows it, `bar', `bar' will be aligned as the type of the
2629 /// zero length bitfield.
2630 UseZeroLengthBitfieldAlignment = true;
2631
2632 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00002633 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
2634 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00002635 ZeroLengthBitfieldBoundary = 32;
2636
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002637 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002638 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2639 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002640 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 +00002641 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002642 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002643 } else {
2644 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 +00002645 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002646 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002647 }
2648
Chad Rosier9f1210c2011-07-26 07:03:04 +00002649 // FIXME: Override "preferred align" for double and long long.
Daniel Dunbara2a41612009-09-14 00:02:24 +00002650 } else if (Name == "aapcs") {
2651 // FIXME: Enumerated types are variable width in straight AAPCS.
2652 } else if (Name == "aapcs-linux") {
Chad Rosier9f1210c2011-07-26 07:03:04 +00002653 ;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002654 } else
2655 return false;
2656
2657 return true;
2658 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002659
Chandler Carruthc3a2e652011-09-28 05:56:05 +00002660 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002661 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
2662 Features["vfp2"] = true;
2663 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
2664 Features["neon"] = true;
2665 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002666
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002667 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2668 const std::string &Name,
2669 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00002670 if (Name == "soft-float" || Name == "soft-float-abi" ||
Evgeniy Stepanov35dd7322012-01-11 11:21:31 +00002671 Name == "vfp2" || Name == "vfp3" || Name == "neon" || Name == "d16") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002672 Features[Name] = Enabled;
2673 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002674 return false;
2675
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002676 return true;
2677 }
2678
2679 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002680 FPU = NoFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002681 SoftFloat = SoftFloatABI = false;
2682 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
2683 if (Features[i] == "+soft-float")
2684 SoftFloat = true;
2685 else if (Features[i] == "+soft-float-abi")
2686 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002687 else if (Features[i] == "+vfp2")
2688 FPU = VFP2FPU;
2689 else if (Features[i] == "+vfp3")
2690 FPU = VFP3FPU;
2691 else if (Features[i] == "+neon")
2692 FPU = NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002693 }
2694
2695 // Remove front-end specific options which the backend handles differently.
2696 std::vector<std::string>::iterator it;
2697 it = std::find(Features.begin(), Features.end(), "+soft-float");
2698 if (it != Features.end())
2699 Features.erase(it);
2700 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2701 if (it != Features.end())
2702 Features.erase(it);
2703 }
2704
Chris Lattner5f9e2722011-07-23 10:55:15 +00002705 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00002706 return llvm::StringSwitch<const char*>(Name)
2707 .Cases("arm8", "arm810", "4")
2708 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2709 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2710 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2711 .Case("ep9312", "4T")
2712 .Cases("arm10tdmi", "arm1020t", "5T")
2713 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2714 .Case("arm926ej-s", "5TEJ")
2715 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2716 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002717 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002718 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002719 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002720 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2721 .Cases("cortex-a8", "cortex-a9", "7A")
Bob Wilson06f45632011-01-06 16:57:20 +00002722 .Case("cortex-m3", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00002723 .Case("cortex-m0", "6M")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002724 .Default(0);
2725 }
2726 virtual bool setCPU(const std::string &Name) {
2727 if (!getCPUDefineSuffix(Name))
2728 return false;
2729
2730 CPU = Name;
2731 return true;
2732 }
Chris Lattner33328642009-03-20 15:52:06 +00002733 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002734 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002735 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00002736 Builder.defineMacro("__arm");
2737 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002738
Chris Lattnerc0f59212009-03-02 22:27:17 +00002739 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00002740 Builder.defineMacro("__ARMEL__");
2741 Builder.defineMacro("__LITTLE_ENDIAN__");
2742 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002743
Chris Lattner5f9e2722011-07-23 10:55:15 +00002744 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00002745 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002746
Mike Stump437bb4b2009-04-08 02:07:04 +00002747 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002748
Daniel Dunbareac7c532009-12-18 18:42:37 +00002749 // FIXME: It's more complicated than this and we don't really support
2750 // interworking.
2751 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00002752 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002753
Daniel Dunbareac7c532009-12-18 18:42:37 +00002754 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramera9992772010-01-09 17:55:51 +00002755 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002756
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002757 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00002758 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002759
2760 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00002761 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002762
Bob Wilson84f95cf2011-05-13 18:56:03 +00002763 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002764 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002765 Builder.defineMacro("__THUMBEL__");
2766 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00002767 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002768 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002769 }
2770
2771 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00002772 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002773
2774 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramera9992772010-01-09 17:55:51 +00002775 Builder.defineMacro("__VFP_FP__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002776
2777 // This only gets set when Neon instructions are actually available, unlike
2778 // the VFP define, hence the soft float and arch check. This is subtly
2779 // different from gcc, we follow the intent which was that it should be set
2780 // when Neon instructions are actually available.
Bob Wilson84f95cf2011-05-13 18:56:03 +00002781 if (FPU == NeonFPU && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002782 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00002783 }
2784 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2785 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00002786 Records = BuiltinInfo;
2787 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00002788 }
Bob Wilson8b30a932012-01-26 22:14:27 +00002789 virtual bool isCLZForZeroUndef() const { return false; }
Chris Lattner393ff042008-04-21 18:56:49 +00002790 virtual const char *getVAListDeclaration() const {
John McCall0e9972c2011-05-09 02:19:37 +00002791 return "typedef void* __builtin_va_list;";
Chris Lattner393ff042008-04-21 18:56:49 +00002792 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002793 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002794 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002795 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002796 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002797 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002798 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002799 // FIXME: Check if this is complete
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002800 switch (*Name) {
Eli Friedmana9f54962008-08-20 07:44:10 +00002801 default:
Nate Begemanad487f42008-04-22 05:03:19 +00002802 case 'l': // r0-r7
2803 case 'h': // r8-r15
2804 case 'w': // VFP Floating point register single precision
2805 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00002806 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00002807 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00002808 case 'Q': // A memory address that is a single base register.
2809 Info.setAllowsMemory();
2810 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00002811 case 'U': // a memory reference...
2812 switch (Name[1]) {
2813 case 'q': // ...ARMV4 ldrsb
2814 case 'v': // ...VFP load/store (reg+constant offset)
2815 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00002816 case 't': // address valid for load/store opaque types wider
2817 // than 128-bits
2818 case 'n': // valid address for Neon doubleword vector load/store
2819 case 'm': // valid address for Neon element and structure load/store
2820 case 's': // valid address for non-offset loads/stores of quad-word
2821 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00002822 Info.setAllowsMemory();
2823 Name++;
2824 return true;
2825 }
Nate Begemanad487f42008-04-22 05:03:19 +00002826 }
Chris Lattner393ff042008-04-21 18:56:49 +00002827 return false;
2828 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00002829 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00002830 std::string R;
2831 switch (*Constraint) {
2832 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00002833 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00002834 Constraint++;
2835 break;
Eric Christopher283f4472011-06-17 00:40:18 +00002836 case 'p': // 'p' should be translated to 'r' by default.
2837 R = std::string("r");
2838 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00002839 default:
2840 return std::string(1, *Constraint);
2841 }
2842 return R;
2843 }
Chris Lattner393ff042008-04-21 18:56:49 +00002844 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002845 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00002846 return "";
2847 }
2848};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002849
2850const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002851 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002852 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002853 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
2854
2855 // Float registers
2856 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2857 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2858 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002859 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002860
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002861 // Double registers
2862 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
2863 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00002864 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
2865 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002866
2867 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00002868 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
2869 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002870};
2871
2872void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002873 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002874 Names = GCCRegNames;
2875 NumNames = llvm::array_lengthof(GCCRegNames);
2876}
2877
2878const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002879 { { "a1" }, "r0" },
2880 { { "a2" }, "r1" },
2881 { { "a3" }, "r2" },
2882 { { "a4" }, "r3" },
2883 { { "v1" }, "r4" },
2884 { { "v2" }, "r5" },
2885 { { "v3" }, "r6" },
2886 { { "v4" }, "r7" },
2887 { { "v5" }, "r8" },
2888 { { "v6", "rfp" }, "r9" },
2889 { { "sl" }, "r10" },
2890 { { "fp" }, "r11" },
2891 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002892 { { "r13" }, "sp" },
2893 { { "r14" }, "lr" },
2894 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002895 // The S, D and Q registers overlap, but aren't really aliases; we
2896 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002897};
2898
2899void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2900 unsigned &NumAliases) const {
2901 Aliases = GCCRegAliases;
2902 NumAliases = llvm::array_lengthof(GCCRegAliases);
2903}
Chris Lattner2752c012010-03-03 19:03:45 +00002904
2905const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00002906#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00002907#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00002908 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00002909#include "clang/Basic/BuiltinsARM.def"
2910};
Chris Lattner393ff042008-04-21 18:56:49 +00002911} // end anonymous namespace.
2912
Eli Friedmana9f54962008-08-20 07:44:10 +00002913namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00002914class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00002915 public DarwinTargetInfo<ARMTargetInfo> {
2916protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00002917 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00002918 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00002919 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00002920 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002921
Torok Edwin5f6c1942009-06-30 17:10:35 +00002922public:
Mike Stump1eb44332009-09-09 15:08:12 +00002923 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar350b9f32010-05-27 07:00:26 +00002924 : DarwinTargetInfo<ARMTargetInfo>(triple) {
2925 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00002926 // iOS always has 64-bit atomic instructions.
2927 // FIXME: This should be based off of the target features in ARMTargetInfo.
2928 MaxAtomicInlineWidth = 64;
Daniel Dunbar350b9f32010-05-27 07:00:26 +00002929 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002930};
2931} // end anonymous namespace.
2932
Tony Linthicum96319392011-12-12 21:14:55 +00002933
2934namespace {
2935// Hexagon abstract base class
2936class HexagonTargetInfo : public TargetInfo {
2937 static const Builtin::Info BuiltinInfo[];
2938 static const char * const GCCRegNames[];
2939 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2940 std::string CPU;
2941public:
2942 HexagonTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00002943 BigEndian = false;
Tony Linthicum96319392011-12-12 21:14:55 +00002944 DescriptionString = ("e-p:32:32:32-"
2945 "i64:64:64-i32:32:32-"
2946 "i16:16:16-i1:32:32-a:0:0");
2947
2948 // {} in inline assembly are packet specifiers, not assembly variant
2949 // specifiers.
2950 NoAsmVariants = true;
2951 }
2952
2953 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2954 unsigned &NumRecords) const {
2955 Records = BuiltinInfo;
2956 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
2957 }
2958
2959 virtual bool validateAsmConstraint(const char *&Name,
2960 TargetInfo::ConstraintInfo &Info) const {
2961 return true;
2962 }
2963
2964 virtual void getTargetDefines(const LangOptions &Opts,
2965 MacroBuilder &Builder) const;
2966
2967 virtual const char *getVAListDeclaration() const {
2968 return "typedef char* __builtin_va_list;";
2969 }
2970 virtual void getGCCRegNames(const char * const *&Names,
2971 unsigned &NumNames) const;
2972 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2973 unsigned &NumAliases) const;
2974 virtual const char *getClobbers() const {
2975 return "";
2976 }
Sebastian Pop43115d42012-01-13 20:37:10 +00002977
2978 static const char *getHexagonCPUSuffix(StringRef Name) {
2979 return llvm::StringSwitch<const char*>(Name)
2980 .Case("hexagonv2", "2")
2981 .Case("hexagonv3", "3")
2982 .Case("hexagonv4", "4")
2983 .Default(0);
2984 }
2985
Tony Linthicum96319392011-12-12 21:14:55 +00002986 virtual bool setCPU(const std::string &Name) {
Sebastian Pop43115d42012-01-13 20:37:10 +00002987 if (!getHexagonCPUSuffix(Name))
2988 return false;
2989
Tony Linthicum96319392011-12-12 21:14:55 +00002990 CPU = Name;
2991 return true;
2992 }
2993};
2994
2995void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
2996 MacroBuilder &Builder) const {
2997 Builder.defineMacro("qdsp6");
2998 Builder.defineMacro("__qdsp6", "1");
2999 Builder.defineMacro("__qdsp6__", "1");
3000
3001 Builder.defineMacro("hexagon");
3002 Builder.defineMacro("__hexagon", "1");
3003 Builder.defineMacro("__hexagon__", "1");
3004
3005 if(CPU == "hexagonv1") {
3006 Builder.defineMacro("__HEXAGON_V1__");
3007 Builder.defineMacro("__HEXAGON_ARCH__", "1");
3008 if(Opts.HexagonQdsp6Compat) {
3009 Builder.defineMacro("__QDSP6_V1__");
3010 Builder.defineMacro("__QDSP6_ARCH__", "1");
3011 }
3012 }
3013 else if(CPU == "hexagonv2") {
3014 Builder.defineMacro("__HEXAGON_V2__");
3015 Builder.defineMacro("__HEXAGON_ARCH__", "2");
3016 if(Opts.HexagonQdsp6Compat) {
3017 Builder.defineMacro("__QDSP6_V2__");
3018 Builder.defineMacro("__QDSP6_ARCH__", "2");
3019 }
3020 }
3021 else if(CPU == "hexagonv3") {
3022 Builder.defineMacro("__HEXAGON_V3__");
3023 Builder.defineMacro("__HEXAGON_ARCH__", "3");
3024 if(Opts.HexagonQdsp6Compat) {
3025 Builder.defineMacro("__QDSP6_V3__");
3026 Builder.defineMacro("__QDSP6_ARCH__", "3");
3027 }
3028 }
3029 else if(CPU == "hexagonv4") {
3030 Builder.defineMacro("__HEXAGON_V4__");
3031 Builder.defineMacro("__HEXAGON_ARCH__", "4");
3032 if(Opts.HexagonQdsp6Compat) {
3033 Builder.defineMacro("__QDSP6_V4__");
3034 Builder.defineMacro("__QDSP6_ARCH__", "4");
3035 }
3036 }
3037}
3038
3039const char * const HexagonTargetInfo::GCCRegNames[] = {
3040 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3041 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3042 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3043 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
3044 "p0", "p1", "p2", "p3",
3045 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
3046};
3047
3048void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
3049 unsigned &NumNames) const {
3050 Names = GCCRegNames;
3051 NumNames = llvm::array_lengthof(GCCRegNames);
3052}
3053
3054
3055const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
3056 { { "sp" }, "r29" },
3057 { { "fp" }, "r30" },
3058 { { "lr" }, "r31" },
3059 };
3060
3061void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3062 unsigned &NumAliases) const {
3063 Aliases = GCCRegAliases;
3064 NumAliases = llvm::array_lengthof(GCCRegAliases);
3065}
3066
3067
3068const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
3069#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3070#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3071 ALL_LANGUAGES },
3072#include "clang/Basic/BuiltinsHexagon.def"
3073};
3074}
3075
3076
Reid Spencer5f016e22007-07-11 17:01:13 +00003077namespace {
Eli Friedman01b86682008-08-20 07:28:14 +00003078class SparcV8TargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00003079 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3080 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003081 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00003082public:
Eli Friedman01b86682008-08-20 07:28:14 +00003083 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
3084 // FIXME: Support Sparc quad-precision long double?
Eli Friedmane6a24e82011-12-22 03:51:45 +00003085 BigEndian = false;
Eli Friedmaned855cb2008-08-21 00:13:15 +00003086 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 +00003087 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedman01b86682008-08-20 07:28:14 +00003088 }
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003089 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
3090 const std::string &Name,
3091 bool Enabled) const {
3092 if (Name == "soft-float")
3093 Features[Name] = Enabled;
3094 else
3095 return false;
3096
3097 return true;
3098 }
3099 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
3100 SoftFloat = false;
3101 for (unsigned i = 0, e = Features.size(); i != e; ++i)
3102 if (Features[i] == "+soft-float")
3103 SoftFloat = true;
3104 }
Chris Lattner33328642009-03-20 15:52:06 +00003105 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003106 MacroBuilder &Builder) const {
3107 DefineStd(Builder, "sparc", Opts);
3108 Builder.defineMacro("__sparcv8");
3109 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003110
3111 if (SoftFloat)
3112 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00003113 }
3114 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3115 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003116 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00003117 }
3118 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00003119 return "typedef void* __builtin_va_list;";
Gabor Greif26658672008-02-21 16:29:08 +00003120 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003121 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003122 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003123 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003124 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003125 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00003126 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003127 // FIXME: Implement!
3128 return false;
Gabor Greif26658672008-02-21 16:29:08 +00003129 }
3130 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00003131 // FIXME: Implement!
3132 return "";
Gabor Greif26658672008-02-21 16:29:08 +00003133 }
3134};
3135
Chris Lattnere957f532009-01-27 01:58:38 +00003136const char * const SparcV8TargetInfo::GCCRegNames[] = {
3137 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3138 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3139 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3140 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
3141};
3142
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003143void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003144 unsigned &NumNames) const {
3145 Names = GCCRegNames;
3146 NumNames = llvm::array_lengthof(GCCRegNames);
3147}
3148
3149const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003150 { { "g0" }, "r0" },
3151 { { "g1" }, "r1" },
3152 { { "g2" }, "r2" },
3153 { { "g3" }, "r3" },
3154 { { "g4" }, "r4" },
3155 { { "g5" }, "r5" },
3156 { { "g6" }, "r6" },
3157 { { "g7" }, "r7" },
3158 { { "o0" }, "r8" },
3159 { { "o1" }, "r9" },
3160 { { "o2" }, "r10" },
3161 { { "o3" }, "r11" },
3162 { { "o4" }, "r12" },
3163 { { "o5" }, "r13" },
3164 { { "o6", "sp" }, "r14" },
3165 { { "o7" }, "r15" },
3166 { { "l0" }, "r16" },
3167 { { "l1" }, "r17" },
3168 { { "l2" }, "r18" },
3169 { { "l3" }, "r19" },
3170 { { "l4" }, "r20" },
3171 { { "l5" }, "r21" },
3172 { { "l6" }, "r22" },
3173 { { "l7" }, "r23" },
3174 { { "i0" }, "r24" },
3175 { { "i1" }, "r25" },
3176 { { "i2" }, "r26" },
3177 { { "i3" }, "r27" },
3178 { { "i4" }, "r28" },
3179 { { "i5" }, "r29" },
3180 { { "i6", "fp" }, "r30" },
3181 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00003182};
3183
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003184void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003185 unsigned &NumAliases) const {
3186 Aliases = GCCRegAliases;
3187 NumAliases = llvm::array_lengthof(GCCRegAliases);
3188}
Gabor Greif26658672008-02-21 16:29:08 +00003189} // end anonymous namespace.
3190
Eli Friedman01b86682008-08-20 07:28:14 +00003191namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003192class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
3193public:
3194 AuroraUXSparcV8TargetInfo(const std::string& triple) :
3195 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
3196 SizeType = UnsignedInt;
3197 PtrDiffType = SignedInt;
3198 }
3199};
Torok Edwin5f6c1942009-06-30 17:10:35 +00003200class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00003201public:
3202 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003203 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00003204 SizeType = UnsignedInt;
3205 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00003206 }
3207};
3208} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00003209
Chris Lattner2621fd12008-05-08 05:58:21 +00003210namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003211 class MSP430TargetInfo : public TargetInfo {
3212 static const char * const GCCRegNames[];
3213 public:
3214 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003215 BigEndian = false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003216 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00003217 IntWidth = 16; IntAlign = 16;
3218 LongWidth = 32; LongLongWidth = 64;
3219 LongAlign = LongLongAlign = 16;
3220 PointerWidth = 16; PointerAlign = 16;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003221 SuitableAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003222 SizeType = UnsignedInt;
3223 IntMaxType = SignedLong;
3224 UIntMaxType = UnsignedLong;
3225 IntPtrType = SignedShort;
3226 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00003227 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00003228 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003229 }
3230 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003231 MacroBuilder &Builder) const {
3232 Builder.defineMacro("MSP430");
3233 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003234 // FIXME: defines for different 'flavours' of MCU
3235 }
3236 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3237 unsigned &NumRecords) const {
3238 // FIXME: Implement.
3239 Records = 0;
3240 NumRecords = 0;
3241 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003242 virtual void getGCCRegNames(const char * const *&Names,
3243 unsigned &NumNames) const;
3244 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3245 unsigned &NumAliases) const {
3246 // No aliases.
3247 Aliases = 0;
3248 NumAliases = 0;
3249 }
3250 virtual bool validateAsmConstraint(const char *&Name,
3251 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00003252 // No target constraints for now.
3253 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003254 }
3255 virtual const char *getClobbers() const {
3256 // FIXME: Is this really right?
3257 return "";
3258 }
3259 virtual const char *getVAListDeclaration() const {
3260 // FIXME: implement
Anton Korobeynikoveb716852009-05-08 18:24:57 +00003261 return "typedef char* __builtin_va_list;";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003262 }
3263 };
3264
3265 const char * const MSP430TargetInfo::GCCRegNames[] = {
3266 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3267 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3268 };
3269
3270 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
3271 unsigned &NumNames) const {
3272 Names = GCCRegNames;
3273 NumNames = llvm::array_lengthof(GCCRegNames);
3274 }
3275}
3276
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00003277namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00003278
Mike Stump1eb44332009-09-09 15:08:12 +00003279 // LLVM and Clang cannot be used directly to output native binaries for
3280 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00003281 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00003282 //
3283 // TCE uses the llvm bitcode as input and uses it for generating customized
3284 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00003285 // publicly available in http://tce.cs.tut.fi
3286
Eli Friedman209f5bb2011-10-07 19:51:42 +00003287 static const unsigned TCEOpenCLAddrSpaceMap[] = {
3288 3, // opencl_global
3289 4, // opencl_local
3290 5 // opencl_constant
3291 };
3292
Eli Friedmanb63decf2009-08-19 20:47:07 +00003293 class TCETargetInfo : public TargetInfo{
3294 public:
3295 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
3296 TLSSupported = false;
3297 IntWidth = 32;
3298 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003299 PointerWidth = 32;
3300 IntAlign = 32;
3301 LongAlign = LongLongAlign = 32;
3302 PointerAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003303 SuitableAlign = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003304 SizeType = UnsignedInt;
3305 IntMaxType = SignedLong;
3306 UIntMaxType = UnsignedLong;
3307 IntPtrType = SignedInt;
3308 PtrDiffType = SignedInt;
3309 FloatWidth = 32;
3310 FloatAlign = 32;
3311 DoubleWidth = 32;
3312 DoubleAlign = 32;
3313 LongDoubleWidth = 32;
3314 LongDoubleAlign = 32;
3315 FloatFormat = &llvm::APFloat::IEEEsingle;
3316 DoubleFormat = &llvm::APFloat::IEEEsingle;
3317 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00003318 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
3319 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00003320 "f32:32:32-f64:32:32-v64:32:32-"
3321 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00003322 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003323 }
3324
3325 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003326 MacroBuilder &Builder) const {
3327 DefineStd(Builder, "tce", Opts);
3328 Builder.defineMacro("__TCE__");
3329 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00003330 }
3331 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3332 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00003333 virtual const char *getClobbers() const {
3334 return "";
3335 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003336 virtual const char *getVAListDeclaration() const {
3337 return "typedef void* __builtin_va_list;";
3338 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003339 virtual void getGCCRegNames(const char * const *&Names,
3340 unsigned &NumNames) const {}
3341 virtual bool validateAsmConstraint(const char *&Name,
3342 TargetInfo::ConstraintInfo &info) const {
3343 return true;
3344 }
3345 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3346 unsigned &NumAliases) const {}
3347 };
3348}
3349
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003350namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003351class MipsTargetInfoBase : public TargetInfo {
3352 std::string CPU;
3353protected:
3354 std::string ABI;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003355public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003356 MipsTargetInfoBase(const std::string& triple, const std::string& ABIStr)
Akira Hatanaka148735e2011-11-05 01:48:34 +00003357 : TargetInfo(triple), ABI(ABIStr) {}
Eric Christophered734732010-03-02 02:41:08 +00003358 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003359 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00003360 virtual bool setCPU(const std::string &Name) {
3361 CPU = Name;
3362 return true;
3363 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003364 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00003365 Features[ABI] = true;
3366 Features[CPU] = true;
3367 }
3368 virtual void getArchDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003369 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003370 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003371 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003372 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3373 unsigned &NumRecords) const {
3374 // FIXME: Implement!
3375 }
3376 virtual const char *getVAListDeclaration() const {
3377 return "typedef void* __builtin_va_list;";
3378 }
3379 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003380 unsigned &NumNames) const {
3381 static const char * const GCCRegNames[] = {
3382 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
3383 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
3384 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
3385 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
3386 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
3387 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
3388 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
3389 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
3390 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
3391 "$fcc5","$fcc6","$fcc7"
3392 };
3393 Names = GCCRegNames;
3394 NumNames = llvm::array_lengthof(GCCRegNames);
3395 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003396 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003397 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003398 virtual bool validateAsmConstraint(const char *&Name,
3399 TargetInfo::ConstraintInfo &Info) const {
3400 switch (*Name) {
3401 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00003402 return false;
3403
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003404 case 'r': // CPU registers.
3405 case 'd': // Equivalent to "r" unless generating MIPS16 code.
3406 case 'y': // Equivalent to "r", backwards compatibility only.
3407 case 'f': // floating-point registers.
3408 Info.setAllowsRegister();
3409 return true;
3410 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003411 }
3412
3413 virtual const char *getClobbers() const {
3414 // FIXME: Implement!
3415 return "";
3416 }
3417};
3418
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003419class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003420public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003421 Mips32TargetInfoBase(const std::string& triple) :
Akira Hatanaka148735e2011-11-05 01:48:34 +00003422 MipsTargetInfoBase(triple, "o32") {
3423 SizeType = UnsignedInt;
3424 PtrDiffType = SignedInt;
3425 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003426 virtual bool setABI(const std::string &Name) {
3427 if ((Name == "o32") || (Name == "eabi")) {
3428 ABI = Name;
3429 return true;
3430 } else
3431 return false;
3432 }
3433 virtual void getArchDefines(const LangOptions &Opts,
3434 MacroBuilder &Builder) const {
Douglas Gregorc9a23712011-11-09 15:17:16 +00003435 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
3436 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
3437 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
3438
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003439 if (ABI == "o32") {
3440 Builder.defineMacro("__mips_o32");
3441 Builder.defineMacro("_ABIO32", "1");
3442 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
3443 }
3444 else if (ABI == "eabi")
3445 Builder.defineMacro("__mips_eabi");
3446 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003447 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003448 }
3449 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3450 unsigned &NumAliases) const {
3451 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3452 { { "at" }, "$1" },
3453 { { "v0" }, "$2" },
3454 { { "v1" }, "$3" },
3455 { { "a0" }, "$4" },
3456 { { "a1" }, "$5" },
3457 { { "a2" }, "$6" },
3458 { { "a3" }, "$7" },
3459 { { "t0" }, "$8" },
3460 { { "t1" }, "$9" },
3461 { { "t2" }, "$10" },
3462 { { "t3" }, "$11" },
3463 { { "t4" }, "$12" },
3464 { { "t5" }, "$13" },
3465 { { "t6" }, "$14" },
3466 { { "t7" }, "$15" },
3467 { { "s0" }, "$16" },
3468 { { "s1" }, "$17" },
3469 { { "s2" }, "$18" },
3470 { { "s3" }, "$19" },
3471 { { "s4" }, "$20" },
3472 { { "s5" }, "$21" },
3473 { { "s6" }, "$22" },
3474 { { "s7" }, "$23" },
3475 { { "t8" }, "$24" },
3476 { { "t9" }, "$25" },
3477 { { "k0" }, "$26" },
3478 { { "k1" }, "$27" },
3479 { { "gp" }, "$28" },
3480 { { "sp" }, "$29" },
3481 { { "fp" }, "$30" },
3482 { { "ra" }, "$31" }
3483 };
3484 Aliases = GCCRegAliases;
3485 NumAliases = llvm::array_lengthof(GCCRegAliases);
3486 }
3487};
3488
3489class Mips32EBTargetInfo : public Mips32TargetInfoBase {
3490public:
3491 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
3492 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3493 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3494 }
3495 virtual void getTargetDefines(const LangOptions &Opts,
3496 MacroBuilder &Builder) const {
3497 DefineStd(Builder, "mips", Opts);
3498 Builder.defineMacro("_mips");
3499 DefineStd(Builder, "MIPSEB", Opts);
3500 Builder.defineMacro("_MIPSEB");
3501 Builder.defineMacro("__REGISTER_PREFIX__", "");
3502 getArchDefines(Opts, Builder);
3503 }
3504};
3505
3506class Mips32ELTargetInfo : public Mips32TargetInfoBase {
3507public:
3508 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003509 BigEndian = false;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003510 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 +00003511 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003512 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003513 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003514 MacroBuilder &Builder) const {
3515 DefineStd(Builder, "mips", Opts);
3516 Builder.defineMacro("_mips");
3517 DefineStd(Builder, "MIPSEL", Opts);
3518 Builder.defineMacro("_MIPSEL");
3519 Builder.defineMacro("__REGISTER_PREFIX__", "");
3520 getArchDefines(Opts, Builder);
3521 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003522};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003523
3524class Mips64TargetInfoBase : public MipsTargetInfoBase {
3525 virtual void SetDescriptionString(const std::string &Name) = 0;
3526public:
3527 Mips64TargetInfoBase(const std::string& triple) :
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003528 MipsTargetInfoBase(triple, "n64") {
3529 LongWidth = LongAlign = 64;
3530 PointerWidth = PointerAlign = 64;
3531 LongDoubleWidth = LongDoubleAlign = 128;
3532 LongDoubleFormat = &llvm::APFloat::IEEEquad;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003533 SuitableAlign = 128;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003534 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003535 virtual bool setABI(const std::string &Name) {
3536 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003537
3538 if (Name != "n32" && Name != "n64")
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003539 return false;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003540
3541 ABI = Name;
3542
3543 if (Name == "n32") {
3544 LongWidth = LongAlign = 32;
3545 PointerWidth = PointerAlign = 32;
3546 }
3547
3548 return true;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003549 }
3550 virtual void getArchDefines(const LangOptions &Opts,
3551 MacroBuilder &Builder) const {
3552 if (ABI == "n32") {
3553 Builder.defineMacro("__mips_n32");
3554 Builder.defineMacro("_ABIN32", "2");
3555 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
3556 }
3557 else if (ABI == "n64") {
3558 Builder.defineMacro("__mips_n64");
3559 Builder.defineMacro("_ABI64", "3");
3560 Builder.defineMacro("_MIPS_SIM", "_ABI64");
3561 }
3562 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003563 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003564 }
3565 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3566 unsigned &NumAliases) const {
3567 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3568 { { "at" }, "$1" },
3569 { { "v0" }, "$2" },
3570 { { "v1" }, "$3" },
3571 { { "a0" }, "$4" },
3572 { { "a1" }, "$5" },
3573 { { "a2" }, "$6" },
3574 { { "a3" }, "$7" },
3575 { { "a4" }, "$8" },
3576 { { "a5" }, "$9" },
3577 { { "a6" }, "$10" },
3578 { { "a7" }, "$11" },
3579 { { "t0" }, "$12" },
3580 { { "t1" }, "$13" },
3581 { { "t2" }, "$14" },
3582 { { "t3" }, "$15" },
3583 { { "s0" }, "$16" },
3584 { { "s1" }, "$17" },
3585 { { "s2" }, "$18" },
3586 { { "s3" }, "$19" },
3587 { { "s4" }, "$20" },
3588 { { "s5" }, "$21" },
3589 { { "s6" }, "$22" },
3590 { { "s7" }, "$23" },
3591 { { "t8" }, "$24" },
3592 { { "t9" }, "$25" },
3593 { { "k0" }, "$26" },
3594 { { "k1" }, "$27" },
3595 { { "gp" }, "$28" },
3596 { { "sp" }, "$29" },
3597 { { "fp" }, "$30" },
3598 { { "ra" }, "$31" }
3599 };
3600 Aliases = GCCRegAliases;
3601 NumAliases = llvm::array_lengthof(GCCRegAliases);
3602 }
3603};
3604
3605class Mips64EBTargetInfo : public Mips64TargetInfoBase {
3606 virtual void SetDescriptionString(const std::string &Name) {
3607 // Change DescriptionString only if ABI is n32.
3608 if (Name == "n32")
3609 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 +00003610 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3611 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003612 }
3613public:
3614 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3615 // Default ABI is n64.
3616 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 +00003617 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3618 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003619 }
3620 virtual void getTargetDefines(const LangOptions &Opts,
3621 MacroBuilder &Builder) const {
3622 DefineStd(Builder, "mips", Opts);
3623 Builder.defineMacro("_mips");
3624 DefineStd(Builder, "MIPSEB", Opts);
3625 Builder.defineMacro("_MIPSEB");
3626 Builder.defineMacro("__REGISTER_PREFIX__", "");
3627 getArchDefines(Opts, Builder);
3628 }
3629};
3630
3631class Mips64ELTargetInfo : public Mips64TargetInfoBase {
3632 virtual void SetDescriptionString(const std::string &Name) {
3633 // Change DescriptionString only if ABI is n32.
3634 if (Name == "n32")
3635 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 +00003636 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
3637 "-v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003638 }
3639public:
3640 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003641 // Default ABI is n64.
3642 BigEndian = false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003643 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 +00003644 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3645 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003646 }
3647 virtual void getTargetDefines(const LangOptions &Opts,
3648 MacroBuilder &Builder) const {
3649 DefineStd(Builder, "mips", Opts);
3650 Builder.defineMacro("_mips");
3651 DefineStd(Builder, "MIPSEL", Opts);
3652 Builder.defineMacro("_MIPSEL");
3653 Builder.defineMacro("__REGISTER_PREFIX__", "");
3654 getArchDefines(Opts, Builder);
3655 }
3656};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003657} // end anonymous namespace.
3658
Ivan Krasinef05abd2011-08-24 20:22:22 +00003659namespace {
3660class PNaClTargetInfo : public TargetInfo {
3661public:
3662 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003663 BigEndian = false;
Ivan Krasinef05abd2011-08-24 20:22:22 +00003664 this->UserLabelPrefix = "";
3665 this->LongAlign = 32;
3666 this->LongWidth = 32;
3667 this->PointerAlign = 32;
3668 this->PointerWidth = 32;
3669 this->IntMaxType = TargetInfo::SignedLongLong;
3670 this->UIntMaxType = TargetInfo::UnsignedLongLong;
3671 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003672 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003673 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003674 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003675 this->SizeType = TargetInfo::UnsignedInt;
3676 this->PtrDiffType = TargetInfo::SignedInt;
3677 this->IntPtrType = TargetInfo::SignedInt;
David Meyerdd4a8892011-10-11 03:12:01 +00003678 this->RegParmMax = 2;
Ivan Krasinef05abd2011-08-24 20:22:22 +00003679 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
3680 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
3681 }
3682
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003683 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00003684 }
3685 virtual void getArchDefines(const LangOptions &Opts,
3686 MacroBuilder &Builder) const {
3687 Builder.defineMacro("__le32__");
3688 Builder.defineMacro("__pnacl__");
3689 }
3690 virtual void getTargetDefines(const LangOptions &Opts,
3691 MacroBuilder &Builder) const {
Ivan Krasin089ee112011-08-25 23:49:20 +00003692 DefineStd(Builder, "unix", Opts);
3693 Builder.defineMacro("__ELF__");
3694 if (Opts.POSIXThreads)
3695 Builder.defineMacro("_REENTRANT");
3696 if (Opts.CPlusPlus)
3697 Builder.defineMacro("_GNU_SOURCE");
3698
Ivan Krasinef05abd2011-08-24 20:22:22 +00003699 Builder.defineMacro("__native_client__");
3700 getArchDefines(Opts, Builder);
3701 }
3702 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3703 unsigned &NumRecords) const {
3704 }
3705 virtual const char *getVAListDeclaration() const {
Ivan Krasin68018db2011-09-20 14:56:54 +00003706 return "typedef int __builtin_va_list[4];";
Ivan Krasinef05abd2011-08-24 20:22:22 +00003707 }
3708 virtual void getGCCRegNames(const char * const *&Names,
3709 unsigned &NumNames) const;
3710 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3711 unsigned &NumAliases) const;
3712 virtual bool validateAsmConstraint(const char *&Name,
3713 TargetInfo::ConstraintInfo &Info) const {
3714 return false;
3715 }
3716
3717 virtual const char *getClobbers() const {
3718 return "";
3719 }
3720};
3721
3722void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
3723 unsigned &NumNames) const {
3724 Names = NULL;
3725 NumNames = 0;
3726}
3727
3728void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3729 unsigned &NumAliases) const {
3730 Aliases = NULL;
3731 NumAliases = 0;
3732}
3733} // end anonymous namespace.
3734
3735
Reid Spencer5f016e22007-07-11 17:01:13 +00003736//===----------------------------------------------------------------------===//
3737// Driver code
3738//===----------------------------------------------------------------------===//
3739
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003740static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003741 llvm::Triple Triple(T);
3742 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00003743
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003744 switch (Triple.getArch()) {
3745 default:
3746 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00003747
Tony Linthicum96319392011-12-12 21:14:55 +00003748 case llvm::Triple::hexagon:
3749 return new HexagonTargetInfo(T);
3750
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003751 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00003752 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003753 if (Triple.isOSDarwin())
3754 return new DarwinARMTargetInfo(T);
3755
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003756 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00003757 case llvm::Triple::Linux:
3758 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003759 case llvm::Triple::FreeBSD:
Torok Edwin5f6c1942009-06-30 17:10:35 +00003760 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003761 case llvm::Triple::NetBSD:
3762 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003763 case llvm::Triple::RTEMS:
3764 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003765 default:
3766 return new ARMTargetInfo(T);
3767 }
Eli Friedman61538a72008-05-20 14:21:01 +00003768
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003769 case llvm::Triple::msp430:
3770 return new MSP430TargetInfo(T);
Eli Friedman61538a72008-05-20 14:21:01 +00003771
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003772 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003773 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003774 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003775 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003776 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003777 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003778 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003779 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003780 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003781 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003782 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003783 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003784 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003785
3786 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003787 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003788 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003789 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003790 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003791 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003792 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003793 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003794 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003795 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003796 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003797 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003798 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003799
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003800 case llvm::Triple::mips64:
3801 switch (os) {
3802 case llvm::Triple::Linux:
3803 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
3804 case llvm::Triple::RTEMS:
3805 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
3806 case llvm::Triple::FreeBSD:
3807 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
3808 case llvm::Triple::NetBSD:
3809 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
3810 default:
3811 return new Mips64EBTargetInfo(T);
3812 }
3813
3814 case llvm::Triple::mips64el:
3815 switch (os) {
3816 case llvm::Triple::Linux:
3817 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
3818 case llvm::Triple::RTEMS:
3819 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
3820 case llvm::Triple::FreeBSD:
3821 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
3822 case llvm::Triple::NetBSD:
3823 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
3824 default:
3825 return new Mips64ELTargetInfo(T);
3826 }
3827
Ivan Krasinef05abd2011-08-24 20:22:22 +00003828 case llvm::Triple::le32:
3829 switch (os) {
3830 case llvm::Triple::NativeClient:
3831 return new PNaClTargetInfo(T);
3832 default:
3833 return NULL;
3834 }
3835
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003836 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003837 if (Triple.isOSDarwin())
Roman Divackyc81f2a22011-01-06 08:27:10 +00003838 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003839 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003840 case llvm::Triple::Linux:
3841 return new LinuxTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003842 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00003843 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003844 case llvm::Triple::NetBSD:
3845 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
3846 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003847 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003848 default:
3849 return new PPC32TargetInfo(T);
3850 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003851
3852 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003853 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00003854 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003855 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003856 case llvm::Triple::Linux:
3857 return new LinuxTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003858 case llvm::Triple::Lv2:
John Thompson3f6918a2009-11-19 17:18:50 +00003859 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003860 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00003861 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003862 case llvm::Triple::NetBSD:
3863 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
3864 default:
3865 return new PPC64TargetInfo(T);
3866 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003867
Justin Holewinski285dc652011-04-20 19:34:15 +00003868 case llvm::Triple::ptx32:
3869 return new PTX32TargetInfo(T);
3870 case llvm::Triple::ptx64:
3871 return new PTX64TargetInfo(T);
3872
Chris Lattner9cbeb632010-03-06 21:21:27 +00003873 case llvm::Triple::mblaze:
3874 return new MBlazeTargetInfo(T);
3875
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003876 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003877 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003878 case llvm::Triple::Linux:
3879 return new LinuxTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003880 case llvm::Triple::AuroraUX:
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003881 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003882 case llvm::Triple::Solaris:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003883 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003884 case llvm::Triple::NetBSD:
3885 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
3886 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003887 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003888 default:
3889 return new SparcV8TargetInfo(T);
3890 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003891
John Thompson3f6918a2009-11-19 17:18:50 +00003892 // FIXME: Need a real SPU target.
3893 case llvm::Triple::cellspu:
3894 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
3895
Eli Friedmanb63decf2009-08-19 20:47:07 +00003896 case llvm::Triple::tce:
3897 return new TCETargetInfo(T);
3898
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003899 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003900 if (Triple.isOSDarwin())
3901 return new DarwinI386TargetInfo(T);
3902
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003903 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003904 case llvm::Triple::AuroraUX:
3905 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003906 case llvm::Triple::Linux:
3907 return new LinuxTargetInfo<X86_32TargetInfo>(T);
3908 case llvm::Triple::DragonFly:
3909 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
3910 case llvm::Triple::NetBSD:
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00003911 return new NetBSDI386TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003912 case llvm::Triple::OpenBSD:
3913 return new OpenBSDI386TargetInfo(T);
3914 case llvm::Triple::FreeBSD:
3915 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner38e317d2010-07-07 16:01:42 +00003916 case llvm::Triple::Minix:
3917 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003918 case llvm::Triple::Solaris:
3919 return new SolarisTargetInfo<X86_32TargetInfo>(T);
3920 case llvm::Triple::Cygwin:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003921 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003922 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003923 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003924 case llvm::Triple::Win32:
Michael J. Spencera764e832010-10-21 08:22:51 +00003925 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattner86ed3a32010-04-11 19:29:39 +00003926 case llvm::Triple::Haiku:
3927 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003928 case llvm::Triple::RTEMS:
3929 return new RTEMSX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003930 default:
3931 return new X86_32TargetInfo(T);
3932 }
3933
3934 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003935 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
3936 return new DarwinX86_64TargetInfo(T);
3937
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003938 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003939 case llvm::Triple::AuroraUX:
3940 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003941 case llvm::Triple::Linux:
3942 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner7a7ca282010-01-09 05:41:14 +00003943 case llvm::Triple::DragonFly:
3944 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003945 case llvm::Triple::NetBSD:
3946 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
3947 case llvm::Triple::OpenBSD:
3948 return new OpenBSDX86_64TargetInfo(T);
3949 case llvm::Triple::FreeBSD:
3950 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
3951 case llvm::Triple::Solaris:
3952 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00003953 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003954 return new MinGWX86_64TargetInfo(T);
3955 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003956 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003957 default:
3958 return new X86_64TargetInfo(T);
3959 }
3960 }
Reid Spencer5f016e22007-07-11 17:01:13 +00003961}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003962
3963/// CreateTargetInfo - Return the target info object for the specified target
3964/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00003965TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Daniel Dunbarb93292a2009-12-19 03:30:57 +00003966 TargetOptions &Opts) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003967 llvm::Triple Triple(Opts.Triple);
3968
3969 // Construct the target
3970 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
3971 if (!Target) {
3972 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
3973 return 0;
3974 }
3975
Daniel Dunbareac7c532009-12-18 18:42:37 +00003976 // Set the target CPU if specified.
3977 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
3978 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
3979 return 0;
3980 }
3981
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003982 // Set the target ABI if specified.
3983 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
3984 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
3985 return 0;
3986 }
3987
Charles Davis98b7c5c2010-06-11 01:06:47 +00003988 // Set the target C++ ABI.
John McCallee79a4c2010-08-21 22:46:04 +00003989 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davis98b7c5c2010-06-11 01:06:47 +00003990 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
3991 return 0;
3992 }
3993
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003994 // Compute the default target features, we need the target to handle this
3995 // because features may have dependencies on one another.
3996 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003997 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003998
3999 // Apply the user specified deltas.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004000 // First the enables.
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004001 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
4002 ie = Opts.Features.end(); it != ie; ++it) {
4003 const char *Name = it->c_str();
4004
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004005 if (Name[0] != '+')
4006 continue;
4007
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004008 // Apply the feature via the target.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004009 if (!Target->setFeatureEnabled(Features, Name + 1, true)) {
4010 Diags.Report(diag::err_target_invalid_feature) << Name;
4011 return 0;
4012 }
4013 }
4014
4015 // Then the disables.
4016 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
4017 ie = Opts.Features.end(); it != ie; ++it) {
4018 const char *Name = it->c_str();
4019
4020 if (Name[0] == '+')
4021 continue;
4022
4023 // Apply the feature via the target.
4024 if (Name[0] != '-' ||
4025 !Target->setFeatureEnabled(Features, Name + 1, false)) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004026 Diags.Report(diag::err_target_invalid_feature) << Name;
4027 return 0;
4028 }
4029 }
4030
4031 // Add the features to the compile options.
4032 //
4033 // FIXME: If we are completely confident that we have the right set, we only
4034 // need to pass the minuses.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004035 Opts.Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004036 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
4037 ie = Features.end(); it != ie; ++it)
Chris Lattner1e5f83b2011-07-14 18:24:21 +00004038 Opts.Features.push_back(std::string(it->second ? "+" : "-") +
Chris Lattner48b78bd2011-07-14 18:45:41 +00004039 it->first().str());
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004040 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004041
4042 return Target.take();
4043}