blob: eb8358aab18969e1da6a16265f41b64676c7d953 [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"
Benjamin Kramerf8a85782010-01-09 18:20:57 +000029#include <algorithm>
Chris Lattner4b009652007-07-25 00:24:17 +000030using namespace clang;
31
Chris Lattner4b009652007-07-25 00:24:17 +000032//===----------------------------------------------------------------------===//
33// Common code shared among targets.
34//===----------------------------------------------------------------------===//
35
Chris Lattnerc345a802009-03-20 16:06:38 +000036/// DefineStd - Define a macro name and standard variants. For example if
37/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
38/// when in GNU mode.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000039static void DefineStd(MacroBuilder &Builder, llvm::StringRef MacroName,
Chris Lattnerc345a802009-03-20 16:06:38 +000040 const LangOptions &Opts) {
41 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikove7772382009-05-03 13:42:53 +000042
Chris Lattnerc345a802009-03-20 16:06:38 +000043 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
44 // in the user's namespace.
45 if (Opts.GNUMode)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000046 Builder.defineMacro(MacroName);
Anton Korobeynikove7772382009-05-03 13:42:53 +000047
Chris Lattnerc345a802009-03-20 16:06:38 +000048 // Define __unix.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000049 Builder.defineMacro("__" + MacroName);
Anton Korobeynikove7772382009-05-03 13:42:53 +000050
Chris Lattnerc345a802009-03-20 16:06:38 +000051 // Define __unix__.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000052 Builder.defineMacro("__" + MacroName + "__");
Chris Lattnerc345a802009-03-20 16:06:38 +000053}
54
Chris Lattnerbd00eb82008-10-05 21:50:58 +000055//===----------------------------------------------------------------------===//
56// Defines specific to certain operating systems.
57//===----------------------------------------------------------------------===//
Chris Lattner43954312009-08-10 19:03:04 +000058
Edwin Török36565e52009-06-30 17:10:35 +000059namespace {
Douglas Gregor937331f2009-07-01 15:12:53 +000060template<typename TgtInfo>
61class OSTargetInfo : public TgtInfo {
Edwin Török36565e52009-06-30 17:10:35 +000062protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +000063 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000064 MacroBuilder &Builder) const=0;
Edwin Török36565e52009-06-30 17:10:35 +000065public:
Douglas Gregor937331f2009-07-01 15:12:53 +000066 OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
Edwin Török36565e52009-06-30 17:10:35 +000067 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000068 MacroBuilder &Builder) const {
69 TgtInfo::getTargetDefines(Opts, Builder);
70 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Edwin Török2d98f9f2009-06-30 17:00:25 +000071 }
Edwin Török36565e52009-06-30 17:10:35 +000072
73};
Chris Lattnerf54f2212009-08-12 06:24:27 +000074} // end anonymous namespace
Edwin Török2d98f9f2009-06-30 17:00:25 +000075
Chris Lattner43954312009-08-10 19:03:04 +000076
Daniel Dunbareab96a22010-01-26 01:44:04 +000077static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
78 const llvm::Triple &Triple) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000079 Builder.defineMacro("__APPLE_CC__", "5621");
80 Builder.defineMacro("__APPLE__");
81 Builder.defineMacro("__MACH__");
82 Builder.defineMacro("OBJC_NEW_PROPERTIES");
Anton Korobeynikove7772382009-05-03 13:42:53 +000083
Chris Lattner8181e622009-04-07 16:50:40 +000084 // __weak is always defined, for use in blocks and with objc pointers.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000085 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikove7772382009-05-03 13:42:53 +000086
Chris Lattner8181e622009-04-07 16:50:40 +000087 // Darwin defines __strong even in C mode (just to nothing).
88 if (!Opts.ObjC1 || Opts.getGCMode() == LangOptions::NonGC)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000089 Builder.defineMacro("__strong", "");
Chris Lattner8181e622009-04-07 16:50:40 +000090 else
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000091 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
Eli Friedmaneff0a422009-06-04 23:00:29 +000092
93 if (Opts.Static)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000094 Builder.defineMacro("__STATIC__");
Eli Friedmaneff0a422009-06-04 23:00:29 +000095 else
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000096 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +000097
98 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000099 Builder.defineMacro("_REENTRANT");
Daniel Dunbar93f64532009-04-10 19:52:24 +0000100
Daniel Dunbareab96a22010-01-26 01:44:04 +0000101 // Get the OS version number from the triple.
Daniel Dunbar93f64532009-04-10 19:52:24 +0000102 unsigned Maj, Min, Rev;
Mike Stump25cf7602009-09-09 15:08:12 +0000103
Daniel Dunbareab96a22010-01-26 01:44:04 +0000104 // If no version was given, default to to 10.4.0, for simplifying tests.
105 if (Triple.getOSName() == "darwin") {
106 Min = Rev = 0;
107 Maj = 8;
108 } else
109 Triple.getDarwinNumber(Maj, Min, Rev);
110
111 // Set the appropriate OS version define.
112 if (Triple.getEnvironmentName() == "iphoneos") {
113 assert(Maj < 10 && Min < 99 && Rev < 99 && "Invalid version!");
114 char Str[6];
115 Str[0] = '0' + Maj;
116 Str[1] = '0' + (Min / 10);
117 Str[2] = '0' + (Min % 10);
118 Str[3] = '0' + (Rev / 10);
119 Str[4] = '0' + (Rev % 10);
120 Str[5] = '\0';
121 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
122 } else {
123 // For historical reasons that make little sense, the version passed here is
124 // the "darwin" version, which drops the 10 and offsets by 4.
125 Rev = Min;
126 Min = Maj - 4;
127 Maj = 10;
128
129 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
130 assert(Maj < 99 && Min < 10 && Rev < 10 && "Invalid version!");
131 char Str[5];
132 Str[0] = '0' + (Maj / 10);
133 Str[1] = '0' + (Maj % 10);
134 Str[2] = '0' + Min;
135 Str[3] = '0' + Rev;
136 Str[4] = '\0';
137 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar93f64532009-04-10 19:52:24 +0000138 }
Eli Friedman872996c2008-08-20 02:34:37 +0000139}
Chris Lattner4b009652007-07-25 00:24:17 +0000140
Chris Lattner43954312009-08-10 19:03:04 +0000141namespace {
Edwin Török36565e52009-06-30 17:10:35 +0000142template<typename Target>
143class DarwinTargetInfo : public OSTargetInfo<Target> {
144protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000145 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000146 MacroBuilder &Builder) const {
Daniel Dunbareab96a22010-01-26 01:44:04 +0000147 getDarwinDefines(Builder, Opts, Triple);
Edwin Török36565e52009-06-30 17:10:35 +0000148 }
Mike Stump25cf7602009-09-09 15:08:12 +0000149
Edwin Török36565e52009-06-30 17:10:35 +0000150public:
151 DarwinTargetInfo(const std::string& triple) :
152 OSTargetInfo<Target>(triple) {
Eric Christopherd109c622010-06-25 19:04:52 +0000153 this->TLSSupported = llvm::Triple(triple).getDarwinMajorNumber() > 10;
Edwin Török36565e52009-06-30 17:10:35 +0000154 }
155
Anders Carlsson41f80b52010-01-30 18:33:31 +0000156 virtual std::string isValidSectionSpecifier(llvm::StringRef SR) const {
Chris Lattner43954312009-08-10 19:03:04 +0000157 // Let MCSectionMachO validate this.
158 llvm::StringRef Segment, Section;
159 unsigned TAA, StubSize;
160 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
161 TAA, StubSize);
162 }
Anders Carlsson608b5792010-06-08 22:47:50 +0000163
164 virtual const char *getStaticInitSectionSpecifier() const {
165 // FIXME: We should return 0 when building kexts.
166 return "__TEXT,__StaticInit,regular,pure_instructions";
167 }
168
Edwin Török36565e52009-06-30 17:10:35 +0000169};
170
Chris Lattner43954312009-08-10 19:03:04 +0000171
Edwin Török36565e52009-06-30 17:10:35 +0000172// DragonFlyBSD Target
173template<typename Target>
174class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
175protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000176 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000177 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000178 // DragonFly defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000179 Builder.defineMacro("__DragonFly__");
180 Builder.defineMacro("__DragonFly_cc_version", "100001");
181 Builder.defineMacro("__ELF__");
182 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
183 Builder.defineMacro("__tune_i386__");
184 DefineStd(Builder, "unix", Opts);
Edwin Török36565e52009-06-30 17:10:35 +0000185 }
186public:
Mike Stump25cf7602009-09-09 15:08:12 +0000187 DragonFlyBSDTargetInfo(const std::string &triple)
Edwin Török36565e52009-06-30 17:10:35 +0000188 : OSTargetInfo<Target>(triple) {}
189};
190
191// FreeBSD Target
192template<typename Target>
193class FreeBSDTargetInfo : public OSTargetInfo<Target> {
194protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000195 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000196 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000197 // FreeBSD defines; list based off of gcc output
198
Daniel Dunbar608b3882009-08-24 09:10:05 +0000199 // FIXME: Move version number handling to llvm::Triple.
Benjamin Kramereaa3c702010-01-30 19:55:01 +0000200 llvm::StringRef Release = Triple.getOSName().substr(strlen("freebsd"), 1);
Edwin Török36565e52009-06-30 17:10:35 +0000201
Benjamin Kramereaa3c702010-01-30 19:55:01 +0000202 Builder.defineMacro("__FreeBSD__", Release);
203 Builder.defineMacro("__FreeBSD_cc_version", Release + "00001");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000204 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
205 DefineStd(Builder, "unix", Opts);
206 Builder.defineMacro("__ELF__");
Edwin Török36565e52009-06-30 17:10:35 +0000207 }
208public:
Mike Stump25cf7602009-09-09 15:08:12 +0000209 FreeBSDTargetInfo(const std::string &triple)
Duncan Sandscd2cb662009-07-08 13:55:08 +0000210 : OSTargetInfo<Target>(triple) {
211 this->UserLabelPrefix = "";
212 }
Edwin Török36565e52009-06-30 17:10:35 +0000213};
214
Chris Lattner6f4bed52010-07-07 16:01:42 +0000215// Minix Target
216template<typename Target>
217class MinixTargetInfo : public OSTargetInfo<Target> {
218protected:
219 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
220 MacroBuilder &Builder) const {
221 // Minix defines
222
223 Builder.defineMacro("__minix", "3");
224 Builder.defineMacro("_EM_WSIZE", "4");
225 Builder.defineMacro("_EM_PSIZE", "4");
226 Builder.defineMacro("_EM_SSIZE", "2");
227 Builder.defineMacro("_EM_LSIZE", "4");
228 Builder.defineMacro("_EM_FSIZE", "4");
229 Builder.defineMacro("_EM_DSIZE", "8");
230 DefineStd(Builder, "unix", Opts);
231 }
232public:
233 MinixTargetInfo(const std::string &triple)
234 : OSTargetInfo<Target>(triple) {
235 this->UserLabelPrefix = "";
236 }
237};
238
Edwin Török36565e52009-06-30 17:10:35 +0000239// Linux target
240template<typename Target>
241class LinuxTargetInfo : public OSTargetInfo<Target> {
242protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000243 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000244 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000245 // Linux defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000246 DefineStd(Builder, "unix", Opts);
247 DefineStd(Builder, "linux", Opts);
248 Builder.defineMacro("__gnu_linux__");
249 Builder.defineMacro("__ELF__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000250 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000251 Builder.defineMacro("_REENTRANT");
Douglas Gregor9b22a172010-04-21 05:52:38 +0000252 if (Opts.CPlusPlus)
253 Builder.defineMacro("_GNU_SOURCE");
Edwin Török36565e52009-06-30 17:10:35 +0000254 }
255public:
Mike Stump25cf7602009-09-09 15:08:12 +0000256 LinuxTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +0000257 : OSTargetInfo<Target>(triple) {
258 this->UserLabelPrefix = "";
259 }
260};
261
Chris Lattner25fff082009-07-13 20:29:08 +0000262// NetBSD Target
263template<typename Target>
264class NetBSDTargetInfo : public OSTargetInfo<Target> {
265protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000266 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000267 MacroBuilder &Builder) const {
Chris Lattner25fff082009-07-13 20:29:08 +0000268 // NetBSD defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000269 Builder.defineMacro("__NetBSD__");
270 Builder.defineMacro("__unix__");
271 Builder.defineMacro("__ELF__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000272 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000273 Builder.defineMacro("_POSIX_THREADS");
Chris Lattner25fff082009-07-13 20:29:08 +0000274 }
275public:
Mike Stump25cf7602009-09-09 15:08:12 +0000276 NetBSDTargetInfo(const std::string &triple)
Chris Lattner25fff082009-07-13 20:29:08 +0000277 : OSTargetInfo<Target>(triple) {
278 this->UserLabelPrefix = "";
279 }
280};
281
Edwin Török36565e52009-06-30 17:10:35 +0000282// OpenBSD Target
283template<typename Target>
284class OpenBSDTargetInfo : public OSTargetInfo<Target> {
285protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000286 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000287 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000288 // OpenBSD defines; list based off of gcc output
289
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000290 Builder.defineMacro("__OpenBSD__");
291 DefineStd(Builder, "unix", Opts);
292 Builder.defineMacro("__ELF__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000293 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000294 Builder.defineMacro("_POSIX_THREADS");
Edwin Török36565e52009-06-30 17:10:35 +0000295 }
296public:
Mike Stump25cf7602009-09-09 15:08:12 +0000297 OpenBSDTargetInfo(const std::string &triple)
Edwin Török36565e52009-06-30 17:10:35 +0000298 : OSTargetInfo<Target>(triple) {}
299};
300
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000301// PSP Target
302template<typename Target>
303class PSPTargetInfo : public OSTargetInfo<Target> {
304protected:
305 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000306 MacroBuilder &Builder) const {
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000307 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000308 Builder.defineMacro("PSP");
309 Builder.defineMacro("_PSP");
310 Builder.defineMacro("__psp__");
311 Builder.defineMacro("__ELF__");
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000312 }
313public:
314 PSPTargetInfo(const std::string& triple)
315 : OSTargetInfo<Target>(triple) {
316 this->UserLabelPrefix = "";
317 }
318};
319
John Thompsoned7bdbc2009-11-19 17:18:50 +0000320// PS3 PPU Target
321template<typename Target>
322class PS3PPUTargetInfo : public OSTargetInfo<Target> {
323protected:
324 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000325 MacroBuilder &Builder) const {
John Thompsoned7bdbc2009-11-19 17:18:50 +0000326 // PS3 PPU defines.
John Thompsonfdd2fc32010-03-25 16:18:32 +0000327 Builder.defineMacro("__PPC__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000328 Builder.defineMacro("__PPU__");
329 Builder.defineMacro("__CELLOS_LV2__");
330 Builder.defineMacro("__ELF__");
331 Builder.defineMacro("__LP32__");
John Thompson1deeb9f2010-06-24 22:44:13 +0000332 Builder.defineMacro("_ARCH_PPC64");
333 Builder.defineMacro("__powerpc64__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000334 }
335public:
336 PS3PPUTargetInfo(const std::string& triple)
337 : OSTargetInfo<Target>(triple) {
338 this->UserLabelPrefix = "";
John Thompson4c3bd3f2009-12-18 14:21:08 +0000339 this->LongWidth = this->LongAlign = this->PointerWidth = this->PointerAlign = 32;
John Thompson1deeb9f2010-06-24 22:44:13 +0000340 this->IntMaxType = TargetInfo::SignedLongLong;
341 this->UIntMaxType = TargetInfo::UnsignedLongLong;
342 this->Int64Type = TargetInfo::SignedLongLong;
John Thompson4c3bd3f2009-12-18 14:21:08 +0000343 this->SizeType = TargetInfo::UnsignedInt;
John Thompson1deeb9f2010-06-24 22:44:13 +0000344 this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
345 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompsoned7bdbc2009-11-19 17:18:50 +0000346 }
347};
348
349// FIXME: Need a real SPU target.
350// PS3 SPU Target
351template<typename Target>
352class PS3SPUTargetInfo : public OSTargetInfo<Target> {
353protected:
354 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000355 MacroBuilder &Builder) const {
John Thompsoned7bdbc2009-11-19 17:18:50 +0000356 // PS3 PPU defines.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000357 Builder.defineMacro("__SPU__");
358 Builder.defineMacro("__ELF__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000359 }
360public:
361 PS3SPUTargetInfo(const std::string& triple)
362 : OSTargetInfo<Target>(triple) {
363 this->UserLabelPrefix = "";
364 }
365};
366
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +0000367// AuroraUX target
368template<typename Target>
369class AuroraUXTargetInfo : public OSTargetInfo<Target> {
370protected:
371 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000372 MacroBuilder &Builder) const {
373 DefineStd(Builder, "sun", Opts);
374 DefineStd(Builder, "unix", Opts);
375 Builder.defineMacro("__ELF__");
376 Builder.defineMacro("__svr4__");
377 Builder.defineMacro("__SVR4");
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +0000378 }
379public:
380 AuroraUXTargetInfo(const std::string& triple)
381 : OSTargetInfo<Target>(triple) {
382 this->UserLabelPrefix = "";
383 this->WCharType = this->SignedLong;
384 // FIXME: WIntType should be SignedLong
385 }
386};
387
Edwin Török36565e52009-06-30 17:10:35 +0000388// Solaris target
389template<typename Target>
390class SolarisTargetInfo : public OSTargetInfo<Target> {
391protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000392 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000393 MacroBuilder &Builder) const {
394 DefineStd(Builder, "sun", Opts);
395 DefineStd(Builder, "unix", Opts);
396 Builder.defineMacro("__ELF__");
397 Builder.defineMacro("__svr4__");
398 Builder.defineMacro("__SVR4");
Edwin Török36565e52009-06-30 17:10:35 +0000399 }
400public:
Mike Stump25cf7602009-09-09 15:08:12 +0000401 SolarisTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +0000402 : OSTargetInfo<Target>(triple) {
403 this->UserLabelPrefix = "";
404 this->WCharType = this->SignedLong;
405 // FIXME: WIntType should be SignedLong
406 }
407};
Mike Stump25cf7602009-09-09 15:08:12 +0000408} // end anonymous namespace.
Edwin Török36565e52009-06-30 17:10:35 +0000409
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000410//===----------------------------------------------------------------------===//
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000411// Specific target implementations.
412//===----------------------------------------------------------------------===//
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000413
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000414namespace {
415// PPC abstract base class
416class PPCTargetInfo : public TargetInfo {
417 static const Builtin::Info BuiltinInfo[];
418 static const char * const GCCRegNames[];
419 static const TargetInfo::GCCRegAlias GCCRegAliases[];
420
421public:
Eli Friedmand9389be2009-06-05 07:05:05 +0000422 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
423
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000424 virtual void getTargetBuiltins(const Builtin::Info *&Records,
425 unsigned &NumRecords) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000426 Records = BuiltinInfo;
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000427 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000428 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000429
Chris Lattner79682402009-03-20 15:52:06 +0000430 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000431 MacroBuilder &Builder) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000432
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000433 virtual const char *getVAListDeclaration() const {
Chris Lattnera07708f2008-10-27 01:11:29 +0000434 return "typedef char* __builtin_va_list;";
435 // This is the right definition for ABI/V4: System V.4/eabi.
436 /*return "typedef struct __va_list_tag {"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000437 " unsigned char gpr;"
438 " unsigned char fpr;"
439 " unsigned short reserved;"
440 " void* overflow_arg_area;"
441 " void* reg_save_area;"
Chris Lattnera07708f2008-10-27 01:11:29 +0000442 "} __builtin_va_list[1];";*/
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000443 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000444 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000445 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000446 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000447 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +0000448 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000449 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +0000450 switch (*Name) {
Anders Carlsson4ce42302007-11-27 04:11:28 +0000451 default: return false;
452 case 'O': // Zero
John Thompson1deeb9f2010-06-24 22:44:13 +0000453 break;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000454 case 'b': // Base register
455 case 'f': // Floating point register
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000456 Info.setAllowsRegister();
John Thompson1deeb9f2010-06-24 22:44:13 +0000457 break;
458 // FIXME: The following are added to allow parsing.
459 // I just took a guess at what the actions should be.
460 // Also, is more specific checking needed? I.e. specific registers?
461 case 'd': // Floating point register (containing 64-bit value)
462 case 'v': // Altivec vector register
463 Info.setAllowsRegister();
464 break;
465 case 'w':
466 switch (Name[1]) {
467 case 'd':// VSX vector register to hold vector double data
468 case 'f':// VSX vector register to hold vector float data
469 case 's':// VSX vector register to hold scalar float data
470 case 'a':// Any VSX register
471 break;
472 default:
473 return false;
474 }
475 Info.setAllowsRegister();
476 Name++; // Skip over 'w'.
477 break;
478 case 'h': // `MQ', `CTR', or `LINK' register
479 case 'q': // `MQ' register
480 case 'c': // `CTR' register
481 case 'l': // `LINK' register
482 case 'x': // `CR' register (condition register) number 0
483 case 'y': // `CR' register (condition register)
484 case 'z': // `XER[CA]' carry bit (part of the XER register)
485 Info.setAllowsRegister();
486 break;
487 case 'I': // Signed 16-bit constant
488 case 'J': // Unsigned 16-bit constant shifted left 16 bits
489 // (use `L' instead for SImode constants)
490 case 'K': // Unsigned 16-bit constant
491 case 'L': // Signed 16-bit constant shifted left 16 bits
492 case 'M': // Constant larger than 31
493 case 'N': // Exact power of 2
494 case 'P': // Constant whose negation is a signed 16-bit constant
495 case 'G': // Floating point constant that can be loaded into a
496 // register with one instruction per word
497 case 'H': // Integer/Floating point constant that can be loaded
498 // into a register using three instructions
499 break;
500 case 'm': // Memory operand. Note that on PowerPC targets, m can
501 // include addresses that update the base register. It
502 // is therefore only safe to use `m' in an asm statement
503 // if that asm statement accesses the operand exactly once.
504 // The asm statement must also use `%U<opno>' as a
505 // placeholder for the “update” flag in the corresponding
506 // load or store instruction. For example:
507 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
508 // is correct but:
509 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
510 // is not. Use es rather than m if you don't want the base
511 // register to be updated.
John Thompsone0a39472010-06-25 00:02:05 +0000512 case 'e':
513 if (Name[1] != 's')
514 return false;
515 // es: A “stable” memory operand; that is, one which does not
John Thompson1deeb9f2010-06-24 22:44:13 +0000516 // include any automodification of the base register. Unlike
517 // `m', this constraint can be used in asm statements that
518 // might access the operand several times, or that might not
John Thompsone0a39472010-06-25 00:02:05 +0000519 // access it at all.
John Thompson1deeb9f2010-06-24 22:44:13 +0000520 Info.setAllowsMemory();
John Thompsone0a39472010-06-25 00:02:05 +0000521 Name++; // Skip over 'e'.
John Thompson1deeb9f2010-06-24 22:44:13 +0000522 break;
523 case 'Q': // Memory operand that is an offset from a register (it is
524 // usually better to use `m' or `es' in asm statements)
525 case 'Z': // Memory operand that is an indexed or indirect from a
526 // register (it is usually better to use `m' or `es' in
527 // asm statements)
528 Info.setAllowsMemory();
529 Info.setAllowsRegister();
530 break;
531 case 'R': // AIX TOC entry
532 case 'a': // Address operand that is an indexed or indirect from a
533 // register (`p' is preferable for asm statements)
534 case 'S': // Constant suitable as a 64-bit mask operand
535 case 'T': // Constant suitable as a 32-bit mask operand
536 case 'U': // System V Release 4 small data area reference
537 case 't': // AND masks that can be performed by two rldic{l, r}
538 // instructions
539 case 'W': // Vector constant that does not require memory
540 case 'j': // Vector constant that is all zeros.
541 break;
542 // End FIXME.
Anders Carlsson4ce42302007-11-27 04:11:28 +0000543 }
John Thompson1deeb9f2010-06-24 22:44:13 +0000544 return true;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000545 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000546 virtual const char *getClobbers() const {
547 return "";
Anders Carlsson4ce42302007-11-27 04:11:28 +0000548 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000549};
Anders Carlsson4ce42302007-11-27 04:11:28 +0000550
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000551const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000552#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
553#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000554#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000555};
Anton Korobeynikove7772382009-05-03 13:42:53 +0000556
557
Chris Lattnerbef1d722009-03-02 22:27:17 +0000558/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
559/// #defines that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +0000560void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000561 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +0000562 // Target identification.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000563 Builder.defineMacro("__ppc__");
564 Builder.defineMacro("_ARCH_PPC");
Chris Lattnerf8030412010-02-16 18:14:57 +0000565 Builder.defineMacro("__powerpc__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000566 Builder.defineMacro("__POWERPC__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000567 if (PointerWidth == 64) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000568 Builder.defineMacro("_ARCH_PPC64");
569 Builder.defineMacro("_LP64");
570 Builder.defineMacro("__LP64__");
Chris Lattnerf8030412010-02-16 18:14:57 +0000571 Builder.defineMacro("__powerpc64__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000572 Builder.defineMacro("__ppc64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000573 } else {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000574 Builder.defineMacro("__ppc__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000575 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000576
Chris Lattnerbef1d722009-03-02 22:27:17 +0000577 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000578 Builder.defineMacro("_BIG_ENDIAN");
579 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000580
Chris Lattnerbef1d722009-03-02 22:27:17 +0000581 // Subtarget options.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000582 Builder.defineMacro("__NATURAL_ALIGNMENT__");
583 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000584
Chris Lattnerbef1d722009-03-02 22:27:17 +0000585 // FIXME: Should be controlled by command line option.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000586 Builder.defineMacro("__LONG_DOUBLE_128__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000587
588 if (Opts.AltiVec) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000589 Builder.defineMacro("__VEC__", "10206");
590 Builder.defineMacro("__ALTIVEC__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000591 }
Chris Lattnerbef1d722009-03-02 22:27:17 +0000592}
593
Chris Lattner9fd73612008-04-21 18:56:49 +0000594
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000595const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattner14d2bb72009-09-16 05:05:27 +0000596 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
597 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
598 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
599 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
600 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
601 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
602 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
603 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000604 "mq", "lr", "ctr", "ap",
Chris Lattner14d2bb72009-09-16 05:05:27 +0000605 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000606 "xer",
Chris Lattner14d2bb72009-09-16 05:05:27 +0000607 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
608 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
609 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
610 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000611 "vrsave", "vscr",
612 "spe_acc", "spefscr",
613 "sfp"
614};
Chris Lattner4b009652007-07-25 00:24:17 +0000615
Anton Korobeynikove7772382009-05-03 13:42:53 +0000616void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000617 unsigned &NumNames) const {
618 Names = GCCRegNames;
619 NumNames = llvm::array_lengthof(GCCRegNames);
620}
Chris Lattner4b009652007-07-25 00:24:17 +0000621
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000622const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
623 // While some of these aliases do map to different registers
624 // they still share the same register name.
Daniel Dunbar40b774e2009-09-17 07:03:19 +0000625 { { "0" }, "r0" },
626 { { "1"}, "r1" },
627 { { "2" }, "r2" },
628 { { "3" }, "r3" },
629 { { "4" }, "r4" },
630 { { "5" }, "r5" },
631 { { "6" }, "r6" },
632 { { "7" }, "r7" },
633 { { "8" }, "r8" },
634 { { "9" }, "r9" },
635 { { "10" }, "r10" },
636 { { "11" }, "r11" },
637 { { "12" }, "r12" },
638 { { "13" }, "r13" },
639 { { "14" }, "r14" },
640 { { "15" }, "r15" },
641 { { "16" }, "r16" },
642 { { "17" }, "r17" },
643 { { "18" }, "r18" },
644 { { "19" }, "r19" },
645 { { "20" }, "r20" },
646 { { "21" }, "r21" },
647 { { "22" }, "r22" },
648 { { "23" }, "r23" },
649 { { "24" }, "r24" },
650 { { "25" }, "r25" },
651 { { "26" }, "r26" },
652 { { "27" }, "r27" },
653 { { "28" }, "r28" },
654 { { "29" }, "r29" },
655 { { "30" }, "r30" },
656 { { "31" }, "r31" },
657 { { "fr0" }, "f0" },
658 { { "fr1" }, "f1" },
659 { { "fr2" }, "f2" },
660 { { "fr3" }, "f3" },
661 { { "fr4" }, "f4" },
662 { { "fr5" }, "f5" },
663 { { "fr6" }, "f6" },
664 { { "fr7" }, "f7" },
665 { { "fr8" }, "f8" },
666 { { "fr9" }, "f9" },
Mike Stump369c21c2009-09-17 21:15:00 +0000667 { { "fr10" }, "f10" },
Daniel Dunbar40b774e2009-09-17 07:03:19 +0000668 { { "fr11" }, "f11" },
669 { { "fr12" }, "f12" },
670 { { "fr13" }, "f13" },
671 { { "fr14" }, "f14" },
672 { { "fr15" }, "f15" },
673 { { "fr16" }, "f16" },
674 { { "fr17" }, "f17" },
675 { { "fr18" }, "f18" },
676 { { "fr19" }, "f19" },
677 { { "fr20" }, "f20" },
678 { { "fr21" }, "f21" },
679 { { "fr22" }, "f22" },
680 { { "fr23" }, "f23" },
681 { { "fr24" }, "f24" },
682 { { "fr25" }, "f25" },
683 { { "fr26" }, "f26" },
684 { { "fr27" }, "f27" },
685 { { "fr28" }, "f28" },
686 { { "fr29" }, "f29" },
687 { { "fr30" }, "f30" },
688 { { "fr31" }, "f31" },
689 { { "cc" }, "cr0" },
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000690};
691
Anton Korobeynikove7772382009-05-03 13:42:53 +0000692void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000693 unsigned &NumAliases) const {
694 Aliases = GCCRegAliases;
695 NumAliases = llvm::array_lengthof(GCCRegAliases);
696}
697} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +0000698
699namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000700class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000701public:
Chris Lattnerf8030412010-02-16 18:14:57 +0000702 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedman2b161652008-08-21 00:13:15 +0000703 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 +0000704 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnerf8030412010-02-16 18:14:57 +0000705
706 if (getTriple().getOS() == llvm::Triple::FreeBSD)
707 this->SizeType = TargetInfo::UnsignedInt;
Eli Friedman2b161652008-08-21 00:13:15 +0000708 }
Chris Lattner4b009652007-07-25 00:24:17 +0000709};
710} // end anonymous namespace.
711
712namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000713class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000714public:
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000715 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +0000716 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman38e31802009-07-01 03:36:11 +0000717 IntMaxType = SignedLong;
718 UIntMaxType = UnsignedLong;
719 Int64Type = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +0000720 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 +0000721 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnere5fde952008-05-09 06:17:04 +0000722 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000723};
724} // end anonymous namespace.
725
Daniel Dunbar6501cab2010-05-30 00:07:30 +0000726
727namespace {
728class DarwinPPCTargetInfo :
729 public DarwinTargetInfo<PPCTargetInfo> {
730public:
731 DarwinPPCTargetInfo(const std::string& triple)
732 : DarwinTargetInfo<PPCTargetInfo>(triple) {
733 HasAlignMac68kSupport = true;
734 }
735};
736
737class DarwinPPC64TargetInfo :
738 public DarwinTargetInfo<PPC64TargetInfo> {
739public:
740 DarwinPPC64TargetInfo(const std::string& triple)
741 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
742 HasAlignMac68kSupport = true;
743 }
744};
745} // end anonymous namespace.
746
Chris Lattner4b009652007-07-25 00:24:17 +0000747namespace {
Chris Lattner2c026472010-03-06 21:21:27 +0000748// MBlaze abstract base class
749class MBlazeTargetInfo : public TargetInfo {
750 static const char * const GCCRegNames[];
751 static const TargetInfo::GCCRegAlias GCCRegAliases[];
752
753public:
754 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
755 DescriptionString = "E-p:32:32-i8:8:8-i16:16:16-i64:32:32-f64:32:32-"
756 "v64:32:32-v128:32:32-n32";
757 }
758
759 virtual void getTargetBuiltins(const Builtin::Info *&Records,
760 unsigned &NumRecords) const {
761 // FIXME: Implement.
762 Records = 0;
763 NumRecords = 0;
764 }
765
766 virtual void getTargetDefines(const LangOptions &Opts,
767 MacroBuilder &Builder) const;
768
769 virtual const char *getVAListDeclaration() const {
770 return "typedef char* __builtin_va_list;";
771 }
772 virtual const char *getTargetPrefix() const {
773 return "mblaze";
774 }
775 virtual void getGCCRegNames(const char * const *&Names,
776 unsigned &NumNames) const;
777 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
778 unsigned &NumAliases) const;
779 virtual bool validateAsmConstraint(const char *&Name,
780 TargetInfo::ConstraintInfo &Info) const {
781 switch (*Name) {
782 default: return false;
783 case 'O': // Zero
784 return true;
785 case 'b': // Base register
786 case 'f': // Floating point register
787 Info.setAllowsRegister();
788 return true;
789 }
790 }
791 virtual const char *getClobbers() const {
792 return "";
793 }
794};
795
796/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
797/// #defines that are not tied to a specific subtarget.
798void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
799 MacroBuilder &Builder) const {
800 // Target identification.
801 Builder.defineMacro("__microblaze__");
802 Builder.defineMacro("_ARCH_MICROBLAZE");
803 Builder.defineMacro("__MICROBLAZE__");
804
805 // Target properties.
806 Builder.defineMacro("_BIG_ENDIAN");
807 Builder.defineMacro("__BIG_ENDIAN__");
808
809 // Subtarget options.
810 Builder.defineMacro("__REGISTER_PREFIX__", "");
811}
812
813
814const char * const MBlazeTargetInfo::GCCRegNames[] = {
815 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
816 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
817 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
818 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
819 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
820 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
821 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
822 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
823 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
824 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
825};
826
827void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
828 unsigned &NumNames) const {
829 Names = GCCRegNames;
830 NumNames = llvm::array_lengthof(GCCRegNames);
831}
832
833const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
834 { {"f0"}, "r0" },
835 { {"f1"}, "r1" },
836 { {"f2"}, "r2" },
837 { {"f3"}, "r3" },
838 { {"f4"}, "r4" },
839 { {"f5"}, "r5" },
840 { {"f6"}, "r6" },
841 { {"f7"}, "r7" },
842 { {"f8"}, "r8" },
843 { {"f9"}, "r9" },
844 { {"f10"}, "r10" },
845 { {"f11"}, "r11" },
846 { {"f12"}, "r12" },
847 { {"f13"}, "r13" },
848 { {"f14"}, "r14" },
849 { {"f15"}, "r15" },
850 { {"f16"}, "r16" },
851 { {"f17"}, "r17" },
852 { {"f18"}, "r18" },
853 { {"f19"}, "r19" },
854 { {"f20"}, "r20" },
855 { {"f21"}, "r21" },
856 { {"f22"}, "r22" },
857 { {"f23"}, "r23" },
858 { {"f24"}, "r24" },
859 { {"f25"}, "r25" },
860 { {"f26"}, "r26" },
861 { {"f27"}, "r27" },
862 { {"f28"}, "r28" },
863 { {"f29"}, "r29" },
864 { {"f30"}, "r30" },
865 { {"f31"}, "r31" },
866};
867
868void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
869 unsigned &NumAliases) const {
870 Aliases = GCCRegAliases;
871 NumAliases = llvm::array_lengthof(GCCRegAliases);
872}
873} // end anonymous namespace.
874
875namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000876// Namespace for x86 abstract base class
877const Builtin::Info BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000878#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
879#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000880#include "clang/Basic/BuiltinsX86.def"
Eli Friedman872996c2008-08-20 02:34:37 +0000881};
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000882
Nuno Lopesad1010d2009-12-23 17:49:57 +0000883static const char* const GCCRegNames[] = {
Eli Friedman872996c2008-08-20 02:34:37 +0000884 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
885 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
886 "argp", "flags", "fspr", "dirflag", "frame",
887 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
888 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
889 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
890 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
891};
892
893const TargetInfo::GCCRegAlias GCCRegAliases[] = {
894 { { "al", "ah", "eax", "rax" }, "ax" },
895 { { "bl", "bh", "ebx", "rbx" }, "bx" },
896 { { "cl", "ch", "ecx", "rcx" }, "cx" },
897 { { "dl", "dh", "edx", "rdx" }, "dx" },
898 { { "esi", "rsi" }, "si" },
899 { { "edi", "rdi" }, "di" },
900 { { "esp", "rsp" }, "sp" },
901 { { "ebp", "rbp" }, "bp" },
902};
903
904// X86 target abstract base class; x86-32 and x86-64 are very close, so
905// most of the implementation can be shared.
906class X86TargetInfo : public TargetInfo {
Chris Lattner715fe4c2009-03-02 22:40:39 +0000907 enum X86SSEEnum {
908 NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
909 } SSELevel;
Anders Carlssone5e222f2010-01-27 03:47:49 +0000910 enum AMD3DNowEnum {
911 NoAMD3DNow, AMD3DNow, AMD3DNowAthlon
912 } AMD3DNowLevel;
913
Eric Christopher6c4e7872010-04-02 23:50:19 +0000914 bool HasAES;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +0000915 bool HasAVX;
916
Eli Friedman872996c2008-08-20 02:34:37 +0000917public:
Anton Korobeynikove7772382009-05-03 13:42:53 +0000918 X86TargetInfo(const std::string& triple)
Eric Christopher6c4e7872010-04-02 23:50:19 +0000919 : TargetInfo(triple), SSELevel(NoMMXSSE), AMD3DNowLevel(NoAMD3DNow),
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +0000920 HasAES(false), HasAVX(false) {
Eli Friedman872996c2008-08-20 02:34:37 +0000921 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner4b009652007-07-25 00:24:17 +0000922 }
923 virtual void getTargetBuiltins(const Builtin::Info *&Records,
924 unsigned &NumRecords) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000925 Records = BuiltinInfo;
926 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000927 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000928 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman872996c2008-08-20 02:34:37 +0000929 unsigned &NumNames) const {
930 Names = GCCRegNames;
931 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000932 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000933 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000934 unsigned &NumAliases) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000935 Aliases = GCCRegAliases;
936 NumAliases = llvm::array_lengthof(GCCRegAliases);
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000937 }
Anders Carlsson36834a72009-02-28 17:11:49 +0000938 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman872996c2008-08-20 02:34:37 +0000939 TargetInfo::ConstraintInfo &info) const;
940 virtual std::string convertConstraint(const char Constraint) const;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000941 virtual const char *getClobbers() const {
Eli Friedman872996c2008-08-20 02:34:37 +0000942 return "~{dirflag},~{fpsr},~{flags}";
943 }
Chris Lattner79682402009-03-20 15:52:06 +0000944 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000945 MacroBuilder &Builder) const;
Daniel Dunbar0838f962009-05-06 21:07:50 +0000946 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
947 const std::string &Name,
948 bool Enabled) const;
Mike Stump25cf7602009-09-09 15:08:12 +0000949 virtual void getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000950 llvm::StringMap<bool> &Features) const;
Daniel Dunbar4f7cd962009-12-19 03:30:57 +0000951 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Chris Lattner4b009652007-07-25 00:24:17 +0000952};
Chris Lattner7d6220c2009-03-02 22:20:04 +0000953
Mike Stump25cf7602009-09-09 15:08:12 +0000954void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000955 llvm::StringMap<bool> &Features) const {
Daniel Dunbar07181d72009-05-06 03:16:41 +0000956 // FIXME: This should not be here.
957 Features["3dnow"] = false;
958 Features["3dnowa"] = false;
959 Features["mmx"] = false;
960 Features["sse"] = false;
961 Features["sse2"] = false;
962 Features["sse3"] = false;
963 Features["ssse3"] = false;
964 Features["sse41"] = false;
965 Features["sse42"] = false;
Eric Christopher6c4e7872010-04-02 23:50:19 +0000966 Features["aes"] = false;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +0000967 Features["avx"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000968
Daniel Dunbar07181d72009-05-06 03:16:41 +0000969 // LLVM does not currently recognize this.
970 // Features["sse4a"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000971
Daniel Dunbar07181d72009-05-06 03:16:41 +0000972 // FIXME: This *really* should not be here.
973
974 // X86_64 always has SSE2.
975 if (PointerWidth == 64)
976 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
977
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000978 if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
979 CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
980 ;
981 else if (CPU == "pentium-mmx" || CPU == "pentium2")
982 setFeatureEnabled(Features, "mmx", true);
983 else if (CPU == "pentium3")
984 setFeatureEnabled(Features, "sse", true);
985 else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64")
986 setFeatureEnabled(Features, "sse2", true);
987 else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona")
988 setFeatureEnabled(Features, "sse3", true);
989 else if (CPU == "core2")
990 setFeatureEnabled(Features, "ssse3", true);
991 else if (CPU == "penryn") {
992 setFeatureEnabled(Features, "sse4", true);
993 Features["sse42"] = false;
994 } else if (CPU == "atom")
995 setFeatureEnabled(Features, "sse3", true);
Eric Christopher6c4e7872010-04-02 23:50:19 +0000996 else if (CPU == "corei7") {
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000997 setFeatureEnabled(Features, "sse4", true);
Eric Christopher6c4e7872010-04-02 23:50:19 +0000998 setFeatureEnabled(Features, "aes", true);
999 }
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001000 else if (CPU == "k6" || CPU == "winchip-c6")
1001 setFeatureEnabled(Features, "mmx", true);
Mike Stump25cf7602009-09-09 15:08:12 +00001002 else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001003 CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
1004 setFeatureEnabled(Features, "mmx", true);
1005 setFeatureEnabled(Features, "3dnow", true);
1006 } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
1007 setFeatureEnabled(Features, "sse", true);
1008 setFeatureEnabled(Features, "3dnowa", true);
1009 } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
1010 CPU == "athlon-fx") {
Mike Stump25cf7602009-09-09 15:08:12 +00001011 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001012 setFeatureEnabled(Features, "3dnowa", true);
1013 } else if (CPU == "c3-2")
1014 setFeatureEnabled(Features, "sse", true);
Daniel Dunbar07181d72009-05-06 03:16:41 +00001015}
1016
Daniel Dunbar0838f962009-05-06 21:07:50 +00001017bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump25cf7602009-09-09 15:08:12 +00001018 const std::string &Name,
Daniel Dunbar0838f962009-05-06 21:07:50 +00001019 bool Enabled) const {
Eric Christopher850e2012010-03-04 02:26:37 +00001020 // FIXME: This *really* should not be here. We need some way of translating
1021 // options into llvm subtarget features.
1022 if (!Features.count(Name) &&
1023 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar0838f962009-05-06 21:07:50 +00001024 return false;
1025
1026 if (Enabled) {
1027 if (Name == "mmx")
1028 Features["mmx"] = true;
1029 else if (Name == "sse")
1030 Features["mmx"] = Features["sse"] = true;
1031 else if (Name == "sse2")
1032 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
1033 else if (Name == "sse3")
Mike Stump25cf7602009-09-09 15:08:12 +00001034 Features["mmx"] = Features["sse"] = Features["sse2"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001035 Features["sse3"] = true;
1036 else if (Name == "ssse3")
Mike Stump25cf7602009-09-09 15:08:12 +00001037 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001038 Features["ssse3"] = true;
Eric Christopher850e2012010-03-04 02:26:37 +00001039 else if (Name == "sse4" || Name == "sse4.2")
Mike Stump25cf7602009-09-09 15:08:12 +00001040 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001041 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Eric Christopher850e2012010-03-04 02:26:37 +00001042 else if (Name == "sse4.1")
1043 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1044 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001045 else if (Name == "3dnow")
1046 Features["3dnowa"] = true;
1047 else if (Name == "3dnowa")
1048 Features["3dnow"] = Features["3dnowa"] = true;
Eric Christopher6c4e7872010-04-02 23:50:19 +00001049 else if (Name == "aes")
1050 Features["aes"] = true;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001051 else if (Name == "avx")
1052 Features["avx"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001053 } else {
1054 if (Name == "mmx")
Mike Stump25cf7602009-09-09 15:08:12 +00001055 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001056 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1057 else if (Name == "sse")
Mike Stump25cf7602009-09-09 15:08:12 +00001058 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001059 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1060 else if (Name == "sse2")
Mike Stump25cf7602009-09-09 15:08:12 +00001061 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001062 Features["sse41"] = Features["sse42"] = false;
1063 else if (Name == "sse3")
Mike Stump25cf7602009-09-09 15:08:12 +00001064 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001065 Features["sse42"] = false;
1066 else if (Name == "ssse3")
1067 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1068 else if (Name == "sse4")
1069 Features["sse41"] = Features["sse42"] = false;
Eric Christopherd794f782010-03-04 02:31:44 +00001070 else if (Name == "sse4.2")
1071 Features["sse42"] = false;
1072 else if (Name == "sse4.1")
1073 Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001074 else if (Name == "3dnow")
1075 Features["3dnow"] = Features["3dnowa"] = false;
1076 else if (Name == "3dnowa")
1077 Features["3dnowa"] = false;
Eric Christopher6c4e7872010-04-02 23:50:19 +00001078 else if (Name == "aes")
1079 Features["aes"] = false;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001080 else if (Name == "avx")
1081 Features["avx"] = false;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001082 }
1083
1084 return true;
1085}
1086
Daniel Dunbar07181d72009-05-06 03:16:41 +00001087/// HandleTargetOptions - Perform initialization based on the user
1088/// configured set of features.
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00001089void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001090 // Remember the maximum enabled sselevel.
1091 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1092 // Ignore disabled features.
1093 if (Features[i][0] == '-')
1094 continue;
1095
Eric Christopher6c4e7872010-04-02 23:50:19 +00001096 if (Features[i].substr(1) == "aes") {
1097 HasAES = true;
1098 continue;
1099 }
1100
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001101 // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1102 // For now let it be enabled together with other SSE levels.
1103 if (Features[i].substr(1) == "avx") {
1104 HasAVX = true;
1105 continue;
1106 }
1107
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001108 assert(Features[i][0] == '+' && "Invalid target feature!");
1109 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1110 .Case("sse42", SSE42)
1111 .Case("sse41", SSE41)
1112 .Case("ssse3", SSSE3)
Nuno Lopes3a16d782010-03-12 10:20:09 +00001113 .Case("sse3", SSE3)
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001114 .Case("sse2", SSE2)
1115 .Case("sse", SSE1)
1116 .Case("mmx", MMX)
1117 .Default(NoMMXSSE);
1118 SSELevel = std::max(SSELevel, Level);
Anders Carlssone5e222f2010-01-27 03:47:49 +00001119
1120 AMD3DNowEnum ThreeDNowLevel =
1121 llvm::StringSwitch<AMD3DNowEnum>(Features[i].substr(1))
1122 .Case("3dnowa", AMD3DNowAthlon)
1123 .Case("3dnow", AMD3DNow)
1124 .Default(NoAMD3DNow);
1125
1126 AMD3DNowLevel = std::max(AMD3DNowLevel, ThreeDNowLevel);
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001127 }
Chris Lattner7d6220c2009-03-02 22:20:04 +00001128}
Chris Lattnerbef1d722009-03-02 22:27:17 +00001129
1130/// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
1131/// that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +00001132void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001133 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00001134 // Target identification.
1135 if (PointerWidth == 64) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001136 Builder.defineMacro("_LP64");
1137 Builder.defineMacro("__LP64__");
1138 Builder.defineMacro("__amd64__");
1139 Builder.defineMacro("__amd64");
1140 Builder.defineMacro("__x86_64");
1141 Builder.defineMacro("__x86_64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +00001142 } else {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001143 DefineStd(Builder, "i386", Opts);
Chris Lattnerbef1d722009-03-02 22:27:17 +00001144 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001145
Eric Christopher6c4e7872010-04-02 23:50:19 +00001146 if (HasAES)
1147 Builder.defineMacro("__AES__");
1148
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001149 if (HasAVX)
1150 Builder.defineMacro("__AVX__");
1151
Chris Lattnerbef1d722009-03-02 22:27:17 +00001152 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001153 Builder.defineMacro("__LITTLE_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001154
Chris Lattnerbef1d722009-03-02 22:27:17 +00001155 // Subtarget options.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001156 Builder.defineMacro("__nocona");
1157 Builder.defineMacro("__nocona__");
1158 Builder.defineMacro("__tune_nocona__");
1159 Builder.defineMacro("__REGISTER_PREFIX__", "");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001160
Chris Lattner25ac1c12009-04-19 17:32:33 +00001161 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1162 // functions in glibc header files that use FP Stack inline asm which the
1163 // backend can't deal with (PR879).
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001164 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001165
Chris Lattner715fe4c2009-03-02 22:40:39 +00001166 // Each case falls through to the previous one here.
1167 switch (SSELevel) {
1168 case SSE42:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001169 Builder.defineMacro("__SSE4_2__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001170 case SSE41:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001171 Builder.defineMacro("__SSE4_1__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001172 case SSSE3:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001173 Builder.defineMacro("__SSSE3__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001174 case SSE3:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001175 Builder.defineMacro("__SSE3__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001176 case SSE2:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001177 Builder.defineMacro("__SSE2__");
1178 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner715fe4c2009-03-02 22:40:39 +00001179 case SSE1:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001180 Builder.defineMacro("__SSE__");
1181 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Chris Lattner715fe4c2009-03-02 22:40:39 +00001182 case MMX:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001183 Builder.defineMacro("__MMX__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001184 case NoMMXSSE:
1185 break;
1186 }
Anders Carlssone5e222f2010-01-27 03:47:49 +00001187
1188 // Each case falls through to the previous one here.
1189 switch (AMD3DNowLevel) {
1190 case AMD3DNowAthlon:
1191 Builder.defineMacro("__3dNOW_A__");
1192 case AMD3DNow:
1193 Builder.defineMacro("__3dNOW__");
1194 case NoAMD3DNow:
1195 break;
1196 }
Chris Lattnerbef1d722009-03-02 22:27:17 +00001197}
Anton Korobeynikove7772382009-05-03 13:42:53 +00001198
1199
Eli Friedman872996c2008-08-20 02:34:37 +00001200bool
Anders Carlsson36834a72009-02-28 17:11:49 +00001201X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001202 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +00001203 switch (*Name) {
Eli Friedman872996c2008-08-20 02:34:37 +00001204 default: return false;
1205 case 'a': // eax.
1206 case 'b': // ebx.
1207 case 'c': // ecx.
1208 case 'd': // edx.
1209 case 'S': // esi.
1210 case 'D': // edi.
1211 case 'A': // edx:eax.
1212 case 't': // top of floating point stack.
1213 case 'u': // second from top of floating point stack.
1214 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson2285e622008-10-06 00:41:45 +00001215 case 'y': // Any MMX register.
Anders Carlssond2459f92008-10-06 19:17:39 +00001216 case 'x': // Any SSE register.
Eli Friedman872996c2008-08-20 02:34:37 +00001217 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Anton Korobeynikove7772382009-05-03 13:42:53 +00001218 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +00001219 // x86_64 instructions.
Anton Korobeynikove7772382009-05-03 13:42:53 +00001220 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +00001221 // x86_64 instructions.
Eli Friedman872996c2008-08-20 02:34:37 +00001222 case 'N': // unsigned 8-bit integer constant for use with in and out
1223 // instructions.
Eli Friedman7e17aed2009-06-08 20:45:44 +00001224 case 'R': // "legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001225 Info.setAllowsRegister();
Eli Friedman872996c2008-08-20 02:34:37 +00001226 return true;
1227 }
1228}
1229
1230std::string
1231X86TargetInfo::convertConstraint(const char Constraint) const {
1232 switch (Constraint) {
1233 case 'a': return std::string("{ax}");
1234 case 'b': return std::string("{bx}");
1235 case 'c': return std::string("{cx}");
1236 case 'd': return std::string("{dx}");
1237 case 'S': return std::string("{si}");
1238 case 'D': return std::string("{di}");
1239 case 't': // top of floating point stack.
1240 return std::string("{st}");
1241 case 'u': // second from top of floating point stack.
1242 return std::string("{st(1)}"); // second from top of floating point stack.
1243 default:
1244 return std::string(1, Constraint);
1245 }
1246}
Eli Friedman872996c2008-08-20 02:34:37 +00001247} // end anonymous namespace
Chris Lattner4b009652007-07-25 00:24:17 +00001248
1249namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001250// X86-32 generic target
1251class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +00001252public:
Eli Friedman872996c2008-08-20 02:34:37 +00001253 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1254 DoubleAlign = LongLongAlign = 32;
1255 LongDoubleWidth = 96;
1256 LongDoubleAlign = 32;
Eli Friedman2b161652008-08-21 00:13:15 +00001257 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1258 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001259 "a0:0:64-f80:32:32-n8:16:32";
Eli Friedman04ede302009-03-29 20:31:09 +00001260 SizeType = UnsignedInt;
1261 PtrDiffType = SignedInt;
1262 IntPtrType = SignedInt;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +00001263 RegParmMax = 3;
Daniel Dunbar6f94dbb2010-07-14 23:39:36 +00001264
1265 // Use fpret for all types.
1266 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
1267 (1 << TargetInfo::Double) |
1268 (1 << TargetInfo::LongDouble));
Eli Friedman872996c2008-08-20 02:34:37 +00001269 }
1270 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001271 return "typedef char* __builtin_va_list;";
Eli Friedman872996c2008-08-20 02:34:37 +00001272 }
Chris Lattneraa339182009-09-23 06:06:36 +00001273
1274 int getEHDataRegisterNumber(unsigned RegNo) const {
1275 if (RegNo == 0) return 0;
1276 if (RegNo == 1) return 2;
1277 return -1;
1278 }
Eli Friedman872996c2008-08-20 02:34:37 +00001279};
1280} // end anonymous namespace
1281
1282namespace {
Eli Friedman1c79f4b2009-07-05 18:47:56 +00001283class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
1284public:
1285 OpenBSDI386TargetInfo(const std::string& triple) :
1286 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
1287 SizeType = UnsignedLong;
1288 IntPtrType = SignedLong;
Eli Friedman96ada022009-07-05 22:31:18 +00001289 PtrDiffType = SignedLong;
Eli Friedman1c79f4b2009-07-05 18:47:56 +00001290 }
1291};
1292} // end anonymous namespace
1293
1294namespace {
Edwin Török36565e52009-06-30 17:10:35 +00001295class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman872996c2008-08-20 02:34:37 +00001296public:
Edwin Török36565e52009-06-30 17:10:35 +00001297 DarwinI386TargetInfo(const std::string& triple) :
1298 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman872996c2008-08-20 02:34:37 +00001299 LongDoubleWidth = 128;
1300 LongDoubleAlign = 128;
Eli Friedman04ede302009-03-29 20:31:09 +00001301 SizeType = UnsignedLong;
1302 IntPtrType = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +00001303 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1304 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001305 "a0:0:64-f80:128:128-n8:16:32";
Daniel Dunbar9451c542010-05-27 00:35:16 +00001306 HasAlignMac68kSupport = true;
Edwin Török2d98f9f2009-06-30 17:00:25 +00001307 }
1308
Eli Friedman872996c2008-08-20 02:34:37 +00001309};
Daniel Dunbar64c77a12009-06-29 20:52:51 +00001310} // end anonymous namespace
1311
1312namespace {
Eli Friedman23cb7912008-08-21 01:40:19 +00001313// x86-32 Windows target
1314class WindowsX86_32TargetInfo : public X86_32TargetInfo {
1315public:
1316 WindowsX86_32TargetInfo(const std::string& triple)
1317 : X86_32TargetInfo(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +00001318 TLSSupported = false;
Chris Lattnera8a69e12009-06-24 17:12:15 +00001319 WCharType = UnsignedShort;
Eli Friedmanb28055e2009-06-08 21:16:17 +00001320 DoubleAlign = LongLongAlign = 64;
1321 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 +00001322 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
1323 "v128:128:128-a0:0:64-f80:32:32-n8:16:32";
Eli Friedman23cb7912008-08-21 01:40:19 +00001324 }
Chris Lattner79682402009-03-20 15:52:06 +00001325 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001326 MacroBuilder &Builder) const {
1327 X86_32TargetInfo::getTargetDefines(Opts, Builder);
Eli Friedman23cb7912008-08-21 01:40:19 +00001328 // This list is based off of the the list of things MingW defines
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001329 Builder.defineMacro("_WIN32");
1330 DefineStd(Builder, "WIN32", Opts);
1331 DefineStd(Builder, "WINNT", Opts);
1332 Builder.defineMacro("_X86_");
Eli Friedman23cb7912008-08-21 01:40:19 +00001333 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001334};
1335} // end anonymous namespace
Eli Friedman6b6ca942009-06-08 06:11:14 +00001336
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001337namespace {
1338
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001339// x86-32 Windows Visual Studio target
1340class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
1341public:
1342 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
1343 : WindowsX86_32TargetInfo(triple) {
1344 }
1345 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001346 MacroBuilder &Builder) const {
1347 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001348 // The value of the following reflects processor type.
1349 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
1350 // We lost the original triple, so we use the default.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001351 Builder.defineMacro("_M_IX86", "600");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001352 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001353};
1354} // end anonymous namespace
1355
1356namespace {
1357// x86-32 MinGW target
1358class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
1359public:
1360 MinGWX86_32TargetInfo(const std::string& triple)
1361 : WindowsX86_32TargetInfo(triple) {
1362 }
1363 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001364 MacroBuilder &Builder) const {
1365 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
1366 Builder.defineMacro("__MSVCRT__");
1367 Builder.defineMacro("__MINGW32__");
1368 Builder.defineMacro("__declspec", "__declspec");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001369 }
1370};
1371} // end anonymous namespace
1372
1373namespace {
1374// x86-32 Cygwin target
1375class CygwinX86_32TargetInfo : public X86_32TargetInfo {
1376public:
1377 CygwinX86_32TargetInfo(const std::string& triple)
1378 : X86_32TargetInfo(triple) {
1379 TLSSupported = false;
1380 WCharType = UnsignedShort;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001381 DoubleAlign = LongLongAlign = 64;
1382 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1383 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001384 "a0:0:64-f80:32:32-n8:16:32";
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001385 }
1386 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001387 MacroBuilder &Builder) const {
1388 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1389 Builder.defineMacro("__CYGWIN__");
1390 Builder.defineMacro("__CYGWIN32__");
1391 DefineStd(Builder, "unix", Opts);
Douglas Gregor9b22a172010-04-21 05:52:38 +00001392 if (Opts.CPlusPlus)
1393 Builder.defineMacro("_GNU_SOURCE");
Eli Friedman6b6ca942009-06-08 06:11:14 +00001394 }
Eli Friedman23cb7912008-08-21 01:40:19 +00001395};
1396} // end anonymous namespace
1397
1398namespace {
Chris Lattnerf853e732010-04-11 19:29:39 +00001399// x86-32 Haiku target
1400class HaikuX86_32TargetInfo : public X86_32TargetInfo {
1401public:
1402 HaikuX86_32TargetInfo(const std::string& triple)
1403 : X86_32TargetInfo(triple) {
1404 SizeType = UnsignedLong;
Chris Lattner5b8b18a2010-04-22 17:48:00 +00001405 IntPtrType = SignedLong;
1406 PtrDiffType = SignedLong;
Chris Lattnerf853e732010-04-11 19:29:39 +00001407 }
1408 virtual void getTargetDefines(const LangOptions &Opts,
1409 MacroBuilder &Builder) const {
1410 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1411 Builder.defineMacro("__INTEL__");
1412 Builder.defineMacro("__HAIKU__");
1413 }
1414};
1415} // end anonymous namespace
1416
1417namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001418// x86-64 generic target
1419class X86_64TargetInfo : public X86TargetInfo {
1420public:
Chris Lattner79682402009-03-20 15:52:06 +00001421 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +00001422 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001423 LongDoubleWidth = 128;
1424 LongDoubleAlign = 128;
Rafael Espindolabfa7c002010-06-04 23:15:27 +00001425 LargeArrayMinWidth = 128;
1426 LargeArrayAlign = 128;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00001427 IntMaxType = SignedLong;
1428 UIntMaxType = UnsignedLong;
Eli Friedman38e31802009-07-01 03:36:11 +00001429 Int64Type = SignedLong;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +00001430 RegParmMax = 6;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00001431
Eli Friedman2b161652008-08-21 00:13:15 +00001432 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1433 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001434 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64";
Daniel Dunbar6f94dbb2010-07-14 23:39:36 +00001435
1436 // Use fpret only for long double.
1437 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Chris Lattner4b009652007-07-25 00:24:17 +00001438 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +00001439 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001440 return "typedef struct __va_list_tag {"
1441 " unsigned gp_offset;"
1442 " unsigned fp_offset;"
1443 " void* overflow_arg_area;"
1444 " void* reg_save_area;"
John McCall33bf24b2010-05-28 18:25:28 +00001445 "} __va_list_tag;"
Eli Friedman3c79eee2009-07-03 00:45:06 +00001446 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson7dd1c952007-11-24 23:38:12 +00001447 }
Chris Lattneraa339182009-09-23 06:06:36 +00001448
1449 int getEHDataRegisterNumber(unsigned RegNo) const {
1450 if (RegNo == 0) return 0;
1451 if (RegNo == 1) return 1;
1452 return -1;
1453 }
Eli Friedman872996c2008-08-20 02:34:37 +00001454};
1455} // end anonymous namespace
1456
1457namespace {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001458// x86-64 Windows target
1459class WindowsX86_64TargetInfo : public X86_64TargetInfo {
1460public:
1461 WindowsX86_64TargetInfo(const std::string& triple)
1462 : X86_64TargetInfo(triple) {
1463 TLSSupported = false;
1464 WCharType = UnsignedShort;
Mike Stump4da7a162009-10-08 23:00:00 +00001465 LongWidth = LongAlign = 32;
Nate Begeman3736cc22010-07-21 18:11:42 +00001466 DoubleAlign = LongLongAlign = 64;
Nate Begeman472bd992010-07-21 02:02:56 +00001467 IntMaxType = SignedLongLong;
1468 UIntMaxType = UnsignedLongLong;
1469 Int64Type = SignedLongLong;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001470 }
1471 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001472 MacroBuilder &Builder) const {
1473 X86_64TargetInfo::getTargetDefines(Opts, Builder);
1474 Builder.defineMacro("_WIN64");
1475 DefineStd(Builder, "WIN64", Opts);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001476 }
1477};
1478} // end anonymous namespace
1479
1480namespace {
1481// x86-64 Windows Visual Studio target
1482class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
1483public:
1484 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
1485 : WindowsX86_64TargetInfo(triple) {
1486 }
1487 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001488 MacroBuilder &Builder) const {
1489 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1490 Builder.defineMacro("_M_X64");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001491 }
1492 virtual const char *getVAListDeclaration() const {
1493 return "typedef char* va_list;";
1494 }
1495};
1496} // end anonymous namespace
1497
1498namespace {
1499// x86-64 MinGW target
1500class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
1501public:
1502 MinGWX86_64TargetInfo(const std::string& triple)
1503 : WindowsX86_64TargetInfo(triple) {
1504 }
1505 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001506 MacroBuilder &Builder) const {
1507 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1508 Builder.defineMacro("__MSVCRT__");
1509 Builder.defineMacro("__MINGW64__");
1510 Builder.defineMacro("__declspec");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001511 }
1512};
1513} // end anonymous namespace
1514
1515namespace {
Eli Friedman38e31802009-07-01 03:36:11 +00001516class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
1517public:
Mike Stump25cf7602009-09-09 15:08:12 +00001518 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman38e31802009-07-01 03:36:11 +00001519 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
1520 Int64Type = SignedLongLong;
1521 }
1522};
1523} // end anonymous namespace
1524
1525namespace {
Eli Friedman96ada022009-07-05 22:31:18 +00001526class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
1527public:
Mike Stump25cf7602009-09-09 15:08:12 +00001528 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman96ada022009-07-05 22:31:18 +00001529 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
1530 IntMaxType = SignedLongLong;
1531 UIntMaxType = UnsignedLongLong;
1532 Int64Type = SignedLongLong;
1533 }
1534};
1535} // end anonymous namespace
1536
1537namespace {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001538class ARMTargetInfo : public TargetInfo {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001539 // Possible FPU choices.
1540 enum FPUMode {
1541 NoFPU,
1542 VFP2FPU,
1543 VFP3FPU,
1544 NeonFPU
1545 };
1546
1547 static bool FPUModeIsVFP(FPUMode Mode) {
1548 return Mode >= VFP2FPU && Mode <= NeonFPU;
1549 }
1550
1551 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1552 static const char * const GCCRegNames[];
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001553
Daniel Dunbar33b40752009-12-18 18:42:37 +00001554 std::string ABI, CPU;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001555
1556 unsigned FPU : 3;
1557
Daniel Dunbar48075d82009-12-19 04:15:38 +00001558 unsigned IsThumb : 1;
1559
1560 // Initialized via features.
1561 unsigned SoftFloat : 1;
1562 unsigned SoftFloatABI : 1;
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001563
Chris Lattnerb4527522010-03-03 19:03:45 +00001564 static const Builtin::Info BuiltinInfo[];
1565
Chris Lattner9fd73612008-04-21 18:56:49 +00001566public:
Daniel Dunbarf0156562009-09-17 16:21:10 +00001567 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbar33b40752009-12-18 18:42:37 +00001568 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001569 {
Daniel Dunbarb9531632009-09-14 00:02:24 +00001570 SizeType = UnsignedInt;
1571 PtrDiffType = SignedInt;
Daniel Dunbarf0156562009-09-17 16:21:10 +00001572
Chris Lattnere20b8122010-04-23 16:29:58 +00001573 // {} in inline assembly are neon specifiers, not assembly variant
1574 // specifiers.
1575 NoAsmVariants = true;
1576
Daniel Dunbar33b40752009-12-18 18:42:37 +00001577 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0a542ca2009-12-18 19:57:13 +00001578 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001579 if (IsThumb) {
1580 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1581 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001582 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001583 } else {
1584 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1585 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001586 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001587 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001588 }
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001589 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbarb9531632009-09-14 00:02:24 +00001590 virtual bool setABI(const std::string &Name) {
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001591 ABI = Name;
1592
Daniel Dunbarb9531632009-09-14 00:02:24 +00001593 // The defaults (above) are for AAPCS, check if we need to change them.
1594 //
1595 // FIXME: We need support for -meabi... we could just mangle it into the
1596 // name.
1597 if (Name == "apcs-gnu") {
Daniel Dunbarda94a772010-01-27 20:23:08 +00001598 DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
Daniel Dunbarb9531632009-09-14 00:02:24 +00001599 SizeType = UnsignedLong;
1600
Daniel Dunbar9eb811b2010-04-22 16:14:54 +00001601 // Do not respect the alignment of bit-field types when laying out
1602 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
1603 UseBitFieldTypeAlignment = false;
1604
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001605 if (IsThumb) {
1606 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1607 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001608 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001609 } else {
1610 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1611 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001612 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001613 }
1614
Daniel Dunbarb9531632009-09-14 00:02:24 +00001615 // FIXME: Override "preferred align" for double and long long.
1616 } else if (Name == "aapcs") {
1617 // FIXME: Enumerated types are variable width in straight AAPCS.
1618 } else if (Name == "aapcs-linux") {
1619 ;
1620 } else
1621 return false;
1622
1623 return true;
1624 }
Daniel Dunbar48075d82009-12-19 04:15:38 +00001625
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001626 void getDefaultFeatures(const std::string &CPU,
1627 llvm::StringMap<bool> &Features) const {
1628 // FIXME: This should not be here.
1629 Features["vfp2"] = false;
1630 Features["vfp3"] = false;
1631 Features["neon"] = false;
1632
1633 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
1634 Features["vfp2"] = true;
1635 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
1636 Features["neon"] = true;
1637 }
1638
Daniel Dunbar48075d82009-12-19 04:15:38 +00001639 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1640 const std::string &Name,
1641 bool Enabled) const {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001642 if (Name == "soft-float" || Name == "soft-float-abi") {
1643 Features[Name] = Enabled;
1644 } else if (Name == "vfp2" || Name == "vfp3" || Name == "neon") {
1645 // These effectively are a single option, reset them when any is enabled.
1646 if (Enabled)
1647 Features["vfp2"] = Features["vfp3"] = Features["neon"] = false;
1648 Features[Name] = Enabled;
1649 } else
Daniel Dunbar48075d82009-12-19 04:15:38 +00001650 return false;
1651
Daniel Dunbar48075d82009-12-19 04:15:38 +00001652 return true;
1653 }
1654
1655 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001656 FPU = NoFPU;
Daniel Dunbar48075d82009-12-19 04:15:38 +00001657 SoftFloat = SoftFloatABI = false;
1658 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
1659 if (Features[i] == "+soft-float")
1660 SoftFloat = true;
1661 else if (Features[i] == "+soft-float-abi")
1662 SoftFloatABI = true;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001663 else if (Features[i] == "+vfp2")
1664 FPU = VFP2FPU;
1665 else if (Features[i] == "+vfp3")
1666 FPU = VFP3FPU;
1667 else if (Features[i] == "+neon")
1668 FPU = NeonFPU;
Daniel Dunbar48075d82009-12-19 04:15:38 +00001669 }
1670
1671 // Remove front-end specific options which the backend handles differently.
1672 std::vector<std::string>::iterator it;
1673 it = std::find(Features.begin(), Features.end(), "+soft-float");
1674 if (it != Features.end())
1675 Features.erase(it);
1676 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
1677 if (it != Features.end())
1678 Features.erase(it);
1679 }
1680
Daniel Dunbar33b40752009-12-18 18:42:37 +00001681 static const char *getCPUDefineSuffix(llvm::StringRef Name) {
1682 return llvm::StringSwitch<const char*>(Name)
1683 .Cases("arm8", "arm810", "4")
1684 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
1685 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
1686 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
1687 .Case("ep9312", "4T")
1688 .Cases("arm10tdmi", "arm1020t", "5T")
1689 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
1690 .Case("arm926ej-s", "5TEJ")
1691 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
1692 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001693 .Case("arm1136j-s", "6J")
Daniel Dunbar33b40752009-12-18 18:42:37 +00001694 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001695 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbar33b40752009-12-18 18:42:37 +00001696 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
1697 .Cases("cortex-a8", "cortex-a9", "7A")
1698 .Default(0);
1699 }
1700 virtual bool setCPU(const std::string &Name) {
1701 if (!getCPUDefineSuffix(Name))
1702 return false;
1703
1704 CPU = Name;
1705 return true;
1706 }
Chris Lattner79682402009-03-20 15:52:06 +00001707 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001708 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00001709 // Target identification.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001710 Builder.defineMacro("__arm");
1711 Builder.defineMacro("__arm__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001712
Chris Lattnerbef1d722009-03-02 22:27:17 +00001713 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001714 Builder.defineMacro("__ARMEL__");
1715 Builder.defineMacro("__LITTLE_ENDIAN__");
1716 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001717
1718 llvm::StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001719 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001720
Mike Stumpf90a29f2009-04-08 02:07:04 +00001721 // Subtarget options.
Daniel Dunbarf0156562009-09-17 16:21:10 +00001722
Daniel Dunbar33b40752009-12-18 18:42:37 +00001723 // FIXME: It's more complicated than this and we don't really support
1724 // interworking.
1725 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001726 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001727
Daniel Dunbar33b40752009-12-18 18:42:37 +00001728 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001729 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001730
Daniel Dunbar48075d82009-12-19 04:15:38 +00001731 if (SoftFloat)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001732 Builder.defineMacro("__SOFTFP__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001733
1734 if (CPU == "xscale")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001735 Builder.defineMacro("__XSCALE__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001736
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001737 bool IsThumb2 = IsThumb && (CPUArch == "6T2" || CPUArch.startswith("7"));
Daniel Dunbarf0156562009-09-17 16:21:10 +00001738 if (IsThumb) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001739 Builder.defineMacro("__THUMBEL__");
1740 Builder.defineMacro("__thumb__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001741 if (IsThumb2)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001742 Builder.defineMacro("__thumb2__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001743 }
1744
1745 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001746 Builder.defineMacro("__APCS_32__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001747
1748 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001749 Builder.defineMacro("__VFP_FP__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001750
1751 // This only gets set when Neon instructions are actually available, unlike
1752 // the VFP define, hence the soft float and arch check. This is subtly
1753 // different from gcc, we follow the intent which was that it should be set
1754 // when Neon instructions are actually available.
1755 if (FPU == NeonFPU && !SoftFloat && IsThumb2)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001756 Builder.defineMacro("__ARM_NEON__");
Chris Lattner9fd73612008-04-21 18:56:49 +00001757 }
1758 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1759 unsigned &NumRecords) const {
Chris Lattnerb4527522010-03-03 19:03:45 +00001760 Records = BuiltinInfo;
1761 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner9fd73612008-04-21 18:56:49 +00001762 }
1763 virtual const char *getVAListDeclaration() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001764 return "typedef char* __builtin_va_list;";
Chris Lattner9fd73612008-04-21 18:56:49 +00001765 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001766 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001767 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001768 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001769 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001770 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001771 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001772 // FIXME: Check if this is complete
Anders Carlsson36834a72009-02-28 17:11:49 +00001773 switch (*Name) {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001774 default:
Nate Begeman222823a2008-04-22 05:03:19 +00001775 case 'l': // r0-r7
1776 case 'h': // r8-r15
1777 case 'w': // VFP Floating point register single precision
1778 case 'P': // VFP Floating point register double precision
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001779 Info.setAllowsRegister();
Nate Begeman222823a2008-04-22 05:03:19 +00001780 return true;
1781 }
Chris Lattner9fd73612008-04-21 18:56:49 +00001782 return false;
1783 }
1784 virtual const char *getClobbers() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001785 // FIXME: Is this really right?
Chris Lattner9fd73612008-04-21 18:56:49 +00001786 return "";
1787 }
1788};
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001789
1790const char * const ARMTargetInfo::GCCRegNames[] = {
1791 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1792 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1793};
1794
1795void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
1796 unsigned &NumNames) const {
1797 Names = GCCRegNames;
1798 NumNames = llvm::array_lengthof(GCCRegNames);
1799}
1800
1801const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
1802
1803 { { "a1" }, "r0" },
1804 { { "a2" }, "r1" },
1805 { { "a3" }, "r2" },
1806 { { "a4" }, "r3" },
1807 { { "v1" }, "r4" },
1808 { { "v2" }, "r5" },
1809 { { "v3" }, "r6" },
1810 { { "v4" }, "r7" },
1811 { { "v5" }, "r8" },
1812 { { "v6", "rfp" }, "r9" },
1813 { { "sl" }, "r10" },
1814 { { "fp" }, "r11" },
1815 { { "ip" }, "r12" },
1816 { { "sp" }, "r13" },
1817 { { "lr" }, "r14" },
1818 { { "pc" }, "r15" },
1819};
1820
1821void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1822 unsigned &NumAliases) const {
1823 Aliases = GCCRegAliases;
1824 NumAliases = llvm::array_lengthof(GCCRegAliases);
1825}
Chris Lattnerb4527522010-03-03 19:03:45 +00001826
1827const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
1828#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
1829#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
1830#include "clang/Basic/BuiltinsARM.def"
1831};
Chris Lattner9fd73612008-04-21 18:56:49 +00001832} // end anonymous namespace.
1833
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001834
1835namespace {
Mike Stump25cf7602009-09-09 15:08:12 +00001836class DarwinARMTargetInfo :
Edwin Török36565e52009-06-30 17:10:35 +00001837 public DarwinTargetInfo<ARMTargetInfo> {
1838protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +00001839 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001840 MacroBuilder &Builder) const {
Daniel Dunbareab96a22010-01-26 01:44:04 +00001841 getDarwinDefines(Builder, Opts, Triple);
Eli Friedman8f575172009-04-19 21:38:35 +00001842 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001843
Edwin Török36565e52009-06-30 17:10:35 +00001844public:
Mike Stump25cf7602009-09-09 15:08:12 +00001845 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar01045582010-05-27 07:00:26 +00001846 : DarwinTargetInfo<ARMTargetInfo>(triple) {
1847 HasAlignMac68kSupport = true;
1848 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001849};
1850} // end anonymous namespace.
1851
Chris Lattner4b009652007-07-25 00:24:17 +00001852namespace {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001853class SparcV8TargetInfo : public TargetInfo {
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001854 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1855 static const char * const GCCRegNames[];
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001856public:
Eli Friedmanff158dd2008-08-20 07:28:14 +00001857 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
1858 // FIXME: Support Sparc quad-precision long double?
Eli Friedman2b161652008-08-21 00:13:15 +00001859 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 +00001860 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedmanff158dd2008-08-20 07:28:14 +00001861 }
Chris Lattner79682402009-03-20 15:52:06 +00001862 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001863 MacroBuilder &Builder) const {
1864 DefineStd(Builder, "sparc", Opts);
1865 Builder.defineMacro("__sparcv8");
1866 Builder.defineMacro("__REGISTER_PREFIX__", "");
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001867 }
1868 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1869 unsigned &NumRecords) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001870 // FIXME: Implement!
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001871 }
1872 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001873 return "typedef void* __builtin_va_list;";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001874 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001875 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001876 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001877 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001878 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001879 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001880 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001881 // FIXME: Implement!
1882 return false;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001883 }
1884 virtual const char *getClobbers() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001885 // FIXME: Implement!
1886 return "";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001887 }
1888};
1889
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001890const char * const SparcV8TargetInfo::GCCRegNames[] = {
1891 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1892 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1893 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1894 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
1895};
1896
Anton Korobeynikove7772382009-05-03 13:42:53 +00001897void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001898 unsigned &NumNames) const {
1899 Names = GCCRegNames;
1900 NumNames = llvm::array_lengthof(GCCRegNames);
1901}
1902
1903const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikove7772382009-05-03 13:42:53 +00001904 { { "g0" }, "r0" },
1905 { { "g1" }, "r1" },
1906 { { "g2" }, "r2" },
1907 { { "g3" }, "r3" },
1908 { { "g4" }, "r4" },
1909 { { "g5" }, "r5" },
1910 { { "g6" }, "r6" },
1911 { { "g7" }, "r7" },
1912 { { "o0" }, "r8" },
1913 { { "o1" }, "r9" },
1914 { { "o2" }, "r10" },
1915 { { "o3" }, "r11" },
1916 { { "o4" }, "r12" },
1917 { { "o5" }, "r13" },
1918 { { "o6", "sp" }, "r14" },
1919 { { "o7" }, "r15" },
1920 { { "l0" }, "r16" },
1921 { { "l1" }, "r17" },
1922 { { "l2" }, "r18" },
1923 { { "l3" }, "r19" },
1924 { { "l4" }, "r20" },
1925 { { "l5" }, "r21" },
1926 { { "l6" }, "r22" },
1927 { { "l7" }, "r23" },
1928 { { "i0" }, "r24" },
1929 { { "i1" }, "r25" },
1930 { { "i2" }, "r26" },
1931 { { "i3" }, "r27" },
1932 { { "i4" }, "r28" },
1933 { { "i5" }, "r29" },
1934 { { "i6", "fp" }, "r30" },
1935 { { "i7" }, "r31" },
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001936};
1937
Anton Korobeynikove7772382009-05-03 13:42:53 +00001938void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001939 unsigned &NumAliases) const {
1940 Aliases = GCCRegAliases;
1941 NumAliases = llvm::array_lengthof(GCCRegAliases);
1942}
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001943} // end anonymous namespace.
1944
Eli Friedmanff158dd2008-08-20 07:28:14 +00001945namespace {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00001946class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
1947public:
1948 AuroraUXSparcV8TargetInfo(const std::string& triple) :
1949 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
1950 SizeType = UnsignedInt;
1951 PtrDiffType = SignedInt;
1952 }
1953};
Edwin Török36565e52009-06-30 17:10:35 +00001954class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001955public:
1956 SolarisSparcV8TargetInfo(const std::string& triple) :
Edwin Török36565e52009-06-30 17:10:35 +00001957 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedman7cca0982008-11-02 02:43:55 +00001958 SizeType = UnsignedInt;
1959 PtrDiffType = SignedInt;
Eli Friedmanff158dd2008-08-20 07:28:14 +00001960 }
1961};
1962} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +00001963
Chris Lattner85970f32008-05-08 05:58:21 +00001964namespace {
1965 class PIC16TargetInfo : public TargetInfo{
1966 public:
1967 PIC16TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +00001968 TLSSupported = false;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001969 IntWidth = 16;
1970 LongWidth = LongLongWidth = 32;
1971 PointerWidth = 16;
1972 IntAlign = 8;
1973 LongAlign = LongLongAlign = 8;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001974 PointerAlign = 8;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001975 SizeType = UnsignedInt;
1976 IntMaxType = SignedLong;
1977 UIntMaxType = UnsignedLong;
Chris Lattnerd9ef7242009-02-13 22:28:55 +00001978 IntPtrType = SignedShort;
Eli Friedman7cca0982008-11-02 02:43:55 +00001979 PtrDiffType = SignedInt;
Edward O'Callaghan14a70a32009-11-21 00:49:54 +00001980 SigAtomicType = SignedLong;
Sanjiv Guptaae8f1e82009-06-02 04:43:46 +00001981 FloatWidth = 32;
1982 FloatAlign = 32;
1983 DoubleWidth = 32;
1984 DoubleAlign = 32;
1985 LongDoubleWidth = 32;
1986 LongDoubleAlign = 32;
1987 FloatFormat = &llvm::APFloat::IEEEsingle;
1988 DoubleFormat = &llvm::APFloat::IEEEsingle;
1989 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner2e17d912009-11-07 18:59:41 +00001990 DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8-f32:32:32-n8";
Sanjiv Guptaae8f1e82009-06-02 04:43:46 +00001991
Chris Lattner85970f32008-05-08 05:58:21 +00001992 }
Chris Lattner727b3c42008-05-09 06:08:39 +00001993 virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }
1994 virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }
Chris Lattner79682402009-03-20 15:52:06 +00001995 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001996 MacroBuilder &Builder) const {
1997 Builder.defineMacro("__pic16");
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00001998 Builder.defineMacro("__PIC16");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001999 Builder.defineMacro("rom", "__attribute__((address_space(1)))");
2000 Builder.defineMacro("ram", "__attribute__((address_space(0)))");
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00002001 Builder.defineMacro("__section(SectName)",
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00002002 "__attribute__((section(SectName)))");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002003 Builder.defineMacro("near",
Sanjiv Gupta09e95f02009-10-24 18:08:20 +00002004 "__attribute__((section(\"Address=NEAR\")))");
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00002005 Builder.defineMacro("__address(Addr)",
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00002006 "__attribute__((section(\"Address=\"#Addr)))");
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00002007 Builder.defineMacro("__config(conf)", "asm(\"CONFIG \"#conf)");
2008 Builder.defineMacro("__idlocs(value)", "asm(\"__IDLOCS \"#value)");
2009 Builder.defineMacro("interrupt",
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00002010 "__attribute__((section(\"interrupt=0x4\"))) \
2011 __attribute__((used))");
Chris Lattner85970f32008-05-08 05:58:21 +00002012 }
2013 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2014 unsigned &NumRecords) const {}
Mike Stump25cf7602009-09-09 15:08:12 +00002015 virtual const char *getVAListDeclaration() const {
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00002016 return "typedef char* __builtin_va_list;";
Daniel Dunbar2e967de2009-08-24 09:54:37 +00002017 }
2018 virtual const char *getClobbers() const {
2019 return "";
2020 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00002021 virtual void getGCCRegNames(const char * const *&Names,
2022 unsigned &NumNames) const {}
2023 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner85970f32008-05-08 05:58:21 +00002024 TargetInfo::ConstraintInfo &info) const {
2025 return true;
2026 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00002027 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner85970f32008-05-08 05:58:21 +00002028 unsigned &NumAliases) const {}
2029 virtual bool useGlobalsForAutomaticVariables() const {return true;}
2030 };
2031}
2032
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002033namespace {
2034 class MSP430TargetInfo : public TargetInfo {
2035 static const char * const GCCRegNames[];
2036 public:
2037 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
2038 TLSSupported = false;
Anton Korobeynikov2a6630a2010-01-30 12:55:11 +00002039 IntWidth = 16; IntAlign = 16;
2040 LongWidth = 32; LongLongWidth = 64;
2041 LongAlign = LongLongAlign = 16;
2042 PointerWidth = 16; PointerAlign = 16;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002043 SizeType = UnsignedInt;
2044 IntMaxType = SignedLong;
2045 UIntMaxType = UnsignedLong;
2046 IntPtrType = SignedShort;
2047 PtrDiffType = SignedInt;
Edward O'Callaghan14a70a32009-11-21 00:49:54 +00002048 SigAtomicType = SignedLong;
Anton Korobeynikov314713f2009-12-19 01:32:37 +00002049 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002050 }
2051 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002052 MacroBuilder &Builder) const {
2053 Builder.defineMacro("MSP430");
2054 Builder.defineMacro("__MSP430__");
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002055 // FIXME: defines for different 'flavours' of MCU
2056 }
2057 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2058 unsigned &NumRecords) const {
2059 // FIXME: Implement.
2060 Records = 0;
2061 NumRecords = 0;
2062 }
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002063 virtual void getGCCRegNames(const char * const *&Names,
2064 unsigned &NumNames) const;
2065 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2066 unsigned &NumAliases) const {
2067 // No aliases.
2068 Aliases = 0;
2069 NumAliases = 0;
2070 }
2071 virtual bool validateAsmConstraint(const char *&Name,
2072 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov174219b2009-10-15 23:17:13 +00002073 // No target constraints for now.
2074 return false;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002075 }
2076 virtual const char *getClobbers() const {
2077 // FIXME: Is this really right?
2078 return "";
2079 }
2080 virtual const char *getVAListDeclaration() const {
2081 // FIXME: implement
Anton Korobeynikovf5955592009-05-08 18:24:57 +00002082 return "typedef char* __builtin_va_list;";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002083 }
2084 };
2085
2086 const char * const MSP430TargetInfo::GCCRegNames[] = {
2087 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2088 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2089 };
2090
2091 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
2092 unsigned &NumNames) const {
2093 Names = GCCRegNames;
2094 NumNames = llvm::array_lengthof(GCCRegNames);
2095 }
2096}
2097
2098
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002099namespace {
2100 class SystemZTargetInfo : public TargetInfo {
2101 static const char * const GCCRegNames[];
2102 public:
2103 SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
2104 TLSSupported = false;
2105 IntWidth = IntAlign = 32;
2106 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
2107 PointerWidth = PointerAlign = 64;
Chris Lattner2e17d912009-11-07 18:59:41 +00002108 DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
2109 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002110 }
2111 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002112 MacroBuilder &Builder) const {
2113 Builder.defineMacro("__s390__");
2114 Builder.defineMacro("__s390x__");
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002115 }
2116 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2117 unsigned &NumRecords) const {
2118 // FIXME: Implement.
2119 Records = 0;
2120 NumRecords = 0;
2121 }
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002122
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002123 virtual void getGCCRegNames(const char * const *&Names,
2124 unsigned &NumNames) const;
2125 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2126 unsigned &NumAliases) const {
2127 // No aliases.
2128 Aliases = 0;
2129 NumAliases = 0;
2130 }
2131 virtual bool validateAsmConstraint(const char *&Name,
2132 TargetInfo::ConstraintInfo &info) const {
2133 // FIXME: implement
2134 return true;
2135 }
2136 virtual const char *getClobbers() const {
2137 // FIXME: Is this really right?
2138 return "";
2139 }
2140 virtual const char *getVAListDeclaration() const {
2141 // FIXME: implement
2142 return "typedef char* __builtin_va_list;";
2143 }
2144 };
2145
2146 const char * const SystemZTargetInfo::GCCRegNames[] = {
2147 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2148 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2149 };
2150
2151 void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
2152 unsigned &NumNames) const {
2153 Names = GCCRegNames;
2154 NumNames = llvm::array_lengthof(GCCRegNames);
2155 }
2156}
2157
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002158namespace {
2159 class BlackfinTargetInfo : public TargetInfo {
2160 static const char * const GCCRegNames[];
2161 public:
2162 BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
2163 TLSSupported = false;
2164 DoubleAlign = 32;
2165 LongLongAlign = 32;
2166 LongDoubleAlign = 32;
Chris Lattner2e17d912009-11-07 18:59:41 +00002167 DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002168 }
2169
2170 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002171 MacroBuilder &Builder) const {
2172 DefineStd(Builder, "bfin", Opts);
2173 DefineStd(Builder, "BFIN", Opts);
2174 Builder.defineMacro("__ADSPBLACKFIN__");
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002175 // FIXME: This one is really dependent on -mcpu
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002176 Builder.defineMacro("__ADSPLPBLACKFIN__");
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002177 // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
2178 }
2179
2180 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2181 unsigned &NumRecords) const {
2182 // FIXME: Implement.
2183 Records = 0;
2184 NumRecords = 0;
2185 }
2186
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002187 virtual void getGCCRegNames(const char * const *&Names,
2188 unsigned &NumNames) const;
2189
2190 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2191 unsigned &NumAliases) const {
2192 // No aliases.
2193 Aliases = 0;
2194 NumAliases = 0;
2195 }
2196
2197 virtual bool validateAsmConstraint(const char *&Name,
2198 TargetInfo::ConstraintInfo &Info) const {
2199 if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
2200 Info.setAllowsRegister();
2201 return true;
2202 }
2203 return false;
2204 }
2205
2206 virtual const char *getClobbers() const {
2207 return "";
2208 }
2209
2210 virtual const char *getVAListDeclaration() const {
2211 return "typedef char* __builtin_va_list;";
2212 }
2213 };
2214
2215 const char * const BlackfinTargetInfo::GCCRegNames[] = {
2216 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2217 "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
2218 "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
2219 "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
2220 "a0", "a1", "cc",
2221 "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
2222 "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
2223 };
2224
2225 void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
2226 unsigned &NumNames) const {
2227 Names = GCCRegNames;
2228 NumNames = llvm::array_lengthof(GCCRegNames);
2229 }
2230}
2231
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002232namespace {
2233
Mike Stump25cf7602009-09-09 15:08:12 +00002234 // LLVM and Clang cannot be used directly to output native binaries for
2235 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002236 // type and alignment information.
Mike Stump25cf7602009-09-09 15:08:12 +00002237 //
2238 // TCE uses the llvm bitcode as input and uses it for generating customized
2239 // target processor and program binary. TCE co-design environment is
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002240 // publicly available in http://tce.cs.tut.fi
2241
2242 class TCETargetInfo : public TargetInfo{
2243 public:
2244 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
2245 TLSSupported = false;
2246 IntWidth = 32;
2247 LongWidth = LongLongWidth = 32;
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002248 PointerWidth = 32;
2249 IntAlign = 32;
2250 LongAlign = LongLongAlign = 32;
2251 PointerAlign = 32;
2252 SizeType = UnsignedInt;
2253 IntMaxType = SignedLong;
2254 UIntMaxType = UnsignedLong;
2255 IntPtrType = SignedInt;
2256 PtrDiffType = SignedInt;
2257 FloatWidth = 32;
2258 FloatAlign = 32;
2259 DoubleWidth = 32;
2260 DoubleAlign = 32;
2261 LongDoubleWidth = 32;
2262 LongDoubleAlign = 32;
2263 FloatFormat = &llvm::APFloat::IEEEsingle;
2264 DoubleFormat = &llvm::APFloat::IEEEsingle;
2265 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner8a1db932010-03-04 21:07:38 +00002266 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
2267 "i16:16:32-i32:32:32-i64:32:32-"
2268 "f32:32:32-f64:64:64-v64:64:64-"
2269 "v128:128:128-a0:0:64-n32";
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002270 }
2271
2272 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002273 MacroBuilder &Builder) const {
2274 DefineStd(Builder, "tce", Opts);
2275 Builder.defineMacro("__TCE__");
2276 Builder.defineMacro("__TCE_V1__");
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002277 }
2278 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2279 unsigned &NumRecords) const {}
Daniel Dunbar2e967de2009-08-24 09:54:37 +00002280 virtual const char *getClobbers() const {
2281 return "";
2282 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002283 virtual const char *getVAListDeclaration() const {
2284 return "typedef void* __builtin_va_list;";
2285 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002286 virtual void getGCCRegNames(const char * const *&Names,
2287 unsigned &NumNames) const {}
2288 virtual bool validateAsmConstraint(const char *&Name,
2289 TargetInfo::ConstraintInfo &info) const {
2290 return true;
2291 }
2292 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2293 unsigned &NumAliases) const {}
2294 };
2295}
2296
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002297namespace {
2298class MipsTargetInfo : public TargetInfo {
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002299 std::string ABI, CPU;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002300 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2301 static const char * const GCCRegNames[];
2302public:
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002303 MipsTargetInfo(const std::string& triple) : TargetInfo(triple), ABI("o32") {
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002304 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2305 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2306 }
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002307 virtual const char *getABI() const { return ABI.c_str(); }
2308 virtual bool setABI(const std::string &Name) {
2309
2310 if ((Name == "o32") || (Name == "eabi")) {
2311 ABI = Name;
2312 return true;
2313 } else
2314 return false;
2315 }
2316 virtual bool setCPU(const std::string &Name) {
2317 CPU = Name;
2318 return true;
2319 }
2320 void getDefaultFeatures(const std::string &CPU,
2321 llvm::StringMap<bool> &Features) const {
2322 Features[ABI] = true;
2323 Features[CPU] = true;
2324 }
2325 virtual void getArchDefines(const LangOptions &Opts,
2326 MacroBuilder &Builder) const {
2327 if (ABI == "o32")
2328 Builder.defineMacro("__mips_o32");
2329 else if (ABI == "eabi")
2330 Builder.defineMacro("__mips_eabi");
2331 }
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002332 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002333 MacroBuilder &Builder) const {
2334 DefineStd(Builder, "mips", Opts);
2335 Builder.defineMacro("_mips");
2336 DefineStd(Builder, "MIPSEB", Opts);
2337 Builder.defineMacro("_MIPSEB");
2338 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002339 getArchDefines(Opts, Builder);
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002340 }
2341 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2342 unsigned &NumRecords) const {
2343 // FIXME: Implement!
2344 }
2345 virtual const char *getVAListDeclaration() const {
2346 return "typedef void* __builtin_va_list;";
2347 }
2348 virtual void getGCCRegNames(const char * const *&Names,
2349 unsigned &NumNames) const;
2350 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2351 unsigned &NumAliases) const;
2352 virtual bool validateAsmConstraint(const char *&Name,
2353 TargetInfo::ConstraintInfo &Info) const {
2354 switch (*Name) {
2355 default:
2356 case 'r': // CPU registers.
2357 case 'd': // Equivalent to "r" unless generating MIPS16 code.
2358 case 'y': // Equivalent to "r", backwards compatibility only.
2359 case 'f': // floating-point registers.
2360 Info.setAllowsRegister();
2361 return true;
2362 }
2363 return false;
2364 }
2365
2366 virtual const char *getClobbers() const {
2367 // FIXME: Implement!
2368 return "";
2369 }
2370};
2371
2372const char * const MipsTargetInfo::GCCRegNames[] = {
2373 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
2374 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
2375 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
2376 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
2377 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
2378 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
2379 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
2380 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
2381 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
2382 "$fcc5","$fcc6","$fcc7"
2383};
2384
2385void MipsTargetInfo::getGCCRegNames(const char * const *&Names,
2386 unsigned &NumNames) const {
2387 Names = GCCRegNames;
2388 NumNames = llvm::array_lengthof(GCCRegNames);
2389}
2390
2391const TargetInfo::GCCRegAlias MipsTargetInfo::GCCRegAliases[] = {
2392 { { "at" }, "$1" },
2393 { { "v0" }, "$2" },
2394 { { "v1" }, "$3" },
2395 { { "a0" }, "$4" },
2396 { { "a1" }, "$5" },
2397 { { "a2" }, "$6" },
2398 { { "a3" }, "$7" },
2399 { { "t0" }, "$8" },
2400 { { "t1" }, "$9" },
2401 { { "t2" }, "$10" },
2402 { { "t3" }, "$11" },
2403 { { "t4" }, "$12" },
2404 { { "t5" }, "$13" },
2405 { { "t6" }, "$14" },
2406 { { "t7" }, "$15" },
2407 { { "s0" }, "$16" },
2408 { { "s1" }, "$17" },
2409 { { "s2" }, "$18" },
2410 { { "s3" }, "$19" },
2411 { { "s4" }, "$20" },
2412 { { "s5" }, "$21" },
2413 { { "s6" }, "$22" },
2414 { { "s7" }, "$23" },
2415 { { "t8" }, "$24" },
2416 { { "t9" }, "$25" },
2417 { { "k0" }, "$26" },
2418 { { "k1" }, "$27" },
2419 { { "gp" }, "$28" },
2420 { { "sp" }, "$29" },
2421 { { "fp" }, "$30" },
2422 { { "ra" }, "$31" }
2423};
2424
2425void MipsTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2426 unsigned &NumAliases) const {
2427 Aliases = GCCRegAliases;
2428 NumAliases = llvm::array_lengthof(GCCRegAliases);
2429}
2430} // end anonymous namespace.
2431
2432namespace {
2433class MipselTargetInfo : public MipsTargetInfo {
2434public:
2435 MipselTargetInfo(const std::string& triple) : MipsTargetInfo(triple) {
2436 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2437 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2438 }
2439
2440 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002441 MacroBuilder &Builder) const;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002442};
2443
2444void MipselTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002445 MacroBuilder &Builder) const {
2446 DefineStd(Builder, "mips", Opts);
2447 Builder.defineMacro("_mips");
2448 DefineStd(Builder, "MIPSEL", Opts);
2449 Builder.defineMacro("_MIPSEL");
2450 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002451 getArchDefines(Opts, Builder);
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002452}
2453} // end anonymous namespace.
2454
Chris Lattner4b009652007-07-25 00:24:17 +00002455//===----------------------------------------------------------------------===//
2456// Driver code
2457//===----------------------------------------------------------------------===//
2458
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002459static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002460 llvm::Triple Triple(T);
2461 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002462
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002463 switch (Triple.getArch()) {
2464 default:
2465 return NULL;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002466
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002467 case llvm::Triple::arm:
Daniel Dunbar3f361b52009-09-11 01:14:50 +00002468 case llvm::Triple::thumb:
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002469 switch (os) {
Rafael Espindolad16a2202010-06-10 00:46:51 +00002470 case llvm::Triple::Linux:
2471 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002472 case llvm::Triple::Darwin:
Eli Friedman2b161652008-08-21 00:13:15 +00002473 return new DarwinARMTargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002474 case llvm::Triple::FreeBSD:
Edwin Török36565e52009-06-30 17:10:35 +00002475 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002476 default:
2477 return new ARMTargetInfo(T);
2478 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002479
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002480 case llvm::Triple::bfin:
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002481 return new BlackfinTargetInfo(T);
2482
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002483 case llvm::Triple::msp430:
2484 return new MSP430TargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002485
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002486 case llvm::Triple::mips:
2487 if (os == llvm::Triple::Psp)
2488 return new PSPTargetInfo<MipsTargetInfo>(T);
2489 if (os == llvm::Triple::Linux)
2490 return new LinuxTargetInfo<MipsTargetInfo>(T);
2491 return new MipsTargetInfo(T);
2492
2493 case llvm::Triple::mipsel:
2494 if (os == llvm::Triple::Psp)
2495 return new PSPTargetInfo<MipselTargetInfo>(T);
2496 if (os == llvm::Triple::Linux)
2497 return new LinuxTargetInfo<MipselTargetInfo>(T);
2498 return new MipselTargetInfo(T);
2499
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002500 case llvm::Triple::pic16:
2501 return new PIC16TargetInfo(T);
2502
2503 case llvm::Triple::ppc:
2504 if (os == llvm::Triple::Darwin)
Daniel Dunbar6501cab2010-05-30 00:07:30 +00002505 return new DarwinPPCTargetInfo(T);
Chris Lattnerf8030412010-02-16 18:14:57 +00002506 else if (os == llvm::Triple::FreeBSD)
2507 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002508 return new PPC32TargetInfo(T);
2509
2510 case llvm::Triple::ppc64:
2511 if (os == llvm::Triple::Darwin)
Daniel Dunbar6501cab2010-05-30 00:07:30 +00002512 return new DarwinPPC64TargetInfo(T);
John Thompsoned7bdbc2009-11-19 17:18:50 +00002513 else if (os == llvm::Triple::Lv2)
2514 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Chris Lattnerf8030412010-02-16 18:14:57 +00002515 else if (os == llvm::Triple::FreeBSD)
2516 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002517 return new PPC64TargetInfo(T);
2518
Chris Lattner2c026472010-03-06 21:21:27 +00002519 case llvm::Triple::mblaze:
2520 return new MBlazeTargetInfo(T);
2521
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002522 case llvm::Triple::sparc:
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002523 if (os == llvm::Triple::AuroraUX)
2524 return new AuroraUXSparcV8TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002525 if (os == llvm::Triple::Solaris)
2526 return new SolarisSparcV8TargetInfo(T);
2527 return new SparcV8TargetInfo(T);
2528
John Thompsoned7bdbc2009-11-19 17:18:50 +00002529 // FIXME: Need a real SPU target.
2530 case llvm::Triple::cellspu:
2531 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
2532
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002533 case llvm::Triple::systemz:
2534 return new SystemZTargetInfo(T);
2535
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002536 case llvm::Triple::tce:
2537 return new TCETargetInfo(T);
2538
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002539 case llvm::Triple::x86:
2540 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002541 case llvm::Triple::AuroraUX:
2542 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002543 case llvm::Triple::Darwin:
2544 return new DarwinI386TargetInfo(T);
2545 case llvm::Triple::Linux:
2546 return new LinuxTargetInfo<X86_32TargetInfo>(T);
2547 case llvm::Triple::DragonFly:
2548 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
2549 case llvm::Triple::NetBSD:
2550 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
2551 case llvm::Triple::OpenBSD:
2552 return new OpenBSDI386TargetInfo(T);
2553 case llvm::Triple::FreeBSD:
2554 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner6f4bed52010-07-07 16:01:42 +00002555 case llvm::Triple::Minix:
2556 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002557 case llvm::Triple::Solaris:
2558 return new SolarisTargetInfo<X86_32TargetInfo>(T);
2559 case llvm::Triple::Cygwin:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002560 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002561 case llvm::Triple::MinGW32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002562 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002563 case llvm::Triple::Win32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002564 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattnerf853e732010-04-11 19:29:39 +00002565 case llvm::Triple::Haiku:
2566 return new HaikuX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002567 default:
2568 return new X86_32TargetInfo(T);
2569 }
2570
2571 case llvm::Triple::x86_64:
2572 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002573 case llvm::Triple::AuroraUX:
2574 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002575 case llvm::Triple::Darwin:
2576 return new DarwinX86_64TargetInfo(T);
2577 case llvm::Triple::Linux:
2578 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner1eac0812010-01-09 05:41:14 +00002579 case llvm::Triple::DragonFly:
2580 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002581 case llvm::Triple::NetBSD:
2582 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
2583 case llvm::Triple::OpenBSD:
2584 return new OpenBSDX86_64TargetInfo(T);
2585 case llvm::Triple::FreeBSD:
2586 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
2587 case llvm::Triple::Solaris:
2588 return new SolarisTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002589 case llvm::Triple::MinGW64:
2590 return new MinGWX86_64TargetInfo(T);
2591 case llvm::Triple::Win32: // This is what Triple.h supports now.
2592 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002593 default:
2594 return new X86_64TargetInfo(T);
2595 }
2596 }
Chris Lattner4b009652007-07-25 00:24:17 +00002597}
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002598
2599/// CreateTargetInfo - Return the target info object for the specified target
2600/// triple.
2601TargetInfo *TargetInfo::CreateTargetInfo(Diagnostic &Diags,
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002602 TargetOptions &Opts) {
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002603 llvm::Triple Triple(Opts.Triple);
2604
2605 // Construct the target
2606 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
2607 if (!Target) {
2608 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
2609 return 0;
2610 }
2611
Daniel Dunbar33b40752009-12-18 18:42:37 +00002612 // Set the target CPU if specified.
2613 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
2614 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
2615 return 0;
2616 }
2617
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002618 // Set the target ABI if specified.
2619 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
2620 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
2621 return 0;
2622 }
2623
Charles Davisfed3a2b2010-06-11 01:06:47 +00002624 // Set the target C++ ABI.
2625 if (!Target->setCXXABI(Opts.CXXABI)) {
2626 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
2627 return 0;
2628 }
2629
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002630 // Compute the default target features, we need the target to handle this
2631 // because features may have dependencies on one another.
2632 llvm::StringMap<bool> Features;
2633 Target->getDefaultFeatures(Opts.CPU, Features);
2634
2635 // Apply the user specified deltas.
2636 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
2637 ie = Opts.Features.end(); it != ie; ++it) {
2638 const char *Name = it->c_str();
2639
2640 // Apply the feature via the target.
2641 if ((Name[0] != '-' && Name[0] != '+') ||
2642 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
2643 Diags.Report(diag::err_target_invalid_feature) << Name;
2644 return 0;
2645 }
2646 }
2647
2648 // Add the features to the compile options.
2649 //
2650 // FIXME: If we are completely confident that we have the right set, we only
2651 // need to pass the minuses.
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002652 Opts.Features.clear();
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002653 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
2654 ie = Features.end(); it != ie; ++it)
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002655 Opts.Features.push_back(std::string(it->second ? "+" : "-") + it->first());
2656 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002657
2658 return Target.take();
2659}