blob: adca2633b5b6a8491c97b5bbde7e7b1400200675 [file] [log] [blame]
Chris Lattner4b009652007-07-25 00:24:17 +00001//===--- Targets.cpp - Implement -arch option and targets -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner959e5be2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner4b009652007-07-25 00:24:17 +00007//
8//===----------------------------------------------------------------------===//
9//
Anton Korobeynikove7772382009-05-03 13:42:53 +000010// This file implements construction of a TargetInfo object from a
Ted Kremenek38591a22007-12-12 18:05:32 +000011// target triple.
Chris Lattner4b009652007-07-25 00:24:17 +000012//
13//===----------------------------------------------------------------------===//
14
Chris Lattner4b009652007-07-25 00:24:17 +000015#include "clang/Basic/TargetInfo.h"
Daniel Dunbarca3e9912009-11-15 06:48:46 +000016#include "clang/Basic/Builtins.h"
17#include "clang/Basic/Diagnostic.h"
Chris Lattnerddae7102008-12-04 22:54:33 +000018#include "clang/Basic/LangOptions.h"
Chandler Carrutha088d5b2010-01-20 06:13:02 +000019#include "clang/Basic/MacroBuilder.h"
Daniel Dunbarca3e9912009-11-15 06:48:46 +000020#include "clang/Basic/TargetBuiltins.h"
21#include "clang/Basic/TargetOptions.h"
Eli Friedmand4011892008-05-20 14:27:34 +000022#include "llvm/ADT/APFloat.h"
Daniel Dunbarca3e9912009-11-15 06:48:46 +000023#include "llvm/ADT/OwningPtr.h"
Daniel Dunbar8dd8f262009-11-11 09:38:56 +000024#include "llvm/ADT/STLExtras.h"
Daniel Dunbar0433a022009-08-19 20:04:03 +000025#include "llvm/ADT/StringRef.h"
Daniel Dunbar8dd8f262009-11-11 09:38:56 +000026#include "llvm/ADT/StringSwitch.h"
Chris Lattnerf54f2212009-08-12 06:24:27 +000027#include "llvm/ADT/Triple.h"
Chris Lattner43954312009-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 Johannesen8fa024c2010-10-29 23:24:33 +000030#include "llvm/Type.h"
Benjamin Kramerf8a85782010-01-09 18:20:57 +000031#include <algorithm>
Chris Lattner4b009652007-07-25 00:24:17 +000032using namespace clang;
33
Chris Lattner4b009652007-07-25 00:24:17 +000034//===----------------------------------------------------------------------===//
35// Common code shared among targets.
36//===----------------------------------------------------------------------===//
37
Chris Lattnerc345a802009-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 Lattnerc345a802009-03-20 16:06:38 +000042 const LangOptions &Opts) {
43 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikove7772382009-05-03 13:42:53 +000044
Chris Lattnerc345a802009-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 Kramer9ffb10432010-01-09 17:55:51 +000048 Builder.defineMacro(MacroName);
Anton Korobeynikove7772382009-05-03 13:42:53 +000049
Chris Lattnerc345a802009-03-20 16:06:38 +000050 // Define __unix.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000051 Builder.defineMacro("__" + MacroName);
Anton Korobeynikove7772382009-05-03 13:42:53 +000052
Chris Lattnerc345a802009-03-20 16:06:38 +000053 // Define __unix__.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000054 Builder.defineMacro("__" + MacroName + "__");
Chris Lattnerc345a802009-03-20 16:06:38 +000055}
56
Chris Lattnerbd00eb82008-10-05 21:50:58 +000057//===----------------------------------------------------------------------===//
58// Defines specific to certain operating systems.
59//===----------------------------------------------------------------------===//
Chris Lattner43954312009-08-10 19:03:04 +000060
Edwin Török36565e52009-06-30 17:10:35 +000061namespace {
Douglas Gregor937331f2009-07-01 15:12:53 +000062template<typename TgtInfo>
63class OSTargetInfo : public TgtInfo {
Edwin Török36565e52009-06-30 17:10:35 +000064protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +000065 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000066 MacroBuilder &Builder) const=0;
Edwin Török36565e52009-06-30 17:10:35 +000067public:
Douglas Gregor937331f2009-07-01 15:12:53 +000068 OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
Edwin Török36565e52009-06-30 17:10:35 +000069 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000070 MacroBuilder &Builder) const {
71 TgtInfo::getTargetDefines(Opts, Builder);
72 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Edwin Török2d98f9f2009-06-30 17:00:25 +000073 }
Edwin Török36565e52009-06-30 17:10:35 +000074
75};
Chris Lattnerf54f2212009-08-12 06:24:27 +000076} // end anonymous namespace
Edwin Török2d98f9f2009-06-30 17:00:25 +000077
Chris Lattner43954312009-08-10 19:03:04 +000078
Daniel Dunbareab96a22010-01-26 01:44:04 +000079static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +000080 const llvm::Triple &Triple,
Chris Lattner5f9e2722011-07-23 10:55:15 +000081 StringRef &PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +000082 VersionTuple &PlatformMinVersion) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000083 Builder.defineMacro("__APPLE_CC__", "5621");
84 Builder.defineMacro("__APPLE__");
85 Builder.defineMacro("__MACH__");
86 Builder.defineMacro("OBJC_NEW_PROPERTIES");
Anton Korobeynikove7772382009-05-03 13:42:53 +000087
John McCall098df7f2011-06-16 00:03:19 +000088 if (!Opts.ObjCAutoRefCount) {
John McCallf85e1932011-06-15 23:02:42 +000089 // __weak is always defined, for use in blocks and with objc pointers.
90 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikove7772382009-05-03 13:42:53 +000091
John McCallf85e1932011-06-15 23:02:42 +000092 // Darwin defines __strong even in C mode (just to nothing).
Douglas Gregore289d812011-09-13 17:21:33 +000093 if (Opts.getGC() != LangOptions::NonGC)
John McCallf85e1932011-06-15 23:02:42 +000094 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
95 else
96 Builder.defineMacro("__strong", "");
Eric Christopher7c9adf92011-07-07 22:55:26 +000097
John McCallf85e1932011-06-15 23:02:42 +000098 // __unsafe_unretained is defined to nothing in non-ARC mode. We even
99 // allow this in C, since one might have block pointers in structs that
100 // are used in pure C code and in Objective-C ARC.
101 Builder.defineMacro("__unsafe_unretained", "");
Eric Christopher7c9adf92011-07-07 22:55:26 +0000102
John McCallf85e1932011-06-15 23:02:42 +0000103 // The Objective-C bridged cast keywords are defined to nothing in non-ARC
104 // mode; then they become normal, C-style casts.
105 Builder.defineMacro("__bridge", "");
106 Builder.defineMacro("__bridge_transfer", "");
107 Builder.defineMacro("__bridge_retained", "");
John McCall18164422011-06-17 21:23:37 +0000108 Builder.defineMacro("__bridge_retain", "");
John McCallf85e1932011-06-15 23:02:42 +0000109 }
Eric Christopher7c9adf92011-07-07 22:55:26 +0000110
Eli Friedmaneff0a422009-06-04 23:00:29 +0000111 if (Opts.Static)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000112 Builder.defineMacro("__STATIC__");
Eli Friedmaneff0a422009-06-04 23:00:29 +0000113 else
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000114 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000115
116 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000117 Builder.defineMacro("_REENTRANT");
Daniel Dunbar93f64532009-04-10 19:52:24 +0000118
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000119 // Get the platform type and version number from the triple.
Daniel Dunbar93f64532009-04-10 19:52:24 +0000120 unsigned Maj, Min, Rev;
Mike Stump25cf7602009-09-09 15:08:12 +0000121
Daniel Dunbareab96a22010-01-26 01:44:04 +0000122 // If no version was given, default to to 10.4.0, for simplifying tests.
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000123 if (Triple.getOSName() == "darwin" || Triple.getOSName() == "osx") {
124 PlatformName = "macosx";
Daniel Dunbareab96a22010-01-26 01:44:04 +0000125 Min = Rev = 0;
126 Maj = 8;
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000127 } else {
128 // Otherwise, honor all three triple forms ("-darwinNNN[-iphoneos]",
129 // "-osxNNN", and "-iosNNN").
130
131 if (Triple.getOS() == llvm::Triple::Darwin) {
132 // For historical reasons that make little sense, the version passed here
133 // is the "darwin" version, which drops the 10 and offsets by 4.
134 Triple.getOSVersion(Maj, Min, Rev);
135
136 if (Triple.getEnvironmentName() == "iphoneos") {
137 PlatformName = "ios";
138 } else {
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000139 PlatformName = "macosx";
140 Rev = Min;
141 Min = Maj - 4;
142 Maj = 10;
143 }
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000144 } else {
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000145 Triple.getOSVersion(Maj, Min, Rev);
Daniel Dunbara4ff6482011-04-19 23:34:21 +0000146 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000147 }
148 }
Daniel Dunbareab96a22010-01-26 01:44:04 +0000149
Chad Rosierd9259f32011-07-19 20:00:06 +0000150 // If -ccc-host-triple arch-pc-win32-macho option specified, we're
Eric Christopher895d4222011-07-29 21:20:35 +0000151 // generating code for Win32 ABI. No need to emit
Chad Rosierd9259f32011-07-19 20:00:06 +0000152 // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
153 if (PlatformName == "win32") {
154 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
155 return;
156 }
157
Daniel Dunbareab96a22010-01-26 01:44:04 +0000158 // Set the appropriate OS version define.
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000159 if (PlatformName == "ios") {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000160 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbareab96a22010-01-26 01:44:04 +0000161 char Str[6];
162 Str[0] = '0' + Maj;
163 Str[1] = '0' + (Min / 10);
164 Str[2] = '0' + (Min % 10);
165 Str[3] = '0' + (Rev / 10);
166 Str[4] = '0' + (Rev % 10);
167 Str[5] = '\0';
168 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
169 } else {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000170 // Note that the Driver allows versions which aren't representable in the
171 // define (because we only get a single digit for the minor and micro
172 // revision numbers). So, we limit them to the maximum representable
173 // version.
Daniel Dunbareab96a22010-01-26 01:44:04 +0000174 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000175 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbareab96a22010-01-26 01:44:04 +0000176 char Str[5];
177 Str[0] = '0' + (Maj / 10);
178 Str[1] = '0' + (Maj % 10);
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000179 Str[2] = '0' + std::min(Min, 9U);
180 Str[3] = '0' + std::min(Rev, 9U);
Daniel Dunbareab96a22010-01-26 01:44:04 +0000181 Str[4] = '\0';
182 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar93f64532009-04-10 19:52:24 +0000183 }
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000184
185 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman872996c2008-08-20 02:34:37 +0000186}
Chris Lattner4b009652007-07-25 00:24:17 +0000187
Chris Lattner43954312009-08-10 19:03:04 +0000188namespace {
Edwin Török36565e52009-06-30 17:10:35 +0000189template<typename Target>
190class DarwinTargetInfo : public OSTargetInfo<Target> {
191protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000192 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000193 MacroBuilder &Builder) const {
Eric Christopher7c9adf92011-07-07 22:55:26 +0000194 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000195 this->PlatformMinVersion);
Edwin Török36565e52009-06-30 17:10:35 +0000196 }
Mike Stump25cf7602009-09-09 15:08:12 +0000197
Edwin Török36565e52009-06-30 17:10:35 +0000198public:
199 DarwinTargetInfo(const std::string& triple) :
200 OSTargetInfo<Target>(triple) {
Eric Christopheraa7333c2011-07-02 00:20:22 +0000201 llvm::Triple T = llvm::Triple(triple);
202 this->TLSSupported = T.isMacOSX() && !T.isMacOSXVersionLT(10,7);
Daniel Dunbare177d3b2011-02-21 23:12:51 +0000203 this->MCountName = "\01mcount";
Edwin Török36565e52009-06-30 17:10:35 +0000204 }
205
Chris Lattner5f9e2722011-07-23 10:55:15 +0000206 virtual std::string isValidSectionSpecifier(StringRef SR) const {
Chris Lattner43954312009-08-10 19:03:04 +0000207 // Let MCSectionMachO validate this.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000208 StringRef Segment, Section;
Chris Lattner43954312009-08-10 19:03:04 +0000209 unsigned TAA, StubSize;
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000210 bool HasTAA;
Chris Lattner43954312009-08-10 19:03:04 +0000211 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000212 TAA, HasTAA, StubSize);
Chris Lattner43954312009-08-10 19:03:04 +0000213 }
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000214
Anders Carlsson608b5792010-06-08 22:47:50 +0000215 virtual const char *getStaticInitSectionSpecifier() const {
216 // FIXME: We should return 0 when building kexts.
217 return "__TEXT,__StaticInit,regular,pure_instructions";
218 }
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000219
Edwin Török36565e52009-06-30 17:10:35 +0000220};
221
Chris Lattner43954312009-08-10 19:03:04 +0000222
Edwin Török36565e52009-06-30 17:10:35 +0000223// DragonFlyBSD Target
224template<typename Target>
225class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
226protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000227 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000228 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000229 // DragonFly defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000230 Builder.defineMacro("__DragonFly__");
231 Builder.defineMacro("__DragonFly_cc_version", "100001");
232 Builder.defineMacro("__ELF__");
233 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
234 Builder.defineMacro("__tune_i386__");
235 DefineStd(Builder, "unix", Opts);
Edwin Török36565e52009-06-30 17:10:35 +0000236 }
237public:
Mike Stump25cf7602009-09-09 15:08:12 +0000238 DragonFlyBSDTargetInfo(const std::string &triple)
Edwin Török36565e52009-06-30 17:10:35 +0000239 : OSTargetInfo<Target>(triple) {}
240};
241
242// FreeBSD Target
243template<typename Target>
244class FreeBSDTargetInfo : public OSTargetInfo<Target> {
245protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000246 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000247 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000248 // FreeBSD defines; list based off of gcc output
249
Benjamin Kramer474202f2011-10-18 10:10:08 +0000250 unsigned Release = Triple.getOSMajorVersion();
251 if (Release == 0U)
252 Release = 8;
Edwin Török36565e52009-06-30 17:10:35 +0000253
Benjamin Kramer474202f2011-10-18 10:10:08 +0000254 Builder.defineMacro("__FreeBSD__", Twine(Release));
255 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000256 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
257 DefineStd(Builder, "unix", Opts);
258 Builder.defineMacro("__ELF__");
Edwin Török36565e52009-06-30 17:10:35 +0000259 }
260public:
Mike Stump25cf7602009-09-09 15:08:12 +0000261 FreeBSDTargetInfo(const std::string &triple)
Duncan Sandscd2cb662009-07-08 13:55:08 +0000262 : OSTargetInfo<Target>(triple) {
263 this->UserLabelPrefix = "";
Roman Divackybe4c8702011-02-10 16:52:03 +0000264
265 llvm::Triple Triple(triple);
266 switch (Triple.getArch()) {
267 default:
268 case llvm::Triple::x86:
269 case llvm::Triple::x86_64:
270 this->MCountName = ".mcount";
271 break;
272 case llvm::Triple::mips:
273 case llvm::Triple::mipsel:
274 case llvm::Triple::ppc:
275 case llvm::Triple::ppc64:
276 this->MCountName = "_mcount";
277 break;
278 case llvm::Triple::arm:
279 this->MCountName = "__mcount";
280 break;
281 }
282
Duncan Sandscd2cb662009-07-08 13:55:08 +0000283 }
Edwin Török36565e52009-06-30 17:10:35 +0000284};
285
Chris Lattner6f4bed52010-07-07 16:01:42 +0000286// Minix Target
287template<typename Target>
288class MinixTargetInfo : public OSTargetInfo<Target> {
289protected:
290 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
291 MacroBuilder &Builder) const {
292 // Minix defines
293
294 Builder.defineMacro("__minix", "3");
295 Builder.defineMacro("_EM_WSIZE", "4");
296 Builder.defineMacro("_EM_PSIZE", "4");
297 Builder.defineMacro("_EM_SSIZE", "2");
298 Builder.defineMacro("_EM_LSIZE", "4");
299 Builder.defineMacro("_EM_FSIZE", "4");
300 Builder.defineMacro("_EM_DSIZE", "8");
301 DefineStd(Builder, "unix", Opts);
302 }
303public:
304 MinixTargetInfo(const std::string &triple)
305 : OSTargetInfo<Target>(triple) {
306 this->UserLabelPrefix = "";
307 }
308};
309
Edwin Török36565e52009-06-30 17:10:35 +0000310// Linux target
311template<typename Target>
312class LinuxTargetInfo : public OSTargetInfo<Target> {
313protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000314 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000315 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000316 // Linux defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000317 DefineStd(Builder, "unix", Opts);
318 DefineStd(Builder, "linux", Opts);
319 Builder.defineMacro("__gnu_linux__");
320 Builder.defineMacro("__ELF__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000321 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000322 Builder.defineMacro("_REENTRANT");
Douglas Gregor9b22a172010-04-21 05:52:38 +0000323 if (Opts.CPlusPlus)
324 Builder.defineMacro("_GNU_SOURCE");
Edwin Török36565e52009-06-30 17:10:35 +0000325 }
326public:
Mike Stump25cf7602009-09-09 15:08:12 +0000327 LinuxTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +0000328 : OSTargetInfo<Target>(triple) {
329 this->UserLabelPrefix = "";
Douglas Gregor12e84642011-01-12 21:19:25 +0000330 this->WIntType = TargetInfo::UnsignedInt;
Edwin Török36565e52009-06-30 17:10:35 +0000331 }
Benjamin Kramer86d18c52011-10-15 17:53:33 +0000332
333 virtual const char *getStaticInitSectionSpecifier() const {
334 return ".text.startup";
335 }
Edwin Török36565e52009-06-30 17:10:35 +0000336};
337
Chris Lattner25fff082009-07-13 20:29:08 +0000338// NetBSD Target
339template<typename Target>
340class NetBSDTargetInfo : public OSTargetInfo<Target> {
341protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000342 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000343 MacroBuilder &Builder) const {
Chris Lattner25fff082009-07-13 20:29:08 +0000344 // NetBSD defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000345 Builder.defineMacro("__NetBSD__");
346 Builder.defineMacro("__unix__");
347 Builder.defineMacro("__ELF__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000348 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000349 Builder.defineMacro("_POSIX_THREADS");
Chris Lattner25fff082009-07-13 20:29:08 +0000350 }
351public:
Mike Stump25cf7602009-09-09 15:08:12 +0000352 NetBSDTargetInfo(const std::string &triple)
Chris Lattner25fff082009-07-13 20:29:08 +0000353 : OSTargetInfo<Target>(triple) {
354 this->UserLabelPrefix = "";
355 }
356};
357
Edwin Török36565e52009-06-30 17:10:35 +0000358// OpenBSD Target
359template<typename Target>
360class OpenBSDTargetInfo : public OSTargetInfo<Target> {
361protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000362 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000363 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000364 // OpenBSD defines; list based off of gcc output
365
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000366 Builder.defineMacro("__OpenBSD__");
367 DefineStd(Builder, "unix", Opts);
368 Builder.defineMacro("__ELF__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000369 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000370 Builder.defineMacro("_POSIX_THREADS");
Edwin Török36565e52009-06-30 17:10:35 +0000371 }
372public:
Mike Stump25cf7602009-09-09 15:08:12 +0000373 OpenBSDTargetInfo(const std::string &triple)
Edwin Török36565e52009-06-30 17:10:35 +0000374 : OSTargetInfo<Target>(triple) {}
375};
376
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000377// PSP Target
378template<typename Target>
379class PSPTargetInfo : public OSTargetInfo<Target> {
380protected:
381 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000382 MacroBuilder &Builder) const {
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000383 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000384 Builder.defineMacro("PSP");
385 Builder.defineMacro("_PSP");
386 Builder.defineMacro("__psp__");
387 Builder.defineMacro("__ELF__");
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000388 }
389public:
390 PSPTargetInfo(const std::string& triple)
391 : OSTargetInfo<Target>(triple) {
392 this->UserLabelPrefix = "";
393 }
394};
395
John Thompsoned7bdbc2009-11-19 17:18:50 +0000396// PS3 PPU Target
397template<typename Target>
398class PS3PPUTargetInfo : public OSTargetInfo<Target> {
399protected:
400 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000401 MacroBuilder &Builder) const {
John Thompsoned7bdbc2009-11-19 17:18:50 +0000402 // PS3 PPU defines.
John Thompsonfdd2fc32010-03-25 16:18:32 +0000403 Builder.defineMacro("__PPC__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000404 Builder.defineMacro("__PPU__");
405 Builder.defineMacro("__CELLOS_LV2__");
406 Builder.defineMacro("__ELF__");
407 Builder.defineMacro("__LP32__");
John Thompson1deeb9f2010-06-24 22:44:13 +0000408 Builder.defineMacro("_ARCH_PPC64");
409 Builder.defineMacro("__powerpc64__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000410 }
411public:
412 PS3PPUTargetInfo(const std::string& triple)
413 : OSTargetInfo<Target>(triple) {
414 this->UserLabelPrefix = "";
John Thompson4c3bd3f2009-12-18 14:21:08 +0000415 this->LongWidth = this->LongAlign = this->PointerWidth = this->PointerAlign = 32;
John Thompson1deeb9f2010-06-24 22:44:13 +0000416 this->IntMaxType = TargetInfo::SignedLongLong;
417 this->UIntMaxType = TargetInfo::UnsignedLongLong;
418 this->Int64Type = TargetInfo::SignedLongLong;
John Thompson4c3bd3f2009-12-18 14:21:08 +0000419 this->SizeType = TargetInfo::UnsignedInt;
John Thompson1deeb9f2010-06-24 22:44:13 +0000420 this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
421 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompsoned7bdbc2009-11-19 17:18:50 +0000422 }
423};
424
425// FIXME: Need a real SPU target.
426// PS3 SPU Target
427template<typename Target>
428class PS3SPUTargetInfo : public OSTargetInfo<Target> {
429protected:
430 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000431 MacroBuilder &Builder) const {
John Thompsoned7bdbc2009-11-19 17:18:50 +0000432 // PS3 PPU defines.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000433 Builder.defineMacro("__SPU__");
434 Builder.defineMacro("__ELF__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000435 }
436public:
437 PS3SPUTargetInfo(const std::string& triple)
438 : OSTargetInfo<Target>(triple) {
439 this->UserLabelPrefix = "";
440 }
441};
442
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +0000443// AuroraUX target
444template<typename Target>
445class AuroraUXTargetInfo : public OSTargetInfo<Target> {
446protected:
447 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000448 MacroBuilder &Builder) const {
449 DefineStd(Builder, "sun", Opts);
450 DefineStd(Builder, "unix", Opts);
451 Builder.defineMacro("__ELF__");
452 Builder.defineMacro("__svr4__");
453 Builder.defineMacro("__SVR4");
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +0000454 }
455public:
456 AuroraUXTargetInfo(const std::string& triple)
457 : OSTargetInfo<Target>(triple) {
458 this->UserLabelPrefix = "";
459 this->WCharType = this->SignedLong;
460 // FIXME: WIntType should be SignedLong
461 }
462};
463
Edwin Török36565e52009-06-30 17:10:35 +0000464// Solaris target
465template<typename Target>
466class SolarisTargetInfo : public OSTargetInfo<Target> {
467protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000468 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000469 MacroBuilder &Builder) const {
470 DefineStd(Builder, "sun", Opts);
471 DefineStd(Builder, "unix", Opts);
472 Builder.defineMacro("__ELF__");
473 Builder.defineMacro("__svr4__");
474 Builder.defineMacro("__SVR4");
Edwin Török36565e52009-06-30 17:10:35 +0000475 }
476public:
Mike Stump25cf7602009-09-09 15:08:12 +0000477 SolarisTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +0000478 : OSTargetInfo<Target>(triple) {
479 this->UserLabelPrefix = "";
480 this->WCharType = this->SignedLong;
481 // FIXME: WIntType should be SignedLong
482 }
483};
Michael J. Spencer01e70082010-10-21 05:21:48 +0000484
485// Windows target
486template<typename Target>
487class WindowsTargetInfo : public OSTargetInfo<Target> {
488protected:
489 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
490 MacroBuilder &Builder) const {
Michael J. Spencer4fb461c2010-10-21 08:22:51 +0000491 Builder.defineMacro("_WIN32");
492 }
493 void getVisualStudioDefines(const LangOptions &Opts,
494 MacroBuilder &Builder) const {
Michael J. Spencer01e70082010-10-21 05:21:48 +0000495 if (Opts.CPlusPlus) {
496 if (Opts.RTTI)
497 Builder.defineMacro("_CPPRTTI");
498
499 if (Opts.Exceptions)
500 Builder.defineMacro("_CPPUNWIND");
501 }
502
503 if (!Opts.CharIsSigned)
504 Builder.defineMacro("_CHAR_UNSIGNED");
505
506 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
507 // but it works for now.
508 if (Opts.POSIXThreads)
509 Builder.defineMacro("_MT");
Michael J. Spencer4fb461c2010-10-21 08:22:51 +0000510
Michael J. Spencer01e70082010-10-21 05:21:48 +0000511 if (Opts.MSCVersion != 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000512 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencer01e70082010-10-21 05:21:48 +0000513
Francois Pichet62ec1f22011-09-17 17:15:52 +0000514 if (Opts.MicrosoftExt) {
Michael J. Spencer01e70082010-10-21 05:21:48 +0000515 Builder.defineMacro("_MSC_EXTENSIONS");
516
517 if (Opts.CPlusPlus0x) {
518 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
519 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
520 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
521 }
522 }
523
524 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencer01e70082010-10-21 05:21:48 +0000525 }
526
Michael J. Spencer01e70082010-10-21 05:21:48 +0000527public:
528 WindowsTargetInfo(const std::string &triple)
529 : OSTargetInfo<Target>(triple) {}
530};
531
Mike Stump25cf7602009-09-09 15:08:12 +0000532} // end anonymous namespace.
Edwin Török36565e52009-06-30 17:10:35 +0000533
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000534//===----------------------------------------------------------------------===//
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000535// Specific target implementations.
536//===----------------------------------------------------------------------===//
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000537
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000538namespace {
539// PPC abstract base class
540class PPCTargetInfo : public TargetInfo {
541 static const Builtin::Info BuiltinInfo[];
542 static const char * const GCCRegNames[];
543 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000544public:
Eli Friedmand9389be2009-06-05 07:05:05 +0000545 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
546
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000547 virtual void getTargetBuiltins(const Builtin::Info *&Records,
548 unsigned &NumRecords) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000549 Records = BuiltinInfo;
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000550 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000551 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000552
Chris Lattner79682402009-03-20 15:52:06 +0000553 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000554 MacroBuilder &Builder) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000555
Anton Korobeynikove7772382009-05-03 13:42:53 +0000556 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000557 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000558 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000559 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +0000560 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000561 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +0000562 switch (*Name) {
Anders Carlsson4ce42302007-11-27 04:11:28 +0000563 default: return false;
564 case 'O': // Zero
John Thompson1deeb9f2010-06-24 22:44:13 +0000565 break;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000566 case 'b': // Base register
567 case 'f': // Floating point register
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000568 Info.setAllowsRegister();
John Thompson1deeb9f2010-06-24 22:44:13 +0000569 break;
570 // FIXME: The following are added to allow parsing.
571 // I just took a guess at what the actions should be.
572 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000573 case 'd': // Floating point register (containing 64-bit value)
John Thompson1deeb9f2010-06-24 22:44:13 +0000574 case 'v': // Altivec vector register
575 Info.setAllowsRegister();
576 break;
577 case 'w':
578 switch (Name[1]) {
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000579 case 'd':// VSX vector register to hold vector double data
580 case 'f':// VSX vector register to hold vector float data
581 case 's':// VSX vector register to hold scalar float data
582 case 'a':// Any VSX register
John Thompson1deeb9f2010-06-24 22:44:13 +0000583 break;
584 default:
585 return false;
586 }
587 Info.setAllowsRegister();
588 Name++; // Skip over 'w'.
589 break;
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000590 case 'h': // `MQ', `CTR', or `LINK' register
591 case 'q': // `MQ' register
592 case 'c': // `CTR' register
593 case 'l': // `LINK' register
594 case 'x': // `CR' register (condition register) number 0
595 case 'y': // `CR' register (condition register)
596 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson1deeb9f2010-06-24 22:44:13 +0000597 Info.setAllowsRegister();
598 break;
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000599 case 'I': // Signed 16-bit constant
John Thompson1deeb9f2010-06-24 22:44:13 +0000600 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000601 // (use `L' instead for SImode constants)
602 case 'K': // Unsigned 16-bit constant
603 case 'L': // Signed 16-bit constant shifted left 16 bits
604 case 'M': // Constant larger than 31
605 case 'N': // Exact power of 2
606 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson1deeb9f2010-06-24 22:44:13 +0000607 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000608 // register with one instruction per word
John Thompson1deeb9f2010-06-24 22:44:13 +0000609 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000610 // into a register using three instructions
John Thompson1deeb9f2010-06-24 22:44:13 +0000611 break;
612 case 'm': // Memory operand. Note that on PowerPC targets, m can
613 // include addresses that update the base register. It
614 // is therefore only safe to use `m' in an asm statement
615 // if that asm statement accesses the operand exactly once.
616 // The asm statement must also use `%U<opno>' as a
Sebastian Redl097ce222010-08-17 22:42:34 +0000617 // placeholder for the "update" flag in the corresponding
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000618 // load or store instruction. For example:
John Thompson1deeb9f2010-06-24 22:44:13 +0000619 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000620 // is correct but:
John Thompson1deeb9f2010-06-24 22:44:13 +0000621 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
622 // is not. Use es rather than m if you don't want the base
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000623 // register to be updated.
624 case 'e':
John Thompsone0a39472010-06-25 00:02:05 +0000625 if (Name[1] != 's')
626 return false;
Sebastian Redl097ce222010-08-17 22:42:34 +0000627 // es: A "stable" memory operand; that is, one which does not
John Thompson1deeb9f2010-06-24 22:44:13 +0000628 // include any automodification of the base register. Unlike
629 // `m', this constraint can be used in asm statements that
630 // might access the operand several times, or that might not
John Thompsone0a39472010-06-25 00:02:05 +0000631 // access it at all.
John Thompson1deeb9f2010-06-24 22:44:13 +0000632 Info.setAllowsMemory();
John Thompsone0a39472010-06-25 00:02:05 +0000633 Name++; // Skip over 'e'.
John Thompson1deeb9f2010-06-24 22:44:13 +0000634 break;
635 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000636 // usually better to use `m' or `es' in asm statements)
John Thompson1deeb9f2010-06-24 22:44:13 +0000637 case 'Z': // Memory operand that is an indexed or indirect from a
638 // register (it is usually better to use `m' or `es' in
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000639 // asm statements)
John Thompson1deeb9f2010-06-24 22:44:13 +0000640 Info.setAllowsMemory();
641 Info.setAllowsRegister();
642 break;
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000643 case 'R': // AIX TOC entry
John Thompson1deeb9f2010-06-24 22:44:13 +0000644 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000645 // register (`p' is preferable for asm statements)
646 case 'S': // Constant suitable as a 64-bit mask operand
647 case 'T': // Constant suitable as a 32-bit mask operand
648 case 'U': // System V Release 4 small data area reference
John Thompson1deeb9f2010-06-24 22:44:13 +0000649 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000650 // instructions
651 case 'W': // Vector constant that does not require memory
652 case 'j': // Vector constant that is all zeros.
John Thompson1deeb9f2010-06-24 22:44:13 +0000653 break;
654 // End FIXME.
Anders Carlsson4ce42302007-11-27 04:11:28 +0000655 }
John Thompson1deeb9f2010-06-24 22:44:13 +0000656 return true;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000657 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000658 virtual const char *getClobbers() const {
659 return "";
Anders Carlsson4ce42302007-11-27 04:11:28 +0000660 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000661};
Anders Carlsson4ce42302007-11-27 04:11:28 +0000662
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000663const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000664#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000665#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000666 ALL_LANGUAGES },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000667#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000668};
Anton Korobeynikove7772382009-05-03 13:42:53 +0000669
670
Chris Lattnerbef1d722009-03-02 22:27:17 +0000671/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
672/// #defines that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +0000673void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000674 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +0000675 // Target identification.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000676 Builder.defineMacro("__ppc__");
677 Builder.defineMacro("_ARCH_PPC");
Chris Lattnerf8030412010-02-16 18:14:57 +0000678 Builder.defineMacro("__powerpc__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000679 Builder.defineMacro("__POWERPC__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000680 if (PointerWidth == 64) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000681 Builder.defineMacro("_ARCH_PPC64");
682 Builder.defineMacro("_LP64");
683 Builder.defineMacro("__LP64__");
Chris Lattnerf8030412010-02-16 18:14:57 +0000684 Builder.defineMacro("__powerpc64__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000685 Builder.defineMacro("__ppc64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000686 } else {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000687 Builder.defineMacro("__ppc__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000688 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000689
Chris Lattnerbef1d722009-03-02 22:27:17 +0000690 // Target properties.
Joerg Sonnenberger7cd1de52011-07-05 14:56:12 +0000691 if (getTriple().getOS() != llvm::Triple::NetBSD)
692 Builder.defineMacro("_BIG_ENDIAN");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000693 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000694
Chris Lattnerbef1d722009-03-02 22:27:17 +0000695 // Subtarget options.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000696 Builder.defineMacro("__NATURAL_ALIGNMENT__");
697 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000698
Chris Lattnerbef1d722009-03-02 22:27:17 +0000699 // FIXME: Should be controlled by command line option.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000700 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000701
John Thompsoned7bdbc2009-11-19 17:18:50 +0000702 if (Opts.AltiVec) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000703 Builder.defineMacro("__VEC__", "10206");
704 Builder.defineMacro("__ALTIVEC__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000705 }
Chris Lattnerbef1d722009-03-02 22:27:17 +0000706}
707
Chris Lattner9fd73612008-04-21 18:56:49 +0000708
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000709const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattner14d2bb72009-09-16 05:05:27 +0000710 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
711 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
712 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
713 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
714 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
715 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
716 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
717 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000718 "mq", "lr", "ctr", "ap",
Chris Lattner14d2bb72009-09-16 05:05:27 +0000719 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000720 "xer",
Chris Lattner14d2bb72009-09-16 05:05:27 +0000721 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
722 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
723 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
724 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000725 "vrsave", "vscr",
726 "spe_acc", "spefscr",
727 "sfp"
728};
Chris Lattner4b009652007-07-25 00:24:17 +0000729
Anton Korobeynikove7772382009-05-03 13:42:53 +0000730void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000731 unsigned &NumNames) const {
732 Names = GCCRegNames;
733 NumNames = llvm::array_lengthof(GCCRegNames);
734}
Chris Lattner4b009652007-07-25 00:24:17 +0000735
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000736const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
737 // While some of these aliases do map to different registers
738 // they still share the same register name.
Daniel Dunbar40b774e2009-09-17 07:03:19 +0000739 { { "0" }, "r0" },
740 { { "1"}, "r1" },
741 { { "2" }, "r2" },
742 { { "3" }, "r3" },
743 { { "4" }, "r4" },
744 { { "5" }, "r5" },
745 { { "6" }, "r6" },
746 { { "7" }, "r7" },
747 { { "8" }, "r8" },
748 { { "9" }, "r9" },
749 { { "10" }, "r10" },
750 { { "11" }, "r11" },
751 { { "12" }, "r12" },
752 { { "13" }, "r13" },
753 { { "14" }, "r14" },
754 { { "15" }, "r15" },
755 { { "16" }, "r16" },
756 { { "17" }, "r17" },
757 { { "18" }, "r18" },
758 { { "19" }, "r19" },
759 { { "20" }, "r20" },
760 { { "21" }, "r21" },
761 { { "22" }, "r22" },
762 { { "23" }, "r23" },
763 { { "24" }, "r24" },
764 { { "25" }, "r25" },
765 { { "26" }, "r26" },
766 { { "27" }, "r27" },
767 { { "28" }, "r28" },
768 { { "29" }, "r29" },
769 { { "30" }, "r30" },
770 { { "31" }, "r31" },
771 { { "fr0" }, "f0" },
772 { { "fr1" }, "f1" },
773 { { "fr2" }, "f2" },
774 { { "fr3" }, "f3" },
775 { { "fr4" }, "f4" },
776 { { "fr5" }, "f5" },
777 { { "fr6" }, "f6" },
778 { { "fr7" }, "f7" },
779 { { "fr8" }, "f8" },
780 { { "fr9" }, "f9" },
Mike Stump369c21c2009-09-17 21:15:00 +0000781 { { "fr10" }, "f10" },
Daniel Dunbar40b774e2009-09-17 07:03:19 +0000782 { { "fr11" }, "f11" },
783 { { "fr12" }, "f12" },
784 { { "fr13" }, "f13" },
785 { { "fr14" }, "f14" },
786 { { "fr15" }, "f15" },
787 { { "fr16" }, "f16" },
788 { { "fr17" }, "f17" },
789 { { "fr18" }, "f18" },
790 { { "fr19" }, "f19" },
791 { { "fr20" }, "f20" },
792 { { "fr21" }, "f21" },
793 { { "fr22" }, "f22" },
794 { { "fr23" }, "f23" },
795 { { "fr24" }, "f24" },
796 { { "fr25" }, "f25" },
797 { { "fr26" }, "f26" },
798 { { "fr27" }, "f27" },
799 { { "fr28" }, "f28" },
800 { { "fr29" }, "f29" },
801 { { "fr30" }, "f30" },
802 { { "fr31" }, "f31" },
803 { { "cc" }, "cr0" },
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000804};
805
Anton Korobeynikove7772382009-05-03 13:42:53 +0000806void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000807 unsigned &NumAliases) const {
808 Aliases = GCCRegAliases;
809 NumAliases = llvm::array_lengthof(GCCRegAliases);
810}
811} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +0000812
813namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000814class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000815public:
Chris Lattnerf8030412010-02-16 18:14:57 +0000816 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedman2b161652008-08-21 00:13:15 +0000817 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +0000818 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnerf8030412010-02-16 18:14:57 +0000819
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000820 switch (getTriple().getOS()) {
821 case llvm::Triple::FreeBSD:
822 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000823 SizeType = UnsignedInt;
824 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +0000825 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000826 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000827 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000828 }
829
830 virtual const char *getVAListDeclaration() const {
831 // This is the ELF definition, and is overridden by the Darwin sub-target
832 return "typedef struct __va_list_tag {"
833 " unsigned char gpr;"
834 " unsigned char fpr;"
835 " unsigned short reserved;"
836 " void* overflow_arg_area;"
837 " void* reg_save_area;"
838 "} __builtin_va_list[1];";
Eli Friedman2b161652008-08-21 00:13:15 +0000839 }
Chris Lattner4b009652007-07-25 00:24:17 +0000840};
841} // end anonymous namespace.
842
843namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000844class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000845public:
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000846 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +0000847 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman38e31802009-07-01 03:36:11 +0000848 IntMaxType = SignedLong;
849 UIntMaxType = UnsignedLong;
850 Int64Type = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +0000851 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +0000852 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnere5fde952008-05-09 06:17:04 +0000853 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000854 virtual const char *getVAListDeclaration() const {
855 return "typedef char* __builtin_va_list;";
856 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000857};
858} // end anonymous namespace.
859
Daniel Dunbar6501cab2010-05-30 00:07:30 +0000860
861namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +0000862class DarwinPPC32TargetInfo :
863 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar6501cab2010-05-30 00:07:30 +0000864public:
Roman Divackyc81f2a22011-01-06 08:27:10 +0000865 DarwinPPC32TargetInfo(const std::string& triple)
866 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar6501cab2010-05-30 00:07:30 +0000867 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +0000868 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
869 }
870 virtual const char *getVAListDeclaration() const {
871 return "typedef char* __builtin_va_list;";
Daniel Dunbar6501cab2010-05-30 00:07:30 +0000872 }
873};
874
875class DarwinPPC64TargetInfo :
876 public DarwinTargetInfo<PPC64TargetInfo> {
877public:
878 DarwinPPC64TargetInfo(const std::string& triple)
879 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
880 HasAlignMac68kSupport = true;
881 }
882};
883} // end anonymous namespace.
884
Chris Lattner4b009652007-07-25 00:24:17 +0000885namespace {
Justin Holewinski25bedca2011-10-03 17:28:37 +0000886 static const unsigned PTXAddrSpaceMap[] = {
887 0, // opencl_global
888 4, // opencl_local
889 1 // opencl_constant
890 };
Justin Holewinski285dc652011-04-20 19:34:15 +0000891 class PTXTargetInfo : public TargetInfo {
892 static const char * const GCCRegNames[];
893 static const Builtin::Info BuiltinInfo[];
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000894 std::vector<llvm::StringRef> AvailableFeatures;
Justin Holewinski285dc652011-04-20 19:34:15 +0000895 public:
896 PTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
897 TLSSupported = false;
898 LongWidth = LongAlign = 64;
Justin Holewinski25bedca2011-10-03 17:28:37 +0000899 AddrSpaceMap = &PTXAddrSpaceMap;
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000900 // Define available target features
901 // These must be defined in sorted order!
902 AvailableFeatures.push_back("compute10");
903 AvailableFeatures.push_back("compute11");
904 AvailableFeatures.push_back("compute12");
905 AvailableFeatures.push_back("compute13");
906 AvailableFeatures.push_back("compute20");
907 AvailableFeatures.push_back("double");
908 AvailableFeatures.push_back("no-fma");
909 AvailableFeatures.push_back("ptx20");
910 AvailableFeatures.push_back("ptx21");
911 AvailableFeatures.push_back("ptx22");
912 AvailableFeatures.push_back("ptx23");
913 AvailableFeatures.push_back("sm10");
914 AvailableFeatures.push_back("sm11");
915 AvailableFeatures.push_back("sm12");
916 AvailableFeatures.push_back("sm13");
917 AvailableFeatures.push_back("sm20");
918 AvailableFeatures.push_back("sm21");
919 AvailableFeatures.push_back("sm22");
920 AvailableFeatures.push_back("sm23");
Justin Holewinski285dc652011-04-20 19:34:15 +0000921 }
922 virtual void getTargetDefines(const LangOptions &Opts,
923 MacroBuilder &Builder) const {
924 Builder.defineMacro("__PTX__");
925 }
926 virtual void getTargetBuiltins(const Builtin::Info *&Records,
927 unsigned &NumRecords) const {
928 Records = BuiltinInfo;
929 NumRecords = clang::PTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
930 }
931
932 virtual void getGCCRegNames(const char * const *&Names,
933 unsigned &NumNames) const;
934 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
935 unsigned &NumAliases) const {
936 // No aliases.
937 Aliases = 0;
938 NumAliases = 0;
939 }
940 virtual bool validateAsmConstraint(const char *&Name,
941 TargetInfo::ConstraintInfo &info) const {
942 // FIXME: implement
943 return true;
944 }
945 virtual const char *getClobbers() const {
946 // FIXME: Is this really right?
947 return "";
948 }
949 virtual const char *getVAListDeclaration() const {
950 // FIXME: implement
951 return "typedef char* __builtin_va_list;";
952 }
Justin Holewinski808ef662011-09-15 12:13:38 +0000953
954 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
955 const std::string &Name,
956 bool Enabled) const;
Justin Holewinski285dc652011-04-20 19:34:15 +0000957 };
958
959 const Builtin::Info PTXTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000960#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +0000961#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000962 ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +0000963#include "clang/Basic/BuiltinsPTX.def"
964 };
965
966 const char * const PTXTargetInfo::GCCRegNames[] = {
967 "r0"
968 };
969
970 void PTXTargetInfo::getGCCRegNames(const char * const *&Names,
971 unsigned &NumNames) const {
972 Names = GCCRegNames;
973 NumNames = llvm::array_lengthof(GCCRegNames);
974 }
975
Justin Holewinski808ef662011-09-15 12:13:38 +0000976 bool PTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
977 const std::string &Name,
978 bool Enabled) const {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000979 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
980 Name)) {
981 Features[Name] = Enabled;
982 return true;
Justin Holewinski808ef662011-09-15 12:13:38 +0000983 } else {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000984 return false;
Justin Holewinski808ef662011-09-15 12:13:38 +0000985 }
Justin Holewinski808ef662011-09-15 12:13:38 +0000986 }
Justin Holewinski285dc652011-04-20 19:34:15 +0000987
988 class PTX32TargetInfo : public PTXTargetInfo {
989 public:
990 PTX32TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
991 PointerWidth = PointerAlign = 32;
992 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
993 DescriptionString
994 = "e-p:32:32-i64:64:64-f64:64:64-n1:8:16:32:64";
995 }
996 };
997
998 class PTX64TargetInfo : public PTXTargetInfo {
999 public:
1000 PTX64TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
1001 PointerWidth = PointerAlign = 64;
1002 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
1003 DescriptionString
1004 = "e-p:64:64-i64:64:64-f64:64:64-n1:8:16:32:64";
1005 }
1006 };
1007}
1008
1009namespace {
Chris Lattner2c026472010-03-06 21:21:27 +00001010// MBlaze abstract base class
1011class MBlazeTargetInfo : public TargetInfo {
1012 static const char * const GCCRegNames[];
1013 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1014
1015public:
1016 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +00001017 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner2c026472010-03-06 21:21:27 +00001018 }
1019
1020 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1021 unsigned &NumRecords) const {
1022 // FIXME: Implement.
1023 Records = 0;
1024 NumRecords = 0;
1025 }
1026
1027 virtual void getTargetDefines(const LangOptions &Opts,
1028 MacroBuilder &Builder) const;
1029
1030 virtual const char *getVAListDeclaration() const {
1031 return "typedef char* __builtin_va_list;";
1032 }
1033 virtual const char *getTargetPrefix() const {
1034 return "mblaze";
1035 }
1036 virtual void getGCCRegNames(const char * const *&Names,
1037 unsigned &NumNames) const;
1038 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1039 unsigned &NumAliases) const;
1040 virtual bool validateAsmConstraint(const char *&Name,
1041 TargetInfo::ConstraintInfo &Info) const {
1042 switch (*Name) {
1043 default: return false;
1044 case 'O': // Zero
1045 return true;
1046 case 'b': // Base register
1047 case 'f': // Floating point register
1048 Info.setAllowsRegister();
1049 return true;
1050 }
1051 }
1052 virtual const char *getClobbers() const {
1053 return "";
1054 }
1055};
1056
1057/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1058/// #defines that are not tied to a specific subtarget.
1059void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1060 MacroBuilder &Builder) const {
1061 // Target identification.
1062 Builder.defineMacro("__microblaze__");
1063 Builder.defineMacro("_ARCH_MICROBLAZE");
1064 Builder.defineMacro("__MICROBLAZE__");
1065
1066 // Target properties.
1067 Builder.defineMacro("_BIG_ENDIAN");
1068 Builder.defineMacro("__BIG_ENDIAN__");
1069
1070 // Subtarget options.
1071 Builder.defineMacro("__REGISTER_PREFIX__", "");
1072}
1073
1074
1075const char * const MBlazeTargetInfo::GCCRegNames[] = {
1076 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1077 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1078 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1079 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1080 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1081 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1082 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1083 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1084 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1085 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1086};
1087
1088void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1089 unsigned &NumNames) const {
1090 Names = GCCRegNames;
1091 NumNames = llvm::array_lengthof(GCCRegNames);
1092}
1093
1094const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1095 { {"f0"}, "r0" },
1096 { {"f1"}, "r1" },
1097 { {"f2"}, "r2" },
1098 { {"f3"}, "r3" },
1099 { {"f4"}, "r4" },
1100 { {"f5"}, "r5" },
1101 { {"f6"}, "r6" },
1102 { {"f7"}, "r7" },
1103 { {"f8"}, "r8" },
1104 { {"f9"}, "r9" },
1105 { {"f10"}, "r10" },
1106 { {"f11"}, "r11" },
1107 { {"f12"}, "r12" },
1108 { {"f13"}, "r13" },
1109 { {"f14"}, "r14" },
1110 { {"f15"}, "r15" },
1111 { {"f16"}, "r16" },
1112 { {"f17"}, "r17" },
1113 { {"f18"}, "r18" },
1114 { {"f19"}, "r19" },
1115 { {"f20"}, "r20" },
1116 { {"f21"}, "r21" },
1117 { {"f22"}, "r22" },
1118 { {"f23"}, "r23" },
1119 { {"f24"}, "r24" },
1120 { {"f25"}, "r25" },
1121 { {"f26"}, "r26" },
1122 { {"f27"}, "r27" },
1123 { {"f28"}, "r28" },
1124 { {"f29"}, "r29" },
1125 { {"f30"}, "r30" },
1126 { {"f31"}, "r31" },
1127};
1128
1129void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1130 unsigned &NumAliases) const {
1131 Aliases = GCCRegAliases;
1132 NumAliases = llvm::array_lengthof(GCCRegAliases);
1133}
1134} // end anonymous namespace.
1135
1136namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001137// Namespace for x86 abstract base class
1138const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001139#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001140#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001141 ALL_LANGUAGES },
Chris Lattner99ca9d62009-06-14 01:05:48 +00001142#include "clang/Basic/BuiltinsX86.def"
Eli Friedman872996c2008-08-20 02:34:37 +00001143};
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001144
Nuno Lopesad1010d2009-12-23 17:49:57 +00001145static const char* const GCCRegNames[] = {
Eli Friedman872996c2008-08-20 02:34:37 +00001146 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1147 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001148 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman872996c2008-08-20 02:34:37 +00001149 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1150 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1151 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001152 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eli Friedman872996c2008-08-20 02:34:37 +00001153};
1154
Eric Christophercfd323d2011-06-21 00:05:20 +00001155const TargetInfo::AddlRegName AddlRegNames[] = {
1156 { { "al", "ah", "eax", "rax" }, 0 },
1157 { { "bl", "bh", "ebx", "rbx" }, 3 },
1158 { { "cl", "ch", "ecx", "rcx" }, 2 },
1159 { { "dl", "dh", "edx", "rdx" }, 1 },
1160 { { "esi", "rsi" }, 4 },
1161 { { "edi", "rdi" }, 5 },
1162 { { "esp", "rsp" }, 7 },
1163 { { "ebp", "rbp" }, 6 },
Eli Friedman872996c2008-08-20 02:34:37 +00001164};
1165
1166// X86 target abstract base class; x86-32 and x86-64 are very close, so
1167// most of the implementation can be shared.
1168class X86TargetInfo : public TargetInfo {
Chris Lattner715fe4c2009-03-02 22:40:39 +00001169 enum X86SSEEnum {
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001170 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
Chris Lattner715fe4c2009-03-02 22:40:39 +00001171 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001172 enum MMX3DNowEnum {
1173 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1174 } MMX3DNowLevel;
Anders Carlssone5e222f2010-01-27 03:47:49 +00001175
Eric Christopher6c4e7872010-04-02 23:50:19 +00001176 bool HasAES;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001177 bool HasAVX;
1178
Chandler Carruth499d9722011-09-28 08:55:34 +00001179 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1180 ///
1181 /// Each enumeration represents a particular CPU supported by Clang. These
1182 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1183 enum CPUKind {
1184 CK_Generic,
1185
1186 /// \name i386
1187 /// i386-generation processors.
1188 //@{
1189 CK_i386,
1190 //@}
1191
1192 /// \name i486
1193 /// i486-generation processors.
1194 //@{
1195 CK_i486,
1196 CK_WinChipC6,
1197 CK_WinChip2,
1198 CK_C3,
1199 //@}
1200
1201 /// \name i586
1202 /// i586-generation processors, P5 microarchitecture based.
1203 //@{
1204 CK_i586,
1205 CK_Pentium,
1206 CK_PentiumMMX,
1207 //@}
1208
1209 /// \name i686
1210 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1211 //@{
1212 CK_i686,
1213 CK_PentiumPro,
1214 CK_Pentium2,
1215 CK_Pentium3,
1216 CK_Pentium3M,
1217 CK_PentiumM,
1218 CK_C3_2,
1219
1220 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1221 /// Clang however has some logic to suport this.
1222 // FIXME: Warn, deprecate, and potentially remove this.
1223 CK_Yonah,
1224 //@}
1225
1226 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001227 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001228 //@{
1229 CK_Pentium4,
1230 CK_Pentium4M,
1231 CK_Prescott,
1232 CK_Nocona,
1233 //@}
1234
1235 /// \name Core
1236 /// Core microarchitecture based processors.
1237 //@{
1238 CK_Core2,
1239
1240 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1241 /// codename which GCC no longer accepts as an option to -march, but Clang
1242 /// has some logic for recognizing it.
1243 // FIXME: Warn, deprecate, and potentially remove this.
1244 CK_Penryn,
1245 //@}
1246
1247 /// \name Atom
1248 /// Atom processors
1249 //@{
1250 CK_Atom,
1251 //@}
1252
1253 /// \name Nehalem
1254 /// Nehalem microarchitecture based processors.
1255 //@{
1256 CK_Corei7,
1257 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001258 CK_CoreAVXi,
Chandler Carruth499d9722011-09-28 08:55:34 +00001259 //@}
1260
1261 /// \name K6
1262 /// K6 architecture processors.
1263 //@{
1264 CK_K6,
1265 CK_K6_2,
1266 CK_K6_3,
1267 //@}
1268
1269 /// \name K7
1270 /// K7 architecture processors.
1271 //@{
1272 CK_Athlon,
1273 CK_AthlonThunderbird,
1274 CK_Athlon4,
1275 CK_AthlonXP,
1276 CK_AthlonMP,
1277 //@}
1278
1279 /// \name K8
1280 /// K8 architecture processors.
1281 //@{
1282 CK_Athlon64,
1283 CK_Athlon64SSE3,
1284 CK_AthlonFX,
1285 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001286 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001287 CK_Opteron,
1288 CK_OpteronSSE3,
1289
1290 /// This specification is deprecated and will be removed in the future.
1291 /// Users should prefer \see CK_K8.
1292 // FIXME: Warn on this when the CPU is set to it.
1293 CK_x86_64,
1294 //@}
1295
1296 /// \name Geode
1297 /// Geode processors.
1298 //@{
1299 CK_Geode
1300 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001301 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001302
Eli Friedman872996c2008-08-20 02:34:37 +00001303public:
Anton Korobeynikove7772382009-05-03 13:42:53 +00001304 X86TargetInfo(const std::string& triple)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001305 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001306 HasAES(false), HasAVX(false), CPU(CK_Generic) {
Eli Friedman872996c2008-08-20 02:34:37 +00001307 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner4b009652007-07-25 00:24:17 +00001308 }
1309 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1310 unsigned &NumRecords) const {
Eli Friedman872996c2008-08-20 02:34:37 +00001311 Records = BuiltinInfo;
1312 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +00001313 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001314 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman872996c2008-08-20 02:34:37 +00001315 unsigned &NumNames) const {
1316 Names = GCCRegNames;
1317 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson7dd1c952007-11-24 23:38:12 +00001318 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001319 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson7dd1c952007-11-24 23:38:12 +00001320 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001321 Aliases = 0;
1322 NumAliases = 0;
1323 }
1324 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1325 unsigned &NumNames) const {
1326 Names = AddlRegNames;
1327 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlsson8b58e8a2007-10-13 00:45:48 +00001328 }
Anders Carlsson36834a72009-02-28 17:11:49 +00001329 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman872996c2008-08-20 02:34:37 +00001330 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001331 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlsson4ce42302007-11-27 04:11:28 +00001332 virtual const char *getClobbers() const {
Eli Friedman872996c2008-08-20 02:34:37 +00001333 return "~{dirflag},~{fpsr},~{flags}";
1334 }
Chris Lattner79682402009-03-20 15:52:06 +00001335 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001336 MacroBuilder &Builder) const;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001337 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1338 const std::string &Name,
1339 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001340 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00001341 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001342 virtual const char* getABI() const {
1343 return MMX3DNowLevel == NoMMX3DNow ? "no-mmx" : "";
1344 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001345 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001346 CPU = llvm::StringSwitch<CPUKind>(Name)
1347 .Case("i386", CK_i386)
1348 .Case("i486", CK_i486)
1349 .Case("winchip-c6", CK_WinChipC6)
1350 .Case("winchip2", CK_WinChip2)
1351 .Case("c3", CK_C3)
1352 .Case("i586", CK_i586)
1353 .Case("pentium", CK_Pentium)
1354 .Case("pentium-mmx", CK_PentiumMMX)
1355 .Case("i686", CK_i686)
1356 .Case("pentiumpro", CK_PentiumPro)
1357 .Case("pentium2", CK_Pentium2)
1358 .Case("pentium3", CK_Pentium3)
1359 .Case("pentium3m", CK_Pentium3M)
1360 .Case("pentium-m", CK_PentiumM)
1361 .Case("c3-2", CK_C3_2)
1362 .Case("yonah", CK_Yonah)
1363 .Case("pentium4", CK_Pentium4)
1364 .Case("pentium4m", CK_Pentium4M)
1365 .Case("prescott", CK_Prescott)
1366 .Case("nocona", CK_Nocona)
1367 .Case("core2", CK_Core2)
1368 .Case("penryn", CK_Penryn)
1369 .Case("atom", CK_Atom)
1370 .Case("corei7", CK_Corei7)
1371 .Case("corei7-avx", CK_Corei7AVX)
1372 .Case("core-avx-i", CK_CoreAVXi)
1373 .Case("k6", CK_K6)
1374 .Case("k6-2", CK_K6_2)
1375 .Case("k6-3", CK_K6_3)
1376 .Case("athlon", CK_Athlon)
1377 .Case("athlon-tbird", CK_AthlonThunderbird)
1378 .Case("athlon-4", CK_Athlon4)
1379 .Case("athlon-xp", CK_AthlonXP)
1380 .Case("athlon-mp", CK_AthlonMP)
1381 .Case("athlon64", CK_Athlon64)
1382 .Case("athlon64-sse3", CK_Athlon64SSE3)
1383 .Case("athlon-fx", CK_AthlonFX)
1384 .Case("k8", CK_K8)
1385 .Case("k8-sse3", CK_K8SSE3)
1386 .Case("opteron", CK_Opteron)
1387 .Case("opteron-sse3", CK_OpteronSSE3)
1388 .Case("x86-64", CK_x86_64)
1389 .Case("geode", CK_Geode)
1390 .Default(CK_Generic);
1391
Chandler Carruth26a39142011-09-28 09:45:08 +00001392 // Perform any per-CPU checks necessary to determine if this CPU is
1393 // acceptable.
1394 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1395 // invalid without explaining *why*.
1396 switch (CPU) {
1397 case CK_Generic:
1398 // No processor selected!
1399 return false;
1400
1401 case CK_i386:
1402 case CK_i486:
1403 case CK_WinChipC6:
1404 case CK_WinChip2:
1405 case CK_C3:
1406 case CK_i586:
1407 case CK_Pentium:
1408 case CK_PentiumMMX:
1409 case CK_i686:
1410 case CK_PentiumPro:
1411 case CK_Pentium2:
1412 case CK_Pentium3:
1413 case CK_Pentium3M:
1414 case CK_PentiumM:
1415 case CK_Yonah:
1416 case CK_C3_2:
1417 case CK_Pentium4:
1418 case CK_Pentium4M:
1419 case CK_Prescott:
1420 case CK_K6:
1421 case CK_K6_2:
1422 case CK_K6_3:
1423 case CK_Athlon:
1424 case CK_AthlonThunderbird:
1425 case CK_Athlon4:
1426 case CK_AthlonXP:
1427 case CK_AthlonMP:
1428 case CK_Geode:
1429 // Only accept certain architectures when compiling in 32-bit mode.
1430 if (PointerWidth != 32)
1431 return false;
1432
1433 // Fallthrough
1434 case CK_Nocona:
1435 case CK_Core2:
1436 case CK_Penryn:
1437 case CK_Atom:
1438 case CK_Corei7:
1439 case CK_Corei7AVX:
1440 case CK_CoreAVXi:
1441 case CK_Athlon64:
1442 case CK_Athlon64SSE3:
1443 case CK_AthlonFX:
1444 case CK_K8:
1445 case CK_K8SSE3:
1446 case CK_Opteron:
1447 case CK_OpteronSSE3:
1448 case CK_x86_64:
1449 return true;
1450 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001451 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001452 }
Chris Lattner4b009652007-07-25 00:24:17 +00001453};
Chris Lattner7d6220c2009-03-02 22:20:04 +00001454
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001455void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar07181d72009-05-06 03:16:41 +00001456 // FIXME: This should not be here.
1457 Features["3dnow"] = false;
1458 Features["3dnowa"] = false;
1459 Features["mmx"] = false;
1460 Features["sse"] = false;
1461 Features["sse2"] = false;
1462 Features["sse3"] = false;
1463 Features["ssse3"] = false;
1464 Features["sse41"] = false;
1465 Features["sse42"] = false;
Eric Christopher6c4e7872010-04-02 23:50:19 +00001466 Features["aes"] = false;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001467 Features["avx"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001468
Daniel Dunbar07181d72009-05-06 03:16:41 +00001469 // LLVM does not currently recognize this.
1470 // Features["sse4a"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001471
Daniel Dunbar07181d72009-05-06 03:16:41 +00001472 // FIXME: This *really* should not be here.
1473
1474 // X86_64 always has SSE2.
1475 if (PointerWidth == 64)
1476 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1477
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001478 switch (CPU) {
1479 case CK_Generic:
1480 case CK_i386:
1481 case CK_i486:
1482 case CK_i586:
1483 case CK_Pentium:
1484 case CK_i686:
1485 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001486 break;
1487 case CK_PentiumMMX:
1488 case CK_Pentium2:
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001489 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001490 break;
1491 case CK_Pentium3:
1492 case CK_Pentium3M:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001493 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001494 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001495 break;
1496 case CK_PentiumM:
1497 case CK_Pentium4:
1498 case CK_Pentium4M:
1499 case CK_x86_64:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001500 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001501 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001502 break;
1503 case CK_Yonah:
1504 case CK_Prescott:
1505 case CK_Nocona:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001506 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001507 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001508 break;
1509 case CK_Core2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001510 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001511 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001512 break;
1513 case CK_Penryn:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001514 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001515 setFeatureEnabled(Features, "sse4", true);
1516 Features["sse42"] = false;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001517 break;
1518 case CK_Atom:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001519 setFeatureEnabled(Features, "mmx", true);
Chandler Carruth49defe62011-09-28 10:36:46 +00001520 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001521 break;
1522 case CK_Corei7:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001523 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001524 setFeatureEnabled(Features, "sse4", true);
Eric Christopher6c4e7872010-04-02 23:50:19 +00001525 setFeatureEnabled(Features, "aes", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001526 break;
1527 case CK_Corei7AVX:
1528 case CK_CoreAVXi:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001529 setFeatureEnabled(Features, "mmx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00001530 setFeatureEnabled(Features, "sse4", true);
1531 setFeatureEnabled(Features, "aes", true);
Bruno Cardoso Lopese02d3912011-07-11 23:33:46 +00001532 //setFeatureEnabled(Features, "avx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001533 break;
1534 case CK_K6:
1535 case CK_WinChipC6:
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001536 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001537 break;
1538 case CK_K6_2:
1539 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001540 case CK_WinChip2:
1541 case CK_C3:
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001542 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001543 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00001544 case CK_Athlon:
1545 case CK_AthlonThunderbird:
1546 case CK_Geode:
1547 setFeatureEnabled(Features, "3dnowa", true);
1548 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001549 case CK_Athlon4:
1550 case CK_AthlonXP:
1551 case CK_AthlonMP:
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001552 setFeatureEnabled(Features, "sse", true);
1553 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001554 break;
1555 case CK_K8:
1556 case CK_Opteron:
1557 case CK_Athlon64:
1558 case CK_AthlonFX:
Mike Stump25cf7602009-09-09 15:08:12 +00001559 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001560 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001561 break;
1562 case CK_K8SSE3:
1563 case CK_OpteronSSE3:
1564 case CK_Athlon64SSE3:
Roman Divackyc8b09a12010-12-29 13:28:29 +00001565 setFeatureEnabled(Features, "sse3", true);
1566 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001567 break;
1568 case CK_C3_2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001569 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001570 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001571 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001572 }
Daniel Dunbar07181d72009-05-06 03:16:41 +00001573}
1574
Daniel Dunbar0838f962009-05-06 21:07:50 +00001575bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump25cf7602009-09-09 15:08:12 +00001576 const std::string &Name,
Daniel Dunbar0838f962009-05-06 21:07:50 +00001577 bool Enabled) const {
Eric Christopher850e2012010-03-04 02:26:37 +00001578 // FIXME: This *really* should not be here. We need some way of translating
1579 // options into llvm subtarget features.
1580 if (!Features.count(Name) &&
1581 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar0838f962009-05-06 21:07:50 +00001582 return false;
1583
1584 if (Enabled) {
1585 if (Name == "mmx")
1586 Features["mmx"] = true;
1587 else if (Name == "sse")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001588 Features["sse"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001589 else if (Name == "sse2")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001590 Features["sse"] = Features["sse2"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001591 else if (Name == "sse3")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001592 Features["sse"] = Features["sse2"] = Features["sse3"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001593 else if (Name == "ssse3")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001594 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001595 Features["ssse3"] = true;
Eric Christopher850e2012010-03-04 02:26:37 +00001596 else if (Name == "sse4" || Name == "sse4.2")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001597 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001598 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Eric Christopher850e2012010-03-04 02:26:37 +00001599 else if (Name == "sse4.1")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001600 Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopher850e2012010-03-04 02:26:37 +00001601 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001602 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001603 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001604 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001605 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christopher6c4e7872010-04-02 23:50:19 +00001606 else if (Name == "aes")
1607 Features["aes"] = true;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001608 else if (Name == "avx")
Bruno Cardoso Lopes292772c2011-08-18 00:07:03 +00001609 Features["avx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1610 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001611 } else {
1612 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001613 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001614 else if (Name == "sse")
Mike Stump25cf7602009-09-09 15:08:12 +00001615 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001616 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1617 else if (Name == "sse2")
Mike Stump25cf7602009-09-09 15:08:12 +00001618 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001619 Features["sse41"] = Features["sse42"] = false;
1620 else if (Name == "sse3")
Mike Stump25cf7602009-09-09 15:08:12 +00001621 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001622 Features["sse42"] = false;
1623 else if (Name == "ssse3")
1624 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00001625 else if (Name == "sse4" || Name == "sse4.1")
Daniel Dunbar0838f962009-05-06 21:07:50 +00001626 Features["sse41"] = Features["sse42"] = false;
Eric Christopherd794f782010-03-04 02:31:44 +00001627 else if (Name == "sse4.2")
1628 Features["sse42"] = false;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001629 else if (Name == "3dnow")
1630 Features["3dnow"] = Features["3dnowa"] = false;
1631 else if (Name == "3dnowa")
1632 Features["3dnowa"] = false;
Eric Christopher6c4e7872010-04-02 23:50:19 +00001633 else if (Name == "aes")
1634 Features["aes"] = false;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001635 else if (Name == "avx")
1636 Features["avx"] = false;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001637 }
1638
1639 return true;
1640}
1641
Daniel Dunbar07181d72009-05-06 03:16:41 +00001642/// HandleTargetOptions - Perform initialization based on the user
1643/// configured set of features.
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00001644void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001645 // Remember the maximum enabled sselevel.
1646 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1647 // Ignore disabled features.
1648 if (Features[i][0] == '-')
1649 continue;
1650
Eric Christopher6c4e7872010-04-02 23:50:19 +00001651 if (Features[i].substr(1) == "aes") {
1652 HasAES = true;
1653 continue;
1654 }
1655
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001656 // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1657 // For now let it be enabled together with other SSE levels.
1658 if (Features[i].substr(1) == "avx") {
1659 HasAVX = true;
1660 continue;
1661 }
1662
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001663 assert(Features[i][0] == '+' && "Invalid target feature!");
1664 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1665 .Case("sse42", SSE42)
1666 .Case("sse41", SSE41)
1667 .Case("ssse3", SSSE3)
Nuno Lopes3a16d782010-03-12 10:20:09 +00001668 .Case("sse3", SSE3)
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001669 .Case("sse2", SSE2)
1670 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001671 .Default(NoSSE);
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001672 SSELevel = std::max(SSELevel, Level);
Michael J. Spencerd5513a32010-10-21 03:16:25 +00001673
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001674 MMX3DNowEnum ThreeDNowLevel =
1675 llvm::StringSwitch<MMX3DNowEnum>(Features[i].substr(1))
Anders Carlssone5e222f2010-01-27 03:47:49 +00001676 .Case("3dnowa", AMD3DNowAthlon)
1677 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001678 .Case("mmx", MMX)
1679 .Default(NoMMX3DNow);
Michael J. Spencerd5513a32010-10-21 03:16:25 +00001680
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001681 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001682 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001683
1684 // Don't tell the backend if we're turning off mmx; it will end up disabling
1685 // SSE, which we don't want.
1686 std::vector<std::string>::iterator it;
1687 it = std::find(Features.begin(), Features.end(), "-mmx");
1688 if (it != Features.end())
1689 Features.erase(it);
Chris Lattner7d6220c2009-03-02 22:20:04 +00001690}
Chris Lattnerbef1d722009-03-02 22:27:17 +00001691
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001692/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
1693/// definitions for this particular subtarget.
Chris Lattner79682402009-03-20 15:52:06 +00001694void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001695 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00001696 // Target identification.
1697 if (PointerWidth == 64) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001698 Builder.defineMacro("_LP64");
1699 Builder.defineMacro("__LP64__");
1700 Builder.defineMacro("__amd64__");
1701 Builder.defineMacro("__amd64");
1702 Builder.defineMacro("__x86_64");
1703 Builder.defineMacro("__x86_64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +00001704 } else {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001705 DefineStd(Builder, "i386", Opts);
Chris Lattnerbef1d722009-03-02 22:27:17 +00001706 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001707
Chris Lattnerc0f59212009-03-02 22:27:17 +00001708 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001709 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
1710 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001711 switch (CPU) {
1712 case CK_Generic:
1713 break;
1714 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001715 // The rest are coming from the i386 define above.
1716 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001717 break;
1718 case CK_i486:
1719 case CK_WinChipC6:
1720 case CK_WinChip2:
1721 case CK_C3:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001722 Builder.defineMacro("__i486");
1723 Builder.defineMacro("__i486__");
1724 Builder.defineMacro("__tune_i486__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001725 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00001726 case CK_PentiumMMX:
1727 Builder.defineMacro("__pentium_mmx__");
1728 Builder.defineMacro("__tune_pentium_mmx__");
1729 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001730 case CK_i586:
1731 case CK_Pentium:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001732 Builder.defineMacro("__i586");
1733 Builder.defineMacro("__i586__");
1734 Builder.defineMacro("__tune_i586__");
1735 Builder.defineMacro("__pentium");
1736 Builder.defineMacro("__pentium__");
1737 Builder.defineMacro("__tune_pentium__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001738 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001739 case CK_Pentium3:
1740 case CK_Pentium3M:
1741 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001742 Builder.defineMacro("__tune_pentium3__");
1743 // Fallthrough
1744 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001745 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001746 Builder.defineMacro("__tune_pentium2__");
1747 // Fallthrough
1748 case CK_PentiumPro:
1749 Builder.defineMacro("__tune_i686__");
1750 Builder.defineMacro("__tune_pentiumpro__");
1751 // Fallthrough
1752 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001753 Builder.defineMacro("__i686");
1754 Builder.defineMacro("__i686__");
1755 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
1756 Builder.defineMacro("__pentiumpro");
1757 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001758 break;
1759 case CK_Pentium4:
1760 case CK_Pentium4M:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001761 Builder.defineMacro("__pentium4");
1762 Builder.defineMacro("__pentium4__");
1763 Builder.defineMacro("__tune_pentium4__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001764 break;
1765 case CK_Yonah:
1766 case CK_Prescott:
1767 case CK_Nocona:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001768 Builder.defineMacro("__nocona");
1769 Builder.defineMacro("__nocona__");
1770 Builder.defineMacro("__tune_nocona__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001771 break;
1772 case CK_Core2:
1773 case CK_Penryn:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001774 Builder.defineMacro("__core2");
1775 Builder.defineMacro("__core2__");
1776 Builder.defineMacro("__tune_core2__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001777 break;
1778 case CK_Atom:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001779 Builder.defineMacro("__atom");
1780 Builder.defineMacro("__atom__");
1781 Builder.defineMacro("__tune_atom__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001782 break;
1783 case CK_Corei7:
1784 case CK_Corei7AVX:
1785 case CK_CoreAVXi:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001786 Builder.defineMacro("__corei7");
1787 Builder.defineMacro("__corei7__");
1788 Builder.defineMacro("__tune_corei7__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001789 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001790 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001791 Builder.defineMacro("__k6_2__");
1792 Builder.defineMacro("__tune_k6_2__");
1793 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001794 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001795 if (CPU != CK_K6_2) { // In case of fallthrough
1796 // FIXME: GCC may be enabling these in cases where some other k6
1797 // architecture is specified but -m3dnow is explicitly provided. The
1798 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001799 Builder.defineMacro("__k6_3__");
1800 Builder.defineMacro("__tune_k6_3__");
1801 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00001802 // Fallthrough
1803 case CK_K6:
1804 Builder.defineMacro("__k6");
1805 Builder.defineMacro("__k6__");
1806 Builder.defineMacro("__tune_k6__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001807 break;
1808 case CK_Athlon:
1809 case CK_AthlonThunderbird:
1810 case CK_Athlon4:
1811 case CK_AthlonXP:
1812 case CK_AthlonMP:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001813 Builder.defineMacro("__athlon");
1814 Builder.defineMacro("__athlon__");
1815 Builder.defineMacro("__tune_athlon__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001816 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001817 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001818 Builder.defineMacro("__tune_athlon_sse__");
1819 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001820 break;
1821 case CK_K8:
1822 case CK_K8SSE3:
1823 case CK_x86_64:
1824 case CK_Opteron:
1825 case CK_OpteronSSE3:
1826 case CK_Athlon64:
1827 case CK_Athlon64SSE3:
1828 case CK_AthlonFX:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001829 Builder.defineMacro("__k8");
1830 Builder.defineMacro("__k8__");
1831 Builder.defineMacro("__tune_k8__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001832 break;
1833 case CK_Geode:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001834 Builder.defineMacro("__geode");
1835 Builder.defineMacro("__geode__");
1836 Builder.defineMacro("__tune_geode__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001837 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001838 }
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001839
Chris Lattnerbef1d722009-03-02 22:27:17 +00001840 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001841 Builder.defineMacro("__LITTLE_ENDIAN__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001842 Builder.defineMacro("__REGISTER_PREFIX__", "");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001843
Chris Lattner25ac1c12009-04-19 17:32:33 +00001844 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1845 // functions in glibc header files that use FP Stack inline asm which the
1846 // backend can't deal with (PR879).
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001847 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001848
Chandler Carruth88c75b02011-09-28 09:54:07 +00001849 if (HasAES)
1850 Builder.defineMacro("__AES__");
1851
1852 if (HasAVX)
1853 Builder.defineMacro("__AVX__");
1854
Chris Lattner715fe4c2009-03-02 22:40:39 +00001855 // Each case falls through to the previous one here.
1856 switch (SSELevel) {
1857 case SSE42:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001858 Builder.defineMacro("__SSE4_2__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001859 case SSE41:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001860 Builder.defineMacro("__SSE4_1__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001861 case SSSE3:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001862 Builder.defineMacro("__SSSE3__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001863 case SSE3:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001864 Builder.defineMacro("__SSE3__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001865 case SSE2:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001866 Builder.defineMacro("__SSE2__");
1867 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner715fe4c2009-03-02 22:40:39 +00001868 case SSE1:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001869 Builder.defineMacro("__SSE__");
1870 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001871 case NoSSE:
Chris Lattner715fe4c2009-03-02 22:40:39 +00001872 break;
1873 }
Michael J. Spencer3d796932010-10-18 07:10:59 +00001874
Francois Pichet62ec1f22011-09-17 17:15:52 +00001875 if (Opts.MicrosoftExt && PointerWidth == 32) {
Michael J. Spencer01e70082010-10-21 05:21:48 +00001876 switch (SSELevel) {
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00001877 case SSE42:
1878 case SSE41:
1879 case SSSE3:
1880 case SSE3:
Michael J. Spencer01e70082010-10-21 05:21:48 +00001881 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001882 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencer01e70082010-10-21 05:21:48 +00001883 break;
1884 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001885 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencer01e70082010-10-21 05:21:48 +00001886 break;
1887 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001888 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencer01e70082010-10-21 05:21:48 +00001889 }
1890 }
1891
Anders Carlssone5e222f2010-01-27 03:47:49 +00001892 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001893 switch (MMX3DNowLevel) {
Anders Carlssone5e222f2010-01-27 03:47:49 +00001894 case AMD3DNowAthlon:
1895 Builder.defineMacro("__3dNOW_A__");
1896 case AMD3DNow:
1897 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001898 case MMX:
1899 Builder.defineMacro("__MMX__");
1900 case NoMMX3DNow:
Anders Carlssone5e222f2010-01-27 03:47:49 +00001901 break;
1902 }
Chris Lattnerbef1d722009-03-02 22:27:17 +00001903}
Anton Korobeynikove7772382009-05-03 13:42:53 +00001904
1905
Eli Friedman872996c2008-08-20 02:34:37 +00001906bool
Anders Carlsson36834a72009-02-28 17:11:49 +00001907X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001908 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +00001909 switch (*Name) {
Eli Friedman872996c2008-08-20 02:34:37 +00001910 default: return false;
Dale Johanneseneba819a2010-08-24 22:33:12 +00001911 case 'Y': // first letter of a pair:
1912 switch (*(Name+1)) {
1913 default: return false;
1914 case '0': // First SSE register.
1915 case 't': // Any SSE register, when SSE2 is enabled.
1916 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
1917 case 'm': // any MMX register, when inter-unit moves enabled.
1918 break; // falls through to setAllowsRegister.
1919 }
Eli Friedman872996c2008-08-20 02:34:37 +00001920 case 'a': // eax.
1921 case 'b': // ebx.
1922 case 'c': // ecx.
1923 case 'd': // edx.
1924 case 'S': // esi.
1925 case 'D': // edi.
1926 case 'A': // edx:eax.
Dale Johanneseneba819a2010-08-24 22:33:12 +00001927 case 'f': // any x87 floating point stack register.
Eli Friedman872996c2008-08-20 02:34:37 +00001928 case 't': // top of floating point stack.
1929 case 'u': // second from top of floating point stack.
1930 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson2285e622008-10-06 00:41:45 +00001931 case 'y': // Any MMX register.
Anders Carlssond2459f92008-10-06 19:17:39 +00001932 case 'x': // Any SSE register.
Eli Friedman872996c2008-08-20 02:34:37 +00001933 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johanneseneba819a2010-08-24 22:33:12 +00001934 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
1935 case 'l': // "Index" registers: any general register that can be used as an
1936 // index in a base+index memory access.
1937 Info.setAllowsRegister();
1938 return true;
1939 case 'C': // SSE floating point constant.
1940 case 'G': // x87 floating point constant.
Anton Korobeynikove7772382009-05-03 13:42:53 +00001941 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +00001942 // x86_64 instructions.
Anton Korobeynikove7772382009-05-03 13:42:53 +00001943 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +00001944 // x86_64 instructions.
Eli Friedman872996c2008-08-20 02:34:37 +00001945 return true;
1946 }
Dale Johanneseneba819a2010-08-24 22:33:12 +00001947 return false;
Eli Friedman872996c2008-08-20 02:34:37 +00001948}
1949
Dale Johannesen3a161e52010-10-29 23:12:32 +00001950
Eli Friedman872996c2008-08-20 02:34:37 +00001951std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00001952X86TargetInfo::convertConstraint(const char *&Constraint) const {
1953 switch (*Constraint) {
Eli Friedman872996c2008-08-20 02:34:37 +00001954 case 'a': return std::string("{ax}");
1955 case 'b': return std::string("{bx}");
1956 case 'c': return std::string("{cx}");
1957 case 'd': return std::string("{dx}");
1958 case 'S': return std::string("{si}");
1959 case 'D': return std::string("{di}");
Dale Johannesena49254e2010-10-22 21:07:10 +00001960 case 'p': // address
1961 return std::string("im");
Eli Friedman872996c2008-08-20 02:34:37 +00001962 case 't': // top of floating point stack.
1963 return std::string("{st}");
1964 case 'u': // second from top of floating point stack.
1965 return std::string("{st(1)}"); // second from top of floating point stack.
1966 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00001967 return std::string(1, *Constraint);
Eli Friedman872996c2008-08-20 02:34:37 +00001968 }
1969}
Eli Friedman872996c2008-08-20 02:34:37 +00001970} // end anonymous namespace
Chris Lattner4b009652007-07-25 00:24:17 +00001971
1972namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001973// X86-32 generic target
1974class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +00001975public:
Eli Friedman872996c2008-08-20 02:34:37 +00001976 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1977 DoubleAlign = LongLongAlign = 32;
1978 LongDoubleWidth = 96;
1979 LongDoubleAlign = 32;
Eli Friedman2b161652008-08-21 00:13:15 +00001980 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1981 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00001982 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman04ede302009-03-29 20:31:09 +00001983 SizeType = UnsignedInt;
1984 PtrDiffType = SignedInt;
1985 IntPtrType = SignedInt;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +00001986 RegParmMax = 3;
Daniel Dunbar6f94dbb2010-07-14 23:39:36 +00001987
1988 // Use fpret for all types.
1989 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
1990 (1 << TargetInfo::Double) |
1991 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00001992
1993 // x86-32 has atomics up to 8 bytes
1994 // FIXME: Check that we actually have cmpxchg8b before setting
1995 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
1996 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman872996c2008-08-20 02:34:37 +00001997 }
1998 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001999 return "typedef char* __builtin_va_list;";
Eli Friedman872996c2008-08-20 02:34:37 +00002000 }
Michael J. Spencerd5513a32010-10-21 03:16:25 +00002001
Chris Lattneraa339182009-09-23 06:06:36 +00002002 int getEHDataRegisterNumber(unsigned RegNo) const {
2003 if (RegNo == 0) return 0;
2004 if (RegNo == 1) return 2;
2005 return -1;
2006 }
Eli Friedman872996c2008-08-20 02:34:37 +00002007};
2008} // end anonymous namespace
2009
2010namespace {
Eli Friedman1c79f4b2009-07-05 18:47:56 +00002011class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2012public:
2013 OpenBSDI386TargetInfo(const std::string& triple) :
2014 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2015 SizeType = UnsignedLong;
2016 IntPtrType = SignedLong;
Eli Friedman96ada022009-07-05 22:31:18 +00002017 PtrDiffType = SignedLong;
Eli Friedman1c79f4b2009-07-05 18:47:56 +00002018 }
2019};
2020} // end anonymous namespace
2021
2022namespace {
Edwin Török36565e52009-06-30 17:10:35 +00002023class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman872996c2008-08-20 02:34:37 +00002024public:
Edwin Török36565e52009-06-30 17:10:35 +00002025 DarwinI386TargetInfo(const std::string& triple) :
2026 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman872996c2008-08-20 02:34:37 +00002027 LongDoubleWidth = 128;
2028 LongDoubleAlign = 128;
Eli Friedman04ede302009-03-29 20:31:09 +00002029 SizeType = UnsignedLong;
2030 IntPtrType = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +00002031 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2032 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002033 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar9451c542010-05-27 00:35:16 +00002034 HasAlignMac68kSupport = true;
Edwin Török2d98f9f2009-06-30 17:00:25 +00002035 }
2036
Eli Friedman872996c2008-08-20 02:34:37 +00002037};
Daniel Dunbar64c77a12009-06-29 20:52:51 +00002038} // end anonymous namespace
2039
2040namespace {
Eli Friedman23cb7912008-08-21 01:40:19 +00002041// x86-32 Windows target
Michael J. Spencer01e70082010-10-21 05:21:48 +00002042class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman23cb7912008-08-21 01:40:19 +00002043public:
2044 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencer01e70082010-10-21 05:21:48 +00002045 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +00002046 TLSSupported = false;
Chris Lattnera8a69e12009-06-24 17:12:15 +00002047 WCharType = UnsignedShort;
Eli Friedmanb28055e2009-06-08 21:16:17 +00002048 DoubleAlign = LongLongAlign = 64;
2049 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Anton Korobeynikov186e7d32009-12-19 02:05:07 +00002050 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002051 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman23cb7912008-08-21 01:40:19 +00002052 }
Chris Lattner79682402009-03-20 15:52:06 +00002053 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002054 MacroBuilder &Builder) const {
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00002055 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
Eli Friedman23cb7912008-08-21 01:40:19 +00002056 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002057};
2058} // end anonymous namespace
Eli Friedman6b6ca942009-06-08 06:11:14 +00002059
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002060namespace {
2061
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002062// x86-32 Windows Visual Studio target
2063class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2064public:
2065 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2066 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002067 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00002068 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002069 }
2070 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002071 MacroBuilder &Builder) const {
2072 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00002073 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002074 // The value of the following reflects processor type.
2075 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2076 // We lost the original triple, so we use the default.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002077 Builder.defineMacro("_M_IX86", "600");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002078 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002079};
2080} // end anonymous namespace
2081
2082namespace {
2083// x86-32 MinGW target
2084class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2085public:
2086 MinGWX86_32TargetInfo(const std::string& triple)
2087 : WindowsX86_32TargetInfo(triple) {
2088 }
2089 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002090 MacroBuilder &Builder) const {
2091 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00002092 DefineStd(Builder, "WIN32", Opts);
2093 DefineStd(Builder, "WINNT", Opts);
2094 Builder.defineMacro("_X86_");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002095 Builder.defineMacro("__MSVCRT__");
2096 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002097
2098 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2099 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002100 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002101 // Provide "as-is" __declspec.
2102 Builder.defineMacro("__declspec", "__declspec");
2103 else
2104 // Provide alias of __attribute__ like mingw32-gcc.
2105 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002106 }
2107};
2108} // end anonymous namespace
2109
2110namespace {
2111// x86-32 Cygwin target
2112class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2113public:
2114 CygwinX86_32TargetInfo(const std::string& triple)
2115 : X86_32TargetInfo(triple) {
2116 TLSSupported = false;
2117 WCharType = UnsignedShort;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002118 DoubleAlign = LongLongAlign = 64;
2119 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2120 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002121 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002122 }
2123 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002124 MacroBuilder &Builder) const {
2125 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2126 Builder.defineMacro("__CYGWIN__");
2127 Builder.defineMacro("__CYGWIN32__");
2128 DefineStd(Builder, "unix", Opts);
Douglas Gregor9b22a172010-04-21 05:52:38 +00002129 if (Opts.CPlusPlus)
2130 Builder.defineMacro("_GNU_SOURCE");
Eli Friedman6b6ca942009-06-08 06:11:14 +00002131 }
Eli Friedman23cb7912008-08-21 01:40:19 +00002132};
2133} // end anonymous namespace
2134
2135namespace {
Chris Lattnerf853e732010-04-11 19:29:39 +00002136// x86-32 Haiku target
2137class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2138public:
2139 HaikuX86_32TargetInfo(const std::string& triple)
2140 : X86_32TargetInfo(triple) {
2141 SizeType = UnsignedLong;
Chris Lattner5b8b18a2010-04-22 17:48:00 +00002142 IntPtrType = SignedLong;
2143 PtrDiffType = SignedLong;
Rafael Espindolaa7bdfdd2010-11-09 16:41:02 +00002144 this->UserLabelPrefix = "";
Eli Friedman08f845b2010-08-22 01:00:03 +00002145 }
Chris Lattnerf853e732010-04-11 19:29:39 +00002146 virtual void getTargetDefines(const LangOptions &Opts,
2147 MacroBuilder &Builder) const {
2148 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2149 Builder.defineMacro("__INTEL__");
2150 Builder.defineMacro("__HAIKU__");
2151 }
2152};
2153} // end anonymous namespace
2154
Douglas Gregordca52262011-07-01 22:41:14 +00002155// RTEMS Target
2156template<typename Target>
2157class RTEMSTargetInfo : public OSTargetInfo<Target> {
2158protected:
2159 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2160 MacroBuilder &Builder) const {
2161 // RTEMS defines; list based off of gcc output
2162
Douglas Gregordca52262011-07-01 22:41:14 +00002163 Builder.defineMacro("__rtems__");
2164 Builder.defineMacro("__ELF__");
2165 }
2166public:
2167 RTEMSTargetInfo(const std::string &triple)
2168 : OSTargetInfo<Target>(triple) {
2169 this->UserLabelPrefix = "";
2170
2171 llvm::Triple Triple(triple);
2172 switch (Triple.getArch()) {
2173 default:
2174 case llvm::Triple::x86:
2175 // this->MCountName = ".mcount";
2176 break;
2177 case llvm::Triple::mips:
2178 case llvm::Triple::mipsel:
2179 case llvm::Triple::ppc:
2180 case llvm::Triple::ppc64:
2181 // this->MCountName = "_mcount";
2182 break;
2183 case llvm::Triple::arm:
2184 // this->MCountName = "__mcount";
2185 break;
2186 }
2187
2188 }
2189};
2190
2191namespace {
2192// x86-32 RTEMS target
2193class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2194public:
2195 RTEMSX86_32TargetInfo(const std::string& triple)
2196 : X86_32TargetInfo(triple) {
2197 SizeType = UnsignedLong;
2198 IntPtrType = SignedLong;
2199 PtrDiffType = SignedLong;
2200 this->UserLabelPrefix = "";
2201 }
2202 virtual void getTargetDefines(const LangOptions &Opts,
2203 MacroBuilder &Builder) const {
2204 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2205 Builder.defineMacro("__INTEL__");
2206 Builder.defineMacro("__rtems__");
2207 }
2208};
2209} // end anonymous namespace
2210
Chris Lattnerf853e732010-04-11 19:29:39 +00002211namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00002212// x86-64 generic target
2213class X86_64TargetInfo : public X86TargetInfo {
2214public:
Chris Lattner79682402009-03-20 15:52:06 +00002215 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +00002216 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002217 LongDoubleWidth = 128;
2218 LongDoubleAlign = 128;
Rafael Espindolabfa7c002010-06-04 23:15:27 +00002219 LargeArrayMinWidth = 128;
2220 LargeArrayAlign = 128;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00002221 IntMaxType = SignedLong;
2222 UIntMaxType = UnsignedLong;
Eli Friedman38e31802009-07-01 03:36:11 +00002223 Int64Type = SignedLong;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +00002224 RegParmMax = 6;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00002225
Eli Friedman2b161652008-08-21 00:13:15 +00002226 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2227 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002228 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbar6f94dbb2010-07-14 23:39:36 +00002229
2230 // Use fpret only for long double.
2231 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00002232
2233 // x86-64 has atomics up to 16 bytes.
2234 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
2235 // on CPUs with cmpxchg16b
2236 MaxAtomicPromoteWidth = 128;
2237 MaxAtomicInlineWidth = 64;
Chris Lattner4b009652007-07-25 00:24:17 +00002238 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +00002239 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002240 return "typedef struct __va_list_tag {"
2241 " unsigned gp_offset;"
2242 " unsigned fp_offset;"
2243 " void* overflow_arg_area;"
2244 " void* reg_save_area;"
John McCall33bf24b2010-05-28 18:25:28 +00002245 "} __va_list_tag;"
Eli Friedman3c79eee2009-07-03 00:45:06 +00002246 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson7dd1c952007-11-24 23:38:12 +00002247 }
Michael J. Spencer3d796932010-10-18 07:10:59 +00002248
Chris Lattneraa339182009-09-23 06:06:36 +00002249 int getEHDataRegisterNumber(unsigned RegNo) const {
2250 if (RegNo == 0) return 0;
2251 if (RegNo == 1) return 1;
2252 return -1;
2253 }
Eli Friedman872996c2008-08-20 02:34:37 +00002254};
2255} // end anonymous namespace
2256
2257namespace {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002258// x86-64 Windows target
Michael J. Spencer01e70082010-10-21 05:21:48 +00002259class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002260public:
2261 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencer01e70082010-10-21 05:21:48 +00002262 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002263 TLSSupported = false;
2264 WCharType = UnsignedShort;
Mike Stump4da7a162009-10-08 23:00:00 +00002265 LongWidth = LongAlign = 32;
Michael J. Spencer3d796932010-10-18 07:10:59 +00002266 DoubleAlign = LongLongAlign = 64;
Nate Begeman472bd992010-07-21 02:02:56 +00002267 IntMaxType = SignedLongLong;
2268 UIntMaxType = UnsignedLongLong;
2269 Int64Type = SignedLongLong;
Cameron Esfahani32083822010-09-15 00:28:12 +00002270 SizeType = UnsignedLongLong;
2271 PtrDiffType = SignedLongLong;
2272 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00002273 this->UserLabelPrefix = "";
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002274 }
2275 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002276 MacroBuilder &Builder) const {
Michael J. Spencer01e70082010-10-21 05:21:48 +00002277 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002278 Builder.defineMacro("_WIN64");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002279 }
NAKAMURA Takumi79521992011-01-17 22:56:23 +00002280 virtual const char *getVAListDeclaration() const {
2281 return "typedef char* __builtin_va_list;";
2282 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002283};
2284} // end anonymous namespace
2285
2286namespace {
2287// x86-64 Windows Visual Studio target
2288class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2289public:
2290 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2291 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002292 LongDoubleWidth = LongDoubleAlign = 64;
2293 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002294 }
2295 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002296 MacroBuilder &Builder) const {
2297 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00002298 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002299 Builder.defineMacro("_M_X64");
Michael J. Spencer01e70082010-10-21 05:21:48 +00002300 Builder.defineMacro("_M_AMD64");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002301 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002302};
2303} // end anonymous namespace
2304
2305namespace {
2306// x86-64 MinGW target
2307class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2308public:
2309 MinGWX86_64TargetInfo(const std::string& triple)
2310 : WindowsX86_64TargetInfo(triple) {
2311 }
2312 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002313 MacroBuilder &Builder) const {
2314 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00002315 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002316 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00002317 Builder.defineMacro("__MINGW32__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002318 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002319
2320 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2321 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002322 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002323 // Provide "as-is" __declspec.
2324 Builder.defineMacro("__declspec", "__declspec");
2325 else
2326 // Provide alias of __attribute__ like mingw32-gcc.
2327 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002328 }
2329};
2330} // end anonymous namespace
2331
2332namespace {
Eli Friedman38e31802009-07-01 03:36:11 +00002333class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2334public:
Mike Stump25cf7602009-09-09 15:08:12 +00002335 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman38e31802009-07-01 03:36:11 +00002336 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2337 Int64Type = SignedLongLong;
2338 }
2339};
2340} // end anonymous namespace
2341
2342namespace {
Eli Friedman96ada022009-07-05 22:31:18 +00002343class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
2344public:
Mike Stump25cf7602009-09-09 15:08:12 +00002345 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman96ada022009-07-05 22:31:18 +00002346 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
2347 IntMaxType = SignedLongLong;
2348 UIntMaxType = UnsignedLongLong;
2349 Int64Type = SignedLongLong;
2350 }
2351};
2352} // end anonymous namespace
2353
2354namespace {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00002355class ARMTargetInfo : public TargetInfo {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002356 // Possible FPU choices.
2357 enum FPUMode {
2358 NoFPU,
2359 VFP2FPU,
2360 VFP3FPU,
2361 NeonFPU
2362 };
2363
2364 static bool FPUModeIsVFP(FPUMode Mode) {
2365 return Mode >= VFP2FPU && Mode <= NeonFPU;
2366 }
2367
2368 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2369 static const char * const GCCRegNames[];
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002370
Daniel Dunbar33b40752009-12-18 18:42:37 +00002371 std::string ABI, CPU;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002372
2373 unsigned FPU : 3;
2374
Daniel Dunbar48075d82009-12-19 04:15:38 +00002375 unsigned IsThumb : 1;
2376
2377 // Initialized via features.
2378 unsigned SoftFloat : 1;
2379 unsigned SoftFloatABI : 1;
Daniel Dunbar0d83d512009-09-14 00:35:03 +00002380
Chris Lattnerb4527522010-03-03 19:03:45 +00002381 static const Builtin::Info BuiltinInfo[];
2382
Chris Lattner9fd73612008-04-21 18:56:49 +00002383public:
Daniel Dunbarf0156562009-09-17 16:21:10 +00002384 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbar33b40752009-12-18 18:42:37 +00002385 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar0d83d512009-09-14 00:35:03 +00002386 {
Daniel Dunbarb9531632009-09-14 00:02:24 +00002387 SizeType = UnsignedInt;
2388 PtrDiffType = SignedInt;
Daniel Dunbarf0156562009-09-17 16:21:10 +00002389
Chris Lattnere20b8122010-04-23 16:29:58 +00002390 // {} in inline assembly are neon specifiers, not assembly variant
2391 // specifiers.
2392 NoAsmVariants = true;
Michael J. Spencerd5513a32010-10-21 03:16:25 +00002393
Daniel Dunbar33b40752009-12-18 18:42:37 +00002394 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0a542ca2009-12-18 19:57:13 +00002395 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00002396 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002397 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2398 // so set preferred for small types to 32.
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00002399 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
2400 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002401 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00002402 } else {
2403 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2404 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002405 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00002406 }
John McCall68086b92010-08-21 22:46:04 +00002407
2408 // ARM targets default to using the ARM C++ ABI.
2409 CXXABI = CXXABI_ARM;
Eli Friedman2be46072011-10-14 20:59:01 +00002410
2411 // ARM has atomics up to 8 bytes
2412 // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e
2413 MaxAtomicPromoteWidth = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002414 }
Daniel Dunbar0d83d512009-09-14 00:35:03 +00002415 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbarb9531632009-09-14 00:02:24 +00002416 virtual bool setABI(const std::string &Name) {
Daniel Dunbar0d83d512009-09-14 00:35:03 +00002417 ABI = Name;
2418
Daniel Dunbarb9531632009-09-14 00:02:24 +00002419 // The defaults (above) are for AAPCS, check if we need to change them.
2420 //
2421 // FIXME: We need support for -meabi... we could just mangle it into the
2422 // name.
2423 if (Name == "apcs-gnu") {
Daniel Dunbarda94a772010-01-27 20:23:08 +00002424 DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
Daniel Dunbarb9531632009-09-14 00:02:24 +00002425 SizeType = UnsignedLong;
2426
Daniel Dunbar9eb811b2010-04-22 16:14:54 +00002427 // Do not respect the alignment of bit-field types when laying out
2428 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
2429 UseBitFieldTypeAlignment = false;
2430
Chad Rosier61a62212011-08-04 01:21:14 +00002431 /// Do force alignment of members that follow zero length bitfields. If
2432 /// the alignment of the zero-length bitfield is greater than the member
2433 /// that follows it, `bar', `bar' will be aligned as the type of the
2434 /// zero length bitfield.
2435 UseZeroLengthBitfieldAlignment = true;
2436
2437 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00002438 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
2439 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00002440 ZeroLengthBitfieldBoundary = 32;
2441
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00002442 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002443 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2444 // so set preferred for small types to 32.
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00002445 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 +00002446 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002447 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00002448 } else {
2449 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 +00002450 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002451 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00002452 }
2453
Daniel Dunbarb9531632009-09-14 00:02:24 +00002454 // FIXME: Override "preferred align" for double and long long.
2455 } else if (Name == "aapcs") {
2456 // FIXME: Enumerated types are variable width in straight AAPCS.
2457 } else if (Name == "aapcs-linux") {
2458 ;
2459 } else
2460 return false;
2461
2462 return true;
2463 }
Daniel Dunbar48075d82009-12-19 04:15:38 +00002464
Chandler Carruthc3a2e652011-09-28 05:56:05 +00002465 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002466 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
2467 Features["vfp2"] = true;
2468 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
2469 Features["neon"] = true;
2470 }
Michael J. Spencerd5513a32010-10-21 03:16:25 +00002471
Daniel Dunbar48075d82009-12-19 04:15:38 +00002472 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2473 const std::string &Name,
2474 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00002475 if (Name == "soft-float" || Name == "soft-float-abi" ||
Stephen Hines64f85312011-10-21 14:54:52 -07002476 Name == "vfp2" || Name == "vfp3" || Name == "neon" ||
2477 Name == "long64") {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002478 Features[Name] = Enabled;
2479 } else
Daniel Dunbar48075d82009-12-19 04:15:38 +00002480 return false;
2481
Daniel Dunbar48075d82009-12-19 04:15:38 +00002482 return true;
2483 }
2484
2485 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002486 FPU = NoFPU;
Daniel Dunbar48075d82009-12-19 04:15:38 +00002487 SoftFloat = SoftFloatABI = false;
2488 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
2489 if (Features[i] == "+soft-float")
2490 SoftFloat = true;
2491 else if (Features[i] == "+soft-float-abi")
2492 SoftFloatABI = true;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002493 else if (Features[i] == "+vfp2")
2494 FPU = VFP2FPU;
2495 else if (Features[i] == "+vfp3")
2496 FPU = VFP3FPU;
2497 else if (Features[i] == "+neon")
2498 FPU = NeonFPU;
Stephen Hines64f85312011-10-21 14:54:52 -07002499 else if (Features[i] == "+long64")
2500 LongWidth = LongAlign = 64; // RenderScript uses a 64-bit long type
Daniel Dunbar48075d82009-12-19 04:15:38 +00002501 }
2502
2503 // Remove front-end specific options which the backend handles differently.
2504 std::vector<std::string>::iterator it;
2505 it = std::find(Features.begin(), Features.end(), "+soft-float");
2506 if (it != Features.end())
2507 Features.erase(it);
2508 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2509 if (it != Features.end())
2510 Features.erase(it);
2511 }
2512
Chris Lattner5f9e2722011-07-23 10:55:15 +00002513 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbar33b40752009-12-18 18:42:37 +00002514 return llvm::StringSwitch<const char*>(Name)
2515 .Cases("arm8", "arm810", "4")
2516 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2517 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2518 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2519 .Case("ep9312", "4T")
2520 .Cases("arm10tdmi", "arm1020t", "5T")
2521 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2522 .Case("arm926ej-s", "5TEJ")
2523 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2524 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002525 .Case("arm1136j-s", "6J")
Daniel Dunbar33b40752009-12-18 18:42:37 +00002526 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002527 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbar33b40752009-12-18 18:42:37 +00002528 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2529 .Cases("cortex-a8", "cortex-a9", "7A")
Bob Wilson06f45632011-01-06 16:57:20 +00002530 .Case("cortex-m3", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00002531 .Case("cortex-m0", "6M")
Daniel Dunbar33b40752009-12-18 18:42:37 +00002532 .Default(0);
2533 }
2534 virtual bool setCPU(const std::string &Name) {
2535 if (!getCPUDefineSuffix(Name))
2536 return false;
2537
2538 CPU = Name;
2539 return true;
2540 }
Chris Lattner79682402009-03-20 15:52:06 +00002541 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002542 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00002543 // Target identification.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002544 Builder.defineMacro("__arm");
2545 Builder.defineMacro("__arm__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00002546
Chris Lattnerbef1d722009-03-02 22:27:17 +00002547 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002548 Builder.defineMacro("__ARMEL__");
2549 Builder.defineMacro("__LITTLE_ENDIAN__");
2550 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbar33b40752009-12-18 18:42:37 +00002551
Chris Lattner5f9e2722011-07-23 10:55:15 +00002552 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002553 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00002554
Mike Stumpf90a29f2009-04-08 02:07:04 +00002555 // Subtarget options.
Daniel Dunbarf0156562009-09-17 16:21:10 +00002556
Daniel Dunbar33b40752009-12-18 18:42:37 +00002557 // FIXME: It's more complicated than this and we don't really support
2558 // interworking.
2559 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002560 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00002561
Daniel Dunbar33b40752009-12-18 18:42:37 +00002562 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002563 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00002564
Daniel Dunbar48075d82009-12-19 04:15:38 +00002565 if (SoftFloat)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002566 Builder.defineMacro("__SOFTFP__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00002567
2568 if (CPU == "xscale")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002569 Builder.defineMacro("__XSCALE__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00002570
Bob Wilson84f95cf2011-05-13 18:56:03 +00002571 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbarf0156562009-09-17 16:21:10 +00002572 if (IsThumb) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002573 Builder.defineMacro("__THUMBEL__");
2574 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00002575 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002576 Builder.defineMacro("__thumb2__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00002577 }
2578
2579 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002580 Builder.defineMacro("__APCS_32__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002581
2582 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002583 Builder.defineMacro("__VFP_FP__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002584
2585 // This only gets set when Neon instructions are actually available, unlike
2586 // the VFP define, hence the soft float and arch check. This is subtly
2587 // different from gcc, we follow the intent which was that it should be set
2588 // when Neon instructions are actually available.
Bob Wilson84f95cf2011-05-13 18:56:03 +00002589 if (FPU == NeonFPU && !SoftFloat && IsARMv7)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002590 Builder.defineMacro("__ARM_NEON__");
Chris Lattner9fd73612008-04-21 18:56:49 +00002591 }
2592 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2593 unsigned &NumRecords) const {
Chris Lattnerb4527522010-03-03 19:03:45 +00002594 Records = BuiltinInfo;
2595 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner9fd73612008-04-21 18:56:49 +00002596 }
2597 virtual const char *getVAListDeclaration() const {
John McCall0e9972c2011-05-09 02:19:37 +00002598 return "typedef void* __builtin_va_list;";
Chris Lattner9fd73612008-04-21 18:56:49 +00002599 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00002600 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002601 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00002602 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002603 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00002604 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00002605 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00002606 // FIXME: Check if this is complete
Anders Carlsson36834a72009-02-28 17:11:49 +00002607 switch (*Name) {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00002608 default:
Nate Begeman222823a2008-04-22 05:03:19 +00002609 case 'l': // r0-r7
2610 case 'h': // r8-r15
2611 case 'w': // VFP Floating point register single precision
2612 case 'P': // VFP Floating point register double precision
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00002613 Info.setAllowsRegister();
Nate Begeman222823a2008-04-22 05:03:19 +00002614 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00002615 case 'Q': // A memory address that is a single base register.
2616 Info.setAllowsMemory();
2617 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00002618 case 'U': // a memory reference...
2619 switch (Name[1]) {
2620 case 'q': // ...ARMV4 ldrsb
2621 case 'v': // ...VFP load/store (reg+constant offset)
2622 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00002623 case 't': // address valid for load/store opaque types wider
2624 // than 128-bits
2625 case 'n': // valid address for Neon doubleword vector load/store
2626 case 'm': // valid address for Neon element and structure load/store
2627 case 's': // valid address for non-offset loads/stores of quad-word
2628 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00002629 Info.setAllowsMemory();
2630 Name++;
2631 return true;
2632 }
Nate Begeman222823a2008-04-22 05:03:19 +00002633 }
Chris Lattner9fd73612008-04-21 18:56:49 +00002634 return false;
2635 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00002636 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00002637 std::string R;
2638 switch (*Constraint) {
2639 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00002640 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00002641 Constraint++;
2642 break;
Eric Christopher283f4472011-06-17 00:40:18 +00002643 case 'p': // 'p' should be translated to 'r' by default.
2644 R = std::string("r");
2645 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00002646 default:
2647 return std::string(1, *Constraint);
2648 }
2649 return R;
2650 }
Chris Lattner9fd73612008-04-21 18:56:49 +00002651 virtual const char *getClobbers() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00002652 // FIXME: Is this really right?
Chris Lattner9fd73612008-04-21 18:56:49 +00002653 return "";
2654 }
2655};
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002656
2657const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbar663e9f82010-08-11 02:17:20 +00002658 // Integer registers
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002659 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbar663e9f82010-08-11 02:17:20 +00002660 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
2661
2662 // Float registers
2663 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2664 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2665 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen0bbb50d2010-10-27 23:34:42 +00002666 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbar663e9f82010-08-11 02:17:20 +00002667
Dale Johannesen0bbb50d2010-10-27 23:34:42 +00002668 // Double registers
2669 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
2670 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesen0d79b042010-10-28 01:05:37 +00002671 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
2672 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen0bbb50d2010-10-27 23:34:42 +00002673
2674 // Quad registers
Dale Johannesen0d79b042010-10-28 01:05:37 +00002675 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
2676 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002677};
2678
2679void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar00ea8f02010-08-11 02:17:11 +00002680 unsigned &NumNames) const {
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002681 Names = GCCRegNames;
2682 NumNames = llvm::array_lengthof(GCCRegNames);
2683}
2684
2685const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002686 { { "a1" }, "r0" },
2687 { { "a2" }, "r1" },
2688 { { "a3" }, "r2" },
2689 { { "a4" }, "r3" },
2690 { { "v1" }, "r4" },
2691 { { "v2" }, "r5" },
2692 { { "v3" }, "r6" },
2693 { { "v4" }, "r7" },
2694 { { "v5" }, "r8" },
2695 { { "v6", "rfp" }, "r9" },
2696 { { "sl" }, "r10" },
2697 { { "fp" }, "r11" },
2698 { { "ip" }, "r12" },
Daniel Dunbar00ea8f02010-08-11 02:17:11 +00002699 { { "r13" }, "sp" },
2700 { { "r14" }, "lr" },
2701 { { "r15" }, "pc" },
Dale Johannesen0bbb50d2010-10-27 23:34:42 +00002702 // The S, D and Q registers overlap, but aren't really aliases; we
2703 // don't want to substitute one of these for a different-sized one.
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002704};
2705
2706void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2707 unsigned &NumAliases) const {
2708 Aliases = GCCRegAliases;
2709 NumAliases = llvm::array_lengthof(GCCRegAliases);
2710}
Chris Lattnerb4527522010-03-03 19:03:45 +00002711
2712const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00002713#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00002714#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00002715 ALL_LANGUAGES },
Chris Lattnerb4527522010-03-03 19:03:45 +00002716#include "clang/Basic/BuiltinsARM.def"
2717};
Chris Lattner9fd73612008-04-21 18:56:49 +00002718} // end anonymous namespace.
2719
Eli Friedmanbe727fe2008-08-20 07:44:10 +00002720
2721namespace {
Mike Stump25cf7602009-09-09 15:08:12 +00002722class DarwinARMTargetInfo :
Edwin Török36565e52009-06-30 17:10:35 +00002723 public DarwinTargetInfo<ARMTargetInfo> {
2724protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +00002725 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002726 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00002727 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedman8f575172009-04-19 21:38:35 +00002728 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00002729
Edwin Török36565e52009-06-30 17:10:35 +00002730public:
Mike Stump25cf7602009-09-09 15:08:12 +00002731 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar01045582010-05-27 07:00:26 +00002732 : DarwinTargetInfo<ARMTargetInfo>(triple) {
2733 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00002734 // iOS always has 64-bit atomic instructions.
2735 // FIXME: This should be based off of the target features in ARMTargetInfo.
2736 MaxAtomicInlineWidth = 64;
Daniel Dunbar01045582010-05-27 07:00:26 +00002737 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00002738};
2739} // end anonymous namespace.
2740
Chris Lattner4b009652007-07-25 00:24:17 +00002741namespace {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002742class SparcV8TargetInfo : public TargetInfo {
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002743 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2744 static const char * const GCCRegNames[];
Bruno Cardoso Lopes584a4562010-11-09 17:21:19 +00002745 bool SoftFloat;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002746public:
Eli Friedmanff158dd2008-08-20 07:28:14 +00002747 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
2748 // FIXME: Support Sparc quad-precision long double?
Eli Friedman2b161652008-08-21 00:13:15 +00002749 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00002750 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedmanff158dd2008-08-20 07:28:14 +00002751 }
Bruno Cardoso Lopes584a4562010-11-09 17:21:19 +00002752 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2753 const std::string &Name,
2754 bool Enabled) const {
2755 if (Name == "soft-float")
2756 Features[Name] = Enabled;
2757 else
2758 return false;
2759
2760 return true;
2761 }
2762 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
2763 SoftFloat = false;
2764 for (unsigned i = 0, e = Features.size(); i != e; ++i)
2765 if (Features[i] == "+soft-float")
2766 SoftFloat = true;
2767 }
Chris Lattner79682402009-03-20 15:52:06 +00002768 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002769 MacroBuilder &Builder) const {
2770 DefineStd(Builder, "sparc", Opts);
2771 Builder.defineMacro("__sparcv8");
2772 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes584a4562010-11-09 17:21:19 +00002773
2774 if (SoftFloat)
2775 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002776 }
2777 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2778 unsigned &NumRecords) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002779 // FIXME: Implement!
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002780 }
2781 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002782 return "typedef void* __builtin_va_list;";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002783 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00002784 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002785 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00002786 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002787 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00002788 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002789 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002790 // FIXME: Implement!
2791 return false;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002792 }
2793 virtual const char *getClobbers() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002794 // FIXME: Implement!
2795 return "";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002796 }
2797};
2798
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002799const char * const SparcV8TargetInfo::GCCRegNames[] = {
2800 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2801 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2802 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2803 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
2804};
2805
Anton Korobeynikove7772382009-05-03 13:42:53 +00002806void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002807 unsigned &NumNames) const {
2808 Names = GCCRegNames;
2809 NumNames = llvm::array_lengthof(GCCRegNames);
2810}
2811
2812const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikove7772382009-05-03 13:42:53 +00002813 { { "g0" }, "r0" },
2814 { { "g1" }, "r1" },
2815 { { "g2" }, "r2" },
2816 { { "g3" }, "r3" },
2817 { { "g4" }, "r4" },
2818 { { "g5" }, "r5" },
2819 { { "g6" }, "r6" },
2820 { { "g7" }, "r7" },
2821 { { "o0" }, "r8" },
2822 { { "o1" }, "r9" },
2823 { { "o2" }, "r10" },
2824 { { "o3" }, "r11" },
2825 { { "o4" }, "r12" },
2826 { { "o5" }, "r13" },
2827 { { "o6", "sp" }, "r14" },
2828 { { "o7" }, "r15" },
2829 { { "l0" }, "r16" },
2830 { { "l1" }, "r17" },
2831 { { "l2" }, "r18" },
2832 { { "l3" }, "r19" },
2833 { { "l4" }, "r20" },
2834 { { "l5" }, "r21" },
2835 { { "l6" }, "r22" },
2836 { { "l7" }, "r23" },
2837 { { "i0" }, "r24" },
2838 { { "i1" }, "r25" },
2839 { { "i2" }, "r26" },
2840 { { "i3" }, "r27" },
2841 { { "i4" }, "r28" },
2842 { { "i5" }, "r29" },
2843 { { "i6", "fp" }, "r30" },
2844 { { "i7" }, "r31" },
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002845};
2846
Anton Korobeynikove7772382009-05-03 13:42:53 +00002847void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002848 unsigned &NumAliases) const {
2849 Aliases = GCCRegAliases;
2850 NumAliases = llvm::array_lengthof(GCCRegAliases);
2851}
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002852} // end anonymous namespace.
2853
Eli Friedmanff158dd2008-08-20 07:28:14 +00002854namespace {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002855class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
2856public:
2857 AuroraUXSparcV8TargetInfo(const std::string& triple) :
2858 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
2859 SizeType = UnsignedInt;
2860 PtrDiffType = SignedInt;
2861 }
2862};
Edwin Török36565e52009-06-30 17:10:35 +00002863class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002864public:
2865 SolarisSparcV8TargetInfo(const std::string& triple) :
Edwin Török36565e52009-06-30 17:10:35 +00002866 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedman7cca0982008-11-02 02:43:55 +00002867 SizeType = UnsignedInt;
2868 PtrDiffType = SignedInt;
Eli Friedmanff158dd2008-08-20 07:28:14 +00002869 }
2870};
2871} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +00002872
Chris Lattner85970f32008-05-08 05:58:21 +00002873namespace {
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002874 class MSP430TargetInfo : public TargetInfo {
2875 static const char * const GCCRegNames[];
2876 public:
2877 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
2878 TLSSupported = false;
Anton Korobeynikov2a6630a2010-01-30 12:55:11 +00002879 IntWidth = 16; IntAlign = 16;
2880 LongWidth = 32; LongLongWidth = 64;
2881 LongAlign = LongLongAlign = 16;
2882 PointerWidth = 16; PointerAlign = 16;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002883 SizeType = UnsignedInt;
2884 IntMaxType = SignedLong;
2885 UIntMaxType = UnsignedLong;
2886 IntPtrType = SignedShort;
2887 PtrDiffType = SignedInt;
Edward O'Callaghan14a70a32009-11-21 00:49:54 +00002888 SigAtomicType = SignedLong;
Anton Korobeynikov314713f2009-12-19 01:32:37 +00002889 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002890 }
2891 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002892 MacroBuilder &Builder) const {
2893 Builder.defineMacro("MSP430");
2894 Builder.defineMacro("__MSP430__");
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002895 // FIXME: defines for different 'flavours' of MCU
2896 }
2897 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2898 unsigned &NumRecords) const {
2899 // FIXME: Implement.
2900 Records = 0;
2901 NumRecords = 0;
2902 }
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002903 virtual void getGCCRegNames(const char * const *&Names,
2904 unsigned &NumNames) const;
2905 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2906 unsigned &NumAliases) const {
2907 // No aliases.
2908 Aliases = 0;
2909 NumAliases = 0;
2910 }
2911 virtual bool validateAsmConstraint(const char *&Name,
2912 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov174219b2009-10-15 23:17:13 +00002913 // No target constraints for now.
2914 return false;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002915 }
2916 virtual const char *getClobbers() const {
2917 // FIXME: Is this really right?
2918 return "";
2919 }
2920 virtual const char *getVAListDeclaration() const {
2921 // FIXME: implement
Anton Korobeynikovf5955592009-05-08 18:24:57 +00002922 return "typedef char* __builtin_va_list;";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002923 }
2924 };
2925
2926 const char * const MSP430TargetInfo::GCCRegNames[] = {
2927 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2928 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2929 };
2930
2931 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
2932 unsigned &NumNames) const {
2933 Names = GCCRegNames;
2934 NumNames = llvm::array_lengthof(GCCRegNames);
2935 }
2936}
2937
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002938namespace {
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002939
Mike Stump25cf7602009-09-09 15:08:12 +00002940 // LLVM and Clang cannot be used directly to output native binaries for
2941 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002942 // type and alignment information.
Mike Stump25cf7602009-09-09 15:08:12 +00002943 //
2944 // TCE uses the llvm bitcode as input and uses it for generating customized
2945 // target processor and program binary. TCE co-design environment is
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002946 // publicly available in http://tce.cs.tut.fi
2947
Eli Friedman209f5bb2011-10-07 19:51:42 +00002948 static const unsigned TCEOpenCLAddrSpaceMap[] = {
2949 3, // opencl_global
2950 4, // opencl_local
2951 5 // opencl_constant
2952 };
2953
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002954 class TCETargetInfo : public TargetInfo{
2955 public:
2956 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
2957 TLSSupported = false;
2958 IntWidth = 32;
2959 LongWidth = LongLongWidth = 32;
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002960 PointerWidth = 32;
2961 IntAlign = 32;
2962 LongAlign = LongLongAlign = 32;
2963 PointerAlign = 32;
2964 SizeType = UnsignedInt;
2965 IntMaxType = SignedLong;
2966 UIntMaxType = UnsignedLong;
2967 IntPtrType = SignedInt;
2968 PtrDiffType = SignedInt;
2969 FloatWidth = 32;
2970 FloatAlign = 32;
2971 DoubleWidth = 32;
2972 DoubleAlign = 32;
2973 LongDoubleWidth = 32;
2974 LongDoubleAlign = 32;
2975 FloatFormat = &llvm::APFloat::IEEEsingle;
2976 DoubleFormat = &llvm::APFloat::IEEEsingle;
2977 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner8a1db932010-03-04 21:07:38 +00002978 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
2979 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00002980 "f32:32:32-f64:32:32-v64:32:32-"
2981 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00002982 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002983 }
2984
2985 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002986 MacroBuilder &Builder) const {
2987 DefineStd(Builder, "tce", Opts);
2988 Builder.defineMacro("__TCE__");
2989 Builder.defineMacro("__TCE_V1__");
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002990 }
2991 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2992 unsigned &NumRecords) const {}
Daniel Dunbar2e967de2009-08-24 09:54:37 +00002993 virtual const char *getClobbers() const {
2994 return "";
2995 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002996 virtual const char *getVAListDeclaration() const {
2997 return "typedef void* __builtin_va_list;";
2998 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002999 virtual void getGCCRegNames(const char * const *&Names,
3000 unsigned &NumNames) const {}
3001 virtual bool validateAsmConstraint(const char *&Name,
3002 TargetInfo::ConstraintInfo &info) const {
3003 return true;
3004 }
3005 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3006 unsigned &NumAliases) const {}
3007 };
3008}
3009
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003010namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003011class MipsTargetInfoBase : public TargetInfo {
3012 std::string CPU;
3013protected:
3014 std::string ABI;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003015public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003016 MipsTargetInfoBase(const std::string& triple, const std::string& ABIStr)
3017 : TargetInfo(triple), ABI(ABIStr) {
Akira Hatanaka619e8872011-06-02 00:09:17 +00003018 SizeType = UnsignedInt;
3019 PtrDiffType = SignedInt;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003020 }
Eric Christopher03cc0ef2010-03-02 02:41:08 +00003021 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003022 virtual bool setABI(const std::string &Name) = 0;
Eric Christopher03cc0ef2010-03-02 02:41:08 +00003023 virtual bool setCPU(const std::string &Name) {
3024 CPU = Name;
3025 return true;
3026 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003027 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christopher03cc0ef2010-03-02 02:41:08 +00003028 Features[ABI] = true;
3029 Features[CPU] = true;
3030 }
3031 virtual void getArchDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003032 MacroBuilder &Builder) const = 0;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003033 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003034 MacroBuilder &Builder) const = 0;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003035 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3036 unsigned &NumRecords) const {
3037 // FIXME: Implement!
3038 }
3039 virtual const char *getVAListDeclaration() const {
3040 return "typedef void* __builtin_va_list;";
3041 }
3042 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003043 unsigned &NumNames) const {
3044 static const char * const GCCRegNames[] = {
3045 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
3046 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
3047 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
3048 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
3049 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
3050 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
3051 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
3052 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
3053 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
3054 "$fcc5","$fcc6","$fcc7"
3055 };
3056 Names = GCCRegNames;
3057 NumNames = llvm::array_lengthof(GCCRegNames);
3058 }
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003059 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003060 unsigned &NumAliases) const = 0;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003061 virtual bool validateAsmConstraint(const char *&Name,
3062 TargetInfo::ConstraintInfo &Info) const {
3063 switch (*Name) {
3064 default:
3065 case 'r': // CPU registers.
3066 case 'd': // Equivalent to "r" unless generating MIPS16 code.
3067 case 'y': // Equivalent to "r", backwards compatibility only.
3068 case 'f': // floating-point registers.
3069 Info.setAllowsRegister();
3070 return true;
3071 }
3072 return false;
3073 }
3074
3075 virtual const char *getClobbers() const {
3076 // FIXME: Implement!
3077 return "";
3078 }
3079};
3080
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003081class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003082public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003083 Mips32TargetInfoBase(const std::string& triple) :
3084 MipsTargetInfoBase(triple, "o32") {}
3085 virtual bool setABI(const std::string &Name) {
3086 if ((Name == "o32") || (Name == "eabi")) {
3087 ABI = Name;
3088 return true;
3089 } else
3090 return false;
3091 }
3092 virtual void getArchDefines(const LangOptions &Opts,
3093 MacroBuilder &Builder) const {
3094 if (ABI == "o32") {
3095 Builder.defineMacro("__mips_o32");
3096 Builder.defineMacro("_ABIO32", "1");
3097 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
3098 }
3099 else if (ABI == "eabi")
3100 Builder.defineMacro("__mips_eabi");
3101 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003102 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003103 }
3104 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3105 unsigned &NumAliases) const {
3106 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3107 { { "at" }, "$1" },
3108 { { "v0" }, "$2" },
3109 { { "v1" }, "$3" },
3110 { { "a0" }, "$4" },
3111 { { "a1" }, "$5" },
3112 { { "a2" }, "$6" },
3113 { { "a3" }, "$7" },
3114 { { "t0" }, "$8" },
3115 { { "t1" }, "$9" },
3116 { { "t2" }, "$10" },
3117 { { "t3" }, "$11" },
3118 { { "t4" }, "$12" },
3119 { { "t5" }, "$13" },
3120 { { "t6" }, "$14" },
3121 { { "t7" }, "$15" },
3122 { { "s0" }, "$16" },
3123 { { "s1" }, "$17" },
3124 { { "s2" }, "$18" },
3125 { { "s3" }, "$19" },
3126 { { "s4" }, "$20" },
3127 { { "s5" }, "$21" },
3128 { { "s6" }, "$22" },
3129 { { "s7" }, "$23" },
3130 { { "t8" }, "$24" },
3131 { { "t9" }, "$25" },
3132 { { "k0" }, "$26" },
3133 { { "k1" }, "$27" },
3134 { { "gp" }, "$28" },
3135 { { "sp" }, "$29" },
3136 { { "fp" }, "$30" },
3137 { { "ra" }, "$31" }
3138 };
3139 Aliases = GCCRegAliases;
3140 NumAliases = llvm::array_lengthof(GCCRegAliases);
3141 }
3142};
3143
3144class Mips32EBTargetInfo : public Mips32TargetInfoBase {
3145public:
3146 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
3147 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3148 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3149 }
3150 virtual void getTargetDefines(const LangOptions &Opts,
3151 MacroBuilder &Builder) const {
3152 DefineStd(Builder, "mips", Opts);
3153 Builder.defineMacro("_mips");
3154 DefineStd(Builder, "MIPSEB", Opts);
3155 Builder.defineMacro("_MIPSEB");
3156 Builder.defineMacro("__REGISTER_PREFIX__", "");
3157 getArchDefines(Opts, Builder);
3158 }
3159};
3160
3161class Mips32ELTargetInfo : public Mips32TargetInfoBase {
3162public:
3163 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003164 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 +00003165 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003166 }
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003167 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003168 MacroBuilder &Builder) const {
3169 DefineStd(Builder, "mips", Opts);
3170 Builder.defineMacro("_mips");
3171 DefineStd(Builder, "MIPSEL", Opts);
3172 Builder.defineMacro("_MIPSEL");
3173 Builder.defineMacro("__REGISTER_PREFIX__", "");
3174 getArchDefines(Opts, Builder);
3175 }
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003176};
3177
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003178class Mips64TargetInfoBase : public MipsTargetInfoBase {
3179 virtual void SetDescriptionString(const std::string &Name) = 0;
3180public:
3181 Mips64TargetInfoBase(const std::string& triple) :
Akira Hatanaka12507592011-10-22 00:07:27 +00003182 MipsTargetInfoBase(triple, "n64") {
3183 LongWidth = LongAlign = 64;
3184 PointerWidth = PointerAlign = 64;
3185 LongDoubleWidth = LongDoubleAlign = 128;
3186 LongDoubleFormat = &llvm::APFloat::IEEEquad;
3187 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003188 virtual bool setABI(const std::string &Name) {
3189 SetDescriptionString(Name);
Akira Hatanaka12507592011-10-22 00:07:27 +00003190
3191 if (Name != "n32" && Name != "n64")
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003192 return false;
Akira Hatanaka12507592011-10-22 00:07:27 +00003193
3194 ABI = Name;
3195
3196 if (Name == "n32") {
3197 LongWidth = LongAlign = 32;
3198 PointerWidth = PointerAlign = 32;
3199 }
3200
3201 return true;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003202 }
3203 virtual void getArchDefines(const LangOptions &Opts,
3204 MacroBuilder &Builder) const {
3205 if (ABI == "n32") {
3206 Builder.defineMacro("__mips_n32");
3207 Builder.defineMacro("_ABIN32", "2");
3208 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
3209 }
3210 else if (ABI == "n64") {
3211 Builder.defineMacro("__mips_n64");
3212 Builder.defineMacro("_ABI64", "3");
3213 Builder.defineMacro("_MIPS_SIM", "_ABI64");
3214 }
3215 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003216 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003217 }
3218 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3219 unsigned &NumAliases) const {
3220 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3221 { { "at" }, "$1" },
3222 { { "v0" }, "$2" },
3223 { { "v1" }, "$3" },
3224 { { "a0" }, "$4" },
3225 { { "a1" }, "$5" },
3226 { { "a2" }, "$6" },
3227 { { "a3" }, "$7" },
3228 { { "a4" }, "$8" },
3229 { { "a5" }, "$9" },
3230 { { "a6" }, "$10" },
3231 { { "a7" }, "$11" },
3232 { { "t0" }, "$12" },
3233 { { "t1" }, "$13" },
3234 { { "t2" }, "$14" },
3235 { { "t3" }, "$15" },
3236 { { "s0" }, "$16" },
3237 { { "s1" }, "$17" },
3238 { { "s2" }, "$18" },
3239 { { "s3" }, "$19" },
3240 { { "s4" }, "$20" },
3241 { { "s5" }, "$21" },
3242 { { "s6" }, "$22" },
3243 { { "s7" }, "$23" },
3244 { { "t8" }, "$24" },
3245 { { "t9" }, "$25" },
3246 { { "k0" }, "$26" },
3247 { { "k1" }, "$27" },
3248 { { "gp" }, "$28" },
3249 { { "sp" }, "$29" },
3250 { { "fp" }, "$30" },
3251 { { "ra" }, "$31" }
3252 };
3253 Aliases = GCCRegAliases;
3254 NumAliases = llvm::array_lengthof(GCCRegAliases);
3255 }
3256};
3257
3258class Mips64EBTargetInfo : public Mips64TargetInfoBase {
3259 virtual void SetDescriptionString(const std::string &Name) {
3260 // Change DescriptionString only if ABI is n32.
3261 if (Name == "n32")
3262 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanaka12507592011-10-22 00:07:27 +00003263 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3264 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003265 }
3266public:
3267 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3268 // Default ABI is n64.
3269 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanaka12507592011-10-22 00:07:27 +00003270 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3271 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003272 }
3273 virtual void getTargetDefines(const LangOptions &Opts,
3274 MacroBuilder &Builder) const {
3275 DefineStd(Builder, "mips", Opts);
3276 Builder.defineMacro("_mips");
3277 DefineStd(Builder, "MIPSEB", Opts);
3278 Builder.defineMacro("_MIPSEB");
3279 Builder.defineMacro("__REGISTER_PREFIX__", "");
3280 getArchDefines(Opts, Builder);
3281 }
3282};
3283
3284class Mips64ELTargetInfo : public Mips64TargetInfoBase {
3285 virtual void SetDescriptionString(const std::string &Name) {
3286 // Change DescriptionString only if ABI is n32.
3287 if (Name == "n32")
3288 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanaka12507592011-10-22 00:07:27 +00003289 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
3290 "-v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003291 }
3292public:
3293 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3294 // Default ABI is n64.
3295 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanaka12507592011-10-22 00:07:27 +00003296 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3297 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003298 }
3299 virtual void getTargetDefines(const LangOptions &Opts,
3300 MacroBuilder &Builder) const {
3301 DefineStd(Builder, "mips", Opts);
3302 Builder.defineMacro("_mips");
3303 DefineStd(Builder, "MIPSEL", Opts);
3304 Builder.defineMacro("_MIPSEL");
3305 Builder.defineMacro("__REGISTER_PREFIX__", "");
3306 getArchDefines(Opts, Builder);
3307 }
3308};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003309} // end anonymous namespace.
3310
Ivan Krasinef05abd2011-08-24 20:22:22 +00003311namespace {
3312class PNaClTargetInfo : public TargetInfo {
3313public:
3314 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
3315 this->UserLabelPrefix = "";
3316 this->LongAlign = 32;
3317 this->LongWidth = 32;
3318 this->PointerAlign = 32;
3319 this->PointerWidth = 32;
3320 this->IntMaxType = TargetInfo::SignedLongLong;
3321 this->UIntMaxType = TargetInfo::UnsignedLongLong;
3322 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003323 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003324 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003325 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003326 this->SizeType = TargetInfo::UnsignedInt;
3327 this->PtrDiffType = TargetInfo::SignedInt;
3328 this->IntPtrType = TargetInfo::SignedInt;
David Meyerdd4a8892011-10-11 03:12:01 +00003329 this->RegParmMax = 2;
Ivan Krasinef05abd2011-08-24 20:22:22 +00003330 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
3331 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
3332 }
3333
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003334 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00003335 }
3336 virtual void getArchDefines(const LangOptions &Opts,
3337 MacroBuilder &Builder) const {
3338 Builder.defineMacro("__le32__");
3339 Builder.defineMacro("__pnacl__");
3340 }
3341 virtual void getTargetDefines(const LangOptions &Opts,
3342 MacroBuilder &Builder) const {
Ivan Krasin089ee112011-08-25 23:49:20 +00003343 DefineStd(Builder, "unix", Opts);
3344 Builder.defineMacro("__ELF__");
3345 if (Opts.POSIXThreads)
3346 Builder.defineMacro("_REENTRANT");
3347 if (Opts.CPlusPlus)
3348 Builder.defineMacro("_GNU_SOURCE");
3349
Ivan Krasinef05abd2011-08-24 20:22:22 +00003350 Builder.defineMacro("__native_client__");
3351 getArchDefines(Opts, Builder);
3352 }
3353 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3354 unsigned &NumRecords) const {
3355 }
3356 virtual const char *getVAListDeclaration() const {
Ivan Krasin68018db2011-09-20 14:56:54 +00003357 return "typedef int __builtin_va_list[4];";
Ivan Krasinef05abd2011-08-24 20:22:22 +00003358 }
3359 virtual void getGCCRegNames(const char * const *&Names,
3360 unsigned &NumNames) const;
3361 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3362 unsigned &NumAliases) const;
3363 virtual bool validateAsmConstraint(const char *&Name,
3364 TargetInfo::ConstraintInfo &Info) const {
3365 return false;
3366 }
3367
3368 virtual const char *getClobbers() const {
3369 return "";
3370 }
3371};
3372
3373void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
3374 unsigned &NumNames) const {
3375 Names = NULL;
3376 NumNames = 0;
3377}
3378
3379void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3380 unsigned &NumAliases) const {
3381 Aliases = NULL;
3382 NumAliases = 0;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003383}
3384} // end anonymous namespace.
3385
Ivan Krasinef05abd2011-08-24 20:22:22 +00003386
Chris Lattner4b009652007-07-25 00:24:17 +00003387//===----------------------------------------------------------------------===//
3388// Driver code
3389//===----------------------------------------------------------------------===//
3390
Daniel Dunbarca3e9912009-11-15 06:48:46 +00003391static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003392 llvm::Triple Triple(T);
3393 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00003394
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003395 switch (Triple.getArch()) {
3396 default:
3397 return NULL;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00003398
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003399 case llvm::Triple::arm:
Daniel Dunbar3f361b52009-09-11 01:14:50 +00003400 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003401 if (Triple.isOSDarwin())
3402 return new DarwinARMTargetInfo(T);
3403
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003404 switch (os) {
Rafael Espindolad16a2202010-06-10 00:46:51 +00003405 case llvm::Triple::Linux:
3406 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003407 case llvm::Triple::FreeBSD:
Edwin Török36565e52009-06-30 17:10:35 +00003408 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003409 case llvm::Triple::NetBSD:
3410 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003411 case llvm::Triple::RTEMS:
3412 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003413 default:
3414 return new ARMTargetInfo(T);
3415 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00003416
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003417 case llvm::Triple::msp430:
3418 return new MSP430TargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00003419
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003420 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003421 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003422 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003423 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003424 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003425 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003426 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003427 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003428 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003429 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003430 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003431 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003432 }
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003433
3434 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003435 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003436 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003437 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003438 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003439 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003440 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003441 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003442 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003443 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003444 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003445 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003446 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003447
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003448 case llvm::Triple::mips64:
3449 switch (os) {
3450 case llvm::Triple::Linux:
3451 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
3452 case llvm::Triple::RTEMS:
3453 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
3454 case llvm::Triple::FreeBSD:
3455 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
3456 case llvm::Triple::NetBSD:
3457 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
3458 default:
3459 return new Mips64EBTargetInfo(T);
3460 }
3461
3462 case llvm::Triple::mips64el:
3463 switch (os) {
3464 case llvm::Triple::Linux:
3465 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
3466 case llvm::Triple::RTEMS:
3467 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
3468 case llvm::Triple::FreeBSD:
3469 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
3470 case llvm::Triple::NetBSD:
3471 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
3472 default:
3473 return new Mips64ELTargetInfo(T);
3474 }
3475
Ivan Krasinef05abd2011-08-24 20:22:22 +00003476 case llvm::Triple::le32:
3477 switch (os) {
3478 case llvm::Triple::NativeClient:
3479 return new PNaClTargetInfo(T);
3480 default:
3481 return NULL;
Chris Lattnere03ae302010-02-16 18:14:57 +00003482 }
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003483
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003484 case llvm::Triple::ppc:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003485 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00003486 return new DarwinPPC32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003487 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003488 case llvm::Triple::Linux:
3489 return new LinuxTargetInfo<PPC32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003490 case llvm::Triple::FreeBSD:
Chris Lattnerf8030412010-02-16 18:14:57 +00003491 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003492 case llvm::Triple::NetBSD:
3493 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
3494 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003495 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003496 default:
3497 return new PPC32TargetInfo(T);
3498 }
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003499
3500 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003501 if (Triple.isOSDarwin())
Daniel Dunbar6501cab2010-05-30 00:07:30 +00003502 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003503 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003504 case llvm::Triple::Linux:
3505 return new LinuxTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003506 case llvm::Triple::Lv2:
John Thompsoned7bdbc2009-11-19 17:18:50 +00003507 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003508 case llvm::Triple::FreeBSD:
Chris Lattnerf8030412010-02-16 18:14:57 +00003509 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003510 case llvm::Triple::NetBSD:
3511 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
3512 default:
3513 return new PPC64TargetInfo(T);
3514 }
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003515
Justin Holewinski285dc652011-04-20 19:34:15 +00003516 case llvm::Triple::ptx32:
3517 return new PTX32TargetInfo(T);
3518 case llvm::Triple::ptx64:
3519 return new PTX64TargetInfo(T);
3520
Chris Lattner2c026472010-03-06 21:21:27 +00003521 case llvm::Triple::mblaze:
3522 return new MBlazeTargetInfo(T);
3523
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003524 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003525 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003526 case llvm::Triple::Linux:
3527 return new LinuxTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003528 case llvm::Triple::AuroraUX:
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00003529 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003530 case llvm::Triple::Solaris:
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003531 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003532 case llvm::Triple::NetBSD:
3533 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
3534 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003535 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003536 default:
3537 return new SparcV8TargetInfo(T);
3538 }
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003539
John Thompsoned7bdbc2009-11-19 17:18:50 +00003540 // FIXME: Need a real SPU target.
3541 case llvm::Triple::cellspu:
3542 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
3543
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00003544 case llvm::Triple::tce:
3545 return new TCETargetInfo(T);
3546
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003547 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003548 if (Triple.isOSDarwin())
3549 return new DarwinI386TargetInfo(T);
3550
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003551 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00003552 case llvm::Triple::AuroraUX:
3553 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003554 case llvm::Triple::Linux:
3555 return new LinuxTargetInfo<X86_32TargetInfo>(T);
3556 case llvm::Triple::DragonFly:
3557 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
3558 case llvm::Triple::NetBSD:
3559 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
3560 case llvm::Triple::OpenBSD:
3561 return new OpenBSDI386TargetInfo(T);
3562 case llvm::Triple::FreeBSD:
3563 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner6f4bed52010-07-07 16:01:42 +00003564 case llvm::Triple::Minix:
3565 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003566 case llvm::Triple::Solaris:
3567 return new SolarisTargetInfo<X86_32TargetInfo>(T);
3568 case llvm::Triple::Cygwin:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00003569 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003570 case llvm::Triple::MinGW32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00003571 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003572 case llvm::Triple::Win32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00003573 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattnerf853e732010-04-11 19:29:39 +00003574 case llvm::Triple::Haiku:
3575 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003576 case llvm::Triple::RTEMS:
3577 return new RTEMSX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003578 default:
3579 return new X86_32TargetInfo(T);
3580 }
3581
3582 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003583 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
3584 return new DarwinX86_64TargetInfo(T);
3585
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003586 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00003587 case llvm::Triple::AuroraUX:
3588 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003589 case llvm::Triple::Linux:
3590 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner1eac0812010-01-09 05:41:14 +00003591 case llvm::Triple::DragonFly:
3592 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003593 case llvm::Triple::NetBSD:
3594 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
3595 case llvm::Triple::OpenBSD:
3596 return new OpenBSDX86_64TargetInfo(T);
3597 case llvm::Triple::FreeBSD:
3598 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
3599 case llvm::Triple::Solaris:
3600 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00003601 case llvm::Triple::MinGW32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00003602 return new MinGWX86_64TargetInfo(T);
3603 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003604 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003605 default:
3606 return new X86_64TargetInfo(T);
3607 }
3608 }
Chris Lattner4b009652007-07-25 00:24:17 +00003609}
Daniel Dunbarca3e9912009-11-15 06:48:46 +00003610
3611/// CreateTargetInfo - Return the target info object for the specified target
3612/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00003613TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00003614 TargetOptions &Opts) {
Daniel Dunbarca3e9912009-11-15 06:48:46 +00003615 llvm::Triple Triple(Opts.Triple);
3616
3617 // Construct the target
3618 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
3619 if (!Target) {
3620 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
3621 return 0;
3622 }
3623
Daniel Dunbar33b40752009-12-18 18:42:37 +00003624 // Set the target CPU if specified.
3625 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
3626 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
3627 return 0;
3628 }
3629
Daniel Dunbarca3e9912009-11-15 06:48:46 +00003630 // Set the target ABI if specified.
3631 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
3632 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
3633 return 0;
3634 }
3635
Charles Davisfed3a2b2010-06-11 01:06:47 +00003636 // Set the target C++ ABI.
John McCall68086b92010-08-21 22:46:04 +00003637 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davisfed3a2b2010-06-11 01:06:47 +00003638 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
3639 return 0;
3640 }
3641
Daniel Dunbarca3e9912009-11-15 06:48:46 +00003642 // Compute the default target features, we need the target to handle this
3643 // because features may have dependencies on one another.
3644 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003645 Target->getDefaultFeatures(Features);
Daniel Dunbarca3e9912009-11-15 06:48:46 +00003646
3647 // Apply the user specified deltas.
3648 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
3649 ie = Opts.Features.end(); it != ie; ++it) {
3650 const char *Name = it->c_str();
3651
3652 // Apply the feature via the target.
3653 if ((Name[0] != '-' && Name[0] != '+') ||
3654 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
3655 Diags.Report(diag::err_target_invalid_feature) << Name;
3656 return 0;
3657 }
3658 }
3659
3660 // Add the features to the compile options.
3661 //
3662 // FIXME: If we are completely confident that we have the right set, we only
3663 // need to pass the minuses.
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00003664 Opts.Features.clear();
Daniel Dunbarca3e9912009-11-15 06:48:46 +00003665 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
3666 ie = Features.end(); it != ie; ++it)
Chris Lattner1e5f83b2011-07-14 18:24:21 +00003667 Opts.Features.push_back(std::string(it->second ? "+" : "-") +
Chris Lattner48b78bd2011-07-14 18:45:41 +00003668 it->first().str());
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00003669 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbarca3e9912009-11-15 06:48:46 +00003670
3671 return Target.take();
3672}