blob: 53274f5c6e37c11af74cd832a9a5f7ba93cc174a [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,
Roman Divackyf051cde2011-10-30 07:48:46 +00001289 CK_AMDFAM10,
Chandler Carruth499d9722011-09-28 08:55:34 +00001290
1291 /// This specification is deprecated and will be removed in the future.
1292 /// Users should prefer \see CK_K8.
1293 // FIXME: Warn on this when the CPU is set to it.
1294 CK_x86_64,
1295 //@}
1296
1297 /// \name Geode
1298 /// Geode processors.
1299 //@{
1300 CK_Geode
1301 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001302 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001303
Eli Friedman872996c2008-08-20 02:34:37 +00001304public:
Anton Korobeynikove7772382009-05-03 13:42:53 +00001305 X86TargetInfo(const std::string& triple)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001306 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001307 HasAES(false), HasAVX(false), CPU(CK_Generic) {
Eli Friedman872996c2008-08-20 02:34:37 +00001308 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner4b009652007-07-25 00:24:17 +00001309 }
1310 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1311 unsigned &NumRecords) const {
Eli Friedman872996c2008-08-20 02:34:37 +00001312 Records = BuiltinInfo;
1313 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +00001314 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001315 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman872996c2008-08-20 02:34:37 +00001316 unsigned &NumNames) const {
1317 Names = GCCRegNames;
1318 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson7dd1c952007-11-24 23:38:12 +00001319 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001320 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson7dd1c952007-11-24 23:38:12 +00001321 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001322 Aliases = 0;
1323 NumAliases = 0;
1324 }
1325 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1326 unsigned &NumNames) const {
1327 Names = AddlRegNames;
1328 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlsson8b58e8a2007-10-13 00:45:48 +00001329 }
Anders Carlsson36834a72009-02-28 17:11:49 +00001330 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman872996c2008-08-20 02:34:37 +00001331 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001332 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlsson4ce42302007-11-27 04:11:28 +00001333 virtual const char *getClobbers() const {
Eli Friedman872996c2008-08-20 02:34:37 +00001334 return "~{dirflag},~{fpsr},~{flags}";
1335 }
Chris Lattner79682402009-03-20 15:52:06 +00001336 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001337 MacroBuilder &Builder) const;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001338 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1339 const std::string &Name,
1340 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001341 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00001342 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001343 virtual const char* getABI() const {
1344 return MMX3DNowLevel == NoMMX3DNow ? "no-mmx" : "";
1345 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001346 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001347 CPU = llvm::StringSwitch<CPUKind>(Name)
1348 .Case("i386", CK_i386)
1349 .Case("i486", CK_i486)
1350 .Case("winchip-c6", CK_WinChipC6)
1351 .Case("winchip2", CK_WinChip2)
1352 .Case("c3", CK_C3)
1353 .Case("i586", CK_i586)
1354 .Case("pentium", CK_Pentium)
1355 .Case("pentium-mmx", CK_PentiumMMX)
1356 .Case("i686", CK_i686)
1357 .Case("pentiumpro", CK_PentiumPro)
1358 .Case("pentium2", CK_Pentium2)
1359 .Case("pentium3", CK_Pentium3)
1360 .Case("pentium3m", CK_Pentium3M)
1361 .Case("pentium-m", CK_PentiumM)
1362 .Case("c3-2", CK_C3_2)
1363 .Case("yonah", CK_Yonah)
1364 .Case("pentium4", CK_Pentium4)
1365 .Case("pentium4m", CK_Pentium4M)
1366 .Case("prescott", CK_Prescott)
1367 .Case("nocona", CK_Nocona)
1368 .Case("core2", CK_Core2)
1369 .Case("penryn", CK_Penryn)
1370 .Case("atom", CK_Atom)
1371 .Case("corei7", CK_Corei7)
1372 .Case("corei7-avx", CK_Corei7AVX)
1373 .Case("core-avx-i", CK_CoreAVXi)
1374 .Case("k6", CK_K6)
1375 .Case("k6-2", CK_K6_2)
1376 .Case("k6-3", CK_K6_3)
1377 .Case("athlon", CK_Athlon)
1378 .Case("athlon-tbird", CK_AthlonThunderbird)
1379 .Case("athlon-4", CK_Athlon4)
1380 .Case("athlon-xp", CK_AthlonXP)
1381 .Case("athlon-mp", CK_AthlonMP)
1382 .Case("athlon64", CK_Athlon64)
1383 .Case("athlon64-sse3", CK_Athlon64SSE3)
1384 .Case("athlon-fx", CK_AthlonFX)
1385 .Case("k8", CK_K8)
1386 .Case("k8-sse3", CK_K8SSE3)
1387 .Case("opteron", CK_Opteron)
1388 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divackyf051cde2011-10-30 07:48:46 +00001389 .Case("amdfam10", CK_AMDFAM10)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001390 .Case("x86-64", CK_x86_64)
1391 .Case("geode", CK_Geode)
1392 .Default(CK_Generic);
1393
Chandler Carruth26a39142011-09-28 09:45:08 +00001394 // Perform any per-CPU checks necessary to determine if this CPU is
1395 // acceptable.
1396 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1397 // invalid without explaining *why*.
1398 switch (CPU) {
1399 case CK_Generic:
1400 // No processor selected!
1401 return false;
1402
1403 case CK_i386:
1404 case CK_i486:
1405 case CK_WinChipC6:
1406 case CK_WinChip2:
1407 case CK_C3:
1408 case CK_i586:
1409 case CK_Pentium:
1410 case CK_PentiumMMX:
1411 case CK_i686:
1412 case CK_PentiumPro:
1413 case CK_Pentium2:
1414 case CK_Pentium3:
1415 case CK_Pentium3M:
1416 case CK_PentiumM:
1417 case CK_Yonah:
1418 case CK_C3_2:
1419 case CK_Pentium4:
1420 case CK_Pentium4M:
1421 case CK_Prescott:
1422 case CK_K6:
1423 case CK_K6_2:
1424 case CK_K6_3:
1425 case CK_Athlon:
1426 case CK_AthlonThunderbird:
1427 case CK_Athlon4:
1428 case CK_AthlonXP:
1429 case CK_AthlonMP:
1430 case CK_Geode:
1431 // Only accept certain architectures when compiling in 32-bit mode.
1432 if (PointerWidth != 32)
1433 return false;
1434
1435 // Fallthrough
1436 case CK_Nocona:
1437 case CK_Core2:
1438 case CK_Penryn:
1439 case CK_Atom:
1440 case CK_Corei7:
1441 case CK_Corei7AVX:
1442 case CK_CoreAVXi:
1443 case CK_Athlon64:
1444 case CK_Athlon64SSE3:
1445 case CK_AthlonFX:
1446 case CK_K8:
1447 case CK_K8SSE3:
1448 case CK_Opteron:
1449 case CK_OpteronSSE3:
Roman Divackyf051cde2011-10-30 07:48:46 +00001450 case CK_AMDFAM10:
Chandler Carruth26a39142011-09-28 09:45:08 +00001451 case CK_x86_64:
1452 return true;
1453 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001454 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001455 }
Chris Lattner4b009652007-07-25 00:24:17 +00001456};
Chris Lattner7d6220c2009-03-02 22:20:04 +00001457
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001458void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar07181d72009-05-06 03:16:41 +00001459 // FIXME: This should not be here.
1460 Features["3dnow"] = false;
1461 Features["3dnowa"] = false;
1462 Features["mmx"] = false;
1463 Features["sse"] = false;
1464 Features["sse2"] = false;
1465 Features["sse3"] = false;
1466 Features["ssse3"] = false;
1467 Features["sse41"] = false;
1468 Features["sse42"] = false;
Roman Divacky9979cfe2011-10-30 13:47:56 +00001469 Features["sse4a"] = false;
Eric Christopher6c4e7872010-04-02 23:50:19 +00001470 Features["aes"] = false;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001471 Features["avx"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001472
Daniel Dunbar07181d72009-05-06 03:16:41 +00001473 // FIXME: This *really* should not be here.
1474
1475 // X86_64 always has SSE2.
1476 if (PointerWidth == 64)
1477 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1478
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001479 switch (CPU) {
1480 case CK_Generic:
1481 case CK_i386:
1482 case CK_i486:
1483 case CK_i586:
1484 case CK_Pentium:
1485 case CK_i686:
1486 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001487 break;
1488 case CK_PentiumMMX:
1489 case CK_Pentium2:
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001490 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001491 break;
1492 case CK_Pentium3:
1493 case CK_Pentium3M:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001494 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001495 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001496 break;
1497 case CK_PentiumM:
1498 case CK_Pentium4:
1499 case CK_Pentium4M:
1500 case CK_x86_64:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001501 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001502 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001503 break;
1504 case CK_Yonah:
1505 case CK_Prescott:
1506 case CK_Nocona:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001507 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001508 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001509 break;
1510 case CK_Core2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001511 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001512 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001513 break;
1514 case CK_Penryn:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001515 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001516 setFeatureEnabled(Features, "sse4", true);
1517 Features["sse42"] = false;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001518 break;
1519 case CK_Atom:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001520 setFeatureEnabled(Features, "mmx", true);
Chandler Carruth49defe62011-09-28 10:36:46 +00001521 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001522 break;
1523 case CK_Corei7:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001524 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001525 setFeatureEnabled(Features, "sse4", true);
Eric Christopher6c4e7872010-04-02 23:50:19 +00001526 setFeatureEnabled(Features, "aes", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001527 break;
1528 case CK_Corei7AVX:
1529 case CK_CoreAVXi:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001530 setFeatureEnabled(Features, "mmx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00001531 setFeatureEnabled(Features, "sse4", true);
1532 setFeatureEnabled(Features, "aes", true);
Bruno Cardoso Lopese02d3912011-07-11 23:33:46 +00001533 //setFeatureEnabled(Features, "avx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001534 break;
1535 case CK_K6:
1536 case CK_WinChipC6:
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001537 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001538 break;
1539 case CK_K6_2:
1540 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001541 case CK_WinChip2:
1542 case CK_C3:
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001543 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001544 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00001545 case CK_Athlon:
1546 case CK_AthlonThunderbird:
1547 case CK_Geode:
1548 setFeatureEnabled(Features, "3dnowa", true);
1549 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001550 case CK_Athlon4:
1551 case CK_AthlonXP:
1552 case CK_AthlonMP:
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001553 setFeatureEnabled(Features, "sse", true);
1554 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001555 break;
1556 case CK_K8:
1557 case CK_Opteron:
1558 case CK_Athlon64:
1559 case CK_AthlonFX:
Mike Stump25cf7602009-09-09 15:08:12 +00001560 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001561 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001562 break;
1563 case CK_K8SSE3:
1564 case CK_OpteronSSE3:
1565 case CK_Athlon64SSE3:
Roman Divacky9979cfe2011-10-30 13:47:56 +00001566 setFeatureEnabled(Features, "sse3", true);
1567 setFeatureEnabled(Features, "3dnowa", true);
1568 break;
Roman Divackyf051cde2011-10-30 07:48:46 +00001569 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00001570 setFeatureEnabled(Features, "sse3", true);
Roman Divacky9979cfe2011-10-30 13:47:56 +00001571 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00001572 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001573 break;
1574 case CK_C3_2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001575 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001576 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001577 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001578 }
Daniel Dunbar07181d72009-05-06 03:16:41 +00001579}
1580
Daniel Dunbar0838f962009-05-06 21:07:50 +00001581bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump25cf7602009-09-09 15:08:12 +00001582 const std::string &Name,
Daniel Dunbar0838f962009-05-06 21:07:50 +00001583 bool Enabled) const {
Eric Christopher850e2012010-03-04 02:26:37 +00001584 // FIXME: This *really* should not be here. We need some way of translating
1585 // options into llvm subtarget features.
1586 if (!Features.count(Name) &&
1587 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar0838f962009-05-06 21:07:50 +00001588 return false;
1589
1590 if (Enabled) {
1591 if (Name == "mmx")
1592 Features["mmx"] = true;
1593 else if (Name == "sse")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001594 Features["sse"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001595 else if (Name == "sse2")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001596 Features["sse"] = Features["sse2"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001597 else if (Name == "sse3")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001598 Features["sse"] = Features["sse2"] = Features["sse3"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001599 else if (Name == "ssse3")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001600 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001601 Features["ssse3"] = true;
Eric Christopher850e2012010-03-04 02:26:37 +00001602 else if (Name == "sse4" || Name == "sse4.2")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001603 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001604 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Eric Christopher850e2012010-03-04 02:26:37 +00001605 else if (Name == "sse4.1")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001606 Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopher850e2012010-03-04 02:26:37 +00001607 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001608 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001609 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001610 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001611 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christopher6c4e7872010-04-02 23:50:19 +00001612 else if (Name == "aes")
1613 Features["aes"] = true;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001614 else if (Name == "avx")
Bruno Cardoso Lopes292772c2011-08-18 00:07:03 +00001615 Features["avx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1616 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Roman Divacky9979cfe2011-10-30 13:47:56 +00001617 else if (Name == "sse4a")
1618 Features["sse4a"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001619 } else {
1620 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001621 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001622 else if (Name == "sse")
Mike Stump25cf7602009-09-09 15:08:12 +00001623 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001624 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1625 else if (Name == "sse2")
Mike Stump25cf7602009-09-09 15:08:12 +00001626 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001627 Features["sse41"] = Features["sse42"] = false;
1628 else if (Name == "sse3")
Mike Stump25cf7602009-09-09 15:08:12 +00001629 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001630 Features["sse42"] = false;
1631 else if (Name == "ssse3")
1632 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00001633 else if (Name == "sse4" || Name == "sse4.1")
Daniel Dunbar0838f962009-05-06 21:07:50 +00001634 Features["sse41"] = Features["sse42"] = false;
Eric Christopherd794f782010-03-04 02:31:44 +00001635 else if (Name == "sse4.2")
1636 Features["sse42"] = false;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001637 else if (Name == "3dnow")
1638 Features["3dnow"] = Features["3dnowa"] = false;
1639 else if (Name == "3dnowa")
1640 Features["3dnowa"] = false;
Eric Christopher6c4e7872010-04-02 23:50:19 +00001641 else if (Name == "aes")
1642 Features["aes"] = false;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001643 else if (Name == "avx")
1644 Features["avx"] = false;
Roman Divacky9979cfe2011-10-30 13:47:56 +00001645 else if (Name == "sse4a")
1646 Features["sse4a"] = false;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001647 }
1648
1649 return true;
1650}
1651
Daniel Dunbar07181d72009-05-06 03:16:41 +00001652/// HandleTargetOptions - Perform initialization based on the user
1653/// configured set of features.
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00001654void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001655 // Remember the maximum enabled sselevel.
1656 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1657 // Ignore disabled features.
1658 if (Features[i][0] == '-')
1659 continue;
1660
Eric Christopher6c4e7872010-04-02 23:50:19 +00001661 if (Features[i].substr(1) == "aes") {
1662 HasAES = true;
1663 continue;
1664 }
1665
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001666 // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1667 // For now let it be enabled together with other SSE levels.
1668 if (Features[i].substr(1) == "avx") {
1669 HasAVX = true;
1670 continue;
1671 }
1672
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001673 assert(Features[i][0] == '+' && "Invalid target feature!");
1674 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1675 .Case("sse42", SSE42)
1676 .Case("sse41", SSE41)
1677 .Case("ssse3", SSSE3)
Nuno Lopes3a16d782010-03-12 10:20:09 +00001678 .Case("sse3", SSE3)
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001679 .Case("sse2", SSE2)
1680 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001681 .Default(NoSSE);
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001682 SSELevel = std::max(SSELevel, Level);
Michael J. Spencerd5513a32010-10-21 03:16:25 +00001683
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001684 MMX3DNowEnum ThreeDNowLevel =
1685 llvm::StringSwitch<MMX3DNowEnum>(Features[i].substr(1))
Anders Carlssone5e222f2010-01-27 03:47:49 +00001686 .Case("3dnowa", AMD3DNowAthlon)
1687 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001688 .Case("mmx", MMX)
1689 .Default(NoMMX3DNow);
Michael J. Spencerd5513a32010-10-21 03:16:25 +00001690
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001691 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001692 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001693
1694 // Don't tell the backend if we're turning off mmx; it will end up disabling
1695 // SSE, which we don't want.
1696 std::vector<std::string>::iterator it;
1697 it = std::find(Features.begin(), Features.end(), "-mmx");
1698 if (it != Features.end())
1699 Features.erase(it);
Chris Lattner7d6220c2009-03-02 22:20:04 +00001700}
Chris Lattnerbef1d722009-03-02 22:27:17 +00001701
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001702/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
1703/// definitions for this particular subtarget.
Chris Lattner79682402009-03-20 15:52:06 +00001704void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001705 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00001706 // Target identification.
1707 if (PointerWidth == 64) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001708 Builder.defineMacro("_LP64");
1709 Builder.defineMacro("__LP64__");
1710 Builder.defineMacro("__amd64__");
1711 Builder.defineMacro("__amd64");
1712 Builder.defineMacro("__x86_64");
1713 Builder.defineMacro("__x86_64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +00001714 } else {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001715 DefineStd(Builder, "i386", Opts);
Chris Lattnerbef1d722009-03-02 22:27:17 +00001716 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001717
Chris Lattnerc0f59212009-03-02 22:27:17 +00001718 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001719 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
1720 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001721 switch (CPU) {
1722 case CK_Generic:
1723 break;
1724 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001725 // The rest are coming from the i386 define above.
1726 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001727 break;
1728 case CK_i486:
1729 case CK_WinChipC6:
1730 case CK_WinChip2:
1731 case CK_C3:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001732 Builder.defineMacro("__i486");
1733 Builder.defineMacro("__i486__");
1734 Builder.defineMacro("__tune_i486__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001735 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00001736 case CK_PentiumMMX:
1737 Builder.defineMacro("__pentium_mmx__");
1738 Builder.defineMacro("__tune_pentium_mmx__");
1739 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001740 case CK_i586:
1741 case CK_Pentium:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001742 Builder.defineMacro("__i586");
1743 Builder.defineMacro("__i586__");
1744 Builder.defineMacro("__tune_i586__");
1745 Builder.defineMacro("__pentium");
1746 Builder.defineMacro("__pentium__");
1747 Builder.defineMacro("__tune_pentium__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001748 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001749 case CK_Pentium3:
1750 case CK_Pentium3M:
1751 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001752 Builder.defineMacro("__tune_pentium3__");
1753 // Fallthrough
1754 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001755 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001756 Builder.defineMacro("__tune_pentium2__");
1757 // Fallthrough
1758 case CK_PentiumPro:
1759 Builder.defineMacro("__tune_i686__");
1760 Builder.defineMacro("__tune_pentiumpro__");
1761 // Fallthrough
1762 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001763 Builder.defineMacro("__i686");
1764 Builder.defineMacro("__i686__");
1765 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
1766 Builder.defineMacro("__pentiumpro");
1767 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001768 break;
1769 case CK_Pentium4:
1770 case CK_Pentium4M:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001771 Builder.defineMacro("__pentium4");
1772 Builder.defineMacro("__pentium4__");
1773 Builder.defineMacro("__tune_pentium4__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001774 break;
1775 case CK_Yonah:
1776 case CK_Prescott:
1777 case CK_Nocona:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001778 Builder.defineMacro("__nocona");
1779 Builder.defineMacro("__nocona__");
1780 Builder.defineMacro("__tune_nocona__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001781 break;
1782 case CK_Core2:
1783 case CK_Penryn:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001784 Builder.defineMacro("__core2");
1785 Builder.defineMacro("__core2__");
1786 Builder.defineMacro("__tune_core2__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001787 break;
1788 case CK_Atom:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001789 Builder.defineMacro("__atom");
1790 Builder.defineMacro("__atom__");
1791 Builder.defineMacro("__tune_atom__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001792 break;
1793 case CK_Corei7:
1794 case CK_Corei7AVX:
1795 case CK_CoreAVXi:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001796 Builder.defineMacro("__corei7");
1797 Builder.defineMacro("__corei7__");
1798 Builder.defineMacro("__tune_corei7__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001799 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001800 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001801 Builder.defineMacro("__k6_2__");
1802 Builder.defineMacro("__tune_k6_2__");
1803 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001804 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001805 if (CPU != CK_K6_2) { // In case of fallthrough
1806 // FIXME: GCC may be enabling these in cases where some other k6
1807 // architecture is specified but -m3dnow is explicitly provided. The
1808 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001809 Builder.defineMacro("__k6_3__");
1810 Builder.defineMacro("__tune_k6_3__");
1811 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00001812 // Fallthrough
1813 case CK_K6:
1814 Builder.defineMacro("__k6");
1815 Builder.defineMacro("__k6__");
1816 Builder.defineMacro("__tune_k6__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001817 break;
1818 case CK_Athlon:
1819 case CK_AthlonThunderbird:
1820 case CK_Athlon4:
1821 case CK_AthlonXP:
1822 case CK_AthlonMP:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001823 Builder.defineMacro("__athlon");
1824 Builder.defineMacro("__athlon__");
1825 Builder.defineMacro("__tune_athlon__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001826 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001827 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001828 Builder.defineMacro("__tune_athlon_sse__");
1829 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001830 break;
1831 case CK_K8:
1832 case CK_K8SSE3:
1833 case CK_x86_64:
1834 case CK_Opteron:
1835 case CK_OpteronSSE3:
1836 case CK_Athlon64:
1837 case CK_Athlon64SSE3:
1838 case CK_AthlonFX:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001839 Builder.defineMacro("__k8");
1840 Builder.defineMacro("__k8__");
1841 Builder.defineMacro("__tune_k8__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001842 break;
Roman Divackyf051cde2011-10-30 07:48:46 +00001843 case CK_AMDFAM10:
1844 Builder.defineMacro("__amdfam10");
1845 Builder.defineMacro("__amdfam10__");
1846 Builder.defineMacro("__tune_amdfam10__");
1847 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001848 case CK_Geode:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001849 Builder.defineMacro("__geode");
1850 Builder.defineMacro("__geode__");
1851 Builder.defineMacro("__tune_geode__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001852 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001853 }
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001854
Chris Lattnerbef1d722009-03-02 22:27:17 +00001855 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001856 Builder.defineMacro("__LITTLE_ENDIAN__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001857 Builder.defineMacro("__REGISTER_PREFIX__", "");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001858
Chris Lattner25ac1c12009-04-19 17:32:33 +00001859 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1860 // functions in glibc header files that use FP Stack inline asm which the
1861 // backend can't deal with (PR879).
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001862 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001863
Chandler Carruth88c75b02011-09-28 09:54:07 +00001864 if (HasAES)
1865 Builder.defineMacro("__AES__");
1866
1867 if (HasAVX)
1868 Builder.defineMacro("__AVX__");
1869
Chris Lattner715fe4c2009-03-02 22:40:39 +00001870 // Each case falls through to the previous one here.
1871 switch (SSELevel) {
1872 case SSE42:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001873 Builder.defineMacro("__SSE4_2__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001874 case SSE41:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001875 Builder.defineMacro("__SSE4_1__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001876 case SSSE3:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001877 Builder.defineMacro("__SSSE3__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001878 case SSE3:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001879 Builder.defineMacro("__SSE3__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001880 case SSE2:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001881 Builder.defineMacro("__SSE2__");
1882 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner715fe4c2009-03-02 22:40:39 +00001883 case SSE1:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001884 Builder.defineMacro("__SSE__");
1885 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001886 case NoSSE:
Chris Lattner715fe4c2009-03-02 22:40:39 +00001887 break;
1888 }
Michael J. Spencer3d796932010-10-18 07:10:59 +00001889
Francois Pichet62ec1f22011-09-17 17:15:52 +00001890 if (Opts.MicrosoftExt && PointerWidth == 32) {
Michael J. Spencer01e70082010-10-21 05:21:48 +00001891 switch (SSELevel) {
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00001892 case SSE42:
1893 case SSE41:
1894 case SSSE3:
1895 case SSE3:
Michael J. Spencer01e70082010-10-21 05:21:48 +00001896 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001897 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencer01e70082010-10-21 05:21:48 +00001898 break;
1899 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001900 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencer01e70082010-10-21 05:21:48 +00001901 break;
1902 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00001903 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencer01e70082010-10-21 05:21:48 +00001904 }
1905 }
1906
Anders Carlssone5e222f2010-01-27 03:47:49 +00001907 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001908 switch (MMX3DNowLevel) {
Anders Carlssone5e222f2010-01-27 03:47:49 +00001909 case AMD3DNowAthlon:
1910 Builder.defineMacro("__3dNOW_A__");
1911 case AMD3DNow:
1912 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001913 case MMX:
1914 Builder.defineMacro("__MMX__");
1915 case NoMMX3DNow:
Anders Carlssone5e222f2010-01-27 03:47:49 +00001916 break;
1917 }
Chris Lattnerbef1d722009-03-02 22:27:17 +00001918}
Anton Korobeynikove7772382009-05-03 13:42:53 +00001919
1920
Eli Friedman872996c2008-08-20 02:34:37 +00001921bool
Anders Carlsson36834a72009-02-28 17:11:49 +00001922X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001923 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +00001924 switch (*Name) {
Eli Friedman872996c2008-08-20 02:34:37 +00001925 default: return false;
Dale Johanneseneba819a2010-08-24 22:33:12 +00001926 case 'Y': // first letter of a pair:
1927 switch (*(Name+1)) {
1928 default: return false;
1929 case '0': // First SSE register.
1930 case 't': // Any SSE register, when SSE2 is enabled.
1931 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
1932 case 'm': // any MMX register, when inter-unit moves enabled.
1933 break; // falls through to setAllowsRegister.
1934 }
Eli Friedman872996c2008-08-20 02:34:37 +00001935 case 'a': // eax.
1936 case 'b': // ebx.
1937 case 'c': // ecx.
1938 case 'd': // edx.
1939 case 'S': // esi.
1940 case 'D': // edi.
1941 case 'A': // edx:eax.
Dale Johanneseneba819a2010-08-24 22:33:12 +00001942 case 'f': // any x87 floating point stack register.
Eli Friedman872996c2008-08-20 02:34:37 +00001943 case 't': // top of floating point stack.
1944 case 'u': // second from top of floating point stack.
1945 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson2285e622008-10-06 00:41:45 +00001946 case 'y': // Any MMX register.
Anders Carlssond2459f92008-10-06 19:17:39 +00001947 case 'x': // Any SSE register.
Eli Friedman872996c2008-08-20 02:34:37 +00001948 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johanneseneba819a2010-08-24 22:33:12 +00001949 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
1950 case 'l': // "Index" registers: any general register that can be used as an
1951 // index in a base+index memory access.
1952 Info.setAllowsRegister();
1953 return true;
1954 case 'C': // SSE floating point constant.
1955 case 'G': // x87 floating point constant.
Anton Korobeynikove7772382009-05-03 13:42:53 +00001956 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +00001957 // x86_64 instructions.
Anton Korobeynikove7772382009-05-03 13:42:53 +00001958 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +00001959 // x86_64 instructions.
Eli Friedman872996c2008-08-20 02:34:37 +00001960 return true;
1961 }
Dale Johanneseneba819a2010-08-24 22:33:12 +00001962 return false;
Eli Friedman872996c2008-08-20 02:34:37 +00001963}
1964
Dale Johannesen3a161e52010-10-29 23:12:32 +00001965
Eli Friedman872996c2008-08-20 02:34:37 +00001966std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00001967X86TargetInfo::convertConstraint(const char *&Constraint) const {
1968 switch (*Constraint) {
Eli Friedman872996c2008-08-20 02:34:37 +00001969 case 'a': return std::string("{ax}");
1970 case 'b': return std::string("{bx}");
1971 case 'c': return std::string("{cx}");
1972 case 'd': return std::string("{dx}");
1973 case 'S': return std::string("{si}");
1974 case 'D': return std::string("{di}");
Dale Johannesena49254e2010-10-22 21:07:10 +00001975 case 'p': // address
1976 return std::string("im");
Eli Friedman872996c2008-08-20 02:34:37 +00001977 case 't': // top of floating point stack.
1978 return std::string("{st}");
1979 case 'u': // second from top of floating point stack.
1980 return std::string("{st(1)}"); // second from top of floating point stack.
1981 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00001982 return std::string(1, *Constraint);
Eli Friedman872996c2008-08-20 02:34:37 +00001983 }
1984}
Eli Friedman872996c2008-08-20 02:34:37 +00001985} // end anonymous namespace
Chris Lattner4b009652007-07-25 00:24:17 +00001986
1987namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001988// X86-32 generic target
1989class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +00001990public:
Eli Friedman872996c2008-08-20 02:34:37 +00001991 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1992 DoubleAlign = LongLongAlign = 32;
1993 LongDoubleWidth = 96;
1994 LongDoubleAlign = 32;
Eli Friedman2b161652008-08-21 00:13:15 +00001995 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1996 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00001997 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman04ede302009-03-29 20:31:09 +00001998 SizeType = UnsignedInt;
1999 PtrDiffType = SignedInt;
2000 IntPtrType = SignedInt;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +00002001 RegParmMax = 3;
Daniel Dunbar6f94dbb2010-07-14 23:39:36 +00002002
2003 // Use fpret for all types.
2004 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2005 (1 << TargetInfo::Double) |
2006 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002007
2008 // x86-32 has atomics up to 8 bytes
2009 // FIXME: Check that we actually have cmpxchg8b before setting
2010 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2011 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman872996c2008-08-20 02:34:37 +00002012 }
2013 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002014 return "typedef char* __builtin_va_list;";
Eli Friedman872996c2008-08-20 02:34:37 +00002015 }
Michael J. Spencerd5513a32010-10-21 03:16:25 +00002016
Chris Lattneraa339182009-09-23 06:06:36 +00002017 int getEHDataRegisterNumber(unsigned RegNo) const {
2018 if (RegNo == 0) return 0;
2019 if (RegNo == 1) return 2;
2020 return -1;
2021 }
Eli Friedman872996c2008-08-20 02:34:37 +00002022};
2023} // end anonymous namespace
2024
2025namespace {
Eli Friedman1c79f4b2009-07-05 18:47:56 +00002026class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2027public:
2028 OpenBSDI386TargetInfo(const std::string& triple) :
2029 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2030 SizeType = UnsignedLong;
2031 IntPtrType = SignedLong;
Eli Friedman96ada022009-07-05 22:31:18 +00002032 PtrDiffType = SignedLong;
Eli Friedman1c79f4b2009-07-05 18:47:56 +00002033 }
2034};
2035} // end anonymous namespace
2036
2037namespace {
Edwin Török36565e52009-06-30 17:10:35 +00002038class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman872996c2008-08-20 02:34:37 +00002039public:
Edwin Török36565e52009-06-30 17:10:35 +00002040 DarwinI386TargetInfo(const std::string& triple) :
2041 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman872996c2008-08-20 02:34:37 +00002042 LongDoubleWidth = 128;
2043 LongDoubleAlign = 128;
Eli Friedman04ede302009-03-29 20:31:09 +00002044 SizeType = UnsignedLong;
2045 IntPtrType = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +00002046 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2047 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002048 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar9451c542010-05-27 00:35:16 +00002049 HasAlignMac68kSupport = true;
Edwin Török2d98f9f2009-06-30 17:00:25 +00002050 }
2051
Eli Friedman872996c2008-08-20 02:34:37 +00002052};
Daniel Dunbar64c77a12009-06-29 20:52:51 +00002053} // end anonymous namespace
2054
2055namespace {
Eli Friedman23cb7912008-08-21 01:40:19 +00002056// x86-32 Windows target
Michael J. Spencer01e70082010-10-21 05:21:48 +00002057class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman23cb7912008-08-21 01:40:19 +00002058public:
2059 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencer01e70082010-10-21 05:21:48 +00002060 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +00002061 TLSSupported = false;
Chris Lattnera8a69e12009-06-24 17:12:15 +00002062 WCharType = UnsignedShort;
Eli Friedmanb28055e2009-06-08 21:16:17 +00002063 DoubleAlign = LongLongAlign = 64;
2064 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 +00002065 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002066 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman23cb7912008-08-21 01:40:19 +00002067 }
Chris Lattner79682402009-03-20 15:52:06 +00002068 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002069 MacroBuilder &Builder) const {
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00002070 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
Eli Friedman23cb7912008-08-21 01:40:19 +00002071 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002072};
2073} // end anonymous namespace
Eli Friedman6b6ca942009-06-08 06:11:14 +00002074
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002075namespace {
2076
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002077// x86-32 Windows Visual Studio target
2078class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2079public:
2080 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2081 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002082 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00002083 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002084 }
2085 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002086 MacroBuilder &Builder) const {
2087 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00002088 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002089 // The value of the following reflects processor type.
2090 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2091 // We lost the original triple, so we use the default.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002092 Builder.defineMacro("_M_IX86", "600");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002093 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002094};
2095} // end anonymous namespace
2096
2097namespace {
2098// x86-32 MinGW target
2099class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2100public:
2101 MinGWX86_32TargetInfo(const std::string& triple)
2102 : WindowsX86_32TargetInfo(triple) {
2103 }
2104 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002105 MacroBuilder &Builder) const {
2106 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00002107 DefineStd(Builder, "WIN32", Opts);
2108 DefineStd(Builder, "WINNT", Opts);
2109 Builder.defineMacro("_X86_");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002110 Builder.defineMacro("__MSVCRT__");
2111 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002112
2113 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2114 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002115 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002116 // Provide "as-is" __declspec.
2117 Builder.defineMacro("__declspec", "__declspec");
2118 else
2119 // Provide alias of __attribute__ like mingw32-gcc.
2120 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002121 }
2122};
2123} // end anonymous namespace
2124
2125namespace {
2126// x86-32 Cygwin target
2127class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2128public:
2129 CygwinX86_32TargetInfo(const std::string& triple)
2130 : X86_32TargetInfo(triple) {
2131 TLSSupported = false;
2132 WCharType = UnsignedShort;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002133 DoubleAlign = LongLongAlign = 64;
2134 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2135 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002136 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002137 }
2138 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002139 MacroBuilder &Builder) const {
2140 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2141 Builder.defineMacro("__CYGWIN__");
2142 Builder.defineMacro("__CYGWIN32__");
2143 DefineStd(Builder, "unix", Opts);
Douglas Gregor9b22a172010-04-21 05:52:38 +00002144 if (Opts.CPlusPlus)
2145 Builder.defineMacro("_GNU_SOURCE");
Eli Friedman6b6ca942009-06-08 06:11:14 +00002146 }
Eli Friedman23cb7912008-08-21 01:40:19 +00002147};
2148} // end anonymous namespace
2149
2150namespace {
Chris Lattnerf853e732010-04-11 19:29:39 +00002151// x86-32 Haiku target
2152class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2153public:
2154 HaikuX86_32TargetInfo(const std::string& triple)
2155 : X86_32TargetInfo(triple) {
2156 SizeType = UnsignedLong;
Chris Lattner5b8b18a2010-04-22 17:48:00 +00002157 IntPtrType = SignedLong;
2158 PtrDiffType = SignedLong;
Rafael Espindolaa7bdfdd2010-11-09 16:41:02 +00002159 this->UserLabelPrefix = "";
Eli Friedman08f845b2010-08-22 01:00:03 +00002160 }
Chris Lattnerf853e732010-04-11 19:29:39 +00002161 virtual void getTargetDefines(const LangOptions &Opts,
2162 MacroBuilder &Builder) const {
2163 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2164 Builder.defineMacro("__INTEL__");
2165 Builder.defineMacro("__HAIKU__");
2166 }
2167};
2168} // end anonymous namespace
2169
Douglas Gregordca52262011-07-01 22:41:14 +00002170// RTEMS Target
2171template<typename Target>
2172class RTEMSTargetInfo : public OSTargetInfo<Target> {
2173protected:
2174 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2175 MacroBuilder &Builder) const {
2176 // RTEMS defines; list based off of gcc output
2177
Douglas Gregordca52262011-07-01 22:41:14 +00002178 Builder.defineMacro("__rtems__");
2179 Builder.defineMacro("__ELF__");
2180 }
2181public:
2182 RTEMSTargetInfo(const std::string &triple)
2183 : OSTargetInfo<Target>(triple) {
2184 this->UserLabelPrefix = "";
2185
2186 llvm::Triple Triple(triple);
2187 switch (Triple.getArch()) {
2188 default:
2189 case llvm::Triple::x86:
2190 // this->MCountName = ".mcount";
2191 break;
2192 case llvm::Triple::mips:
2193 case llvm::Triple::mipsel:
2194 case llvm::Triple::ppc:
2195 case llvm::Triple::ppc64:
2196 // this->MCountName = "_mcount";
2197 break;
2198 case llvm::Triple::arm:
2199 // this->MCountName = "__mcount";
2200 break;
2201 }
2202
2203 }
2204};
2205
2206namespace {
2207// x86-32 RTEMS target
2208class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2209public:
2210 RTEMSX86_32TargetInfo(const std::string& triple)
2211 : X86_32TargetInfo(triple) {
2212 SizeType = UnsignedLong;
2213 IntPtrType = SignedLong;
2214 PtrDiffType = SignedLong;
2215 this->UserLabelPrefix = "";
2216 }
2217 virtual void getTargetDefines(const LangOptions &Opts,
2218 MacroBuilder &Builder) const {
2219 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2220 Builder.defineMacro("__INTEL__");
2221 Builder.defineMacro("__rtems__");
2222 }
2223};
2224} // end anonymous namespace
2225
Chris Lattnerf853e732010-04-11 19:29:39 +00002226namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00002227// x86-64 generic target
2228class X86_64TargetInfo : public X86TargetInfo {
2229public:
Chris Lattner79682402009-03-20 15:52:06 +00002230 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +00002231 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002232 LongDoubleWidth = 128;
2233 LongDoubleAlign = 128;
Rafael Espindolabfa7c002010-06-04 23:15:27 +00002234 LargeArrayMinWidth = 128;
2235 LargeArrayAlign = 128;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00002236 IntMaxType = SignedLong;
2237 UIntMaxType = UnsignedLong;
Eli Friedman38e31802009-07-01 03:36:11 +00002238 Int64Type = SignedLong;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +00002239 RegParmMax = 6;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00002240
Eli Friedman2b161652008-08-21 00:13:15 +00002241 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2242 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002243 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbar6f94dbb2010-07-14 23:39:36 +00002244
2245 // Use fpret only for long double.
2246 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00002247
2248 // x86-64 has atomics up to 16 bytes.
2249 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
2250 // on CPUs with cmpxchg16b
2251 MaxAtomicPromoteWidth = 128;
2252 MaxAtomicInlineWidth = 64;
Chris Lattner4b009652007-07-25 00:24:17 +00002253 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +00002254 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002255 return "typedef struct __va_list_tag {"
2256 " unsigned gp_offset;"
2257 " unsigned fp_offset;"
2258 " void* overflow_arg_area;"
2259 " void* reg_save_area;"
John McCall33bf24b2010-05-28 18:25:28 +00002260 "} __va_list_tag;"
Eli Friedman3c79eee2009-07-03 00:45:06 +00002261 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson7dd1c952007-11-24 23:38:12 +00002262 }
Michael J. Spencer3d796932010-10-18 07:10:59 +00002263
Chris Lattneraa339182009-09-23 06:06:36 +00002264 int getEHDataRegisterNumber(unsigned RegNo) const {
2265 if (RegNo == 0) return 0;
2266 if (RegNo == 1) return 1;
2267 return -1;
2268 }
Eli Friedman872996c2008-08-20 02:34:37 +00002269};
2270} // end anonymous namespace
2271
2272namespace {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002273// x86-64 Windows target
Michael J. Spencer01e70082010-10-21 05:21:48 +00002274class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002275public:
2276 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencer01e70082010-10-21 05:21:48 +00002277 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002278 TLSSupported = false;
2279 WCharType = UnsignedShort;
Mike Stump4da7a162009-10-08 23:00:00 +00002280 LongWidth = LongAlign = 32;
Michael J. Spencer3d796932010-10-18 07:10:59 +00002281 DoubleAlign = LongLongAlign = 64;
Nate Begeman472bd992010-07-21 02:02:56 +00002282 IntMaxType = SignedLongLong;
2283 UIntMaxType = UnsignedLongLong;
2284 Int64Type = SignedLongLong;
Cameron Esfahani32083822010-09-15 00:28:12 +00002285 SizeType = UnsignedLongLong;
2286 PtrDiffType = SignedLongLong;
2287 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00002288 this->UserLabelPrefix = "";
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002289 }
2290 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002291 MacroBuilder &Builder) const {
Michael J. Spencer01e70082010-10-21 05:21:48 +00002292 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002293 Builder.defineMacro("_WIN64");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002294 }
NAKAMURA Takumi79521992011-01-17 22:56:23 +00002295 virtual const char *getVAListDeclaration() const {
2296 return "typedef char* __builtin_va_list;";
2297 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002298};
2299} // end anonymous namespace
2300
2301namespace {
2302// x86-64 Windows Visual Studio target
2303class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2304public:
2305 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2306 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002307 LongDoubleWidth = LongDoubleAlign = 64;
2308 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002309 }
2310 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002311 MacroBuilder &Builder) const {
2312 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00002313 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002314 Builder.defineMacro("_M_X64");
Michael J. Spencer01e70082010-10-21 05:21:48 +00002315 Builder.defineMacro("_M_AMD64");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002316 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002317};
2318} // end anonymous namespace
2319
2320namespace {
2321// x86-64 MinGW target
2322class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2323public:
2324 MinGWX86_64TargetInfo(const std::string& triple)
2325 : WindowsX86_64TargetInfo(triple) {
2326 }
2327 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002328 MacroBuilder &Builder) const {
2329 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00002330 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002331 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00002332 Builder.defineMacro("__MINGW32__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002333 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002334
2335 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2336 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002337 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002338 // Provide "as-is" __declspec.
2339 Builder.defineMacro("__declspec", "__declspec");
2340 else
2341 // Provide alias of __attribute__ like mingw32-gcc.
2342 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002343 }
2344};
2345} // end anonymous namespace
2346
2347namespace {
Eli Friedman38e31802009-07-01 03:36:11 +00002348class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2349public:
Mike Stump25cf7602009-09-09 15:08:12 +00002350 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman38e31802009-07-01 03:36:11 +00002351 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2352 Int64Type = SignedLongLong;
2353 }
2354};
2355} // end anonymous namespace
2356
2357namespace {
Eli Friedman96ada022009-07-05 22:31:18 +00002358class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
2359public:
Mike Stump25cf7602009-09-09 15:08:12 +00002360 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman96ada022009-07-05 22:31:18 +00002361 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
2362 IntMaxType = SignedLongLong;
2363 UIntMaxType = UnsignedLongLong;
2364 Int64Type = SignedLongLong;
2365 }
2366};
2367} // end anonymous namespace
2368
2369namespace {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00002370class ARMTargetInfo : public TargetInfo {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002371 // Possible FPU choices.
2372 enum FPUMode {
2373 NoFPU,
2374 VFP2FPU,
2375 VFP3FPU,
2376 NeonFPU
2377 };
2378
2379 static bool FPUModeIsVFP(FPUMode Mode) {
2380 return Mode >= VFP2FPU && Mode <= NeonFPU;
2381 }
2382
2383 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2384 static const char * const GCCRegNames[];
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002385
Daniel Dunbar33b40752009-12-18 18:42:37 +00002386 std::string ABI, CPU;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002387
2388 unsigned FPU : 3;
2389
Daniel Dunbar48075d82009-12-19 04:15:38 +00002390 unsigned IsThumb : 1;
2391
2392 // Initialized via features.
2393 unsigned SoftFloat : 1;
2394 unsigned SoftFloatABI : 1;
Daniel Dunbar0d83d512009-09-14 00:35:03 +00002395
Chris Lattnerb4527522010-03-03 19:03:45 +00002396 static const Builtin::Info BuiltinInfo[];
2397
Chris Lattner9fd73612008-04-21 18:56:49 +00002398public:
Daniel Dunbarf0156562009-09-17 16:21:10 +00002399 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbar33b40752009-12-18 18:42:37 +00002400 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar0d83d512009-09-14 00:35:03 +00002401 {
Daniel Dunbarb9531632009-09-14 00:02:24 +00002402 SizeType = UnsignedInt;
2403 PtrDiffType = SignedInt;
Daniel Dunbarf0156562009-09-17 16:21:10 +00002404
Chris Lattnere20b8122010-04-23 16:29:58 +00002405 // {} in inline assembly are neon specifiers, not assembly variant
2406 // specifiers.
2407 NoAsmVariants = true;
Michael J. Spencerd5513a32010-10-21 03:16:25 +00002408
Daniel Dunbar33b40752009-12-18 18:42:37 +00002409 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0a542ca2009-12-18 19:57:13 +00002410 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00002411 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002412 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2413 // so set preferred for small types to 32.
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00002414 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
2415 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002416 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00002417 } else {
2418 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2419 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002420 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00002421 }
John McCall68086b92010-08-21 22:46:04 +00002422
2423 // ARM targets default to using the ARM C++ ABI.
2424 CXXABI = CXXABI_ARM;
Eli Friedman2be46072011-10-14 20:59:01 +00002425
2426 // ARM has atomics up to 8 bytes
2427 // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e
2428 MaxAtomicPromoteWidth = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002429 }
Daniel Dunbar0d83d512009-09-14 00:35:03 +00002430 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbarb9531632009-09-14 00:02:24 +00002431 virtual bool setABI(const std::string &Name) {
Daniel Dunbar0d83d512009-09-14 00:35:03 +00002432 ABI = Name;
2433
Daniel Dunbarb9531632009-09-14 00:02:24 +00002434 // The defaults (above) are for AAPCS, check if we need to change them.
2435 //
2436 // FIXME: We need support for -meabi... we could just mangle it into the
2437 // name.
2438 if (Name == "apcs-gnu") {
Daniel Dunbarda94a772010-01-27 20:23:08 +00002439 DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
Daniel Dunbarb9531632009-09-14 00:02:24 +00002440 SizeType = UnsignedLong;
2441
Daniel Dunbar9eb811b2010-04-22 16:14:54 +00002442 // Do not respect the alignment of bit-field types when laying out
2443 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
2444 UseBitFieldTypeAlignment = false;
2445
Chad Rosier61a62212011-08-04 01:21:14 +00002446 /// Do force alignment of members that follow zero length bitfields. If
2447 /// the alignment of the zero-length bitfield is greater than the member
2448 /// that follows it, `bar', `bar' will be aligned as the type of the
2449 /// zero length bitfield.
2450 UseZeroLengthBitfieldAlignment = true;
2451
2452 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00002453 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
2454 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00002455 ZeroLengthBitfieldBoundary = 32;
2456
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00002457 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002458 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2459 // so set preferred for small types to 32.
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00002460 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 +00002461 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002462 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00002463 } else {
2464 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 +00002465 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002466 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00002467 }
2468
Daniel Dunbarb9531632009-09-14 00:02:24 +00002469 // FIXME: Override "preferred align" for double and long long.
2470 } else if (Name == "aapcs") {
2471 // FIXME: Enumerated types are variable width in straight AAPCS.
2472 } else if (Name == "aapcs-linux") {
2473 ;
2474 } else
2475 return false;
2476
2477 return true;
2478 }
Daniel Dunbar48075d82009-12-19 04:15:38 +00002479
Chandler Carruthc3a2e652011-09-28 05:56:05 +00002480 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002481 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
2482 Features["vfp2"] = true;
2483 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
2484 Features["neon"] = true;
2485 }
Michael J. Spencerd5513a32010-10-21 03:16:25 +00002486
Daniel Dunbar48075d82009-12-19 04:15:38 +00002487 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2488 const std::string &Name,
2489 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00002490 if (Name == "soft-float" || Name == "soft-float-abi" ||
Stephen Hines64f85312011-10-21 14:54:52 -07002491 Name == "vfp2" || Name == "vfp3" || Name == "neon" ||
2492 Name == "long64") {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002493 Features[Name] = Enabled;
2494 } else
Daniel Dunbar48075d82009-12-19 04:15:38 +00002495 return false;
2496
Daniel Dunbar48075d82009-12-19 04:15:38 +00002497 return true;
2498 }
2499
2500 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002501 FPU = NoFPU;
Daniel Dunbar48075d82009-12-19 04:15:38 +00002502 SoftFloat = SoftFloatABI = false;
2503 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
2504 if (Features[i] == "+soft-float")
2505 SoftFloat = true;
2506 else if (Features[i] == "+soft-float-abi")
2507 SoftFloatABI = true;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002508 else if (Features[i] == "+vfp2")
2509 FPU = VFP2FPU;
2510 else if (Features[i] == "+vfp3")
2511 FPU = VFP3FPU;
2512 else if (Features[i] == "+neon")
2513 FPU = NeonFPU;
Stephen Hines64f85312011-10-21 14:54:52 -07002514 else if (Features[i] == "+long64")
2515 LongWidth = LongAlign = 64; // RenderScript uses a 64-bit long type
Daniel Dunbar48075d82009-12-19 04:15:38 +00002516 }
2517
2518 // Remove front-end specific options which the backend handles differently.
2519 std::vector<std::string>::iterator it;
2520 it = std::find(Features.begin(), Features.end(), "+soft-float");
2521 if (it != Features.end())
2522 Features.erase(it);
2523 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2524 if (it != Features.end())
2525 Features.erase(it);
2526 }
2527
Chris Lattner5f9e2722011-07-23 10:55:15 +00002528 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbar33b40752009-12-18 18:42:37 +00002529 return llvm::StringSwitch<const char*>(Name)
2530 .Cases("arm8", "arm810", "4")
2531 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2532 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2533 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2534 .Case("ep9312", "4T")
2535 .Cases("arm10tdmi", "arm1020t", "5T")
2536 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2537 .Case("arm926ej-s", "5TEJ")
2538 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2539 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002540 .Case("arm1136j-s", "6J")
Daniel Dunbar33b40752009-12-18 18:42:37 +00002541 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002542 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbar33b40752009-12-18 18:42:37 +00002543 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2544 .Cases("cortex-a8", "cortex-a9", "7A")
Bob Wilson06f45632011-01-06 16:57:20 +00002545 .Case("cortex-m3", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00002546 .Case("cortex-m0", "6M")
Daniel Dunbar33b40752009-12-18 18:42:37 +00002547 .Default(0);
2548 }
2549 virtual bool setCPU(const std::string &Name) {
2550 if (!getCPUDefineSuffix(Name))
2551 return false;
2552
2553 CPU = Name;
2554 return true;
2555 }
Chris Lattner79682402009-03-20 15:52:06 +00002556 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002557 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00002558 // Target identification.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002559 Builder.defineMacro("__arm");
2560 Builder.defineMacro("__arm__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00002561
Chris Lattnerbef1d722009-03-02 22:27:17 +00002562 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002563 Builder.defineMacro("__ARMEL__");
2564 Builder.defineMacro("__LITTLE_ENDIAN__");
2565 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbar33b40752009-12-18 18:42:37 +00002566
Chris Lattner5f9e2722011-07-23 10:55:15 +00002567 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002568 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00002569
Mike Stumpf90a29f2009-04-08 02:07:04 +00002570 // Subtarget options.
Daniel Dunbarf0156562009-09-17 16:21:10 +00002571
Daniel Dunbar33b40752009-12-18 18:42:37 +00002572 // FIXME: It's more complicated than this and we don't really support
2573 // interworking.
2574 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002575 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00002576
Daniel Dunbar33b40752009-12-18 18:42:37 +00002577 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002578 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00002579
Daniel Dunbar48075d82009-12-19 04:15:38 +00002580 if (SoftFloat)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002581 Builder.defineMacro("__SOFTFP__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00002582
2583 if (CPU == "xscale")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002584 Builder.defineMacro("__XSCALE__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00002585
Bob Wilson84f95cf2011-05-13 18:56:03 +00002586 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbarf0156562009-09-17 16:21:10 +00002587 if (IsThumb) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002588 Builder.defineMacro("__THUMBEL__");
2589 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00002590 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002591 Builder.defineMacro("__thumb2__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00002592 }
2593
2594 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002595 Builder.defineMacro("__APCS_32__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002596
2597 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002598 Builder.defineMacro("__VFP_FP__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00002599
2600 // This only gets set when Neon instructions are actually available, unlike
2601 // the VFP define, hence the soft float and arch check. This is subtly
2602 // different from gcc, we follow the intent which was that it should be set
2603 // when Neon instructions are actually available.
Bob Wilson84f95cf2011-05-13 18:56:03 +00002604 if (FPU == NeonFPU && !SoftFloat && IsARMv7)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002605 Builder.defineMacro("__ARM_NEON__");
Chris Lattner9fd73612008-04-21 18:56:49 +00002606 }
2607 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2608 unsigned &NumRecords) const {
Chris Lattnerb4527522010-03-03 19:03:45 +00002609 Records = BuiltinInfo;
2610 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner9fd73612008-04-21 18:56:49 +00002611 }
2612 virtual const char *getVAListDeclaration() const {
John McCall0e9972c2011-05-09 02:19:37 +00002613 return "typedef void* __builtin_va_list;";
Chris Lattner9fd73612008-04-21 18:56:49 +00002614 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00002615 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002616 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00002617 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002618 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00002619 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00002620 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00002621 // FIXME: Check if this is complete
Anders Carlsson36834a72009-02-28 17:11:49 +00002622 switch (*Name) {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00002623 default:
Nate Begeman222823a2008-04-22 05:03:19 +00002624 case 'l': // r0-r7
2625 case 'h': // r8-r15
2626 case 'w': // VFP Floating point register single precision
2627 case 'P': // VFP Floating point register double precision
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00002628 Info.setAllowsRegister();
Nate Begeman222823a2008-04-22 05:03:19 +00002629 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00002630 case 'Q': // A memory address that is a single base register.
2631 Info.setAllowsMemory();
2632 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00002633 case 'U': // a memory reference...
2634 switch (Name[1]) {
2635 case 'q': // ...ARMV4 ldrsb
2636 case 'v': // ...VFP load/store (reg+constant offset)
2637 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00002638 case 't': // address valid for load/store opaque types wider
2639 // than 128-bits
2640 case 'n': // valid address for Neon doubleword vector load/store
2641 case 'm': // valid address for Neon element and structure load/store
2642 case 's': // valid address for non-offset loads/stores of quad-word
2643 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00002644 Info.setAllowsMemory();
2645 Name++;
2646 return true;
2647 }
Nate Begeman222823a2008-04-22 05:03:19 +00002648 }
Chris Lattner9fd73612008-04-21 18:56:49 +00002649 return false;
2650 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00002651 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00002652 std::string R;
2653 switch (*Constraint) {
2654 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00002655 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00002656 Constraint++;
2657 break;
Eric Christopher283f4472011-06-17 00:40:18 +00002658 case 'p': // 'p' should be translated to 'r' by default.
2659 R = std::string("r");
2660 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00002661 default:
2662 return std::string(1, *Constraint);
2663 }
2664 return R;
2665 }
Chris Lattner9fd73612008-04-21 18:56:49 +00002666 virtual const char *getClobbers() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00002667 // FIXME: Is this really right?
Chris Lattner9fd73612008-04-21 18:56:49 +00002668 return "";
2669 }
2670};
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002671
2672const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbar663e9f82010-08-11 02:17:20 +00002673 // Integer registers
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002674 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbar663e9f82010-08-11 02:17:20 +00002675 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
2676
2677 // Float registers
2678 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2679 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2680 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen0bbb50d2010-10-27 23:34:42 +00002681 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbar663e9f82010-08-11 02:17:20 +00002682
Dale Johannesen0bbb50d2010-10-27 23:34:42 +00002683 // Double registers
2684 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
2685 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesen0d79b042010-10-28 01:05:37 +00002686 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
2687 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen0bbb50d2010-10-27 23:34:42 +00002688
2689 // Quad registers
Dale Johannesen0d79b042010-10-28 01:05:37 +00002690 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
2691 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002692};
2693
2694void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar00ea8f02010-08-11 02:17:11 +00002695 unsigned &NumNames) const {
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002696 Names = GCCRegNames;
2697 NumNames = llvm::array_lengthof(GCCRegNames);
2698}
2699
2700const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002701 { { "a1" }, "r0" },
2702 { { "a2" }, "r1" },
2703 { { "a3" }, "r2" },
2704 { { "a4" }, "r3" },
2705 { { "v1" }, "r4" },
2706 { { "v2" }, "r5" },
2707 { { "v3" }, "r6" },
2708 { { "v4" }, "r7" },
2709 { { "v5" }, "r8" },
2710 { { "v6", "rfp" }, "r9" },
2711 { { "sl" }, "r10" },
2712 { { "fp" }, "r11" },
2713 { { "ip" }, "r12" },
Daniel Dunbar00ea8f02010-08-11 02:17:11 +00002714 { { "r13" }, "sp" },
2715 { { "r14" }, "lr" },
2716 { { "r15" }, "pc" },
Dale Johannesen0bbb50d2010-10-27 23:34:42 +00002717 // The S, D and Q registers overlap, but aren't really aliases; we
2718 // don't want to substitute one of these for a different-sized one.
Daniel Dunbar40b774e2009-09-17 07:03:19 +00002719};
2720
2721void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2722 unsigned &NumAliases) const {
2723 Aliases = GCCRegAliases;
2724 NumAliases = llvm::array_lengthof(GCCRegAliases);
2725}
Chris Lattnerb4527522010-03-03 19:03:45 +00002726
2727const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00002728#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00002729#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00002730 ALL_LANGUAGES },
Chris Lattnerb4527522010-03-03 19:03:45 +00002731#include "clang/Basic/BuiltinsARM.def"
2732};
Chris Lattner9fd73612008-04-21 18:56:49 +00002733} // end anonymous namespace.
2734
Eli Friedmanbe727fe2008-08-20 07:44:10 +00002735
2736namespace {
Mike Stump25cf7602009-09-09 15:08:12 +00002737class DarwinARMTargetInfo :
Edwin Török36565e52009-06-30 17:10:35 +00002738 public DarwinTargetInfo<ARMTargetInfo> {
2739protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +00002740 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002741 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00002742 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedman8f575172009-04-19 21:38:35 +00002743 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00002744
Edwin Török36565e52009-06-30 17:10:35 +00002745public:
Mike Stump25cf7602009-09-09 15:08:12 +00002746 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar01045582010-05-27 07:00:26 +00002747 : DarwinTargetInfo<ARMTargetInfo>(triple) {
2748 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00002749 // iOS always has 64-bit atomic instructions.
2750 // FIXME: This should be based off of the target features in ARMTargetInfo.
2751 MaxAtomicInlineWidth = 64;
Daniel Dunbar01045582010-05-27 07:00:26 +00002752 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00002753};
2754} // end anonymous namespace.
2755
Chris Lattner4b009652007-07-25 00:24:17 +00002756namespace {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002757class SparcV8TargetInfo : public TargetInfo {
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002758 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2759 static const char * const GCCRegNames[];
Bruno Cardoso Lopes584a4562010-11-09 17:21:19 +00002760 bool SoftFloat;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002761public:
Eli Friedmanff158dd2008-08-20 07:28:14 +00002762 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
2763 // FIXME: Support Sparc quad-precision long double?
Eli Friedman2b161652008-08-21 00:13:15 +00002764 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 +00002765 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedmanff158dd2008-08-20 07:28:14 +00002766 }
Bruno Cardoso Lopes584a4562010-11-09 17:21:19 +00002767 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2768 const std::string &Name,
2769 bool Enabled) const {
2770 if (Name == "soft-float")
2771 Features[Name] = Enabled;
2772 else
2773 return false;
2774
2775 return true;
2776 }
2777 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
2778 SoftFloat = false;
2779 for (unsigned i = 0, e = Features.size(); i != e; ++i)
2780 if (Features[i] == "+soft-float")
2781 SoftFloat = true;
2782 }
Chris Lattner79682402009-03-20 15:52:06 +00002783 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002784 MacroBuilder &Builder) const {
2785 DefineStd(Builder, "sparc", Opts);
2786 Builder.defineMacro("__sparcv8");
2787 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes584a4562010-11-09 17:21:19 +00002788
2789 if (SoftFloat)
2790 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002791 }
2792 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2793 unsigned &NumRecords) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002794 // FIXME: Implement!
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002795 }
2796 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002797 return "typedef void* __builtin_va_list;";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002798 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00002799 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002800 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00002801 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002802 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00002803 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002804 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002805 // FIXME: Implement!
2806 return false;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002807 }
2808 virtual const char *getClobbers() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002809 // FIXME: Implement!
2810 return "";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002811 }
2812};
2813
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002814const char * const SparcV8TargetInfo::GCCRegNames[] = {
2815 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2816 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2817 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2818 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
2819};
2820
Anton Korobeynikove7772382009-05-03 13:42:53 +00002821void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002822 unsigned &NumNames) const {
2823 Names = GCCRegNames;
2824 NumNames = llvm::array_lengthof(GCCRegNames);
2825}
2826
2827const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikove7772382009-05-03 13:42:53 +00002828 { { "g0" }, "r0" },
2829 { { "g1" }, "r1" },
2830 { { "g2" }, "r2" },
2831 { { "g3" }, "r3" },
2832 { { "g4" }, "r4" },
2833 { { "g5" }, "r5" },
2834 { { "g6" }, "r6" },
2835 { { "g7" }, "r7" },
2836 { { "o0" }, "r8" },
2837 { { "o1" }, "r9" },
2838 { { "o2" }, "r10" },
2839 { { "o3" }, "r11" },
2840 { { "o4" }, "r12" },
2841 { { "o5" }, "r13" },
2842 { { "o6", "sp" }, "r14" },
2843 { { "o7" }, "r15" },
2844 { { "l0" }, "r16" },
2845 { { "l1" }, "r17" },
2846 { { "l2" }, "r18" },
2847 { { "l3" }, "r19" },
2848 { { "l4" }, "r20" },
2849 { { "l5" }, "r21" },
2850 { { "l6" }, "r22" },
2851 { { "l7" }, "r23" },
2852 { { "i0" }, "r24" },
2853 { { "i1" }, "r25" },
2854 { { "i2" }, "r26" },
2855 { { "i3" }, "r27" },
2856 { { "i4" }, "r28" },
2857 { { "i5" }, "r29" },
2858 { { "i6", "fp" }, "r30" },
2859 { { "i7" }, "r31" },
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002860};
2861
Anton Korobeynikove7772382009-05-03 13:42:53 +00002862void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002863 unsigned &NumAliases) const {
2864 Aliases = GCCRegAliases;
2865 NumAliases = llvm::array_lengthof(GCCRegAliases);
2866}
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002867} // end anonymous namespace.
2868
Eli Friedmanff158dd2008-08-20 07:28:14 +00002869namespace {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002870class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
2871public:
2872 AuroraUXSparcV8TargetInfo(const std::string& triple) :
2873 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
2874 SizeType = UnsignedInt;
2875 PtrDiffType = SignedInt;
2876 }
2877};
Edwin Török36565e52009-06-30 17:10:35 +00002878class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002879public:
2880 SolarisSparcV8TargetInfo(const std::string& triple) :
Edwin Török36565e52009-06-30 17:10:35 +00002881 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedman7cca0982008-11-02 02:43:55 +00002882 SizeType = UnsignedInt;
2883 PtrDiffType = SignedInt;
Eli Friedmanff158dd2008-08-20 07:28:14 +00002884 }
2885};
2886} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +00002887
Chris Lattner85970f32008-05-08 05:58:21 +00002888namespace {
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002889 class MSP430TargetInfo : public TargetInfo {
2890 static const char * const GCCRegNames[];
2891 public:
2892 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
2893 TLSSupported = false;
Anton Korobeynikov2a6630a2010-01-30 12:55:11 +00002894 IntWidth = 16; IntAlign = 16;
2895 LongWidth = 32; LongLongWidth = 64;
2896 LongAlign = LongLongAlign = 16;
2897 PointerWidth = 16; PointerAlign = 16;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002898 SizeType = UnsignedInt;
2899 IntMaxType = SignedLong;
2900 UIntMaxType = UnsignedLong;
2901 IntPtrType = SignedShort;
2902 PtrDiffType = SignedInt;
Edward O'Callaghan14a70a32009-11-21 00:49:54 +00002903 SigAtomicType = SignedLong;
Anton Korobeynikov314713f2009-12-19 01:32:37 +00002904 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002905 }
2906 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002907 MacroBuilder &Builder) const {
2908 Builder.defineMacro("MSP430");
2909 Builder.defineMacro("__MSP430__");
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002910 // FIXME: defines for different 'flavours' of MCU
2911 }
2912 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2913 unsigned &NumRecords) const {
2914 // FIXME: Implement.
2915 Records = 0;
2916 NumRecords = 0;
2917 }
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002918 virtual void getGCCRegNames(const char * const *&Names,
2919 unsigned &NumNames) const;
2920 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2921 unsigned &NumAliases) const {
2922 // No aliases.
2923 Aliases = 0;
2924 NumAliases = 0;
2925 }
2926 virtual bool validateAsmConstraint(const char *&Name,
2927 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov174219b2009-10-15 23:17:13 +00002928 // No target constraints for now.
2929 return false;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002930 }
2931 virtual const char *getClobbers() const {
2932 // FIXME: Is this really right?
2933 return "";
2934 }
2935 virtual const char *getVAListDeclaration() const {
2936 // FIXME: implement
Anton Korobeynikovf5955592009-05-08 18:24:57 +00002937 return "typedef char* __builtin_va_list;";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002938 }
2939 };
2940
2941 const char * const MSP430TargetInfo::GCCRegNames[] = {
2942 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2943 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2944 };
2945
2946 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
2947 unsigned &NumNames) const {
2948 Names = GCCRegNames;
2949 NumNames = llvm::array_lengthof(GCCRegNames);
2950 }
2951}
2952
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002953namespace {
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002954
Mike Stump25cf7602009-09-09 15:08:12 +00002955 // LLVM and Clang cannot be used directly to output native binaries for
2956 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002957 // type and alignment information.
Mike Stump25cf7602009-09-09 15:08:12 +00002958 //
2959 // TCE uses the llvm bitcode as input and uses it for generating customized
2960 // target processor and program binary. TCE co-design environment is
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002961 // publicly available in http://tce.cs.tut.fi
2962
Eli Friedman209f5bb2011-10-07 19:51:42 +00002963 static const unsigned TCEOpenCLAddrSpaceMap[] = {
2964 3, // opencl_global
2965 4, // opencl_local
2966 5 // opencl_constant
2967 };
2968
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002969 class TCETargetInfo : public TargetInfo{
2970 public:
2971 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
2972 TLSSupported = false;
2973 IntWidth = 32;
2974 LongWidth = LongLongWidth = 32;
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002975 PointerWidth = 32;
2976 IntAlign = 32;
2977 LongAlign = LongLongAlign = 32;
2978 PointerAlign = 32;
2979 SizeType = UnsignedInt;
2980 IntMaxType = SignedLong;
2981 UIntMaxType = UnsignedLong;
2982 IntPtrType = SignedInt;
2983 PtrDiffType = SignedInt;
2984 FloatWidth = 32;
2985 FloatAlign = 32;
2986 DoubleWidth = 32;
2987 DoubleAlign = 32;
2988 LongDoubleWidth = 32;
2989 LongDoubleAlign = 32;
2990 FloatFormat = &llvm::APFloat::IEEEsingle;
2991 DoubleFormat = &llvm::APFloat::IEEEsingle;
2992 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner8a1db932010-03-04 21:07:38 +00002993 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
2994 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00002995 "f32:32:32-f64:32:32-v64:32:32-"
2996 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00002997 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002998 }
2999
3000 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00003001 MacroBuilder &Builder) const {
3002 DefineStd(Builder, "tce", Opts);
3003 Builder.defineMacro("__TCE__");
3004 Builder.defineMacro("__TCE_V1__");
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00003005 }
3006 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3007 unsigned &NumRecords) const {}
Daniel Dunbar2e967de2009-08-24 09:54:37 +00003008 virtual const char *getClobbers() const {
3009 return "";
3010 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00003011 virtual const char *getVAListDeclaration() const {
3012 return "typedef void* __builtin_va_list;";
3013 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00003014 virtual void getGCCRegNames(const char * const *&Names,
3015 unsigned &NumNames) const {}
3016 virtual bool validateAsmConstraint(const char *&Name,
3017 TargetInfo::ConstraintInfo &info) const {
3018 return true;
3019 }
3020 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3021 unsigned &NumAliases) const {}
3022 };
3023}
3024
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003025namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003026class MipsTargetInfoBase : public TargetInfo {
3027 std::string CPU;
3028protected:
3029 std::string ABI;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003030public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003031 MipsTargetInfoBase(const std::string& triple, const std::string& ABIStr)
3032 : TargetInfo(triple), ABI(ABIStr) {
Akira Hatanaka619e8872011-06-02 00:09:17 +00003033 SizeType = UnsignedInt;
3034 PtrDiffType = SignedInt;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003035 }
Eric Christopher03cc0ef2010-03-02 02:41:08 +00003036 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003037 virtual bool setABI(const std::string &Name) = 0;
Eric Christopher03cc0ef2010-03-02 02:41:08 +00003038 virtual bool setCPU(const std::string &Name) {
3039 CPU = Name;
3040 return true;
3041 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003042 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christopher03cc0ef2010-03-02 02:41:08 +00003043 Features[ABI] = true;
3044 Features[CPU] = true;
3045 }
3046 virtual void getArchDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003047 MacroBuilder &Builder) const = 0;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003048 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003049 MacroBuilder &Builder) const = 0;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003050 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3051 unsigned &NumRecords) const {
3052 // FIXME: Implement!
3053 }
3054 virtual const char *getVAListDeclaration() const {
3055 return "typedef void* __builtin_va_list;";
3056 }
3057 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003058 unsigned &NumNames) const {
3059 static const char * const GCCRegNames[] = {
3060 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
3061 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
3062 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
3063 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
3064 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
3065 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
3066 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
3067 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
3068 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
3069 "$fcc5","$fcc6","$fcc7"
3070 };
3071 Names = GCCRegNames;
3072 NumNames = llvm::array_lengthof(GCCRegNames);
3073 }
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003074 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003075 unsigned &NumAliases) const = 0;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003076 virtual bool validateAsmConstraint(const char *&Name,
3077 TargetInfo::ConstraintInfo &Info) const {
3078 switch (*Name) {
3079 default:
3080 case 'r': // CPU registers.
3081 case 'd': // Equivalent to "r" unless generating MIPS16 code.
3082 case 'y': // Equivalent to "r", backwards compatibility only.
3083 case 'f': // floating-point registers.
3084 Info.setAllowsRegister();
3085 return true;
3086 }
3087 return false;
3088 }
3089
3090 virtual const char *getClobbers() const {
3091 // FIXME: Implement!
3092 return "";
3093 }
3094};
3095
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003096class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003097public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003098 Mips32TargetInfoBase(const std::string& triple) :
3099 MipsTargetInfoBase(triple, "o32") {}
3100 virtual bool setABI(const std::string &Name) {
3101 if ((Name == "o32") || (Name == "eabi")) {
3102 ABI = Name;
3103 return true;
3104 } else
3105 return false;
3106 }
3107 virtual void getArchDefines(const LangOptions &Opts,
3108 MacroBuilder &Builder) const {
3109 if (ABI == "o32") {
3110 Builder.defineMacro("__mips_o32");
3111 Builder.defineMacro("_ABIO32", "1");
3112 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
3113 }
3114 else if (ABI == "eabi")
3115 Builder.defineMacro("__mips_eabi");
3116 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003117 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003118 }
3119 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3120 unsigned &NumAliases) const {
3121 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3122 { { "at" }, "$1" },
3123 { { "v0" }, "$2" },
3124 { { "v1" }, "$3" },
3125 { { "a0" }, "$4" },
3126 { { "a1" }, "$5" },
3127 { { "a2" }, "$6" },
3128 { { "a3" }, "$7" },
3129 { { "t0" }, "$8" },
3130 { { "t1" }, "$9" },
3131 { { "t2" }, "$10" },
3132 { { "t3" }, "$11" },
3133 { { "t4" }, "$12" },
3134 { { "t5" }, "$13" },
3135 { { "t6" }, "$14" },
3136 { { "t7" }, "$15" },
3137 { { "s0" }, "$16" },
3138 { { "s1" }, "$17" },
3139 { { "s2" }, "$18" },
3140 { { "s3" }, "$19" },
3141 { { "s4" }, "$20" },
3142 { { "s5" }, "$21" },
3143 { { "s6" }, "$22" },
3144 { { "s7" }, "$23" },
3145 { { "t8" }, "$24" },
3146 { { "t9" }, "$25" },
3147 { { "k0" }, "$26" },
3148 { { "k1" }, "$27" },
3149 { { "gp" }, "$28" },
3150 { { "sp" }, "$29" },
3151 { { "fp" }, "$30" },
3152 { { "ra" }, "$31" }
3153 };
3154 Aliases = GCCRegAliases;
3155 NumAliases = llvm::array_lengthof(GCCRegAliases);
3156 }
3157};
3158
3159class Mips32EBTargetInfo : public Mips32TargetInfoBase {
3160public:
3161 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
3162 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3163 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3164 }
3165 virtual void getTargetDefines(const LangOptions &Opts,
3166 MacroBuilder &Builder) const {
3167 DefineStd(Builder, "mips", Opts);
3168 Builder.defineMacro("_mips");
3169 DefineStd(Builder, "MIPSEB", Opts);
3170 Builder.defineMacro("_MIPSEB");
3171 Builder.defineMacro("__REGISTER_PREFIX__", "");
3172 getArchDefines(Opts, Builder);
3173 }
3174};
3175
3176class Mips32ELTargetInfo : public Mips32TargetInfoBase {
3177public:
3178 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003179 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 +00003180 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003181 }
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003182 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003183 MacroBuilder &Builder) const {
3184 DefineStd(Builder, "mips", Opts);
3185 Builder.defineMacro("_mips");
3186 DefineStd(Builder, "MIPSEL", Opts);
3187 Builder.defineMacro("_MIPSEL");
3188 Builder.defineMacro("__REGISTER_PREFIX__", "");
3189 getArchDefines(Opts, Builder);
3190 }
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003191};
3192
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003193class Mips64TargetInfoBase : public MipsTargetInfoBase {
3194 virtual void SetDescriptionString(const std::string &Name) = 0;
3195public:
3196 Mips64TargetInfoBase(const std::string& triple) :
Akira Hatanaka12507592011-10-22 00:07:27 +00003197 MipsTargetInfoBase(triple, "n64") {
3198 LongWidth = LongAlign = 64;
3199 PointerWidth = PointerAlign = 64;
3200 LongDoubleWidth = LongDoubleAlign = 128;
3201 LongDoubleFormat = &llvm::APFloat::IEEEquad;
3202 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003203 virtual bool setABI(const std::string &Name) {
3204 SetDescriptionString(Name);
Akira Hatanaka12507592011-10-22 00:07:27 +00003205
3206 if (Name != "n32" && Name != "n64")
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003207 return false;
Akira Hatanaka12507592011-10-22 00:07:27 +00003208
3209 ABI = Name;
3210
3211 if (Name == "n32") {
3212 LongWidth = LongAlign = 32;
3213 PointerWidth = PointerAlign = 32;
3214 }
3215
3216 return true;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003217 }
3218 virtual void getArchDefines(const LangOptions &Opts,
3219 MacroBuilder &Builder) const {
3220 if (ABI == "n32") {
3221 Builder.defineMacro("__mips_n32");
3222 Builder.defineMacro("_ABIN32", "2");
3223 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
3224 }
3225 else if (ABI == "n64") {
3226 Builder.defineMacro("__mips_n64");
3227 Builder.defineMacro("_ABI64", "3");
3228 Builder.defineMacro("_MIPS_SIM", "_ABI64");
3229 }
3230 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003231 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003232 }
3233 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3234 unsigned &NumAliases) const {
3235 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3236 { { "at" }, "$1" },
3237 { { "v0" }, "$2" },
3238 { { "v1" }, "$3" },
3239 { { "a0" }, "$4" },
3240 { { "a1" }, "$5" },
3241 { { "a2" }, "$6" },
3242 { { "a3" }, "$7" },
3243 { { "a4" }, "$8" },
3244 { { "a5" }, "$9" },
3245 { { "a6" }, "$10" },
3246 { { "a7" }, "$11" },
3247 { { "t0" }, "$12" },
3248 { { "t1" }, "$13" },
3249 { { "t2" }, "$14" },
3250 { { "t3" }, "$15" },
3251 { { "s0" }, "$16" },
3252 { { "s1" }, "$17" },
3253 { { "s2" }, "$18" },
3254 { { "s3" }, "$19" },
3255 { { "s4" }, "$20" },
3256 { { "s5" }, "$21" },
3257 { { "s6" }, "$22" },
3258 { { "s7" }, "$23" },
3259 { { "t8" }, "$24" },
3260 { { "t9" }, "$25" },
3261 { { "k0" }, "$26" },
3262 { { "k1" }, "$27" },
3263 { { "gp" }, "$28" },
3264 { { "sp" }, "$29" },
3265 { { "fp" }, "$30" },
3266 { { "ra" }, "$31" }
3267 };
3268 Aliases = GCCRegAliases;
3269 NumAliases = llvm::array_lengthof(GCCRegAliases);
3270 }
3271};
3272
3273class Mips64EBTargetInfo : public Mips64TargetInfoBase {
3274 virtual void SetDescriptionString(const std::string &Name) {
3275 // Change DescriptionString only if ABI is n32.
3276 if (Name == "n32")
3277 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 +00003278 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3279 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003280 }
3281public:
3282 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3283 // Default ABI is n64.
3284 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 +00003285 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3286 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003287 }
3288 virtual void getTargetDefines(const LangOptions &Opts,
3289 MacroBuilder &Builder) const {
3290 DefineStd(Builder, "mips", Opts);
3291 Builder.defineMacro("_mips");
3292 DefineStd(Builder, "MIPSEB", Opts);
3293 Builder.defineMacro("_MIPSEB");
3294 Builder.defineMacro("__REGISTER_PREFIX__", "");
3295 getArchDefines(Opts, Builder);
3296 }
3297};
3298
3299class Mips64ELTargetInfo : public Mips64TargetInfoBase {
3300 virtual void SetDescriptionString(const std::string &Name) {
3301 // Change DescriptionString only if ABI is n32.
3302 if (Name == "n32")
3303 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 +00003304 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
3305 "-v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003306 }
3307public:
3308 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3309 // Default ABI is n64.
3310 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 +00003311 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3312 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003313 }
3314 virtual void getTargetDefines(const LangOptions &Opts,
3315 MacroBuilder &Builder) const {
3316 DefineStd(Builder, "mips", Opts);
3317 Builder.defineMacro("_mips");
3318 DefineStd(Builder, "MIPSEL", Opts);
3319 Builder.defineMacro("_MIPSEL");
3320 Builder.defineMacro("__REGISTER_PREFIX__", "");
3321 getArchDefines(Opts, Builder);
3322 }
3323};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003324} // end anonymous namespace.
3325
Ivan Krasinef05abd2011-08-24 20:22:22 +00003326namespace {
3327class PNaClTargetInfo : public TargetInfo {
3328public:
3329 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
3330 this->UserLabelPrefix = "";
3331 this->LongAlign = 32;
3332 this->LongWidth = 32;
3333 this->PointerAlign = 32;
3334 this->PointerWidth = 32;
3335 this->IntMaxType = TargetInfo::SignedLongLong;
3336 this->UIntMaxType = TargetInfo::UnsignedLongLong;
3337 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003338 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003339 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003340 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003341 this->SizeType = TargetInfo::UnsignedInt;
3342 this->PtrDiffType = TargetInfo::SignedInt;
3343 this->IntPtrType = TargetInfo::SignedInt;
David Meyerdd4a8892011-10-11 03:12:01 +00003344 this->RegParmMax = 2;
Ivan Krasinef05abd2011-08-24 20:22:22 +00003345 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
3346 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
3347 }
3348
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003349 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00003350 }
3351 virtual void getArchDefines(const LangOptions &Opts,
3352 MacroBuilder &Builder) const {
3353 Builder.defineMacro("__le32__");
3354 Builder.defineMacro("__pnacl__");
3355 }
3356 virtual void getTargetDefines(const LangOptions &Opts,
3357 MacroBuilder &Builder) const {
Ivan Krasin089ee112011-08-25 23:49:20 +00003358 DefineStd(Builder, "unix", Opts);
3359 Builder.defineMacro("__ELF__");
3360 if (Opts.POSIXThreads)
3361 Builder.defineMacro("_REENTRANT");
3362 if (Opts.CPlusPlus)
3363 Builder.defineMacro("_GNU_SOURCE");
3364
Ivan Krasinef05abd2011-08-24 20:22:22 +00003365 Builder.defineMacro("__native_client__");
3366 getArchDefines(Opts, Builder);
3367 }
3368 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3369 unsigned &NumRecords) const {
3370 }
3371 virtual const char *getVAListDeclaration() const {
Ivan Krasin68018db2011-09-20 14:56:54 +00003372 return "typedef int __builtin_va_list[4];";
Ivan Krasinef05abd2011-08-24 20:22:22 +00003373 }
3374 virtual void getGCCRegNames(const char * const *&Names,
3375 unsigned &NumNames) const;
3376 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3377 unsigned &NumAliases) const;
3378 virtual bool validateAsmConstraint(const char *&Name,
3379 TargetInfo::ConstraintInfo &Info) const {
3380 return false;
3381 }
3382
3383 virtual const char *getClobbers() const {
3384 return "";
3385 }
3386};
3387
3388void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
3389 unsigned &NumNames) const {
3390 Names = NULL;
3391 NumNames = 0;
3392}
3393
3394void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3395 unsigned &NumAliases) const {
3396 Aliases = NULL;
3397 NumAliases = 0;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003398}
3399} // end anonymous namespace.
3400
Ivan Krasinef05abd2011-08-24 20:22:22 +00003401
Chris Lattner4b009652007-07-25 00:24:17 +00003402//===----------------------------------------------------------------------===//
3403// Driver code
3404//===----------------------------------------------------------------------===//
3405
Daniel Dunbarca3e9912009-11-15 06:48:46 +00003406static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003407 llvm::Triple Triple(T);
3408 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00003409
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003410 switch (Triple.getArch()) {
3411 default:
3412 return NULL;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00003413
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003414 case llvm::Triple::arm:
Daniel Dunbar3f361b52009-09-11 01:14:50 +00003415 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003416 if (Triple.isOSDarwin())
3417 return new DarwinARMTargetInfo(T);
3418
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003419 switch (os) {
Rafael Espindolad16a2202010-06-10 00:46:51 +00003420 case llvm::Triple::Linux:
3421 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003422 case llvm::Triple::FreeBSD:
Edwin Török36565e52009-06-30 17:10:35 +00003423 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003424 case llvm::Triple::NetBSD:
3425 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003426 case llvm::Triple::RTEMS:
3427 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003428 default:
3429 return new ARMTargetInfo(T);
3430 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00003431
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003432 case llvm::Triple::msp430:
3433 return new MSP430TargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00003434
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003435 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003436 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003437 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003438 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003439 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003440 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003441 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003442 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003443 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003444 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003445 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003446 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003447 }
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003448
3449 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003450 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003451 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003452 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003453 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003454 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003455 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003456 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003457 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003458 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003459 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003460 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003461 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003462
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003463 case llvm::Triple::mips64:
3464 switch (os) {
3465 case llvm::Triple::Linux:
3466 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
3467 case llvm::Triple::RTEMS:
3468 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
3469 case llvm::Triple::FreeBSD:
3470 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
3471 case llvm::Triple::NetBSD:
3472 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
3473 default:
3474 return new Mips64EBTargetInfo(T);
3475 }
3476
3477 case llvm::Triple::mips64el:
3478 switch (os) {
3479 case llvm::Triple::Linux:
3480 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
3481 case llvm::Triple::RTEMS:
3482 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
3483 case llvm::Triple::FreeBSD:
3484 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
3485 case llvm::Triple::NetBSD:
3486 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
3487 default:
3488 return new Mips64ELTargetInfo(T);
3489 }
3490
Ivan Krasinef05abd2011-08-24 20:22:22 +00003491 case llvm::Triple::le32:
3492 switch (os) {
3493 case llvm::Triple::NativeClient:
3494 return new PNaClTargetInfo(T);
3495 default:
3496 return NULL;
Chris Lattnere03ae302010-02-16 18:14:57 +00003497 }
Edward O'Callaghan097309f2009-11-15 10:22:07 +00003498
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003499 case llvm::Triple::ppc:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003500 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00003501 return new DarwinPPC32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003502 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003503 case llvm::Triple::Linux:
3504 return new LinuxTargetInfo<PPC32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003505 case llvm::Triple::FreeBSD:
Chris Lattnerf8030412010-02-16 18:14:57 +00003506 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003507 case llvm::Triple::NetBSD:
3508 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
3509 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003510 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003511 default:
3512 return new PPC32TargetInfo(T);
3513 }
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003514
3515 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003516 if (Triple.isOSDarwin())
Daniel Dunbar6501cab2010-05-30 00:07:30 +00003517 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003518 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003519 case llvm::Triple::Linux:
3520 return new LinuxTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003521 case llvm::Triple::Lv2:
John Thompsoned7bdbc2009-11-19 17:18:50 +00003522 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003523 case llvm::Triple::FreeBSD:
Chris Lattnerf8030412010-02-16 18:14:57 +00003524 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003525 case llvm::Triple::NetBSD:
3526 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
3527 default:
3528 return new PPC64TargetInfo(T);
3529 }
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003530
Justin Holewinski285dc652011-04-20 19:34:15 +00003531 case llvm::Triple::ptx32:
3532 return new PTX32TargetInfo(T);
3533 case llvm::Triple::ptx64:
3534 return new PTX64TargetInfo(T);
3535
Chris Lattner2c026472010-03-06 21:21:27 +00003536 case llvm::Triple::mblaze:
3537 return new MBlazeTargetInfo(T);
3538
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003539 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003540 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003541 case llvm::Triple::Linux:
3542 return new LinuxTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003543 case llvm::Triple::AuroraUX:
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00003544 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003545 case llvm::Triple::Solaris:
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003546 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003547 case llvm::Triple::NetBSD:
3548 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
3549 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003550 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003551 default:
3552 return new SparcV8TargetInfo(T);
3553 }
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003554
John Thompsoned7bdbc2009-11-19 17:18:50 +00003555 // FIXME: Need a real SPU target.
3556 case llvm::Triple::cellspu:
3557 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
3558
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00003559 case llvm::Triple::tce:
3560 return new TCETargetInfo(T);
3561
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003562 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003563 if (Triple.isOSDarwin())
3564 return new DarwinI386TargetInfo(T);
3565
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003566 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00003567 case llvm::Triple::AuroraUX:
3568 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003569 case llvm::Triple::Linux:
3570 return new LinuxTargetInfo<X86_32TargetInfo>(T);
3571 case llvm::Triple::DragonFly:
3572 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
3573 case llvm::Triple::NetBSD:
3574 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
3575 case llvm::Triple::OpenBSD:
3576 return new OpenBSDI386TargetInfo(T);
3577 case llvm::Triple::FreeBSD:
3578 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner6f4bed52010-07-07 16:01:42 +00003579 case llvm::Triple::Minix:
3580 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003581 case llvm::Triple::Solaris:
3582 return new SolarisTargetInfo<X86_32TargetInfo>(T);
3583 case llvm::Triple::Cygwin:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00003584 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003585 case llvm::Triple::MinGW32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00003586 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003587 case llvm::Triple::Win32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00003588 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattnerf853e732010-04-11 19:29:39 +00003589 case llvm::Triple::Haiku:
3590 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003591 case llvm::Triple::RTEMS:
3592 return new RTEMSX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003593 default:
3594 return new X86_32TargetInfo(T);
3595 }
3596
3597 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003598 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
3599 return new DarwinX86_64TargetInfo(T);
3600
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003601 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00003602 case llvm::Triple::AuroraUX:
3603 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003604 case llvm::Triple::Linux:
3605 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner1eac0812010-01-09 05:41:14 +00003606 case llvm::Triple::DragonFly:
3607 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003608 case llvm::Triple::NetBSD:
3609 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
3610 case llvm::Triple::OpenBSD:
3611 return new OpenBSDX86_64TargetInfo(T);
3612 case llvm::Triple::FreeBSD:
3613 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
3614 case llvm::Triple::Solaris:
3615 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00003616 case llvm::Triple::MinGW32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00003617 return new MinGWX86_64TargetInfo(T);
3618 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003619 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00003620 default:
3621 return new X86_64TargetInfo(T);
3622 }
3623 }
Chris Lattner4b009652007-07-25 00:24:17 +00003624}
Daniel Dunbarca3e9912009-11-15 06:48:46 +00003625
3626/// CreateTargetInfo - Return the target info object for the specified target
3627/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00003628TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00003629 TargetOptions &Opts) {
Daniel Dunbarca3e9912009-11-15 06:48:46 +00003630 llvm::Triple Triple(Opts.Triple);
3631
3632 // Construct the target
3633 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
3634 if (!Target) {
3635 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
3636 return 0;
3637 }
3638
Daniel Dunbar33b40752009-12-18 18:42:37 +00003639 // Set the target CPU if specified.
3640 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
3641 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
3642 return 0;
3643 }
3644
Daniel Dunbarca3e9912009-11-15 06:48:46 +00003645 // Set the target ABI if specified.
3646 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
3647 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
3648 return 0;
3649 }
3650
Charles Davisfed3a2b2010-06-11 01:06:47 +00003651 // Set the target C++ ABI.
John McCall68086b92010-08-21 22:46:04 +00003652 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davisfed3a2b2010-06-11 01:06:47 +00003653 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
3654 return 0;
3655 }
3656
Daniel Dunbarca3e9912009-11-15 06:48:46 +00003657 // Compute the default target features, we need the target to handle this
3658 // because features may have dependencies on one another.
3659 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003660 Target->getDefaultFeatures(Features);
Daniel Dunbarca3e9912009-11-15 06:48:46 +00003661
3662 // Apply the user specified deltas.
3663 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
3664 ie = Opts.Features.end(); it != ie; ++it) {
3665 const char *Name = it->c_str();
3666
3667 // Apply the feature via the target.
3668 if ((Name[0] != '-' && Name[0] != '+') ||
3669 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
3670 Diags.Report(diag::err_target_invalid_feature) << Name;
3671 return 0;
3672 }
3673 }
3674
3675 // Add the features to the compile options.
3676 //
3677 // FIXME: If we are completely confident that we have the right set, we only
3678 // need to pass the minuses.
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00003679 Opts.Features.clear();
Daniel Dunbarca3e9912009-11-15 06:48:46 +00003680 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
3681 ie = Features.end(); it != ie; ++it)
Chris Lattner1e5f83b2011-07-14 18:24:21 +00003682 Opts.Features.push_back(std::string(it->second ? "+" : "-") +
Chris Lattner48b78bd2011-07-14 18:45:41 +00003683 it->first().str());
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00003684 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbarca3e9912009-11-15 06:48:46 +00003685
3686 return Target.take();
3687}