blob: e019d6a0cbcbf0fcce5a5e882ad374835ff7bb80 [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) {
153 this->TLSSupported = false;
154 }
155
Edwin Török36565e52009-06-30 17:10:35 +0000156 virtual const char *getUnicodeStringSection() const {
157 return "__TEXT,__ustring";
158 }
Mike Stump25cf7602009-09-09 15:08:12 +0000159
Chris Lattner43954312009-08-10 19:03:04 +0000160 virtual std::string isValidSectionSpecifier(const llvm::StringRef &SR) const {
161 // Let MCSectionMachO validate this.
162 llvm::StringRef Segment, Section;
163 unsigned TAA, StubSize;
164 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
165 TAA, StubSize);
166 }
Edwin Török36565e52009-06-30 17:10:35 +0000167};
168
Chris Lattner43954312009-08-10 19:03:04 +0000169
Edwin Török36565e52009-06-30 17:10:35 +0000170// DragonFlyBSD Target
171template<typename Target>
172class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
173protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000174 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000175 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000176 // DragonFly defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000177 Builder.defineMacro("__DragonFly__");
178 Builder.defineMacro("__DragonFly_cc_version", "100001");
179 Builder.defineMacro("__ELF__");
180 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
181 Builder.defineMacro("__tune_i386__");
182 DefineStd(Builder, "unix", Opts);
Edwin Török36565e52009-06-30 17:10:35 +0000183 }
184public:
Mike Stump25cf7602009-09-09 15:08:12 +0000185 DragonFlyBSDTargetInfo(const std::string &triple)
Edwin Török36565e52009-06-30 17:10:35 +0000186 : OSTargetInfo<Target>(triple) {}
187};
188
189// FreeBSD Target
190template<typename Target>
191class FreeBSDTargetInfo : public OSTargetInfo<Target> {
192protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000193 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000194 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000195 // FreeBSD defines; list based off of gcc output
196
Daniel Dunbar608b3882009-08-24 09:10:05 +0000197 // FIXME: Move version number handling to llvm::Triple.
198 const char *FreeBSD = strstr(Triple.getTriple().c_str(),
199 "-freebsd");
Edwin Török36565e52009-06-30 17:10:35 +0000200 FreeBSD += strlen("-freebsd");
201 char release[] = "X";
202 release[0] = FreeBSD[0];
203 char version[] = "X00001";
204 version[0] = FreeBSD[0];
205
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000206 Builder.defineMacro("__FreeBSD__", release);
207 Builder.defineMacro("__FreeBSD_cc_version", version);
208 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
209 DefineStd(Builder, "unix", Opts);
210 Builder.defineMacro("__ELF__");
Edwin Török36565e52009-06-30 17:10:35 +0000211 }
212public:
Mike Stump25cf7602009-09-09 15:08:12 +0000213 FreeBSDTargetInfo(const std::string &triple)
Duncan Sandscd2cb662009-07-08 13:55:08 +0000214 : OSTargetInfo<Target>(triple) {
215 this->UserLabelPrefix = "";
216 }
Edwin Török36565e52009-06-30 17:10:35 +0000217};
218
219// Linux target
220template<typename Target>
221class LinuxTargetInfo : public OSTargetInfo<Target> {
222protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000223 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000224 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000225 // Linux defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000226 DefineStd(Builder, "unix", Opts);
227 DefineStd(Builder, "linux", Opts);
228 Builder.defineMacro("__gnu_linux__");
229 Builder.defineMacro("__ELF__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000230 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000231 Builder.defineMacro("_REENTRANT");
Edwin Török36565e52009-06-30 17:10:35 +0000232 }
233public:
Mike Stump25cf7602009-09-09 15:08:12 +0000234 LinuxTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +0000235 : OSTargetInfo<Target>(triple) {
236 this->UserLabelPrefix = "";
237 }
238};
239
Chris Lattner25fff082009-07-13 20:29:08 +0000240// NetBSD Target
241template<typename Target>
242class NetBSDTargetInfo : public OSTargetInfo<Target> {
243protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000244 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000245 MacroBuilder &Builder) const {
Chris Lattner25fff082009-07-13 20:29:08 +0000246 // NetBSD defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000247 Builder.defineMacro("__NetBSD__");
248 Builder.defineMacro("__unix__");
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("_POSIX_THREADS");
Chris Lattner25fff082009-07-13 20:29:08 +0000252 }
253public:
Mike Stump25cf7602009-09-09 15:08:12 +0000254 NetBSDTargetInfo(const std::string &triple)
Chris Lattner25fff082009-07-13 20:29:08 +0000255 : OSTargetInfo<Target>(triple) {
256 this->UserLabelPrefix = "";
257 }
258};
259
Edwin Török36565e52009-06-30 17:10:35 +0000260// OpenBSD Target
261template<typename Target>
262class OpenBSDTargetInfo : public OSTargetInfo<Target> {
263protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000264 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000265 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000266 // OpenBSD defines; list based off of gcc output
267
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000268 Builder.defineMacro("__OpenBSD__");
269 DefineStd(Builder, "unix", Opts);
270 Builder.defineMacro("__ELF__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000271 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000272 Builder.defineMacro("_POSIX_THREADS");
Edwin Török36565e52009-06-30 17:10:35 +0000273 }
274public:
Mike Stump25cf7602009-09-09 15:08:12 +0000275 OpenBSDTargetInfo(const std::string &triple)
Edwin Török36565e52009-06-30 17:10:35 +0000276 : OSTargetInfo<Target>(triple) {}
277};
278
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000279// PSP Target
280template<typename Target>
281class PSPTargetInfo : public OSTargetInfo<Target> {
282protected:
283 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000284 MacroBuilder &Builder) const {
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000285 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000286 Builder.defineMacro("PSP");
287 Builder.defineMacro("_PSP");
288 Builder.defineMacro("__psp__");
289 Builder.defineMacro("__ELF__");
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000290 }
291public:
292 PSPTargetInfo(const std::string& triple)
293 : OSTargetInfo<Target>(triple) {
294 this->UserLabelPrefix = "";
295 }
296};
297
John Thompsoned7bdbc2009-11-19 17:18:50 +0000298// PS3 PPU Target
299template<typename Target>
300class PS3PPUTargetInfo : public OSTargetInfo<Target> {
301protected:
302 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000303 MacroBuilder &Builder) const {
John Thompsoned7bdbc2009-11-19 17:18:50 +0000304 // PS3 PPU defines.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000305 Builder.defineMacro("__PPU__");
306 Builder.defineMacro("__CELLOS_LV2__");
307 Builder.defineMacro("__ELF__");
308 Builder.defineMacro("__LP32__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000309 }
310public:
311 PS3PPUTargetInfo(const std::string& triple)
312 : OSTargetInfo<Target>(triple) {
313 this->UserLabelPrefix = "";
John Thompson4c3bd3f2009-12-18 14:21:08 +0000314 this->LongWidth = this->LongAlign = this->PointerWidth = this->PointerAlign = 32;
315 this->SizeType = TargetInfo::UnsignedInt;
John Thompsoned7bdbc2009-11-19 17:18:50 +0000316 }
317};
318
319// FIXME: Need a real SPU target.
320// PS3 SPU Target
321template<typename Target>
322class PS3SPUTargetInfo : 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.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000327 Builder.defineMacro("__SPU__");
328 Builder.defineMacro("__ELF__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000329 }
330public:
331 PS3SPUTargetInfo(const std::string& triple)
332 : OSTargetInfo<Target>(triple) {
333 this->UserLabelPrefix = "";
334 }
335};
336
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +0000337// AuroraUX target
338template<typename Target>
339class AuroraUXTargetInfo : public OSTargetInfo<Target> {
340protected:
341 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000342 MacroBuilder &Builder) const {
343 DefineStd(Builder, "sun", Opts);
344 DefineStd(Builder, "unix", Opts);
345 Builder.defineMacro("__ELF__");
346 Builder.defineMacro("__svr4__");
347 Builder.defineMacro("__SVR4");
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +0000348 }
349public:
350 AuroraUXTargetInfo(const std::string& triple)
351 : OSTargetInfo<Target>(triple) {
352 this->UserLabelPrefix = "";
353 this->WCharType = this->SignedLong;
354 // FIXME: WIntType should be SignedLong
355 }
356};
357
Edwin Török36565e52009-06-30 17:10:35 +0000358// Solaris target
359template<typename Target>
360class SolarisTargetInfo : public OSTargetInfo<Target> {
361protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000362 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000363 MacroBuilder &Builder) const {
364 DefineStd(Builder, "sun", Opts);
365 DefineStd(Builder, "unix", Opts);
366 Builder.defineMacro("__ELF__");
367 Builder.defineMacro("__svr4__");
368 Builder.defineMacro("__SVR4");
Edwin Török36565e52009-06-30 17:10:35 +0000369 }
370public:
Mike Stump25cf7602009-09-09 15:08:12 +0000371 SolarisTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +0000372 : OSTargetInfo<Target>(triple) {
373 this->UserLabelPrefix = "";
374 this->WCharType = this->SignedLong;
375 // FIXME: WIntType should be SignedLong
376 }
377};
Mike Stump25cf7602009-09-09 15:08:12 +0000378} // end anonymous namespace.
Edwin Török36565e52009-06-30 17:10:35 +0000379
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000380//===----------------------------------------------------------------------===//
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000381// Specific target implementations.
382//===----------------------------------------------------------------------===//
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000383
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000384namespace {
385// PPC abstract base class
386class PPCTargetInfo : public TargetInfo {
387 static const Builtin::Info BuiltinInfo[];
388 static const char * const GCCRegNames[];
389 static const TargetInfo::GCCRegAlias GCCRegAliases[];
390
391public:
Eli Friedmand9389be2009-06-05 07:05:05 +0000392 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
393
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000394 virtual void getTargetBuiltins(const Builtin::Info *&Records,
395 unsigned &NumRecords) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000396 Records = BuiltinInfo;
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000397 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000398 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000399
Chris Lattner79682402009-03-20 15:52:06 +0000400 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000401 MacroBuilder &Builder) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000402
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000403 virtual const char *getVAListDeclaration() const {
Chris Lattnera07708f2008-10-27 01:11:29 +0000404 return "typedef char* __builtin_va_list;";
405 // This is the right definition for ABI/V4: System V.4/eabi.
406 /*return "typedef struct __va_list_tag {"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000407 " unsigned char gpr;"
408 " unsigned char fpr;"
409 " unsigned short reserved;"
410 " void* overflow_arg_area;"
411 " void* reg_save_area;"
Chris Lattnera07708f2008-10-27 01:11:29 +0000412 "} __builtin_va_list[1];";*/
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000413 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000414 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000415 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000416 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000417 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +0000418 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000419 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +0000420 switch (*Name) {
Anders Carlsson4ce42302007-11-27 04:11:28 +0000421 default: return false;
422 case 'O': // Zero
423 return true;
424 case 'b': // Base register
425 case 'f': // Floating point register
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000426 Info.setAllowsRegister();
Anders Carlsson4ce42302007-11-27 04:11:28 +0000427 return true;
428 }
429 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000430 virtual const char *getClobbers() const {
431 return "";
Anders Carlsson4ce42302007-11-27 04:11:28 +0000432 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000433};
Anders Carlsson4ce42302007-11-27 04:11:28 +0000434
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000435const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000436#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
437#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000438#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000439};
Anton Korobeynikove7772382009-05-03 13:42:53 +0000440
441
Chris Lattnerbef1d722009-03-02 22:27:17 +0000442/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
443/// #defines that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +0000444void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000445 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +0000446 // Target identification.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000447 Builder.defineMacro("__ppc__");
448 Builder.defineMacro("_ARCH_PPC");
449 Builder.defineMacro("__POWERPC__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000450 if (PointerWidth == 64) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000451 Builder.defineMacro("_ARCH_PPC64");
452 Builder.defineMacro("_LP64");
453 Builder.defineMacro("__LP64__");
454 Builder.defineMacro("__ppc64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000455 } else {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000456 Builder.defineMacro("__ppc__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000457 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000458
Chris Lattnerbef1d722009-03-02 22:27:17 +0000459 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000460 Builder.defineMacro("_BIG_ENDIAN");
461 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000462
Chris Lattnerbef1d722009-03-02 22:27:17 +0000463 // Subtarget options.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000464 Builder.defineMacro("__NATURAL_ALIGNMENT__");
465 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000466
Chris Lattnerbef1d722009-03-02 22:27:17 +0000467 // FIXME: Should be controlled by command line option.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000468 Builder.defineMacro("__LONG_DOUBLE_128__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000469
470 if (Opts.AltiVec) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000471 Builder.defineMacro("__VEC__", "10206");
472 Builder.defineMacro("__ALTIVEC__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000473 }
Chris Lattnerbef1d722009-03-02 22:27:17 +0000474}
475
Chris Lattner9fd73612008-04-21 18:56:49 +0000476
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000477const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattner14d2bb72009-09-16 05:05:27 +0000478 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
479 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
480 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
481 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
482 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
483 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
484 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
485 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000486 "mq", "lr", "ctr", "ap",
Chris Lattner14d2bb72009-09-16 05:05:27 +0000487 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000488 "xer",
Chris Lattner14d2bb72009-09-16 05:05:27 +0000489 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
490 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
491 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
492 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000493 "vrsave", "vscr",
494 "spe_acc", "spefscr",
495 "sfp"
496};
Chris Lattner4b009652007-07-25 00:24:17 +0000497
Anton Korobeynikove7772382009-05-03 13:42:53 +0000498void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000499 unsigned &NumNames) const {
500 Names = GCCRegNames;
501 NumNames = llvm::array_lengthof(GCCRegNames);
502}
Chris Lattner4b009652007-07-25 00:24:17 +0000503
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000504const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
505 // While some of these aliases do map to different registers
506 // they still share the same register name.
Daniel Dunbar40b774e2009-09-17 07:03:19 +0000507 { { "0" }, "r0" },
508 { { "1"}, "r1" },
509 { { "2" }, "r2" },
510 { { "3" }, "r3" },
511 { { "4" }, "r4" },
512 { { "5" }, "r5" },
513 { { "6" }, "r6" },
514 { { "7" }, "r7" },
515 { { "8" }, "r8" },
516 { { "9" }, "r9" },
517 { { "10" }, "r10" },
518 { { "11" }, "r11" },
519 { { "12" }, "r12" },
520 { { "13" }, "r13" },
521 { { "14" }, "r14" },
522 { { "15" }, "r15" },
523 { { "16" }, "r16" },
524 { { "17" }, "r17" },
525 { { "18" }, "r18" },
526 { { "19" }, "r19" },
527 { { "20" }, "r20" },
528 { { "21" }, "r21" },
529 { { "22" }, "r22" },
530 { { "23" }, "r23" },
531 { { "24" }, "r24" },
532 { { "25" }, "r25" },
533 { { "26" }, "r26" },
534 { { "27" }, "r27" },
535 { { "28" }, "r28" },
536 { { "29" }, "r29" },
537 { { "30" }, "r30" },
538 { { "31" }, "r31" },
539 { { "fr0" }, "f0" },
540 { { "fr1" }, "f1" },
541 { { "fr2" }, "f2" },
542 { { "fr3" }, "f3" },
543 { { "fr4" }, "f4" },
544 { { "fr5" }, "f5" },
545 { { "fr6" }, "f6" },
546 { { "fr7" }, "f7" },
547 { { "fr8" }, "f8" },
548 { { "fr9" }, "f9" },
Mike Stump369c21c2009-09-17 21:15:00 +0000549 { { "fr10" }, "f10" },
Daniel Dunbar40b774e2009-09-17 07:03:19 +0000550 { { "fr11" }, "f11" },
551 { { "fr12" }, "f12" },
552 { { "fr13" }, "f13" },
553 { { "fr14" }, "f14" },
554 { { "fr15" }, "f15" },
555 { { "fr16" }, "f16" },
556 { { "fr17" }, "f17" },
557 { { "fr18" }, "f18" },
558 { { "fr19" }, "f19" },
559 { { "fr20" }, "f20" },
560 { { "fr21" }, "f21" },
561 { { "fr22" }, "f22" },
562 { { "fr23" }, "f23" },
563 { { "fr24" }, "f24" },
564 { { "fr25" }, "f25" },
565 { { "fr26" }, "f26" },
566 { { "fr27" }, "f27" },
567 { { "fr28" }, "f28" },
568 { { "fr29" }, "f29" },
569 { { "fr30" }, "f30" },
570 { { "fr31" }, "f31" },
571 { { "cc" }, "cr0" },
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000572};
573
Anton Korobeynikove7772382009-05-03 13:42:53 +0000574void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000575 unsigned &NumAliases) const {
576 Aliases = GCCRegAliases;
577 NumAliases = llvm::array_lengthof(GCCRegAliases);
578}
579} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +0000580
581namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000582class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000583public:
Eli Friedman2b161652008-08-21 00:13:15 +0000584 PPC32TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
585 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 +0000586 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Eli Friedman2b161652008-08-21 00:13:15 +0000587 }
Chris Lattner4b009652007-07-25 00:24:17 +0000588};
589} // end anonymous namespace.
590
591namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000592class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000593public:
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000594 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +0000595 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman38e31802009-07-01 03:36:11 +0000596 IntMaxType = SignedLong;
597 UIntMaxType = UnsignedLong;
598 Int64Type = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +0000599 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 +0000600 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnere5fde952008-05-09 06:17:04 +0000601 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000602};
603} // end anonymous namespace.
604
Chris Lattner4b009652007-07-25 00:24:17 +0000605namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000606// Namespace for x86 abstract base class
607const Builtin::Info BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000608#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
609#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000610#include "clang/Basic/BuiltinsX86.def"
Eli Friedman872996c2008-08-20 02:34:37 +0000611};
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000612
Nuno Lopesad1010d2009-12-23 17:49:57 +0000613static const char* const GCCRegNames[] = {
Eli Friedman872996c2008-08-20 02:34:37 +0000614 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
615 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
616 "argp", "flags", "fspr", "dirflag", "frame",
617 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
618 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
619 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
620 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
621};
622
623const TargetInfo::GCCRegAlias GCCRegAliases[] = {
624 { { "al", "ah", "eax", "rax" }, "ax" },
625 { { "bl", "bh", "ebx", "rbx" }, "bx" },
626 { { "cl", "ch", "ecx", "rcx" }, "cx" },
627 { { "dl", "dh", "edx", "rdx" }, "dx" },
628 { { "esi", "rsi" }, "si" },
629 { { "edi", "rdi" }, "di" },
630 { { "esp", "rsp" }, "sp" },
631 { { "ebp", "rbp" }, "bp" },
632};
633
634// X86 target abstract base class; x86-32 and x86-64 are very close, so
635// most of the implementation can be shared.
636class X86TargetInfo : public TargetInfo {
Chris Lattner715fe4c2009-03-02 22:40:39 +0000637 enum X86SSEEnum {
638 NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
639 } SSELevel;
Eli Friedman872996c2008-08-20 02:34:37 +0000640public:
Anton Korobeynikove7772382009-05-03 13:42:53 +0000641 X86TargetInfo(const std::string& triple)
Daniel Dunbar07181d72009-05-06 03:16:41 +0000642 : TargetInfo(triple), SSELevel(NoMMXSSE) {
Eli Friedman872996c2008-08-20 02:34:37 +0000643 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner4b009652007-07-25 00:24:17 +0000644 }
645 virtual void getTargetBuiltins(const Builtin::Info *&Records,
646 unsigned &NumRecords) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000647 Records = BuiltinInfo;
648 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000649 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000650 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman872996c2008-08-20 02:34:37 +0000651 unsigned &NumNames) const {
652 Names = GCCRegNames;
653 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000654 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000655 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000656 unsigned &NumAliases) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000657 Aliases = GCCRegAliases;
658 NumAliases = llvm::array_lengthof(GCCRegAliases);
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000659 }
Anders Carlsson36834a72009-02-28 17:11:49 +0000660 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman872996c2008-08-20 02:34:37 +0000661 TargetInfo::ConstraintInfo &info) const;
662 virtual std::string convertConstraint(const char Constraint) const;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000663 virtual const char *getClobbers() const {
Eli Friedman872996c2008-08-20 02:34:37 +0000664 return "~{dirflag},~{fpsr},~{flags}";
665 }
Chris Lattner79682402009-03-20 15:52:06 +0000666 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000667 MacroBuilder &Builder) const;
Daniel Dunbar0838f962009-05-06 21:07:50 +0000668 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
669 const std::string &Name,
670 bool Enabled) const;
Mike Stump25cf7602009-09-09 15:08:12 +0000671 virtual void getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000672 llvm::StringMap<bool> &Features) const;
Daniel Dunbar4f7cd962009-12-19 03:30:57 +0000673 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Chris Lattner4b009652007-07-25 00:24:17 +0000674};
Chris Lattner7d6220c2009-03-02 22:20:04 +0000675
Mike Stump25cf7602009-09-09 15:08:12 +0000676void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000677 llvm::StringMap<bool> &Features) const {
Daniel Dunbar07181d72009-05-06 03:16:41 +0000678 // FIXME: This should not be here.
679 Features["3dnow"] = false;
680 Features["3dnowa"] = false;
681 Features["mmx"] = false;
682 Features["sse"] = false;
683 Features["sse2"] = false;
684 Features["sse3"] = false;
685 Features["ssse3"] = false;
686 Features["sse41"] = false;
687 Features["sse42"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000688
Daniel Dunbar07181d72009-05-06 03:16:41 +0000689 // LLVM does not currently recognize this.
690 // Features["sse4a"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000691
Daniel Dunbar07181d72009-05-06 03:16:41 +0000692 // FIXME: This *really* should not be here.
693
694 // X86_64 always has SSE2.
695 if (PointerWidth == 64)
696 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
697
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000698 if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
699 CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
700 ;
701 else if (CPU == "pentium-mmx" || CPU == "pentium2")
702 setFeatureEnabled(Features, "mmx", true);
703 else if (CPU == "pentium3")
704 setFeatureEnabled(Features, "sse", true);
705 else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64")
706 setFeatureEnabled(Features, "sse2", true);
707 else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona")
708 setFeatureEnabled(Features, "sse3", true);
709 else if (CPU == "core2")
710 setFeatureEnabled(Features, "ssse3", true);
711 else if (CPU == "penryn") {
712 setFeatureEnabled(Features, "sse4", true);
713 Features["sse42"] = false;
714 } else if (CPU == "atom")
715 setFeatureEnabled(Features, "sse3", true);
716 else if (CPU == "corei7")
717 setFeatureEnabled(Features, "sse4", true);
718 else if (CPU == "k6" || CPU == "winchip-c6")
719 setFeatureEnabled(Features, "mmx", true);
Mike Stump25cf7602009-09-09 15:08:12 +0000720 else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000721 CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
722 setFeatureEnabled(Features, "mmx", true);
723 setFeatureEnabled(Features, "3dnow", true);
724 } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
725 setFeatureEnabled(Features, "sse", true);
726 setFeatureEnabled(Features, "3dnowa", true);
727 } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
728 CPU == "athlon-fx") {
Mike Stump25cf7602009-09-09 15:08:12 +0000729 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000730 setFeatureEnabled(Features, "3dnowa", true);
731 } else if (CPU == "c3-2")
732 setFeatureEnabled(Features, "sse", true);
Daniel Dunbar07181d72009-05-06 03:16:41 +0000733}
734
Daniel Dunbar0838f962009-05-06 21:07:50 +0000735bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump25cf7602009-09-09 15:08:12 +0000736 const std::string &Name,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000737 bool Enabled) const {
738 // FIXME: This *really* should not be here.
739 if (!Features.count(Name) && Name != "sse4")
740 return false;
741
742 if (Enabled) {
743 if (Name == "mmx")
744 Features["mmx"] = true;
745 else if (Name == "sse")
746 Features["mmx"] = Features["sse"] = true;
747 else if (Name == "sse2")
748 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
749 else if (Name == "sse3")
Mike Stump25cf7602009-09-09 15:08:12 +0000750 Features["mmx"] = Features["sse"] = Features["sse2"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000751 Features["sse3"] = true;
752 else if (Name == "ssse3")
Mike Stump25cf7602009-09-09 15:08:12 +0000753 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000754 Features["ssse3"] = true;
755 else if (Name == "sse4")
Mike Stump25cf7602009-09-09 15:08:12 +0000756 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000757 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
758 else if (Name == "3dnow")
759 Features["3dnowa"] = true;
760 else if (Name == "3dnowa")
761 Features["3dnow"] = Features["3dnowa"] = true;
762 } else {
763 if (Name == "mmx")
Mike Stump25cf7602009-09-09 15:08:12 +0000764 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000765 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
766 else if (Name == "sse")
Mike Stump25cf7602009-09-09 15:08:12 +0000767 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000768 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
769 else if (Name == "sse2")
Mike Stump25cf7602009-09-09 15:08:12 +0000770 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000771 Features["sse41"] = Features["sse42"] = false;
772 else if (Name == "sse3")
Mike Stump25cf7602009-09-09 15:08:12 +0000773 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000774 Features["sse42"] = false;
775 else if (Name == "ssse3")
776 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
777 else if (Name == "sse4")
778 Features["sse41"] = Features["sse42"] = false;
779 else if (Name == "3dnow")
780 Features["3dnow"] = Features["3dnowa"] = false;
781 else if (Name == "3dnowa")
782 Features["3dnowa"] = false;
783 }
784
785 return true;
786}
787
Daniel Dunbar07181d72009-05-06 03:16:41 +0000788/// HandleTargetOptions - Perform initialization based on the user
789/// configured set of features.
Daniel Dunbar4f7cd962009-12-19 03:30:57 +0000790void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar8dd8f262009-11-11 09:38:56 +0000791 // Remember the maximum enabled sselevel.
792 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
793 // Ignore disabled features.
794 if (Features[i][0] == '-')
795 continue;
796
797 assert(Features[i][0] == '+' && "Invalid target feature!");
798 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
799 .Case("sse42", SSE42)
800 .Case("sse41", SSE41)
801 .Case("ssse3", SSSE3)
802 .Case("sse2", SSE2)
803 .Case("sse", SSE1)
804 .Case("mmx", MMX)
805 .Default(NoMMXSSE);
806 SSELevel = std::max(SSELevel, Level);
807 }
Chris Lattner7d6220c2009-03-02 22:20:04 +0000808}
Chris Lattnerbef1d722009-03-02 22:27:17 +0000809
810/// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
811/// that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +0000812void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000813 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +0000814 // Target identification.
815 if (PointerWidth == 64) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000816 Builder.defineMacro("_LP64");
817 Builder.defineMacro("__LP64__");
818 Builder.defineMacro("__amd64__");
819 Builder.defineMacro("__amd64");
820 Builder.defineMacro("__x86_64");
821 Builder.defineMacro("__x86_64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000822 } else {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000823 DefineStd(Builder, "i386", Opts);
Chris Lattnerbef1d722009-03-02 22:27:17 +0000824 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000825
Chris Lattnerbef1d722009-03-02 22:27:17 +0000826 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000827 Builder.defineMacro("__LITTLE_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000828
Chris Lattnerbef1d722009-03-02 22:27:17 +0000829 // Subtarget options.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000830 Builder.defineMacro("__nocona");
831 Builder.defineMacro("__nocona__");
832 Builder.defineMacro("__tune_nocona__");
833 Builder.defineMacro("__REGISTER_PREFIX__", "");
Chris Lattner715fe4c2009-03-02 22:40:39 +0000834
Chris Lattner25ac1c12009-04-19 17:32:33 +0000835 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
836 // functions in glibc header files that use FP Stack inline asm which the
837 // backend can't deal with (PR879).
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000838 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000839
Chris Lattner715fe4c2009-03-02 22:40:39 +0000840 // Each case falls through to the previous one here.
841 switch (SSELevel) {
842 case SSE42:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000843 Builder.defineMacro("__SSE4_2__");
Chris Lattner715fe4c2009-03-02 22:40:39 +0000844 case SSE41:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000845 Builder.defineMacro("__SSE4_1__");
Chris Lattner715fe4c2009-03-02 22:40:39 +0000846 case SSSE3:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000847 Builder.defineMacro("__SSSE3__");
Chris Lattner715fe4c2009-03-02 22:40:39 +0000848 case SSE3:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000849 Builder.defineMacro("__SSE3__");
Chris Lattner715fe4c2009-03-02 22:40:39 +0000850 case SSE2:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000851 Builder.defineMacro("__SSE2__");
852 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner715fe4c2009-03-02 22:40:39 +0000853 case SSE1:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000854 Builder.defineMacro("__SSE__");
855 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Chris Lattner715fe4c2009-03-02 22:40:39 +0000856 case MMX:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000857 Builder.defineMacro("__MMX__");
Chris Lattner715fe4c2009-03-02 22:40:39 +0000858 case NoMMXSSE:
859 break;
860 }
Chris Lattnerbef1d722009-03-02 22:27:17 +0000861}
Anton Korobeynikove7772382009-05-03 13:42:53 +0000862
863
Eli Friedman872996c2008-08-20 02:34:37 +0000864bool
Anders Carlsson36834a72009-02-28 17:11:49 +0000865X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000866 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +0000867 switch (*Name) {
Eli Friedman872996c2008-08-20 02:34:37 +0000868 default: return false;
869 case 'a': // eax.
870 case 'b': // ebx.
871 case 'c': // ecx.
872 case 'd': // edx.
873 case 'S': // esi.
874 case 'D': // edi.
875 case 'A': // edx:eax.
876 case 't': // top of floating point stack.
877 case 'u': // second from top of floating point stack.
878 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson2285e622008-10-06 00:41:45 +0000879 case 'y': // Any MMX register.
Anders Carlssond2459f92008-10-06 19:17:39 +0000880 case 'x': // Any SSE register.
Eli Friedman872996c2008-08-20 02:34:37 +0000881 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Anton Korobeynikove7772382009-05-03 13:42:53 +0000882 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +0000883 // x86_64 instructions.
Anton Korobeynikove7772382009-05-03 13:42:53 +0000884 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +0000885 // x86_64 instructions.
Eli Friedman872996c2008-08-20 02:34:37 +0000886 case 'N': // unsigned 8-bit integer constant for use with in and out
887 // instructions.
Eli Friedman7e17aed2009-06-08 20:45:44 +0000888 case 'R': // "legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000889 Info.setAllowsRegister();
Eli Friedman872996c2008-08-20 02:34:37 +0000890 return true;
891 }
892}
893
894std::string
895X86TargetInfo::convertConstraint(const char Constraint) const {
896 switch (Constraint) {
897 case 'a': return std::string("{ax}");
898 case 'b': return std::string("{bx}");
899 case 'c': return std::string("{cx}");
900 case 'd': return std::string("{dx}");
901 case 'S': return std::string("{si}");
902 case 'D': return std::string("{di}");
903 case 't': // top of floating point stack.
904 return std::string("{st}");
905 case 'u': // second from top of floating point stack.
906 return std::string("{st(1)}"); // second from top of floating point stack.
907 default:
908 return std::string(1, Constraint);
909 }
910}
Eli Friedman872996c2008-08-20 02:34:37 +0000911} // end anonymous namespace
Chris Lattner4b009652007-07-25 00:24:17 +0000912
913namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000914// X86-32 generic target
915class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000916public:
Eli Friedman872996c2008-08-20 02:34:37 +0000917 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
918 DoubleAlign = LongLongAlign = 32;
919 LongDoubleWidth = 96;
920 LongDoubleAlign = 32;
Eli Friedman2b161652008-08-21 00:13:15 +0000921 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
922 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +0000923 "a0:0:64-f80:32:32-n8:16:32";
Eli Friedman04ede302009-03-29 20:31:09 +0000924 SizeType = UnsignedInt;
925 PtrDiffType = SignedInt;
926 IntPtrType = SignedInt;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +0000927 RegParmMax = 3;
Eli Friedman872996c2008-08-20 02:34:37 +0000928 }
929 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000930 return "typedef char* __builtin_va_list;";
Eli Friedman872996c2008-08-20 02:34:37 +0000931 }
Chris Lattneraa339182009-09-23 06:06:36 +0000932
933 int getEHDataRegisterNumber(unsigned RegNo) const {
934 if (RegNo == 0) return 0;
935 if (RegNo == 1) return 2;
936 return -1;
937 }
Eli Friedman872996c2008-08-20 02:34:37 +0000938};
939} // end anonymous namespace
940
941namespace {
Eli Friedman1c79f4b2009-07-05 18:47:56 +0000942class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
943public:
944 OpenBSDI386TargetInfo(const std::string& triple) :
945 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
946 SizeType = UnsignedLong;
947 IntPtrType = SignedLong;
Eli Friedman96ada022009-07-05 22:31:18 +0000948 PtrDiffType = SignedLong;
Eli Friedman1c79f4b2009-07-05 18:47:56 +0000949 }
950};
951} // end anonymous namespace
952
953namespace {
Edwin Török36565e52009-06-30 17:10:35 +0000954class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman872996c2008-08-20 02:34:37 +0000955public:
Edwin Török36565e52009-06-30 17:10:35 +0000956 DarwinI386TargetInfo(const std::string& triple) :
957 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman872996c2008-08-20 02:34:37 +0000958 LongDoubleWidth = 128;
959 LongDoubleAlign = 128;
Eli Friedman04ede302009-03-29 20:31:09 +0000960 SizeType = UnsignedLong;
961 IntPtrType = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +0000962 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
963 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +0000964 "a0:0:64-f80:128:128-n8:16:32";
Edwin Török2d98f9f2009-06-30 17:00:25 +0000965 }
966
Eli Friedman872996c2008-08-20 02:34:37 +0000967};
Daniel Dunbar64c77a12009-06-29 20:52:51 +0000968} // end anonymous namespace
969
970namespace {
Eli Friedman23cb7912008-08-21 01:40:19 +0000971// x86-32 Windows target
972class WindowsX86_32TargetInfo : public X86_32TargetInfo {
973public:
974 WindowsX86_32TargetInfo(const std::string& triple)
975 : X86_32TargetInfo(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +0000976 TLSSupported = false;
Chris Lattnera8a69e12009-06-24 17:12:15 +0000977 WCharType = UnsignedShort;
Eli Friedmanb28055e2009-06-08 21:16:17 +0000978 DoubleAlign = LongLongAlign = 64;
979 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 +0000980 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
981 "v128:128:128-a0:0:64-f80:32:32-n8:16:32";
Eli Friedman23cb7912008-08-21 01:40:19 +0000982 }
Chris Lattner79682402009-03-20 15:52:06 +0000983 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000984 MacroBuilder &Builder) const {
985 X86_32TargetInfo::getTargetDefines(Opts, Builder);
Eli Friedman23cb7912008-08-21 01:40:19 +0000986 // This list is based off of the the list of things MingW defines
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000987 Builder.defineMacro("_WIN32");
988 DefineStd(Builder, "WIN32", Opts);
989 DefineStd(Builder, "WINNT", Opts);
990 Builder.defineMacro("_X86_");
Eli Friedman23cb7912008-08-21 01:40:19 +0000991 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +0000992};
993} // end anonymous namespace
Eli Friedman6b6ca942009-06-08 06:11:14 +0000994
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +0000995namespace {
996
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +0000997// x86-32 Windows Visual Studio target
998class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
999public:
1000 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
1001 : WindowsX86_32TargetInfo(triple) {
1002 }
1003 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001004 MacroBuilder &Builder) const {
1005 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001006 // The value of the following reflects processor type.
1007 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
1008 // We lost the original triple, so we use the default.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001009 Builder.defineMacro("_M_IX86", "600");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001010 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001011};
1012} // end anonymous namespace
1013
1014namespace {
1015// x86-32 MinGW target
1016class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
1017public:
1018 MinGWX86_32TargetInfo(const std::string& triple)
1019 : WindowsX86_32TargetInfo(triple) {
1020 }
1021 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001022 MacroBuilder &Builder) const {
1023 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
1024 Builder.defineMacro("__MSVCRT__");
1025 Builder.defineMacro("__MINGW32__");
1026 Builder.defineMacro("__declspec", "__declspec");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001027 }
1028};
1029} // end anonymous namespace
1030
1031namespace {
1032// x86-32 Cygwin target
1033class CygwinX86_32TargetInfo : public X86_32TargetInfo {
1034public:
1035 CygwinX86_32TargetInfo(const std::string& triple)
1036 : X86_32TargetInfo(triple) {
1037 TLSSupported = false;
1038 WCharType = UnsignedShort;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001039 DoubleAlign = LongLongAlign = 64;
1040 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1041 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001042 "a0:0:64-f80:32:32-n8:16:32";
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001043 }
1044 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001045 MacroBuilder &Builder) const {
1046 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1047 Builder.defineMacro("__CYGWIN__");
1048 Builder.defineMacro("__CYGWIN32__");
1049 DefineStd(Builder, "unix", Opts);
Eli Friedman6b6ca942009-06-08 06:11:14 +00001050 }
Eli Friedman23cb7912008-08-21 01:40:19 +00001051};
1052} // end anonymous namespace
1053
1054namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001055// x86-64 generic target
1056class X86_64TargetInfo : public X86TargetInfo {
1057public:
Chris Lattner79682402009-03-20 15:52:06 +00001058 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +00001059 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001060 LongDoubleWidth = 128;
1061 LongDoubleAlign = 128;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00001062 IntMaxType = SignedLong;
1063 UIntMaxType = UnsignedLong;
Eli Friedman38e31802009-07-01 03:36:11 +00001064 Int64Type = SignedLong;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +00001065 RegParmMax = 6;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00001066
Eli Friedman2b161652008-08-21 00:13:15 +00001067 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1068 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001069 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64";
Chris Lattner4b009652007-07-25 00:24:17 +00001070 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +00001071 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001072 return "typedef struct __va_list_tag {"
1073 " unsigned gp_offset;"
1074 " unsigned fp_offset;"
1075 " void* overflow_arg_area;"
1076 " void* reg_save_area;"
Eli Friedman3c79eee2009-07-03 00:45:06 +00001077 "} __va_list_tag;"
1078 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson7dd1c952007-11-24 23:38:12 +00001079 }
Chris Lattneraa339182009-09-23 06:06:36 +00001080
1081 int getEHDataRegisterNumber(unsigned RegNo) const {
1082 if (RegNo == 0) return 0;
1083 if (RegNo == 1) return 1;
1084 return -1;
1085 }
Eli Friedman872996c2008-08-20 02:34:37 +00001086};
1087} // end anonymous namespace
1088
1089namespace {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001090// x86-64 Windows target
1091class WindowsX86_64TargetInfo : public X86_64TargetInfo {
1092public:
1093 WindowsX86_64TargetInfo(const std::string& triple)
1094 : X86_64TargetInfo(triple) {
1095 TLSSupported = false;
1096 WCharType = UnsignedShort;
Mike Stump4da7a162009-10-08 23:00:00 +00001097 LongWidth = LongAlign = 32;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001098 DoubleAlign = LongLongAlign = 64;
1099 }
1100 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001101 MacroBuilder &Builder) const {
1102 X86_64TargetInfo::getTargetDefines(Opts, Builder);
1103 Builder.defineMacro("_WIN64");
1104 DefineStd(Builder, "WIN64", Opts);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001105 }
1106};
1107} // end anonymous namespace
1108
1109namespace {
1110// x86-64 Windows Visual Studio target
1111class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
1112public:
1113 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
1114 : WindowsX86_64TargetInfo(triple) {
1115 }
1116 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001117 MacroBuilder &Builder) const {
1118 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1119 Builder.defineMacro("_M_X64");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001120 }
1121 virtual const char *getVAListDeclaration() const {
1122 return "typedef char* va_list;";
1123 }
1124};
1125} // end anonymous namespace
1126
1127namespace {
1128// x86-64 MinGW target
1129class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
1130public:
1131 MinGWX86_64TargetInfo(const std::string& triple)
1132 : WindowsX86_64TargetInfo(triple) {
1133 }
1134 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001135 MacroBuilder &Builder) const {
1136 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1137 Builder.defineMacro("__MSVCRT__");
1138 Builder.defineMacro("__MINGW64__");
1139 Builder.defineMacro("__declspec");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001140 }
1141};
1142} // end anonymous namespace
1143
1144namespace {
Eli Friedman38e31802009-07-01 03:36:11 +00001145class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
1146public:
Mike Stump25cf7602009-09-09 15:08:12 +00001147 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman38e31802009-07-01 03:36:11 +00001148 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
1149 Int64Type = SignedLongLong;
1150 }
1151};
1152} // end anonymous namespace
1153
1154namespace {
Eli Friedman96ada022009-07-05 22:31:18 +00001155class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
1156public:
Mike Stump25cf7602009-09-09 15:08:12 +00001157 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman96ada022009-07-05 22:31:18 +00001158 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
1159 IntMaxType = SignedLongLong;
1160 UIntMaxType = UnsignedLongLong;
1161 Int64Type = SignedLongLong;
1162 }
1163};
1164} // end anonymous namespace
1165
1166namespace {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001167class ARMTargetInfo : public TargetInfo {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001168 // Possible FPU choices.
1169 enum FPUMode {
1170 NoFPU,
1171 VFP2FPU,
1172 VFP3FPU,
1173 NeonFPU
1174 };
1175
1176 static bool FPUModeIsVFP(FPUMode Mode) {
1177 return Mode >= VFP2FPU && Mode <= NeonFPU;
1178 }
1179
1180 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1181 static const char * const GCCRegNames[];
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001182
Daniel Dunbar33b40752009-12-18 18:42:37 +00001183 std::string ABI, CPU;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001184
1185 unsigned FPU : 3;
1186
Daniel Dunbar48075d82009-12-19 04:15:38 +00001187 unsigned IsThumb : 1;
1188
1189 // Initialized via features.
1190 unsigned SoftFloat : 1;
1191 unsigned SoftFloatABI : 1;
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001192
Chris Lattner9fd73612008-04-21 18:56:49 +00001193public:
Daniel Dunbarf0156562009-09-17 16:21:10 +00001194 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbar33b40752009-12-18 18:42:37 +00001195 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001196 {
Daniel Dunbarb9531632009-09-14 00:02:24 +00001197 SizeType = UnsignedInt;
1198 PtrDiffType = SignedInt;
Daniel Dunbarf0156562009-09-17 16:21:10 +00001199
Daniel Dunbar33b40752009-12-18 18:42:37 +00001200 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0a542ca2009-12-18 19:57:13 +00001201 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001202 if (IsThumb) {
1203 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1204 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001205 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001206 } else {
1207 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1208 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001209 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001210 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001211 }
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001212 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbarb9531632009-09-14 00:02:24 +00001213 virtual bool setABI(const std::string &Name) {
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001214 ABI = Name;
1215
Daniel Dunbarb9531632009-09-14 00:02:24 +00001216 // The defaults (above) are for AAPCS, check if we need to change them.
1217 //
1218 // FIXME: We need support for -meabi... we could just mangle it into the
1219 // name.
1220 if (Name == "apcs-gnu") {
1221 DoubleAlign = LongLongAlign = 32;
1222 SizeType = UnsignedLong;
1223
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001224 if (IsThumb) {
1225 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1226 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001227 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001228 } else {
1229 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1230 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001231 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001232 }
1233
Daniel Dunbarb9531632009-09-14 00:02:24 +00001234 // FIXME: Override "preferred align" for double and long long.
1235 } else if (Name == "aapcs") {
1236 // FIXME: Enumerated types are variable width in straight AAPCS.
1237 } else if (Name == "aapcs-linux") {
1238 ;
1239 } else
1240 return false;
1241
1242 return true;
1243 }
Daniel Dunbar48075d82009-12-19 04:15:38 +00001244
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001245 void getDefaultFeatures(const std::string &CPU,
1246 llvm::StringMap<bool> &Features) const {
1247 // FIXME: This should not be here.
1248 Features["vfp2"] = false;
1249 Features["vfp3"] = false;
1250 Features["neon"] = false;
1251
1252 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
1253 Features["vfp2"] = true;
1254 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
1255 Features["neon"] = true;
1256 }
1257
Daniel Dunbar48075d82009-12-19 04:15:38 +00001258 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1259 const std::string &Name,
1260 bool Enabled) const {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001261 if (Name == "soft-float" || Name == "soft-float-abi") {
1262 Features[Name] = Enabled;
1263 } else if (Name == "vfp2" || Name == "vfp3" || Name == "neon") {
1264 // These effectively are a single option, reset them when any is enabled.
1265 if (Enabled)
1266 Features["vfp2"] = Features["vfp3"] = Features["neon"] = false;
1267 Features[Name] = Enabled;
1268 } else
Daniel Dunbar48075d82009-12-19 04:15:38 +00001269 return false;
1270
Daniel Dunbar48075d82009-12-19 04:15:38 +00001271 return true;
1272 }
1273
1274 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001275 FPU = NoFPU;
Daniel Dunbar48075d82009-12-19 04:15:38 +00001276 SoftFloat = SoftFloatABI = false;
1277 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
1278 if (Features[i] == "+soft-float")
1279 SoftFloat = true;
1280 else if (Features[i] == "+soft-float-abi")
1281 SoftFloatABI = true;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001282 else if (Features[i] == "+vfp2")
1283 FPU = VFP2FPU;
1284 else if (Features[i] == "+vfp3")
1285 FPU = VFP3FPU;
1286 else if (Features[i] == "+neon")
1287 FPU = NeonFPU;
Daniel Dunbar48075d82009-12-19 04:15:38 +00001288 }
1289
1290 // Remove front-end specific options which the backend handles differently.
1291 std::vector<std::string>::iterator it;
1292 it = std::find(Features.begin(), Features.end(), "+soft-float");
1293 if (it != Features.end())
1294 Features.erase(it);
1295 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
1296 if (it != Features.end())
1297 Features.erase(it);
1298 }
1299
Daniel Dunbar33b40752009-12-18 18:42:37 +00001300 static const char *getCPUDefineSuffix(llvm::StringRef Name) {
1301 return llvm::StringSwitch<const char*>(Name)
1302 .Cases("arm8", "arm810", "4")
1303 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
1304 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
1305 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
1306 .Case("ep9312", "4T")
1307 .Cases("arm10tdmi", "arm1020t", "5T")
1308 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
1309 .Case("arm926ej-s", "5TEJ")
1310 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
1311 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001312 .Case("arm1136j-s", "6J")
Daniel Dunbar33b40752009-12-18 18:42:37 +00001313 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001314 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbar33b40752009-12-18 18:42:37 +00001315 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
1316 .Cases("cortex-a8", "cortex-a9", "7A")
1317 .Default(0);
1318 }
1319 virtual bool setCPU(const std::string &Name) {
1320 if (!getCPUDefineSuffix(Name))
1321 return false;
1322
1323 CPU = Name;
1324 return true;
1325 }
Chris Lattner79682402009-03-20 15:52:06 +00001326 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001327 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00001328 // Target identification.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001329 Builder.defineMacro("__arm");
1330 Builder.defineMacro("__arm__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001331
Chris Lattnerbef1d722009-03-02 22:27:17 +00001332 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001333 Builder.defineMacro("__ARMEL__");
1334 Builder.defineMacro("__LITTLE_ENDIAN__");
1335 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001336
1337 llvm::StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001338 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001339
Mike Stumpf90a29f2009-04-08 02:07:04 +00001340 // Subtarget options.
Daniel Dunbarf0156562009-09-17 16:21:10 +00001341
Daniel Dunbar33b40752009-12-18 18:42:37 +00001342 // FIXME: It's more complicated than this and we don't really support
1343 // interworking.
1344 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001345 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001346
Daniel Dunbar33b40752009-12-18 18:42:37 +00001347 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001348 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001349
Daniel Dunbar48075d82009-12-19 04:15:38 +00001350 if (SoftFloat)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001351 Builder.defineMacro("__SOFTFP__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001352
1353 if (CPU == "xscale")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001354 Builder.defineMacro("__XSCALE__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001355
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001356 bool IsThumb2 = IsThumb && (CPUArch == "6T2" || CPUArch.startswith("7"));
Daniel Dunbarf0156562009-09-17 16:21:10 +00001357 if (IsThumb) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001358 Builder.defineMacro("__THUMBEL__");
1359 Builder.defineMacro("__thumb__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001360 if (IsThumb2)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001361 Builder.defineMacro("__thumb2__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001362 }
1363
1364 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001365 Builder.defineMacro("__APCS_32__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001366
1367 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001368 Builder.defineMacro("__VFP_FP__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001369
1370 // This only gets set when Neon instructions are actually available, unlike
1371 // the VFP define, hence the soft float and arch check. This is subtly
1372 // different from gcc, we follow the intent which was that it should be set
1373 // when Neon instructions are actually available.
1374 if (FPU == NeonFPU && !SoftFloat && IsThumb2)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001375 Builder.defineMacro("__ARM_NEON__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001376
Daniel Dunbar0a542ca2009-12-18 19:57:13 +00001377 if (getTriple().getOS() == llvm::Triple::Darwin)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001378 Builder.defineMacro("__USING_SJLJ_EXCEPTIONS__");
Chris Lattner9fd73612008-04-21 18:56:49 +00001379 }
1380 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1381 unsigned &NumRecords) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001382 // FIXME: Implement.
1383 Records = 0;
Chris Lattner9fd73612008-04-21 18:56:49 +00001384 NumRecords = 0;
1385 }
1386 virtual const char *getVAListDeclaration() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001387 return "typedef char* __builtin_va_list;";
Chris Lattner9fd73612008-04-21 18:56:49 +00001388 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001389 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001390 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001391 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001392 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001393 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001394 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001395 // FIXME: Check if this is complete
Anders Carlsson36834a72009-02-28 17:11:49 +00001396 switch (*Name) {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001397 default:
Nate Begeman222823a2008-04-22 05:03:19 +00001398 case 'l': // r0-r7
1399 case 'h': // r8-r15
1400 case 'w': // VFP Floating point register single precision
1401 case 'P': // VFP Floating point register double precision
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001402 Info.setAllowsRegister();
Nate Begeman222823a2008-04-22 05:03:19 +00001403 return true;
1404 }
Chris Lattner9fd73612008-04-21 18:56:49 +00001405 return false;
1406 }
1407 virtual const char *getClobbers() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001408 // FIXME: Is this really right?
Chris Lattner9fd73612008-04-21 18:56:49 +00001409 return "";
1410 }
1411};
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001412
1413const char * const ARMTargetInfo::GCCRegNames[] = {
1414 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1415 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1416};
1417
1418void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
1419 unsigned &NumNames) const {
1420 Names = GCCRegNames;
1421 NumNames = llvm::array_lengthof(GCCRegNames);
1422}
1423
1424const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
1425
1426 { { "a1" }, "r0" },
1427 { { "a2" }, "r1" },
1428 { { "a3" }, "r2" },
1429 { { "a4" }, "r3" },
1430 { { "v1" }, "r4" },
1431 { { "v2" }, "r5" },
1432 { { "v3" }, "r6" },
1433 { { "v4" }, "r7" },
1434 { { "v5" }, "r8" },
1435 { { "v6", "rfp" }, "r9" },
1436 { { "sl" }, "r10" },
1437 { { "fp" }, "r11" },
1438 { { "ip" }, "r12" },
1439 { { "sp" }, "r13" },
1440 { { "lr" }, "r14" },
1441 { { "pc" }, "r15" },
1442};
1443
1444void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1445 unsigned &NumAliases) const {
1446 Aliases = GCCRegAliases;
1447 NumAliases = llvm::array_lengthof(GCCRegAliases);
1448}
Chris Lattner9fd73612008-04-21 18:56:49 +00001449} // end anonymous namespace.
1450
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001451
1452namespace {
Mike Stump25cf7602009-09-09 15:08:12 +00001453class DarwinARMTargetInfo :
Edwin Török36565e52009-06-30 17:10:35 +00001454 public DarwinTargetInfo<ARMTargetInfo> {
1455protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +00001456 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001457 MacroBuilder &Builder) const {
Daniel Dunbareab96a22010-01-26 01:44:04 +00001458 getDarwinDefines(Builder, Opts, Triple);
Eli Friedman8f575172009-04-19 21:38:35 +00001459 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001460
Edwin Török36565e52009-06-30 17:10:35 +00001461public:
Mike Stump25cf7602009-09-09 15:08:12 +00001462 DarwinARMTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +00001463 : DarwinTargetInfo<ARMTargetInfo>(triple) {}
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001464};
1465} // end anonymous namespace.
1466
Chris Lattner4b009652007-07-25 00:24:17 +00001467namespace {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001468class SparcV8TargetInfo : public TargetInfo {
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001469 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1470 static const char * const GCCRegNames[];
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001471public:
Eli Friedmanff158dd2008-08-20 07:28:14 +00001472 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
1473 // FIXME: Support Sparc quad-precision long double?
Eli Friedman2b161652008-08-21 00:13:15 +00001474 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 +00001475 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedmanff158dd2008-08-20 07:28:14 +00001476 }
Chris Lattner79682402009-03-20 15:52:06 +00001477 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001478 MacroBuilder &Builder) const {
1479 DefineStd(Builder, "sparc", Opts);
1480 Builder.defineMacro("__sparcv8");
1481 Builder.defineMacro("__REGISTER_PREFIX__", "");
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001482 }
1483 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1484 unsigned &NumRecords) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001485 // FIXME: Implement!
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001486 }
1487 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001488 return "typedef void* __builtin_va_list;";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001489 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001490 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001491 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001492 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001493 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001494 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001495 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001496 // FIXME: Implement!
1497 return false;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001498 }
1499 virtual const char *getClobbers() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001500 // FIXME: Implement!
1501 return "";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001502 }
1503};
1504
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001505const char * const SparcV8TargetInfo::GCCRegNames[] = {
1506 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1507 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1508 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1509 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
1510};
1511
Anton Korobeynikove7772382009-05-03 13:42:53 +00001512void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001513 unsigned &NumNames) const {
1514 Names = GCCRegNames;
1515 NumNames = llvm::array_lengthof(GCCRegNames);
1516}
1517
1518const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikove7772382009-05-03 13:42:53 +00001519 { { "g0" }, "r0" },
1520 { { "g1" }, "r1" },
1521 { { "g2" }, "r2" },
1522 { { "g3" }, "r3" },
1523 { { "g4" }, "r4" },
1524 { { "g5" }, "r5" },
1525 { { "g6" }, "r6" },
1526 { { "g7" }, "r7" },
1527 { { "o0" }, "r8" },
1528 { { "o1" }, "r9" },
1529 { { "o2" }, "r10" },
1530 { { "o3" }, "r11" },
1531 { { "o4" }, "r12" },
1532 { { "o5" }, "r13" },
1533 { { "o6", "sp" }, "r14" },
1534 { { "o7" }, "r15" },
1535 { { "l0" }, "r16" },
1536 { { "l1" }, "r17" },
1537 { { "l2" }, "r18" },
1538 { { "l3" }, "r19" },
1539 { { "l4" }, "r20" },
1540 { { "l5" }, "r21" },
1541 { { "l6" }, "r22" },
1542 { { "l7" }, "r23" },
1543 { { "i0" }, "r24" },
1544 { { "i1" }, "r25" },
1545 { { "i2" }, "r26" },
1546 { { "i3" }, "r27" },
1547 { { "i4" }, "r28" },
1548 { { "i5" }, "r29" },
1549 { { "i6", "fp" }, "r30" },
1550 { { "i7" }, "r31" },
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001551};
1552
Anton Korobeynikove7772382009-05-03 13:42:53 +00001553void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001554 unsigned &NumAliases) const {
1555 Aliases = GCCRegAliases;
1556 NumAliases = llvm::array_lengthof(GCCRegAliases);
1557}
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001558} // end anonymous namespace.
1559
Eli Friedmanff158dd2008-08-20 07:28:14 +00001560namespace {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00001561class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
1562public:
1563 AuroraUXSparcV8TargetInfo(const std::string& triple) :
1564 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
1565 SizeType = UnsignedInt;
1566 PtrDiffType = SignedInt;
1567 }
1568};
Edwin Török36565e52009-06-30 17:10:35 +00001569class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001570public:
1571 SolarisSparcV8TargetInfo(const std::string& triple) :
Edwin Török36565e52009-06-30 17:10:35 +00001572 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedman7cca0982008-11-02 02:43:55 +00001573 SizeType = UnsignedInt;
1574 PtrDiffType = SignedInt;
Eli Friedmanff158dd2008-08-20 07:28:14 +00001575 }
1576};
1577} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +00001578
Chris Lattner85970f32008-05-08 05:58:21 +00001579namespace {
1580 class PIC16TargetInfo : public TargetInfo{
1581 public:
1582 PIC16TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +00001583 TLSSupported = false;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001584 IntWidth = 16;
1585 LongWidth = LongLongWidth = 32;
1586 PointerWidth = 16;
1587 IntAlign = 8;
1588 LongAlign = LongLongAlign = 8;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001589 PointerAlign = 8;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001590 SizeType = UnsignedInt;
1591 IntMaxType = SignedLong;
1592 UIntMaxType = UnsignedLong;
Chris Lattnerd9ef7242009-02-13 22:28:55 +00001593 IntPtrType = SignedShort;
Eli Friedman7cca0982008-11-02 02:43:55 +00001594 PtrDiffType = SignedInt;
Edward O'Callaghan14a70a32009-11-21 00:49:54 +00001595 SigAtomicType = SignedLong;
Sanjiv Guptaae8f1e82009-06-02 04:43:46 +00001596 FloatWidth = 32;
1597 FloatAlign = 32;
1598 DoubleWidth = 32;
1599 DoubleAlign = 32;
1600 LongDoubleWidth = 32;
1601 LongDoubleAlign = 32;
1602 FloatFormat = &llvm::APFloat::IEEEsingle;
1603 DoubleFormat = &llvm::APFloat::IEEEsingle;
1604 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner2e17d912009-11-07 18:59:41 +00001605 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 +00001606
Chris Lattner85970f32008-05-08 05:58:21 +00001607 }
Chris Lattner727b3c42008-05-09 06:08:39 +00001608 virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }
1609 virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }
Chris Lattner79682402009-03-20 15:52:06 +00001610 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001611 MacroBuilder &Builder) const {
1612 Builder.defineMacro("__pic16");
1613 Builder.defineMacro("rom", "__attribute__((address_space(1)))");
1614 Builder.defineMacro("ram", "__attribute__((address_space(0)))");
1615 Builder.defineMacro("_section(SectName)",
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00001616 "__attribute__((section(SectName)))");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001617 Builder.defineMacro("near",
Sanjiv Gupta09e95f02009-10-24 18:08:20 +00001618 "__attribute__((section(\"Address=NEAR\")))");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001619 Builder.defineMacro("_address(Addr)",
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00001620 "__attribute__((section(\"Address=\"#Addr)))");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001621 Builder.defineMacro("_CONFIG(conf)", "asm(\"CONFIG \"#conf)");
1622 Builder.defineMacro("_interrupt",
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00001623 "__attribute__((section(\"interrupt=0x4\"))) \
1624 __attribute__((used))");
Chris Lattner85970f32008-05-08 05:58:21 +00001625 }
1626 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1627 unsigned &NumRecords) const {}
Mike Stump25cf7602009-09-09 15:08:12 +00001628 virtual const char *getVAListDeclaration() const {
Daniel Dunbar2e967de2009-08-24 09:54:37 +00001629 return "";
1630 }
1631 virtual const char *getClobbers() const {
1632 return "";
1633 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001634 virtual void getGCCRegNames(const char * const *&Names,
1635 unsigned &NumNames) const {}
1636 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner85970f32008-05-08 05:58:21 +00001637 TargetInfo::ConstraintInfo &info) const {
1638 return true;
1639 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001640 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner85970f32008-05-08 05:58:21 +00001641 unsigned &NumAliases) const {}
1642 virtual bool useGlobalsForAutomaticVariables() const {return true;}
1643 };
1644}
1645
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001646namespace {
1647 class MSP430TargetInfo : public TargetInfo {
1648 static const char * const GCCRegNames[];
1649 public:
1650 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
1651 TLSSupported = false;
1652 IntWidth = 16;
Anton Korobeynikov4a2249c2010-01-14 20:22:45 +00001653 LongWidth = 32;
1654 LongLongWidth = 64;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001655 PointerWidth = 16;
1656 IntAlign = 8;
1657 LongAlign = LongLongAlign = 8;
1658 PointerAlign = 8;
1659 SizeType = UnsignedInt;
1660 IntMaxType = SignedLong;
1661 UIntMaxType = UnsignedLong;
1662 IntPtrType = SignedShort;
1663 PtrDiffType = SignedInt;
Edward O'Callaghan14a70a32009-11-21 00:49:54 +00001664 SigAtomicType = SignedLong;
Anton Korobeynikov314713f2009-12-19 01:32:37 +00001665 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001666 }
1667 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001668 MacroBuilder &Builder) const {
1669 Builder.defineMacro("MSP430");
1670 Builder.defineMacro("__MSP430__");
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001671 // FIXME: defines for different 'flavours' of MCU
1672 }
1673 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1674 unsigned &NumRecords) const {
1675 // FIXME: Implement.
1676 Records = 0;
1677 NumRecords = 0;
1678 }
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001679 virtual void getGCCRegNames(const char * const *&Names,
1680 unsigned &NumNames) const;
1681 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1682 unsigned &NumAliases) const {
1683 // No aliases.
1684 Aliases = 0;
1685 NumAliases = 0;
1686 }
1687 virtual bool validateAsmConstraint(const char *&Name,
1688 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov174219b2009-10-15 23:17:13 +00001689 // No target constraints for now.
1690 return false;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001691 }
1692 virtual const char *getClobbers() const {
1693 // FIXME: Is this really right?
1694 return "";
1695 }
1696 virtual const char *getVAListDeclaration() const {
1697 // FIXME: implement
Anton Korobeynikovf5955592009-05-08 18:24:57 +00001698 return "typedef char* __builtin_va_list;";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001699 }
1700 };
1701
1702 const char * const MSP430TargetInfo::GCCRegNames[] = {
1703 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1704 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1705 };
1706
1707 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
1708 unsigned &NumNames) const {
1709 Names = GCCRegNames;
1710 NumNames = llvm::array_lengthof(GCCRegNames);
1711 }
1712}
1713
1714
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001715namespace {
1716 class SystemZTargetInfo : public TargetInfo {
1717 static const char * const GCCRegNames[];
1718 public:
1719 SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
1720 TLSSupported = false;
1721 IntWidth = IntAlign = 32;
1722 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
1723 PointerWidth = PointerAlign = 64;
Chris Lattner2e17d912009-11-07 18:59:41 +00001724 DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
1725 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001726 }
1727 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001728 MacroBuilder &Builder) const {
1729 Builder.defineMacro("__s390__");
1730 Builder.defineMacro("__s390x__");
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001731 }
1732 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1733 unsigned &NumRecords) const {
1734 // FIXME: Implement.
1735 Records = 0;
1736 NumRecords = 0;
1737 }
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001738
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001739 virtual void getGCCRegNames(const char * const *&Names,
1740 unsigned &NumNames) const;
1741 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1742 unsigned &NumAliases) const {
1743 // No aliases.
1744 Aliases = 0;
1745 NumAliases = 0;
1746 }
1747 virtual bool validateAsmConstraint(const char *&Name,
1748 TargetInfo::ConstraintInfo &info) const {
1749 // FIXME: implement
1750 return true;
1751 }
1752 virtual const char *getClobbers() const {
1753 // FIXME: Is this really right?
1754 return "";
1755 }
1756 virtual const char *getVAListDeclaration() const {
1757 // FIXME: implement
1758 return "typedef char* __builtin_va_list;";
1759 }
1760 };
1761
1762 const char * const SystemZTargetInfo::GCCRegNames[] = {
1763 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1764 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1765 };
1766
1767 void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
1768 unsigned &NumNames) const {
1769 Names = GCCRegNames;
1770 NumNames = llvm::array_lengthof(GCCRegNames);
1771 }
1772}
1773
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001774namespace {
1775 class BlackfinTargetInfo : public TargetInfo {
1776 static const char * const GCCRegNames[];
1777 public:
1778 BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
1779 TLSSupported = false;
1780 DoubleAlign = 32;
1781 LongLongAlign = 32;
1782 LongDoubleAlign = 32;
Chris Lattner2e17d912009-11-07 18:59:41 +00001783 DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001784 }
1785
1786 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001787 MacroBuilder &Builder) const {
1788 DefineStd(Builder, "bfin", Opts);
1789 DefineStd(Builder, "BFIN", Opts);
1790 Builder.defineMacro("__ADSPBLACKFIN__");
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001791 // FIXME: This one is really dependent on -mcpu
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001792 Builder.defineMacro("__ADSPLPBLACKFIN__");
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001793 // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
1794 }
1795
1796 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1797 unsigned &NumRecords) const {
1798 // FIXME: Implement.
1799 Records = 0;
1800 NumRecords = 0;
1801 }
1802
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001803 virtual void getGCCRegNames(const char * const *&Names,
1804 unsigned &NumNames) const;
1805
1806 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1807 unsigned &NumAliases) const {
1808 // No aliases.
1809 Aliases = 0;
1810 NumAliases = 0;
1811 }
1812
1813 virtual bool validateAsmConstraint(const char *&Name,
1814 TargetInfo::ConstraintInfo &Info) const {
1815 if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
1816 Info.setAllowsRegister();
1817 return true;
1818 }
1819 return false;
1820 }
1821
1822 virtual const char *getClobbers() const {
1823 return "";
1824 }
1825
1826 virtual const char *getVAListDeclaration() const {
1827 return "typedef char* __builtin_va_list;";
1828 }
1829 };
1830
1831 const char * const BlackfinTargetInfo::GCCRegNames[] = {
1832 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1833 "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
1834 "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
1835 "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
1836 "a0", "a1", "cc",
1837 "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
1838 "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
1839 };
1840
1841 void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
1842 unsigned &NumNames) const {
1843 Names = GCCRegNames;
1844 NumNames = llvm::array_lengthof(GCCRegNames);
1845 }
1846}
1847
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00001848namespace {
1849
Mike Stump25cf7602009-09-09 15:08:12 +00001850 // LLVM and Clang cannot be used directly to output native binaries for
1851 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00001852 // type and alignment information.
Mike Stump25cf7602009-09-09 15:08:12 +00001853 //
1854 // TCE uses the llvm bitcode as input and uses it for generating customized
1855 // target processor and program binary. TCE co-design environment is
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00001856 // publicly available in http://tce.cs.tut.fi
1857
1858 class TCETargetInfo : public TargetInfo{
1859 public:
1860 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
1861 TLSSupported = false;
1862 IntWidth = 32;
1863 LongWidth = LongLongWidth = 32;
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00001864 PointerWidth = 32;
1865 IntAlign = 32;
1866 LongAlign = LongLongAlign = 32;
1867 PointerAlign = 32;
1868 SizeType = UnsignedInt;
1869 IntMaxType = SignedLong;
1870 UIntMaxType = UnsignedLong;
1871 IntPtrType = SignedInt;
1872 PtrDiffType = SignedInt;
1873 FloatWidth = 32;
1874 FloatAlign = 32;
1875 DoubleWidth = 32;
1876 DoubleAlign = 32;
1877 LongDoubleWidth = 32;
1878 LongDoubleAlign = 32;
1879 FloatFormat = &llvm::APFloat::IEEEsingle;
1880 DoubleFormat = &llvm::APFloat::IEEEsingle;
1881 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
1882 DescriptionString = "E-p:32:32:32-a0:32:32"
1883 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64"
Chris Lattner2e17d912009-11-07 18:59:41 +00001884 "-f32:32:32-f64:32:64-n32";
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00001885 }
1886
1887 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001888 MacroBuilder &Builder) const {
1889 DefineStd(Builder, "tce", Opts);
1890 Builder.defineMacro("__TCE__");
1891 Builder.defineMacro("__TCE_V1__");
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00001892 }
1893 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1894 unsigned &NumRecords) const {}
Daniel Dunbar2e967de2009-08-24 09:54:37 +00001895 virtual const char *getClobbers() const {
1896 return "";
1897 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00001898 virtual const char *getVAListDeclaration() const {
1899 return "typedef void* __builtin_va_list;";
1900 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00001901 virtual void getGCCRegNames(const char * const *&Names,
1902 unsigned &NumNames) const {}
1903 virtual bool validateAsmConstraint(const char *&Name,
1904 TargetInfo::ConstraintInfo &info) const {
1905 return true;
1906 }
1907 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1908 unsigned &NumAliases) const {}
1909 };
1910}
1911
Edward O'Callaghan097309f2009-11-15 10:22:07 +00001912namespace {
1913class MipsTargetInfo : public TargetInfo {
1914 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1915 static const char * const GCCRegNames[];
1916public:
1917 MipsTargetInfo(const std::string& triple) : TargetInfo(triple) {
1918 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
1919 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
1920 }
1921 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001922 MacroBuilder &Builder) const {
1923 DefineStd(Builder, "mips", Opts);
1924 Builder.defineMacro("_mips");
1925 DefineStd(Builder, "MIPSEB", Opts);
1926 Builder.defineMacro("_MIPSEB");
1927 Builder.defineMacro("__REGISTER_PREFIX__", "");
Edward O'Callaghan097309f2009-11-15 10:22:07 +00001928 }
1929 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1930 unsigned &NumRecords) const {
1931 // FIXME: Implement!
1932 }
1933 virtual const char *getVAListDeclaration() const {
1934 return "typedef void* __builtin_va_list;";
1935 }
1936 virtual void getGCCRegNames(const char * const *&Names,
1937 unsigned &NumNames) const;
1938 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1939 unsigned &NumAliases) const;
1940 virtual bool validateAsmConstraint(const char *&Name,
1941 TargetInfo::ConstraintInfo &Info) const {
1942 switch (*Name) {
1943 default:
1944 case 'r': // CPU registers.
1945 case 'd': // Equivalent to "r" unless generating MIPS16 code.
1946 case 'y': // Equivalent to "r", backwards compatibility only.
1947 case 'f': // floating-point registers.
1948 Info.setAllowsRegister();
1949 return true;
1950 }
1951 return false;
1952 }
1953
1954 virtual const char *getClobbers() const {
1955 // FIXME: Implement!
1956 return "";
1957 }
1958};
1959
1960const char * const MipsTargetInfo::GCCRegNames[] = {
1961 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
1962 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
1963 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
1964 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
1965 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1966 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1967 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1968 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1969 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
1970 "$fcc5","$fcc6","$fcc7"
1971};
1972
1973void MipsTargetInfo::getGCCRegNames(const char * const *&Names,
1974 unsigned &NumNames) const {
1975 Names = GCCRegNames;
1976 NumNames = llvm::array_lengthof(GCCRegNames);
1977}
1978
1979const TargetInfo::GCCRegAlias MipsTargetInfo::GCCRegAliases[] = {
1980 { { "at" }, "$1" },
1981 { { "v0" }, "$2" },
1982 { { "v1" }, "$3" },
1983 { { "a0" }, "$4" },
1984 { { "a1" }, "$5" },
1985 { { "a2" }, "$6" },
1986 { { "a3" }, "$7" },
1987 { { "t0" }, "$8" },
1988 { { "t1" }, "$9" },
1989 { { "t2" }, "$10" },
1990 { { "t3" }, "$11" },
1991 { { "t4" }, "$12" },
1992 { { "t5" }, "$13" },
1993 { { "t6" }, "$14" },
1994 { { "t7" }, "$15" },
1995 { { "s0" }, "$16" },
1996 { { "s1" }, "$17" },
1997 { { "s2" }, "$18" },
1998 { { "s3" }, "$19" },
1999 { { "s4" }, "$20" },
2000 { { "s5" }, "$21" },
2001 { { "s6" }, "$22" },
2002 { { "s7" }, "$23" },
2003 { { "t8" }, "$24" },
2004 { { "t9" }, "$25" },
2005 { { "k0" }, "$26" },
2006 { { "k1" }, "$27" },
2007 { { "gp" }, "$28" },
2008 { { "sp" }, "$29" },
2009 { { "fp" }, "$30" },
2010 { { "ra" }, "$31" }
2011};
2012
2013void MipsTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2014 unsigned &NumAliases) const {
2015 Aliases = GCCRegAliases;
2016 NumAliases = llvm::array_lengthof(GCCRegAliases);
2017}
2018} // end anonymous namespace.
2019
2020namespace {
2021class MipselTargetInfo : public MipsTargetInfo {
2022public:
2023 MipselTargetInfo(const std::string& triple) : MipsTargetInfo(triple) {
2024 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2025 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2026 }
2027
2028 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002029 MacroBuilder &Builder) const;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002030};
2031
2032void MipselTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002033 MacroBuilder &Builder) const {
2034 DefineStd(Builder, "mips", Opts);
2035 Builder.defineMacro("_mips");
2036 DefineStd(Builder, "MIPSEL", Opts);
2037 Builder.defineMacro("_MIPSEL");
2038 Builder.defineMacro("__REGISTER_PREFIX__", "");
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002039}
2040} // end anonymous namespace.
2041
Chris Lattner4b009652007-07-25 00:24:17 +00002042//===----------------------------------------------------------------------===//
2043// Driver code
2044//===----------------------------------------------------------------------===//
2045
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002046static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002047 llvm::Triple Triple(T);
2048 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002049
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002050 switch (Triple.getArch()) {
2051 default:
2052 return NULL;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002053
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002054 case llvm::Triple::arm:
Daniel Dunbar3f361b52009-09-11 01:14:50 +00002055 case llvm::Triple::thumb:
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002056 switch (os) {
2057 case llvm::Triple::Darwin:
Eli Friedman2b161652008-08-21 00:13:15 +00002058 return new DarwinARMTargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002059 case llvm::Triple::FreeBSD:
Edwin Török36565e52009-06-30 17:10:35 +00002060 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002061 default:
2062 return new ARMTargetInfo(T);
2063 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002064
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002065 case llvm::Triple::bfin:
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002066 return new BlackfinTargetInfo(T);
2067
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002068 case llvm::Triple::msp430:
2069 return new MSP430TargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002070
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002071 case llvm::Triple::mips:
2072 if (os == llvm::Triple::Psp)
2073 return new PSPTargetInfo<MipsTargetInfo>(T);
2074 if (os == llvm::Triple::Linux)
2075 return new LinuxTargetInfo<MipsTargetInfo>(T);
2076 return new MipsTargetInfo(T);
2077
2078 case llvm::Triple::mipsel:
2079 if (os == llvm::Triple::Psp)
2080 return new PSPTargetInfo<MipselTargetInfo>(T);
2081 if (os == llvm::Triple::Linux)
2082 return new LinuxTargetInfo<MipselTargetInfo>(T);
2083 return new MipselTargetInfo(T);
2084
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002085 case llvm::Triple::pic16:
2086 return new PIC16TargetInfo(T);
2087
2088 case llvm::Triple::ppc:
2089 if (os == llvm::Triple::Darwin)
2090 return new DarwinTargetInfo<PPCTargetInfo>(T);
2091 return new PPC32TargetInfo(T);
2092
2093 case llvm::Triple::ppc64:
2094 if (os == llvm::Triple::Darwin)
2095 return new DarwinTargetInfo<PPC64TargetInfo>(T);
John Thompsoned7bdbc2009-11-19 17:18:50 +00002096 else if (os == llvm::Triple::Lv2)
2097 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002098 return new PPC64TargetInfo(T);
2099
2100 case llvm::Triple::sparc:
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002101 if (os == llvm::Triple::AuroraUX)
2102 return new AuroraUXSparcV8TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002103 if (os == llvm::Triple::Solaris)
2104 return new SolarisSparcV8TargetInfo(T);
2105 return new SparcV8TargetInfo(T);
2106
John Thompsoned7bdbc2009-11-19 17:18:50 +00002107 // FIXME: Need a real SPU target.
2108 case llvm::Triple::cellspu:
2109 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
2110
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002111 case llvm::Triple::systemz:
2112 return new SystemZTargetInfo(T);
2113
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002114 case llvm::Triple::tce:
2115 return new TCETargetInfo(T);
2116
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002117 case llvm::Triple::x86:
2118 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002119 case llvm::Triple::AuroraUX:
2120 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002121 case llvm::Triple::Darwin:
2122 return new DarwinI386TargetInfo(T);
2123 case llvm::Triple::Linux:
2124 return new LinuxTargetInfo<X86_32TargetInfo>(T);
2125 case llvm::Triple::DragonFly:
2126 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
2127 case llvm::Triple::NetBSD:
2128 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
2129 case llvm::Triple::OpenBSD:
2130 return new OpenBSDI386TargetInfo(T);
2131 case llvm::Triple::FreeBSD:
2132 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
2133 case llvm::Triple::Solaris:
2134 return new SolarisTargetInfo<X86_32TargetInfo>(T);
2135 case llvm::Triple::Cygwin:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002136 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002137 case llvm::Triple::MinGW32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002138 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002139 case llvm::Triple::Win32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002140 return new VisualStudioWindowsX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002141 default:
2142 return new X86_32TargetInfo(T);
2143 }
2144
2145 case llvm::Triple::x86_64:
2146 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002147 case llvm::Triple::AuroraUX:
2148 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002149 case llvm::Triple::Darwin:
2150 return new DarwinX86_64TargetInfo(T);
2151 case llvm::Triple::Linux:
2152 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner1eac0812010-01-09 05:41:14 +00002153 case llvm::Triple::DragonFly:
2154 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002155 case llvm::Triple::NetBSD:
2156 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
2157 case llvm::Triple::OpenBSD:
2158 return new OpenBSDX86_64TargetInfo(T);
2159 case llvm::Triple::FreeBSD:
2160 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
2161 case llvm::Triple::Solaris:
2162 return new SolarisTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002163 case llvm::Triple::MinGW64:
2164 return new MinGWX86_64TargetInfo(T);
2165 case llvm::Triple::Win32: // This is what Triple.h supports now.
2166 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002167 default:
2168 return new X86_64TargetInfo(T);
2169 }
2170 }
Chris Lattner4b009652007-07-25 00:24:17 +00002171}
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002172
2173/// CreateTargetInfo - Return the target info object for the specified target
2174/// triple.
2175TargetInfo *TargetInfo::CreateTargetInfo(Diagnostic &Diags,
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002176 TargetOptions &Opts) {
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002177 llvm::Triple Triple(Opts.Triple);
2178
2179 // Construct the target
2180 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
2181 if (!Target) {
2182 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
2183 return 0;
2184 }
2185
Daniel Dunbar33b40752009-12-18 18:42:37 +00002186 // Set the target CPU if specified.
2187 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
2188 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
2189 return 0;
2190 }
2191
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002192 // Set the target ABI if specified.
2193 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
2194 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
2195 return 0;
2196 }
2197
2198 // Compute the default target features, we need the target to handle this
2199 // because features may have dependencies on one another.
2200 llvm::StringMap<bool> Features;
2201 Target->getDefaultFeatures(Opts.CPU, Features);
2202
2203 // Apply the user specified deltas.
2204 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
2205 ie = Opts.Features.end(); it != ie; ++it) {
2206 const char *Name = it->c_str();
2207
2208 // Apply the feature via the target.
2209 if ((Name[0] != '-' && Name[0] != '+') ||
2210 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
2211 Diags.Report(diag::err_target_invalid_feature) << Name;
2212 return 0;
2213 }
2214 }
2215
2216 // Add the features to the compile options.
2217 //
2218 // FIXME: If we are completely confident that we have the right set, we only
2219 // need to pass the minuses.
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002220 Opts.Features.clear();
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002221 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
2222 ie = Features.end(); it != ie; ++it)
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002223 Opts.Features.push_back(std::string(it->second ? "+" : "-") + it->first());
2224 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002225
2226 return Target.take();
2227}