blob: 40a029673e555990cf5a816ae56e6213bb2c4f08 [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");
Douglas Gregor05e6d212010-08-06 12:37:52 +00001352 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001353 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001354};
1355} // end anonymous namespace
1356
1357namespace {
1358// x86-32 MinGW target
1359class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
1360public:
1361 MinGWX86_32TargetInfo(const std::string& triple)
1362 : WindowsX86_32TargetInfo(triple) {
1363 }
1364 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001365 MacroBuilder &Builder) const {
1366 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
1367 Builder.defineMacro("__MSVCRT__");
1368 Builder.defineMacro("__MINGW32__");
1369 Builder.defineMacro("__declspec", "__declspec");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001370 }
1371};
1372} // end anonymous namespace
1373
1374namespace {
1375// x86-32 Cygwin target
1376class CygwinX86_32TargetInfo : public X86_32TargetInfo {
1377public:
1378 CygwinX86_32TargetInfo(const std::string& triple)
1379 : X86_32TargetInfo(triple) {
1380 TLSSupported = false;
1381 WCharType = UnsignedShort;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001382 DoubleAlign = LongLongAlign = 64;
1383 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1384 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001385 "a0:0:64-f80:32:32-n8:16:32";
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001386 }
1387 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001388 MacroBuilder &Builder) const {
1389 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1390 Builder.defineMacro("__CYGWIN__");
1391 Builder.defineMacro("__CYGWIN32__");
1392 DefineStd(Builder, "unix", Opts);
Douglas Gregor9b22a172010-04-21 05:52:38 +00001393 if (Opts.CPlusPlus)
1394 Builder.defineMacro("_GNU_SOURCE");
Eli Friedman6b6ca942009-06-08 06:11:14 +00001395 }
Eli Friedman23cb7912008-08-21 01:40:19 +00001396};
1397} // end anonymous namespace
1398
1399namespace {
Chris Lattnerf853e732010-04-11 19:29:39 +00001400// x86-32 Haiku target
1401class HaikuX86_32TargetInfo : public X86_32TargetInfo {
1402public:
1403 HaikuX86_32TargetInfo(const std::string& triple)
1404 : X86_32TargetInfo(triple) {
1405 SizeType = UnsignedLong;
Chris Lattner5b8b18a2010-04-22 17:48:00 +00001406 IntPtrType = SignedLong;
1407 PtrDiffType = SignedLong;
Chris Lattnerf853e732010-04-11 19:29:39 +00001408 }
1409 virtual void getTargetDefines(const LangOptions &Opts,
1410 MacroBuilder &Builder) const {
1411 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1412 Builder.defineMacro("__INTEL__");
1413 Builder.defineMacro("__HAIKU__");
1414 }
1415};
1416} // end anonymous namespace
1417
1418namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001419// x86-64 generic target
1420class X86_64TargetInfo : public X86TargetInfo {
1421public:
Chris Lattner79682402009-03-20 15:52:06 +00001422 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +00001423 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001424 LongDoubleWidth = 128;
1425 LongDoubleAlign = 128;
Rafael Espindolabfa7c002010-06-04 23:15:27 +00001426 LargeArrayMinWidth = 128;
1427 LargeArrayAlign = 128;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00001428 IntMaxType = SignedLong;
1429 UIntMaxType = UnsignedLong;
Eli Friedman38e31802009-07-01 03:36:11 +00001430 Int64Type = SignedLong;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +00001431 RegParmMax = 6;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00001432
Eli Friedman2b161652008-08-21 00:13:15 +00001433 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1434 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001435 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64";
Daniel Dunbar6f94dbb2010-07-14 23:39:36 +00001436
1437 // Use fpret only for long double.
1438 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Chris Lattner4b009652007-07-25 00:24:17 +00001439 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +00001440 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001441 return "typedef struct __va_list_tag {"
1442 " unsigned gp_offset;"
1443 " unsigned fp_offset;"
1444 " void* overflow_arg_area;"
1445 " void* reg_save_area;"
John McCall33bf24b2010-05-28 18:25:28 +00001446 "} __va_list_tag;"
Eli Friedman3c79eee2009-07-03 00:45:06 +00001447 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson7dd1c952007-11-24 23:38:12 +00001448 }
Chris Lattneraa339182009-09-23 06:06:36 +00001449
1450 int getEHDataRegisterNumber(unsigned RegNo) const {
1451 if (RegNo == 0) return 0;
1452 if (RegNo == 1) return 1;
1453 return -1;
1454 }
Eli Friedman872996c2008-08-20 02:34:37 +00001455};
1456} // end anonymous namespace
1457
1458namespace {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001459// x86-64 Windows target
1460class WindowsX86_64TargetInfo : public X86_64TargetInfo {
1461public:
1462 WindowsX86_64TargetInfo(const std::string& triple)
1463 : X86_64TargetInfo(triple) {
1464 TLSSupported = false;
1465 WCharType = UnsignedShort;
Mike Stump4da7a162009-10-08 23:00:00 +00001466 LongWidth = LongAlign = 32;
Nate Begeman3736cc22010-07-21 18:11:42 +00001467 DoubleAlign = LongLongAlign = 64;
Nate Begeman472bd992010-07-21 02:02:56 +00001468 IntMaxType = SignedLongLong;
1469 UIntMaxType = UnsignedLongLong;
1470 Int64Type = SignedLongLong;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001471 }
1472 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001473 MacroBuilder &Builder) const {
1474 X86_64TargetInfo::getTargetDefines(Opts, Builder);
1475 Builder.defineMacro("_WIN64");
1476 DefineStd(Builder, "WIN64", Opts);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001477 }
1478};
1479} // end anonymous namespace
1480
1481namespace {
1482// x86-64 Windows Visual Studio target
1483class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
1484public:
1485 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
1486 : WindowsX86_64TargetInfo(triple) {
1487 }
1488 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001489 MacroBuilder &Builder) const {
1490 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1491 Builder.defineMacro("_M_X64");
Douglas Gregor05e6d212010-08-06 12:37:52 +00001492 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001493 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001494};
1495} // end anonymous namespace
1496
1497namespace {
1498// x86-64 MinGW target
1499class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
1500public:
1501 MinGWX86_64TargetInfo(const std::string& triple)
1502 : WindowsX86_64TargetInfo(triple) {
1503 }
1504 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001505 MacroBuilder &Builder) const {
1506 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1507 Builder.defineMacro("__MSVCRT__");
1508 Builder.defineMacro("__MINGW64__");
1509 Builder.defineMacro("__declspec");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001510 }
1511};
1512} // end anonymous namespace
1513
1514namespace {
Eli Friedman38e31802009-07-01 03:36:11 +00001515class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
1516public:
Mike Stump25cf7602009-09-09 15:08:12 +00001517 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman38e31802009-07-01 03:36:11 +00001518 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
1519 Int64Type = SignedLongLong;
1520 }
1521};
1522} // end anonymous namespace
1523
1524namespace {
Eli Friedman96ada022009-07-05 22:31:18 +00001525class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
1526public:
Mike Stump25cf7602009-09-09 15:08:12 +00001527 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman96ada022009-07-05 22:31:18 +00001528 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
1529 IntMaxType = SignedLongLong;
1530 UIntMaxType = UnsignedLongLong;
1531 Int64Type = SignedLongLong;
1532 }
1533};
1534} // end anonymous namespace
1535
1536namespace {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001537class ARMTargetInfo : public TargetInfo {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001538 // Possible FPU choices.
1539 enum FPUMode {
1540 NoFPU,
1541 VFP2FPU,
1542 VFP3FPU,
1543 NeonFPU
1544 };
1545
1546 static bool FPUModeIsVFP(FPUMode Mode) {
1547 return Mode >= VFP2FPU && Mode <= NeonFPU;
1548 }
1549
1550 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1551 static const char * const GCCRegNames[];
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001552
Daniel Dunbar33b40752009-12-18 18:42:37 +00001553 std::string ABI, CPU;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001554
1555 unsigned FPU : 3;
1556
Daniel Dunbar48075d82009-12-19 04:15:38 +00001557 unsigned IsThumb : 1;
1558
1559 // Initialized via features.
1560 unsigned SoftFloat : 1;
1561 unsigned SoftFloatABI : 1;
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001562
Chris Lattnerb4527522010-03-03 19:03:45 +00001563 static const Builtin::Info BuiltinInfo[];
1564
Chris Lattner9fd73612008-04-21 18:56:49 +00001565public:
Daniel Dunbarf0156562009-09-17 16:21:10 +00001566 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbar33b40752009-12-18 18:42:37 +00001567 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001568 {
Daniel Dunbarb9531632009-09-14 00:02:24 +00001569 SizeType = UnsignedInt;
1570 PtrDiffType = SignedInt;
Daniel Dunbarf0156562009-09-17 16:21:10 +00001571
Chris Lattnere20b8122010-04-23 16:29:58 +00001572 // {} in inline assembly are neon specifiers, not assembly variant
1573 // specifiers.
1574 NoAsmVariants = true;
1575
Daniel Dunbar33b40752009-12-18 18:42:37 +00001576 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0a542ca2009-12-18 19:57:13 +00001577 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001578 if (IsThumb) {
1579 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1580 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001581 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001582 } else {
1583 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1584 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001585 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001586 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001587 }
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001588 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbarb9531632009-09-14 00:02:24 +00001589 virtual bool setABI(const std::string &Name) {
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001590 ABI = Name;
1591
Daniel Dunbarb9531632009-09-14 00:02:24 +00001592 // The defaults (above) are for AAPCS, check if we need to change them.
1593 //
1594 // FIXME: We need support for -meabi... we could just mangle it into the
1595 // name.
1596 if (Name == "apcs-gnu") {
Daniel Dunbarda94a772010-01-27 20:23:08 +00001597 DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
Daniel Dunbarb9531632009-09-14 00:02:24 +00001598 SizeType = UnsignedLong;
1599
Daniel Dunbar9eb811b2010-04-22 16:14:54 +00001600 // Do not respect the alignment of bit-field types when laying out
1601 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
1602 UseBitFieldTypeAlignment = false;
1603
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001604 if (IsThumb) {
1605 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1606 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001607 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001608 } else {
1609 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1610 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001611 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001612 }
1613
Daniel Dunbarb9531632009-09-14 00:02:24 +00001614 // FIXME: Override "preferred align" for double and long long.
1615 } else if (Name == "aapcs") {
1616 // FIXME: Enumerated types are variable width in straight AAPCS.
1617 } else if (Name == "aapcs-linux") {
1618 ;
1619 } else
1620 return false;
1621
1622 return true;
1623 }
Daniel Dunbar48075d82009-12-19 04:15:38 +00001624
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001625 void getDefaultFeatures(const std::string &CPU,
1626 llvm::StringMap<bool> &Features) const {
1627 // FIXME: This should not be here.
1628 Features["vfp2"] = false;
1629 Features["vfp3"] = false;
1630 Features["neon"] = false;
1631
1632 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
1633 Features["vfp2"] = true;
1634 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
1635 Features["neon"] = true;
1636 }
1637
Daniel Dunbar48075d82009-12-19 04:15:38 +00001638 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1639 const std::string &Name,
1640 bool Enabled) const {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001641 if (Name == "soft-float" || Name == "soft-float-abi") {
1642 Features[Name] = Enabled;
1643 } else if (Name == "vfp2" || Name == "vfp3" || Name == "neon") {
1644 // These effectively are a single option, reset them when any is enabled.
1645 if (Enabled)
1646 Features["vfp2"] = Features["vfp3"] = Features["neon"] = false;
1647 Features[Name] = Enabled;
1648 } else
Daniel Dunbar48075d82009-12-19 04:15:38 +00001649 return false;
1650
Daniel Dunbar48075d82009-12-19 04:15:38 +00001651 return true;
1652 }
1653
1654 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001655 FPU = NoFPU;
Daniel Dunbar48075d82009-12-19 04:15:38 +00001656 SoftFloat = SoftFloatABI = false;
1657 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
1658 if (Features[i] == "+soft-float")
1659 SoftFloat = true;
1660 else if (Features[i] == "+soft-float-abi")
1661 SoftFloatABI = true;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001662 else if (Features[i] == "+vfp2")
1663 FPU = VFP2FPU;
1664 else if (Features[i] == "+vfp3")
1665 FPU = VFP3FPU;
1666 else if (Features[i] == "+neon")
1667 FPU = NeonFPU;
Daniel Dunbar48075d82009-12-19 04:15:38 +00001668 }
1669
1670 // Remove front-end specific options which the backend handles differently.
1671 std::vector<std::string>::iterator it;
1672 it = std::find(Features.begin(), Features.end(), "+soft-float");
1673 if (it != Features.end())
1674 Features.erase(it);
1675 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
1676 if (it != Features.end())
1677 Features.erase(it);
1678 }
1679
Daniel Dunbar33b40752009-12-18 18:42:37 +00001680 static const char *getCPUDefineSuffix(llvm::StringRef Name) {
1681 return llvm::StringSwitch<const char*>(Name)
1682 .Cases("arm8", "arm810", "4")
1683 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
1684 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
1685 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
1686 .Case("ep9312", "4T")
1687 .Cases("arm10tdmi", "arm1020t", "5T")
1688 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
1689 .Case("arm926ej-s", "5TEJ")
1690 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
1691 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001692 .Case("arm1136j-s", "6J")
Daniel Dunbar33b40752009-12-18 18:42:37 +00001693 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001694 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbar33b40752009-12-18 18:42:37 +00001695 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
1696 .Cases("cortex-a8", "cortex-a9", "7A")
1697 .Default(0);
1698 }
1699 virtual bool setCPU(const std::string &Name) {
1700 if (!getCPUDefineSuffix(Name))
1701 return false;
1702
1703 CPU = Name;
1704 return true;
1705 }
Chris Lattner79682402009-03-20 15:52:06 +00001706 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001707 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00001708 // Target identification.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001709 Builder.defineMacro("__arm");
1710 Builder.defineMacro("__arm__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001711
Chris Lattnerbef1d722009-03-02 22:27:17 +00001712 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001713 Builder.defineMacro("__ARMEL__");
1714 Builder.defineMacro("__LITTLE_ENDIAN__");
1715 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001716
1717 llvm::StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001718 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001719
Mike Stumpf90a29f2009-04-08 02:07:04 +00001720 // Subtarget options.
Daniel Dunbarf0156562009-09-17 16:21:10 +00001721
Daniel Dunbar33b40752009-12-18 18:42:37 +00001722 // FIXME: It's more complicated than this and we don't really support
1723 // interworking.
1724 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001725 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001726
Daniel Dunbar33b40752009-12-18 18:42:37 +00001727 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001728 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001729
Daniel Dunbar48075d82009-12-19 04:15:38 +00001730 if (SoftFloat)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001731 Builder.defineMacro("__SOFTFP__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001732
1733 if (CPU == "xscale")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001734 Builder.defineMacro("__XSCALE__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001735
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001736 bool IsThumb2 = IsThumb && (CPUArch == "6T2" || CPUArch.startswith("7"));
Daniel Dunbarf0156562009-09-17 16:21:10 +00001737 if (IsThumb) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001738 Builder.defineMacro("__THUMBEL__");
1739 Builder.defineMacro("__thumb__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001740 if (IsThumb2)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001741 Builder.defineMacro("__thumb2__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001742 }
1743
1744 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001745 Builder.defineMacro("__APCS_32__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001746
1747 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001748 Builder.defineMacro("__VFP_FP__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001749
1750 // This only gets set when Neon instructions are actually available, unlike
1751 // the VFP define, hence the soft float and arch check. This is subtly
1752 // different from gcc, we follow the intent which was that it should be set
1753 // when Neon instructions are actually available.
1754 if (FPU == NeonFPU && !SoftFloat && IsThumb2)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001755 Builder.defineMacro("__ARM_NEON__");
Chris Lattner9fd73612008-04-21 18:56:49 +00001756 }
1757 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1758 unsigned &NumRecords) const {
Chris Lattnerb4527522010-03-03 19:03:45 +00001759 Records = BuiltinInfo;
1760 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner9fd73612008-04-21 18:56:49 +00001761 }
1762 virtual const char *getVAListDeclaration() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001763 return "typedef char* __builtin_va_list;";
Chris Lattner9fd73612008-04-21 18:56:49 +00001764 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001765 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001766 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001767 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001768 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001769 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001770 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001771 // FIXME: Check if this is complete
Anders Carlsson36834a72009-02-28 17:11:49 +00001772 switch (*Name) {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001773 default:
Nate Begeman222823a2008-04-22 05:03:19 +00001774 case 'l': // r0-r7
1775 case 'h': // r8-r15
1776 case 'w': // VFP Floating point register single precision
1777 case 'P': // VFP Floating point register double precision
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001778 Info.setAllowsRegister();
Nate Begeman222823a2008-04-22 05:03:19 +00001779 return true;
1780 }
Chris Lattner9fd73612008-04-21 18:56:49 +00001781 return false;
1782 }
1783 virtual const char *getClobbers() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001784 // FIXME: Is this really right?
Chris Lattner9fd73612008-04-21 18:56:49 +00001785 return "";
1786 }
1787};
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001788
1789const char * const ARMTargetInfo::GCCRegNames[] = {
1790 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1791 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1792};
1793
1794void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
1795 unsigned &NumNames) const {
1796 Names = GCCRegNames;
1797 NumNames = llvm::array_lengthof(GCCRegNames);
1798}
1799
1800const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
1801
1802 { { "a1" }, "r0" },
1803 { { "a2" }, "r1" },
1804 { { "a3" }, "r2" },
1805 { { "a4" }, "r3" },
1806 { { "v1" }, "r4" },
1807 { { "v2" }, "r5" },
1808 { { "v3" }, "r6" },
1809 { { "v4" }, "r7" },
1810 { { "v5" }, "r8" },
1811 { { "v6", "rfp" }, "r9" },
1812 { { "sl" }, "r10" },
1813 { { "fp" }, "r11" },
1814 { { "ip" }, "r12" },
1815 { { "sp" }, "r13" },
1816 { { "lr" }, "r14" },
1817 { { "pc" }, "r15" },
1818};
1819
1820void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1821 unsigned &NumAliases) const {
1822 Aliases = GCCRegAliases;
1823 NumAliases = llvm::array_lengthof(GCCRegAliases);
1824}
Chris Lattnerb4527522010-03-03 19:03:45 +00001825
1826const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
1827#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
1828#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
1829#include "clang/Basic/BuiltinsARM.def"
1830};
Chris Lattner9fd73612008-04-21 18:56:49 +00001831} // end anonymous namespace.
1832
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001833
1834namespace {
Mike Stump25cf7602009-09-09 15:08:12 +00001835class DarwinARMTargetInfo :
Edwin Török36565e52009-06-30 17:10:35 +00001836 public DarwinTargetInfo<ARMTargetInfo> {
1837protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +00001838 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001839 MacroBuilder &Builder) const {
Daniel Dunbareab96a22010-01-26 01:44:04 +00001840 getDarwinDefines(Builder, Opts, Triple);
Eli Friedman8f575172009-04-19 21:38:35 +00001841 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001842
Edwin Török36565e52009-06-30 17:10:35 +00001843public:
Mike Stump25cf7602009-09-09 15:08:12 +00001844 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar01045582010-05-27 07:00:26 +00001845 : DarwinTargetInfo<ARMTargetInfo>(triple) {
1846 HasAlignMac68kSupport = true;
1847 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001848};
1849} // end anonymous namespace.
1850
Chris Lattner4b009652007-07-25 00:24:17 +00001851namespace {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001852class SparcV8TargetInfo : public TargetInfo {
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001853 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1854 static const char * const GCCRegNames[];
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001855public:
Eli Friedmanff158dd2008-08-20 07:28:14 +00001856 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
1857 // FIXME: Support Sparc quad-precision long double?
Eli Friedman2b161652008-08-21 00:13:15 +00001858 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 +00001859 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedmanff158dd2008-08-20 07:28:14 +00001860 }
Chris Lattner79682402009-03-20 15:52:06 +00001861 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001862 MacroBuilder &Builder) const {
1863 DefineStd(Builder, "sparc", Opts);
1864 Builder.defineMacro("__sparcv8");
1865 Builder.defineMacro("__REGISTER_PREFIX__", "");
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001866 }
1867 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1868 unsigned &NumRecords) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001869 // FIXME: Implement!
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001870 }
1871 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001872 return "typedef void* __builtin_va_list;";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001873 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001874 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001875 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001876 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001877 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001878 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001879 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001880 // FIXME: Implement!
1881 return false;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001882 }
1883 virtual const char *getClobbers() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001884 // FIXME: Implement!
1885 return "";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001886 }
1887};
1888
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001889const char * const SparcV8TargetInfo::GCCRegNames[] = {
1890 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1891 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1892 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1893 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
1894};
1895
Anton Korobeynikove7772382009-05-03 13:42:53 +00001896void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001897 unsigned &NumNames) const {
1898 Names = GCCRegNames;
1899 NumNames = llvm::array_lengthof(GCCRegNames);
1900}
1901
1902const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikove7772382009-05-03 13:42:53 +00001903 { { "g0" }, "r0" },
1904 { { "g1" }, "r1" },
1905 { { "g2" }, "r2" },
1906 { { "g3" }, "r3" },
1907 { { "g4" }, "r4" },
1908 { { "g5" }, "r5" },
1909 { { "g6" }, "r6" },
1910 { { "g7" }, "r7" },
1911 { { "o0" }, "r8" },
1912 { { "o1" }, "r9" },
1913 { { "o2" }, "r10" },
1914 { { "o3" }, "r11" },
1915 { { "o4" }, "r12" },
1916 { { "o5" }, "r13" },
1917 { { "o6", "sp" }, "r14" },
1918 { { "o7" }, "r15" },
1919 { { "l0" }, "r16" },
1920 { { "l1" }, "r17" },
1921 { { "l2" }, "r18" },
1922 { { "l3" }, "r19" },
1923 { { "l4" }, "r20" },
1924 { { "l5" }, "r21" },
1925 { { "l6" }, "r22" },
1926 { { "l7" }, "r23" },
1927 { { "i0" }, "r24" },
1928 { { "i1" }, "r25" },
1929 { { "i2" }, "r26" },
1930 { { "i3" }, "r27" },
1931 { { "i4" }, "r28" },
1932 { { "i5" }, "r29" },
1933 { { "i6", "fp" }, "r30" },
1934 { { "i7" }, "r31" },
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001935};
1936
Anton Korobeynikove7772382009-05-03 13:42:53 +00001937void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001938 unsigned &NumAliases) const {
1939 Aliases = GCCRegAliases;
1940 NumAliases = llvm::array_lengthof(GCCRegAliases);
1941}
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001942} // end anonymous namespace.
1943
Eli Friedmanff158dd2008-08-20 07:28:14 +00001944namespace {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00001945class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
1946public:
1947 AuroraUXSparcV8TargetInfo(const std::string& triple) :
1948 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
1949 SizeType = UnsignedInt;
1950 PtrDiffType = SignedInt;
1951 }
1952};
Edwin Török36565e52009-06-30 17:10:35 +00001953class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001954public:
1955 SolarisSparcV8TargetInfo(const std::string& triple) :
Edwin Török36565e52009-06-30 17:10:35 +00001956 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedman7cca0982008-11-02 02:43:55 +00001957 SizeType = UnsignedInt;
1958 PtrDiffType = SignedInt;
Eli Friedmanff158dd2008-08-20 07:28:14 +00001959 }
1960};
1961} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +00001962
Chris Lattner85970f32008-05-08 05:58:21 +00001963namespace {
1964 class PIC16TargetInfo : public TargetInfo{
1965 public:
1966 PIC16TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +00001967 TLSSupported = false;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001968 IntWidth = 16;
1969 LongWidth = LongLongWidth = 32;
1970 PointerWidth = 16;
1971 IntAlign = 8;
1972 LongAlign = LongLongAlign = 8;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001973 PointerAlign = 8;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001974 SizeType = UnsignedInt;
1975 IntMaxType = SignedLong;
1976 UIntMaxType = UnsignedLong;
Chris Lattnerd9ef7242009-02-13 22:28:55 +00001977 IntPtrType = SignedShort;
Eli Friedman7cca0982008-11-02 02:43:55 +00001978 PtrDiffType = SignedInt;
Edward O'Callaghan14a70a32009-11-21 00:49:54 +00001979 SigAtomicType = SignedLong;
Sanjiv Guptaae8f1e82009-06-02 04:43:46 +00001980 FloatWidth = 32;
1981 FloatAlign = 32;
1982 DoubleWidth = 32;
1983 DoubleAlign = 32;
1984 LongDoubleWidth = 32;
1985 LongDoubleAlign = 32;
1986 FloatFormat = &llvm::APFloat::IEEEsingle;
1987 DoubleFormat = &llvm::APFloat::IEEEsingle;
1988 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner2e17d912009-11-07 18:59:41 +00001989 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 +00001990
Chris Lattner85970f32008-05-08 05:58:21 +00001991 }
Chris Lattner727b3c42008-05-09 06:08:39 +00001992 virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }
1993 virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }
Chris Lattner79682402009-03-20 15:52:06 +00001994 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001995 MacroBuilder &Builder) const {
1996 Builder.defineMacro("__pic16");
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00001997 Builder.defineMacro("__PIC16");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001998 Builder.defineMacro("rom", "__attribute__((address_space(1)))");
1999 Builder.defineMacro("ram", "__attribute__((address_space(0)))");
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00002000 Builder.defineMacro("__section(SectName)",
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00002001 "__attribute__((section(SectName)))");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002002 Builder.defineMacro("near",
Sanjiv Gupta09e95f02009-10-24 18:08:20 +00002003 "__attribute__((section(\"Address=NEAR\")))");
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00002004 Builder.defineMacro("__address(Addr)",
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00002005 "__attribute__((section(\"Address=\"#Addr)))");
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00002006 Builder.defineMacro("__config(conf)", "asm(\"CONFIG \"#conf)");
2007 Builder.defineMacro("__idlocs(value)", "asm(\"__IDLOCS \"#value)");
2008 Builder.defineMacro("interrupt",
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00002009 "__attribute__((section(\"interrupt=0x4\"))) \
2010 __attribute__((used))");
Chris Lattner85970f32008-05-08 05:58:21 +00002011 }
2012 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2013 unsigned &NumRecords) const {}
Mike Stump25cf7602009-09-09 15:08:12 +00002014 virtual const char *getVAListDeclaration() const {
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00002015 return "typedef char* __builtin_va_list;";
Daniel Dunbar2e967de2009-08-24 09:54:37 +00002016 }
2017 virtual const char *getClobbers() const {
2018 return "";
2019 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00002020 virtual void getGCCRegNames(const char * const *&Names,
2021 unsigned &NumNames) const {}
2022 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner85970f32008-05-08 05:58:21 +00002023 TargetInfo::ConstraintInfo &info) const {
2024 return true;
2025 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00002026 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner85970f32008-05-08 05:58:21 +00002027 unsigned &NumAliases) const {}
2028 virtual bool useGlobalsForAutomaticVariables() const {return true;}
2029 };
2030}
2031
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002032namespace {
2033 class MSP430TargetInfo : public TargetInfo {
2034 static const char * const GCCRegNames[];
2035 public:
2036 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
2037 TLSSupported = false;
Anton Korobeynikov2a6630a2010-01-30 12:55:11 +00002038 IntWidth = 16; IntAlign = 16;
2039 LongWidth = 32; LongLongWidth = 64;
2040 LongAlign = LongLongAlign = 16;
2041 PointerWidth = 16; PointerAlign = 16;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002042 SizeType = UnsignedInt;
2043 IntMaxType = SignedLong;
2044 UIntMaxType = UnsignedLong;
2045 IntPtrType = SignedShort;
2046 PtrDiffType = SignedInt;
Edward O'Callaghan14a70a32009-11-21 00:49:54 +00002047 SigAtomicType = SignedLong;
Anton Korobeynikov314713f2009-12-19 01:32:37 +00002048 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002049 }
2050 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002051 MacroBuilder &Builder) const {
2052 Builder.defineMacro("MSP430");
2053 Builder.defineMacro("__MSP430__");
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002054 // FIXME: defines for different 'flavours' of MCU
2055 }
2056 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2057 unsigned &NumRecords) const {
2058 // FIXME: Implement.
2059 Records = 0;
2060 NumRecords = 0;
2061 }
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002062 virtual void getGCCRegNames(const char * const *&Names,
2063 unsigned &NumNames) const;
2064 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2065 unsigned &NumAliases) const {
2066 // No aliases.
2067 Aliases = 0;
2068 NumAliases = 0;
2069 }
2070 virtual bool validateAsmConstraint(const char *&Name,
2071 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov174219b2009-10-15 23:17:13 +00002072 // No target constraints for now.
2073 return false;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002074 }
2075 virtual const char *getClobbers() const {
2076 // FIXME: Is this really right?
2077 return "";
2078 }
2079 virtual const char *getVAListDeclaration() const {
2080 // FIXME: implement
Anton Korobeynikovf5955592009-05-08 18:24:57 +00002081 return "typedef char* __builtin_va_list;";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002082 }
2083 };
2084
2085 const char * const MSP430TargetInfo::GCCRegNames[] = {
2086 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2087 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2088 };
2089
2090 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
2091 unsigned &NumNames) const {
2092 Names = GCCRegNames;
2093 NumNames = llvm::array_lengthof(GCCRegNames);
2094 }
2095}
2096
2097
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002098namespace {
2099 class SystemZTargetInfo : public TargetInfo {
2100 static const char * const GCCRegNames[];
2101 public:
2102 SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
2103 TLSSupported = false;
2104 IntWidth = IntAlign = 32;
2105 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
2106 PointerWidth = PointerAlign = 64;
Chris Lattner2e17d912009-11-07 18:59:41 +00002107 DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
2108 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002109 }
2110 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002111 MacroBuilder &Builder) const {
2112 Builder.defineMacro("__s390__");
2113 Builder.defineMacro("__s390x__");
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002114 }
2115 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2116 unsigned &NumRecords) const {
2117 // FIXME: Implement.
2118 Records = 0;
2119 NumRecords = 0;
2120 }
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002121
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002122 virtual void getGCCRegNames(const char * const *&Names,
2123 unsigned &NumNames) const;
2124 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2125 unsigned &NumAliases) const {
2126 // No aliases.
2127 Aliases = 0;
2128 NumAliases = 0;
2129 }
2130 virtual bool validateAsmConstraint(const char *&Name,
2131 TargetInfo::ConstraintInfo &info) const {
2132 // FIXME: implement
2133 return true;
2134 }
2135 virtual const char *getClobbers() const {
2136 // FIXME: Is this really right?
2137 return "";
2138 }
2139 virtual const char *getVAListDeclaration() const {
2140 // FIXME: implement
2141 return "typedef char* __builtin_va_list;";
2142 }
2143 };
2144
2145 const char * const SystemZTargetInfo::GCCRegNames[] = {
2146 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2147 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2148 };
2149
2150 void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
2151 unsigned &NumNames) const {
2152 Names = GCCRegNames;
2153 NumNames = llvm::array_lengthof(GCCRegNames);
2154 }
2155}
2156
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002157namespace {
2158 class BlackfinTargetInfo : public TargetInfo {
2159 static const char * const GCCRegNames[];
2160 public:
2161 BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
2162 TLSSupported = false;
2163 DoubleAlign = 32;
2164 LongLongAlign = 32;
2165 LongDoubleAlign = 32;
Chris Lattner2e17d912009-11-07 18:59:41 +00002166 DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002167 }
2168
2169 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002170 MacroBuilder &Builder) const {
2171 DefineStd(Builder, "bfin", Opts);
2172 DefineStd(Builder, "BFIN", Opts);
2173 Builder.defineMacro("__ADSPBLACKFIN__");
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002174 // FIXME: This one is really dependent on -mcpu
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002175 Builder.defineMacro("__ADSPLPBLACKFIN__");
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002176 // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
2177 }
2178
2179 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2180 unsigned &NumRecords) const {
2181 // FIXME: Implement.
2182 Records = 0;
2183 NumRecords = 0;
2184 }
2185
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002186 virtual void getGCCRegNames(const char * const *&Names,
2187 unsigned &NumNames) const;
2188
2189 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2190 unsigned &NumAliases) const {
2191 // No aliases.
2192 Aliases = 0;
2193 NumAliases = 0;
2194 }
2195
2196 virtual bool validateAsmConstraint(const char *&Name,
2197 TargetInfo::ConstraintInfo &Info) const {
2198 if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
2199 Info.setAllowsRegister();
2200 return true;
2201 }
2202 return false;
2203 }
2204
2205 virtual const char *getClobbers() const {
2206 return "";
2207 }
2208
2209 virtual const char *getVAListDeclaration() const {
2210 return "typedef char* __builtin_va_list;";
2211 }
2212 };
2213
2214 const char * const BlackfinTargetInfo::GCCRegNames[] = {
2215 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2216 "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
2217 "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
2218 "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
2219 "a0", "a1", "cc",
2220 "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
2221 "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
2222 };
2223
2224 void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
2225 unsigned &NumNames) const {
2226 Names = GCCRegNames;
2227 NumNames = llvm::array_lengthof(GCCRegNames);
2228 }
2229}
2230
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002231namespace {
2232
Mike Stump25cf7602009-09-09 15:08:12 +00002233 // LLVM and Clang cannot be used directly to output native binaries for
2234 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002235 // type and alignment information.
Mike Stump25cf7602009-09-09 15:08:12 +00002236 //
2237 // TCE uses the llvm bitcode as input and uses it for generating customized
2238 // target processor and program binary. TCE co-design environment is
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002239 // publicly available in http://tce.cs.tut.fi
2240
2241 class TCETargetInfo : public TargetInfo{
2242 public:
2243 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
2244 TLSSupported = false;
2245 IntWidth = 32;
2246 LongWidth = LongLongWidth = 32;
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002247 PointerWidth = 32;
2248 IntAlign = 32;
2249 LongAlign = LongLongAlign = 32;
2250 PointerAlign = 32;
2251 SizeType = UnsignedInt;
2252 IntMaxType = SignedLong;
2253 UIntMaxType = UnsignedLong;
2254 IntPtrType = SignedInt;
2255 PtrDiffType = SignedInt;
2256 FloatWidth = 32;
2257 FloatAlign = 32;
2258 DoubleWidth = 32;
2259 DoubleAlign = 32;
2260 LongDoubleWidth = 32;
2261 LongDoubleAlign = 32;
2262 FloatFormat = &llvm::APFloat::IEEEsingle;
2263 DoubleFormat = &llvm::APFloat::IEEEsingle;
2264 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner8a1db932010-03-04 21:07:38 +00002265 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
2266 "i16:16:32-i32:32:32-i64:32:32-"
2267 "f32:32:32-f64:64:64-v64:64:64-"
2268 "v128:128:128-a0:0:64-n32";
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002269 }
2270
2271 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002272 MacroBuilder &Builder) const {
2273 DefineStd(Builder, "tce", Opts);
2274 Builder.defineMacro("__TCE__");
2275 Builder.defineMacro("__TCE_V1__");
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002276 }
2277 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2278 unsigned &NumRecords) const {}
Daniel Dunbar2e967de2009-08-24 09:54:37 +00002279 virtual const char *getClobbers() const {
2280 return "";
2281 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002282 virtual const char *getVAListDeclaration() const {
2283 return "typedef void* __builtin_va_list;";
2284 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002285 virtual void getGCCRegNames(const char * const *&Names,
2286 unsigned &NumNames) const {}
2287 virtual bool validateAsmConstraint(const char *&Name,
2288 TargetInfo::ConstraintInfo &info) const {
2289 return true;
2290 }
2291 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2292 unsigned &NumAliases) const {}
2293 };
2294}
2295
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002296namespace {
2297class MipsTargetInfo : public TargetInfo {
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002298 std::string ABI, CPU;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002299 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2300 static const char * const GCCRegNames[];
2301public:
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002302 MipsTargetInfo(const std::string& triple) : TargetInfo(triple), ABI("o32") {
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002303 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2304 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2305 }
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002306 virtual const char *getABI() const { return ABI.c_str(); }
2307 virtual bool setABI(const std::string &Name) {
2308
2309 if ((Name == "o32") || (Name == "eabi")) {
2310 ABI = Name;
2311 return true;
2312 } else
2313 return false;
2314 }
2315 virtual bool setCPU(const std::string &Name) {
2316 CPU = Name;
2317 return true;
2318 }
2319 void getDefaultFeatures(const std::string &CPU,
2320 llvm::StringMap<bool> &Features) const {
2321 Features[ABI] = true;
2322 Features[CPU] = true;
2323 }
2324 virtual void getArchDefines(const LangOptions &Opts,
2325 MacroBuilder &Builder) const {
2326 if (ABI == "o32")
2327 Builder.defineMacro("__mips_o32");
2328 else if (ABI == "eabi")
2329 Builder.defineMacro("__mips_eabi");
2330 }
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002331 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002332 MacroBuilder &Builder) const {
2333 DefineStd(Builder, "mips", Opts);
2334 Builder.defineMacro("_mips");
2335 DefineStd(Builder, "MIPSEB", Opts);
2336 Builder.defineMacro("_MIPSEB");
2337 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002338 getArchDefines(Opts, Builder);
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002339 }
2340 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2341 unsigned &NumRecords) const {
2342 // FIXME: Implement!
2343 }
2344 virtual const char *getVAListDeclaration() const {
2345 return "typedef void* __builtin_va_list;";
2346 }
2347 virtual void getGCCRegNames(const char * const *&Names,
2348 unsigned &NumNames) const;
2349 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2350 unsigned &NumAliases) const;
2351 virtual bool validateAsmConstraint(const char *&Name,
2352 TargetInfo::ConstraintInfo &Info) const {
2353 switch (*Name) {
2354 default:
2355 case 'r': // CPU registers.
2356 case 'd': // Equivalent to "r" unless generating MIPS16 code.
2357 case 'y': // Equivalent to "r", backwards compatibility only.
2358 case 'f': // floating-point registers.
2359 Info.setAllowsRegister();
2360 return true;
2361 }
2362 return false;
2363 }
2364
2365 virtual const char *getClobbers() const {
2366 // FIXME: Implement!
2367 return "";
2368 }
2369};
2370
2371const char * const MipsTargetInfo::GCCRegNames[] = {
2372 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
2373 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
2374 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
2375 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
2376 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
2377 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
2378 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
2379 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
2380 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
2381 "$fcc5","$fcc6","$fcc7"
2382};
2383
2384void MipsTargetInfo::getGCCRegNames(const char * const *&Names,
2385 unsigned &NumNames) const {
2386 Names = GCCRegNames;
2387 NumNames = llvm::array_lengthof(GCCRegNames);
2388}
2389
2390const TargetInfo::GCCRegAlias MipsTargetInfo::GCCRegAliases[] = {
2391 { { "at" }, "$1" },
2392 { { "v0" }, "$2" },
2393 { { "v1" }, "$3" },
2394 { { "a0" }, "$4" },
2395 { { "a1" }, "$5" },
2396 { { "a2" }, "$6" },
2397 { { "a3" }, "$7" },
2398 { { "t0" }, "$8" },
2399 { { "t1" }, "$9" },
2400 { { "t2" }, "$10" },
2401 { { "t3" }, "$11" },
2402 { { "t4" }, "$12" },
2403 { { "t5" }, "$13" },
2404 { { "t6" }, "$14" },
2405 { { "t7" }, "$15" },
2406 { { "s0" }, "$16" },
2407 { { "s1" }, "$17" },
2408 { { "s2" }, "$18" },
2409 { { "s3" }, "$19" },
2410 { { "s4" }, "$20" },
2411 { { "s5" }, "$21" },
2412 { { "s6" }, "$22" },
2413 { { "s7" }, "$23" },
2414 { { "t8" }, "$24" },
2415 { { "t9" }, "$25" },
2416 { { "k0" }, "$26" },
2417 { { "k1" }, "$27" },
2418 { { "gp" }, "$28" },
2419 { { "sp" }, "$29" },
2420 { { "fp" }, "$30" },
2421 { { "ra" }, "$31" }
2422};
2423
2424void MipsTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2425 unsigned &NumAliases) const {
2426 Aliases = GCCRegAliases;
2427 NumAliases = llvm::array_lengthof(GCCRegAliases);
2428}
2429} // end anonymous namespace.
2430
2431namespace {
2432class MipselTargetInfo : public MipsTargetInfo {
2433public:
2434 MipselTargetInfo(const std::string& triple) : MipsTargetInfo(triple) {
2435 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2436 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2437 }
2438
2439 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002440 MacroBuilder &Builder) const;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002441};
2442
2443void MipselTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002444 MacroBuilder &Builder) const {
2445 DefineStd(Builder, "mips", Opts);
2446 Builder.defineMacro("_mips");
2447 DefineStd(Builder, "MIPSEL", Opts);
2448 Builder.defineMacro("_MIPSEL");
2449 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002450 getArchDefines(Opts, Builder);
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002451}
2452} // end anonymous namespace.
2453
Chris Lattner4b009652007-07-25 00:24:17 +00002454//===----------------------------------------------------------------------===//
2455// Driver code
2456//===----------------------------------------------------------------------===//
2457
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002458static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002459 llvm::Triple Triple(T);
2460 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002461
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002462 switch (Triple.getArch()) {
2463 default:
2464 return NULL;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002465
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002466 case llvm::Triple::arm:
Daniel Dunbar3f361b52009-09-11 01:14:50 +00002467 case llvm::Triple::thumb:
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002468 switch (os) {
Rafael Espindolad16a2202010-06-10 00:46:51 +00002469 case llvm::Triple::Linux:
2470 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002471 case llvm::Triple::Darwin:
Eli Friedman2b161652008-08-21 00:13:15 +00002472 return new DarwinARMTargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002473 case llvm::Triple::FreeBSD:
Edwin Török36565e52009-06-30 17:10:35 +00002474 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002475 default:
2476 return new ARMTargetInfo(T);
2477 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002478
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002479 case llvm::Triple::bfin:
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002480 return new BlackfinTargetInfo(T);
2481
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002482 case llvm::Triple::msp430:
2483 return new MSP430TargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002484
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002485 case llvm::Triple::mips:
2486 if (os == llvm::Triple::Psp)
2487 return new PSPTargetInfo<MipsTargetInfo>(T);
2488 if (os == llvm::Triple::Linux)
2489 return new LinuxTargetInfo<MipsTargetInfo>(T);
2490 return new MipsTargetInfo(T);
2491
2492 case llvm::Triple::mipsel:
2493 if (os == llvm::Triple::Psp)
2494 return new PSPTargetInfo<MipselTargetInfo>(T);
2495 if (os == llvm::Triple::Linux)
2496 return new LinuxTargetInfo<MipselTargetInfo>(T);
2497 return new MipselTargetInfo(T);
2498
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002499 case llvm::Triple::pic16:
2500 return new PIC16TargetInfo(T);
2501
2502 case llvm::Triple::ppc:
2503 if (os == llvm::Triple::Darwin)
Daniel Dunbar6501cab2010-05-30 00:07:30 +00002504 return new DarwinPPCTargetInfo(T);
Chris Lattnerf8030412010-02-16 18:14:57 +00002505 else if (os == llvm::Triple::FreeBSD)
2506 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002507 return new PPC32TargetInfo(T);
2508
2509 case llvm::Triple::ppc64:
2510 if (os == llvm::Triple::Darwin)
Daniel Dunbar6501cab2010-05-30 00:07:30 +00002511 return new DarwinPPC64TargetInfo(T);
John Thompsoned7bdbc2009-11-19 17:18:50 +00002512 else if (os == llvm::Triple::Lv2)
2513 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Chris Lattnerf8030412010-02-16 18:14:57 +00002514 else if (os == llvm::Triple::FreeBSD)
2515 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002516 return new PPC64TargetInfo(T);
2517
Chris Lattner2c026472010-03-06 21:21:27 +00002518 case llvm::Triple::mblaze:
2519 return new MBlazeTargetInfo(T);
2520
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002521 case llvm::Triple::sparc:
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002522 if (os == llvm::Triple::AuroraUX)
2523 return new AuroraUXSparcV8TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002524 if (os == llvm::Triple::Solaris)
2525 return new SolarisSparcV8TargetInfo(T);
2526 return new SparcV8TargetInfo(T);
2527
John Thompsoned7bdbc2009-11-19 17:18:50 +00002528 // FIXME: Need a real SPU target.
2529 case llvm::Triple::cellspu:
2530 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
2531
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002532 case llvm::Triple::systemz:
2533 return new SystemZTargetInfo(T);
2534
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002535 case llvm::Triple::tce:
2536 return new TCETargetInfo(T);
2537
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002538 case llvm::Triple::x86:
2539 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002540 case llvm::Triple::AuroraUX:
2541 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002542 case llvm::Triple::Darwin:
2543 return new DarwinI386TargetInfo(T);
2544 case llvm::Triple::Linux:
2545 return new LinuxTargetInfo<X86_32TargetInfo>(T);
2546 case llvm::Triple::DragonFly:
2547 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
2548 case llvm::Triple::NetBSD:
2549 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
2550 case llvm::Triple::OpenBSD:
2551 return new OpenBSDI386TargetInfo(T);
2552 case llvm::Triple::FreeBSD:
2553 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner6f4bed52010-07-07 16:01:42 +00002554 case llvm::Triple::Minix:
2555 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002556 case llvm::Triple::Solaris:
2557 return new SolarisTargetInfo<X86_32TargetInfo>(T);
2558 case llvm::Triple::Cygwin:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002559 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002560 case llvm::Triple::MinGW32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002561 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002562 case llvm::Triple::Win32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002563 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattnerf853e732010-04-11 19:29:39 +00002564 case llvm::Triple::Haiku:
2565 return new HaikuX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002566 default:
2567 return new X86_32TargetInfo(T);
2568 }
2569
2570 case llvm::Triple::x86_64:
2571 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002572 case llvm::Triple::AuroraUX:
2573 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002574 case llvm::Triple::Darwin:
2575 return new DarwinX86_64TargetInfo(T);
2576 case llvm::Triple::Linux:
2577 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner1eac0812010-01-09 05:41:14 +00002578 case llvm::Triple::DragonFly:
2579 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002580 case llvm::Triple::NetBSD:
2581 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
2582 case llvm::Triple::OpenBSD:
2583 return new OpenBSDX86_64TargetInfo(T);
2584 case llvm::Triple::FreeBSD:
2585 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
2586 case llvm::Triple::Solaris:
2587 return new SolarisTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002588 case llvm::Triple::MinGW64:
2589 return new MinGWX86_64TargetInfo(T);
2590 case llvm::Triple::Win32: // This is what Triple.h supports now.
2591 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002592 default:
2593 return new X86_64TargetInfo(T);
2594 }
2595 }
Chris Lattner4b009652007-07-25 00:24:17 +00002596}
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002597
2598/// CreateTargetInfo - Return the target info object for the specified target
2599/// triple.
2600TargetInfo *TargetInfo::CreateTargetInfo(Diagnostic &Diags,
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002601 TargetOptions &Opts) {
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002602 llvm::Triple Triple(Opts.Triple);
2603
2604 // Construct the target
2605 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
2606 if (!Target) {
2607 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
2608 return 0;
2609 }
2610
Daniel Dunbar33b40752009-12-18 18:42:37 +00002611 // Set the target CPU if specified.
2612 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
2613 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
2614 return 0;
2615 }
2616
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002617 // Set the target ABI if specified.
2618 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
2619 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
2620 return 0;
2621 }
2622
Charles Davisfed3a2b2010-06-11 01:06:47 +00002623 // Set the target C++ ABI.
2624 if (!Target->setCXXABI(Opts.CXXABI)) {
2625 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
2626 return 0;
2627 }
2628
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002629 // Compute the default target features, we need the target to handle this
2630 // because features may have dependencies on one another.
2631 llvm::StringMap<bool> Features;
2632 Target->getDefaultFeatures(Opts.CPU, Features);
2633
2634 // Apply the user specified deltas.
2635 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
2636 ie = Opts.Features.end(); it != ie; ++it) {
2637 const char *Name = it->c_str();
2638
2639 // Apply the feature via the target.
2640 if ((Name[0] != '-' && Name[0] != '+') ||
2641 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
2642 Diags.Report(diag::err_target_invalid_feature) << Name;
2643 return 0;
2644 }
2645 }
2646
2647 // Add the features to the compile options.
2648 //
2649 // FIXME: If we are completely confident that we have the right set, we only
2650 // need to pass the minuses.
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002651 Opts.Features.clear();
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002652 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
2653 ie = Features.end(); it != ie; ++it)
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002654 Opts.Features.push_back(std::string(it->second ? "+" : "-") + it->first());
2655 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002656
2657 return Target.take();
2658}