blob: 1797804a7aab2902b722034221688369ce8d77b1 [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
Anders Carlsson41f80b52010-01-30 18:33:31 +0000156 virtual std::string isValidSectionSpecifier(llvm::StringRef SR) const {
Chris Lattner43954312009-08-10 19:03:04 +0000157 // Let MCSectionMachO validate this.
158 llvm::StringRef Segment, Section;
159 unsigned TAA, StubSize;
160 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
161 TAA, StubSize);
162 }
Edwin Török36565e52009-06-30 17:10:35 +0000163};
164
Chris Lattner43954312009-08-10 19:03:04 +0000165
Edwin Török36565e52009-06-30 17:10:35 +0000166// DragonFlyBSD Target
167template<typename Target>
168class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
169protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000170 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000171 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000172 // DragonFly defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000173 Builder.defineMacro("__DragonFly__");
174 Builder.defineMacro("__DragonFly_cc_version", "100001");
175 Builder.defineMacro("__ELF__");
176 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
177 Builder.defineMacro("__tune_i386__");
178 DefineStd(Builder, "unix", Opts);
Edwin Török36565e52009-06-30 17:10:35 +0000179 }
180public:
Mike Stump25cf7602009-09-09 15:08:12 +0000181 DragonFlyBSDTargetInfo(const std::string &triple)
Edwin Török36565e52009-06-30 17:10:35 +0000182 : OSTargetInfo<Target>(triple) {}
183};
184
185// FreeBSD Target
186template<typename Target>
187class FreeBSDTargetInfo : public OSTargetInfo<Target> {
188protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000189 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000190 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000191 // FreeBSD defines; list based off of gcc output
192
Daniel Dunbar608b3882009-08-24 09:10:05 +0000193 // FIXME: Move version number handling to llvm::Triple.
Benjamin Kramereaa3c702010-01-30 19:55:01 +0000194 llvm::StringRef Release = Triple.getOSName().substr(strlen("freebsd"), 1);
Edwin Török36565e52009-06-30 17:10:35 +0000195
Benjamin Kramereaa3c702010-01-30 19:55:01 +0000196 Builder.defineMacro("__FreeBSD__", Release);
197 Builder.defineMacro("__FreeBSD_cc_version", Release + "00001");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000198 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
199 DefineStd(Builder, "unix", Opts);
200 Builder.defineMacro("__ELF__");
Edwin Török36565e52009-06-30 17:10:35 +0000201 }
202public:
Mike Stump25cf7602009-09-09 15:08:12 +0000203 FreeBSDTargetInfo(const std::string &triple)
Duncan Sandscd2cb662009-07-08 13:55:08 +0000204 : OSTargetInfo<Target>(triple) {
205 this->UserLabelPrefix = "";
206 }
Edwin Török36565e52009-06-30 17:10:35 +0000207};
208
209// Linux target
210template<typename Target>
211class LinuxTargetInfo : public OSTargetInfo<Target> {
212protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000213 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000214 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000215 // Linux defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000216 DefineStd(Builder, "unix", Opts);
217 DefineStd(Builder, "linux", Opts);
218 Builder.defineMacro("__gnu_linux__");
219 Builder.defineMacro("__ELF__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000220 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000221 Builder.defineMacro("_REENTRANT");
Edwin Török36565e52009-06-30 17:10:35 +0000222 }
223public:
Mike Stump25cf7602009-09-09 15:08:12 +0000224 LinuxTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +0000225 : OSTargetInfo<Target>(triple) {
226 this->UserLabelPrefix = "";
227 }
228};
229
Chris Lattner25fff082009-07-13 20:29:08 +0000230// NetBSD Target
231template<typename Target>
232class NetBSDTargetInfo : public OSTargetInfo<Target> {
233protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000234 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000235 MacroBuilder &Builder) const {
Chris Lattner25fff082009-07-13 20:29:08 +0000236 // NetBSD defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000237 Builder.defineMacro("__NetBSD__");
238 Builder.defineMacro("__unix__");
239 Builder.defineMacro("__ELF__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000240 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000241 Builder.defineMacro("_POSIX_THREADS");
Chris Lattner25fff082009-07-13 20:29:08 +0000242 }
243public:
Mike Stump25cf7602009-09-09 15:08:12 +0000244 NetBSDTargetInfo(const std::string &triple)
Chris Lattner25fff082009-07-13 20:29:08 +0000245 : OSTargetInfo<Target>(triple) {
246 this->UserLabelPrefix = "";
247 }
248};
249
Edwin Török36565e52009-06-30 17:10:35 +0000250// OpenBSD Target
251template<typename Target>
252class OpenBSDTargetInfo : public OSTargetInfo<Target> {
253protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000254 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000255 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000256 // OpenBSD defines; list based off of gcc output
257
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000258 Builder.defineMacro("__OpenBSD__");
259 DefineStd(Builder, "unix", Opts);
260 Builder.defineMacro("__ELF__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000261 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000262 Builder.defineMacro("_POSIX_THREADS");
Edwin Török36565e52009-06-30 17:10:35 +0000263 }
264public:
Mike Stump25cf7602009-09-09 15:08:12 +0000265 OpenBSDTargetInfo(const std::string &triple)
Edwin Török36565e52009-06-30 17:10:35 +0000266 : OSTargetInfo<Target>(triple) {}
267};
268
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000269// PSP Target
270template<typename Target>
271class PSPTargetInfo : public OSTargetInfo<Target> {
272protected:
273 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000274 MacroBuilder &Builder) const {
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000275 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000276 Builder.defineMacro("PSP");
277 Builder.defineMacro("_PSP");
278 Builder.defineMacro("__psp__");
279 Builder.defineMacro("__ELF__");
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000280 }
281public:
282 PSPTargetInfo(const std::string& triple)
283 : OSTargetInfo<Target>(triple) {
284 this->UserLabelPrefix = "";
285 }
286};
287
John Thompsoned7bdbc2009-11-19 17:18:50 +0000288// PS3 PPU Target
289template<typename Target>
290class PS3PPUTargetInfo : public OSTargetInfo<Target> {
291protected:
292 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000293 MacroBuilder &Builder) const {
John Thompsoned7bdbc2009-11-19 17:18:50 +0000294 // PS3 PPU defines.
John Thompsonfdd2fc32010-03-25 16:18:32 +0000295 Builder.defineMacro("__PPC__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000296 Builder.defineMacro("__PPU__");
297 Builder.defineMacro("__CELLOS_LV2__");
298 Builder.defineMacro("__ELF__");
299 Builder.defineMacro("__LP32__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000300 }
301public:
302 PS3PPUTargetInfo(const std::string& triple)
303 : OSTargetInfo<Target>(triple) {
304 this->UserLabelPrefix = "";
John Thompson4c3bd3f2009-12-18 14:21:08 +0000305 this->LongWidth = this->LongAlign = this->PointerWidth = this->PointerAlign = 32;
306 this->SizeType = TargetInfo::UnsignedInt;
John Thompsoned7bdbc2009-11-19 17:18:50 +0000307 }
308};
309
310// FIXME: Need a real SPU target.
311// PS3 SPU Target
312template<typename Target>
313class PS3SPUTargetInfo : public OSTargetInfo<Target> {
314protected:
315 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000316 MacroBuilder &Builder) const {
John Thompsoned7bdbc2009-11-19 17:18:50 +0000317 // PS3 PPU defines.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000318 Builder.defineMacro("__SPU__");
319 Builder.defineMacro("__ELF__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000320 }
321public:
322 PS3SPUTargetInfo(const std::string& triple)
323 : OSTargetInfo<Target>(triple) {
324 this->UserLabelPrefix = "";
325 }
326};
327
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +0000328// AuroraUX target
329template<typename Target>
330class AuroraUXTargetInfo : public OSTargetInfo<Target> {
331protected:
332 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000333 MacroBuilder &Builder) const {
334 DefineStd(Builder, "sun", Opts);
335 DefineStd(Builder, "unix", Opts);
336 Builder.defineMacro("__ELF__");
337 Builder.defineMacro("__svr4__");
338 Builder.defineMacro("__SVR4");
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +0000339 }
340public:
341 AuroraUXTargetInfo(const std::string& triple)
342 : OSTargetInfo<Target>(triple) {
343 this->UserLabelPrefix = "";
344 this->WCharType = this->SignedLong;
345 // FIXME: WIntType should be SignedLong
346 }
347};
348
Edwin Török36565e52009-06-30 17:10:35 +0000349// Solaris target
350template<typename Target>
351class SolarisTargetInfo : public OSTargetInfo<Target> {
352protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000353 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000354 MacroBuilder &Builder) const {
355 DefineStd(Builder, "sun", Opts);
356 DefineStd(Builder, "unix", Opts);
357 Builder.defineMacro("__ELF__");
358 Builder.defineMacro("__svr4__");
359 Builder.defineMacro("__SVR4");
Edwin Török36565e52009-06-30 17:10:35 +0000360 }
361public:
Mike Stump25cf7602009-09-09 15:08:12 +0000362 SolarisTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +0000363 : OSTargetInfo<Target>(triple) {
364 this->UserLabelPrefix = "";
365 this->WCharType = this->SignedLong;
366 // FIXME: WIntType should be SignedLong
367 }
368};
Mike Stump25cf7602009-09-09 15:08:12 +0000369} // end anonymous namespace.
Edwin Török36565e52009-06-30 17:10:35 +0000370
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000371//===----------------------------------------------------------------------===//
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000372// Specific target implementations.
373//===----------------------------------------------------------------------===//
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000374
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000375namespace {
376// PPC abstract base class
377class PPCTargetInfo : public TargetInfo {
378 static const Builtin::Info BuiltinInfo[];
379 static const char * const GCCRegNames[];
380 static const TargetInfo::GCCRegAlias GCCRegAliases[];
381
382public:
Eli Friedmand9389be2009-06-05 07:05:05 +0000383 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
384
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000385 virtual void getTargetBuiltins(const Builtin::Info *&Records,
386 unsigned &NumRecords) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000387 Records = BuiltinInfo;
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000388 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000389 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000390
Chris Lattner79682402009-03-20 15:52:06 +0000391 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000392 MacroBuilder &Builder) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000393
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000394 virtual const char *getVAListDeclaration() const {
Chris Lattnera07708f2008-10-27 01:11:29 +0000395 return "typedef char* __builtin_va_list;";
396 // This is the right definition for ABI/V4: System V.4/eabi.
397 /*return "typedef struct __va_list_tag {"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000398 " unsigned char gpr;"
399 " unsigned char fpr;"
400 " unsigned short reserved;"
401 " void* overflow_arg_area;"
402 " void* reg_save_area;"
Chris Lattnera07708f2008-10-27 01:11:29 +0000403 "} __builtin_va_list[1];";*/
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000404 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000405 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000406 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000407 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000408 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +0000409 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000410 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +0000411 switch (*Name) {
Anders Carlsson4ce42302007-11-27 04:11:28 +0000412 default: return false;
413 case 'O': // Zero
414 return true;
415 case 'b': // Base register
416 case 'f': // Floating point register
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000417 Info.setAllowsRegister();
Anders Carlsson4ce42302007-11-27 04:11:28 +0000418 return true;
419 }
420 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000421 virtual const char *getClobbers() const {
422 return "";
Anders Carlsson4ce42302007-11-27 04:11:28 +0000423 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000424};
Anders Carlsson4ce42302007-11-27 04:11:28 +0000425
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000426const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000427#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
428#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000429#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000430};
Anton Korobeynikove7772382009-05-03 13:42:53 +0000431
432
Chris Lattnerbef1d722009-03-02 22:27:17 +0000433/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
434/// #defines that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +0000435void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000436 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +0000437 // Target identification.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000438 Builder.defineMacro("__ppc__");
439 Builder.defineMacro("_ARCH_PPC");
Chris Lattnerf8030412010-02-16 18:14:57 +0000440 Builder.defineMacro("__powerpc__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000441 Builder.defineMacro("__POWERPC__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000442 if (PointerWidth == 64) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000443 Builder.defineMacro("_ARCH_PPC64");
444 Builder.defineMacro("_LP64");
445 Builder.defineMacro("__LP64__");
Chris Lattnerf8030412010-02-16 18:14:57 +0000446 Builder.defineMacro("__powerpc64__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000447 Builder.defineMacro("__ppc64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000448 } else {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000449 Builder.defineMacro("__ppc__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000450 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000451
Chris Lattnerbef1d722009-03-02 22:27:17 +0000452 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000453 Builder.defineMacro("_BIG_ENDIAN");
454 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000455
Chris Lattnerbef1d722009-03-02 22:27:17 +0000456 // Subtarget options.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000457 Builder.defineMacro("__NATURAL_ALIGNMENT__");
458 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000459
Chris Lattnerbef1d722009-03-02 22:27:17 +0000460 // FIXME: Should be controlled by command line option.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000461 Builder.defineMacro("__LONG_DOUBLE_128__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000462
463 if (Opts.AltiVec) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000464 Builder.defineMacro("__VEC__", "10206");
465 Builder.defineMacro("__ALTIVEC__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000466 }
Chris Lattnerbef1d722009-03-02 22:27:17 +0000467}
468
Chris Lattner9fd73612008-04-21 18:56:49 +0000469
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000470const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattner14d2bb72009-09-16 05:05:27 +0000471 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
472 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
473 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
474 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
475 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
476 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
477 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
478 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000479 "mq", "lr", "ctr", "ap",
Chris Lattner14d2bb72009-09-16 05:05:27 +0000480 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000481 "xer",
Chris Lattner14d2bb72009-09-16 05:05:27 +0000482 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
483 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
484 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
485 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000486 "vrsave", "vscr",
487 "spe_acc", "spefscr",
488 "sfp"
489};
Chris Lattner4b009652007-07-25 00:24:17 +0000490
Anton Korobeynikove7772382009-05-03 13:42:53 +0000491void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000492 unsigned &NumNames) const {
493 Names = GCCRegNames;
494 NumNames = llvm::array_lengthof(GCCRegNames);
495}
Chris Lattner4b009652007-07-25 00:24:17 +0000496
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000497const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
498 // While some of these aliases do map to different registers
499 // they still share the same register name.
Daniel Dunbar40b774e2009-09-17 07:03:19 +0000500 { { "0" }, "r0" },
501 { { "1"}, "r1" },
502 { { "2" }, "r2" },
503 { { "3" }, "r3" },
504 { { "4" }, "r4" },
505 { { "5" }, "r5" },
506 { { "6" }, "r6" },
507 { { "7" }, "r7" },
508 { { "8" }, "r8" },
509 { { "9" }, "r9" },
510 { { "10" }, "r10" },
511 { { "11" }, "r11" },
512 { { "12" }, "r12" },
513 { { "13" }, "r13" },
514 { { "14" }, "r14" },
515 { { "15" }, "r15" },
516 { { "16" }, "r16" },
517 { { "17" }, "r17" },
518 { { "18" }, "r18" },
519 { { "19" }, "r19" },
520 { { "20" }, "r20" },
521 { { "21" }, "r21" },
522 { { "22" }, "r22" },
523 { { "23" }, "r23" },
524 { { "24" }, "r24" },
525 { { "25" }, "r25" },
526 { { "26" }, "r26" },
527 { { "27" }, "r27" },
528 { { "28" }, "r28" },
529 { { "29" }, "r29" },
530 { { "30" }, "r30" },
531 { { "31" }, "r31" },
532 { { "fr0" }, "f0" },
533 { { "fr1" }, "f1" },
534 { { "fr2" }, "f2" },
535 { { "fr3" }, "f3" },
536 { { "fr4" }, "f4" },
537 { { "fr5" }, "f5" },
538 { { "fr6" }, "f6" },
539 { { "fr7" }, "f7" },
540 { { "fr8" }, "f8" },
541 { { "fr9" }, "f9" },
Mike Stump369c21c2009-09-17 21:15:00 +0000542 { { "fr10" }, "f10" },
Daniel Dunbar40b774e2009-09-17 07:03:19 +0000543 { { "fr11" }, "f11" },
544 { { "fr12" }, "f12" },
545 { { "fr13" }, "f13" },
546 { { "fr14" }, "f14" },
547 { { "fr15" }, "f15" },
548 { { "fr16" }, "f16" },
549 { { "fr17" }, "f17" },
550 { { "fr18" }, "f18" },
551 { { "fr19" }, "f19" },
552 { { "fr20" }, "f20" },
553 { { "fr21" }, "f21" },
554 { { "fr22" }, "f22" },
555 { { "fr23" }, "f23" },
556 { { "fr24" }, "f24" },
557 { { "fr25" }, "f25" },
558 { { "fr26" }, "f26" },
559 { { "fr27" }, "f27" },
560 { { "fr28" }, "f28" },
561 { { "fr29" }, "f29" },
562 { { "fr30" }, "f30" },
563 { { "fr31" }, "f31" },
564 { { "cc" }, "cr0" },
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000565};
566
Anton Korobeynikove7772382009-05-03 13:42:53 +0000567void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000568 unsigned &NumAliases) const {
569 Aliases = GCCRegAliases;
570 NumAliases = llvm::array_lengthof(GCCRegAliases);
571}
572} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +0000573
574namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000575class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000576public:
Chris Lattnerf8030412010-02-16 18:14:57 +0000577 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedman2b161652008-08-21 00:13:15 +0000578 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 +0000579 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnerf8030412010-02-16 18:14:57 +0000580
581 if (getTriple().getOS() == llvm::Triple::FreeBSD)
582 this->SizeType = TargetInfo::UnsignedInt;
Eli Friedman2b161652008-08-21 00:13:15 +0000583 }
Chris Lattner4b009652007-07-25 00:24:17 +0000584};
585} // end anonymous namespace.
586
587namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000588class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000589public:
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000590 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +0000591 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman38e31802009-07-01 03:36:11 +0000592 IntMaxType = SignedLong;
593 UIntMaxType = UnsignedLong;
594 Int64Type = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +0000595 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 +0000596 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnere5fde952008-05-09 06:17:04 +0000597 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000598};
599} // end anonymous namespace.
600
Chris Lattner4b009652007-07-25 00:24:17 +0000601namespace {
Chris Lattner2c026472010-03-06 21:21:27 +0000602// MBlaze abstract base class
603class MBlazeTargetInfo : public TargetInfo {
604 static const char * const GCCRegNames[];
605 static const TargetInfo::GCCRegAlias GCCRegAliases[];
606
607public:
608 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
609 DescriptionString = "E-p:32:32-i8:8:8-i16:16:16-i64:32:32-f64:32:32-"
610 "v64:32:32-v128:32:32-n32";
611 }
612
613 virtual void getTargetBuiltins(const Builtin::Info *&Records,
614 unsigned &NumRecords) const {
615 // FIXME: Implement.
616 Records = 0;
617 NumRecords = 0;
618 }
619
620 virtual void getTargetDefines(const LangOptions &Opts,
621 MacroBuilder &Builder) const;
622
623 virtual const char *getVAListDeclaration() const {
624 return "typedef char* __builtin_va_list;";
625 }
626 virtual const char *getTargetPrefix() const {
627 return "mblaze";
628 }
629 virtual void getGCCRegNames(const char * const *&Names,
630 unsigned &NumNames) const;
631 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
632 unsigned &NumAliases) const;
633 virtual bool validateAsmConstraint(const char *&Name,
634 TargetInfo::ConstraintInfo &Info) const {
635 switch (*Name) {
636 default: return false;
637 case 'O': // Zero
638 return true;
639 case 'b': // Base register
640 case 'f': // Floating point register
641 Info.setAllowsRegister();
642 return true;
643 }
644 }
645 virtual const char *getClobbers() const {
646 return "";
647 }
648};
649
650/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
651/// #defines that are not tied to a specific subtarget.
652void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
653 MacroBuilder &Builder) const {
654 // Target identification.
655 Builder.defineMacro("__microblaze__");
656 Builder.defineMacro("_ARCH_MICROBLAZE");
657 Builder.defineMacro("__MICROBLAZE__");
658
659 // Target properties.
660 Builder.defineMacro("_BIG_ENDIAN");
661 Builder.defineMacro("__BIG_ENDIAN__");
662
663 // Subtarget options.
664 Builder.defineMacro("__REGISTER_PREFIX__", "");
665}
666
667
668const char * const MBlazeTargetInfo::GCCRegNames[] = {
669 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
670 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
671 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
672 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
673 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
674 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
675 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
676 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
677 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
678 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
679};
680
681void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
682 unsigned &NumNames) const {
683 Names = GCCRegNames;
684 NumNames = llvm::array_lengthof(GCCRegNames);
685}
686
687const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
688 { {"f0"}, "r0" },
689 { {"f1"}, "r1" },
690 { {"f2"}, "r2" },
691 { {"f3"}, "r3" },
692 { {"f4"}, "r4" },
693 { {"f5"}, "r5" },
694 { {"f6"}, "r6" },
695 { {"f7"}, "r7" },
696 { {"f8"}, "r8" },
697 { {"f9"}, "r9" },
698 { {"f10"}, "r10" },
699 { {"f11"}, "r11" },
700 { {"f12"}, "r12" },
701 { {"f13"}, "r13" },
702 { {"f14"}, "r14" },
703 { {"f15"}, "r15" },
704 { {"f16"}, "r16" },
705 { {"f17"}, "r17" },
706 { {"f18"}, "r18" },
707 { {"f19"}, "r19" },
708 { {"f20"}, "r20" },
709 { {"f21"}, "r21" },
710 { {"f22"}, "r22" },
711 { {"f23"}, "r23" },
712 { {"f24"}, "r24" },
713 { {"f25"}, "r25" },
714 { {"f26"}, "r26" },
715 { {"f27"}, "r27" },
716 { {"f28"}, "r28" },
717 { {"f29"}, "r29" },
718 { {"f30"}, "r30" },
719 { {"f31"}, "r31" },
720};
721
722void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
723 unsigned &NumAliases) const {
724 Aliases = GCCRegAliases;
725 NumAliases = llvm::array_lengthof(GCCRegAliases);
726}
727} // end anonymous namespace.
728
729namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000730// Namespace for x86 abstract base class
731const Builtin::Info BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000732#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
733#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000734#include "clang/Basic/BuiltinsX86.def"
Eli Friedman872996c2008-08-20 02:34:37 +0000735};
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000736
Nuno Lopesad1010d2009-12-23 17:49:57 +0000737static const char* const GCCRegNames[] = {
Eli Friedman872996c2008-08-20 02:34:37 +0000738 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
739 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
740 "argp", "flags", "fspr", "dirflag", "frame",
741 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
742 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
743 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
744 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
745};
746
747const TargetInfo::GCCRegAlias GCCRegAliases[] = {
748 { { "al", "ah", "eax", "rax" }, "ax" },
749 { { "bl", "bh", "ebx", "rbx" }, "bx" },
750 { { "cl", "ch", "ecx", "rcx" }, "cx" },
751 { { "dl", "dh", "edx", "rdx" }, "dx" },
752 { { "esi", "rsi" }, "si" },
753 { { "edi", "rdi" }, "di" },
754 { { "esp", "rsp" }, "sp" },
755 { { "ebp", "rbp" }, "bp" },
756};
757
758// X86 target abstract base class; x86-32 and x86-64 are very close, so
759// most of the implementation can be shared.
760class X86TargetInfo : public TargetInfo {
Chris Lattner715fe4c2009-03-02 22:40:39 +0000761 enum X86SSEEnum {
762 NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
763 } SSELevel;
Anders Carlssone5e222f2010-01-27 03:47:49 +0000764 enum AMD3DNowEnum {
765 NoAMD3DNow, AMD3DNow, AMD3DNowAthlon
766 } AMD3DNowLevel;
767
Eric Christopher6c4e7872010-04-02 23:50:19 +0000768 bool HasAES;
769
Eli Friedman872996c2008-08-20 02:34:37 +0000770public:
Anton Korobeynikove7772382009-05-03 13:42:53 +0000771 X86TargetInfo(const std::string& triple)
Eric Christopher6c4e7872010-04-02 23:50:19 +0000772 : TargetInfo(triple), SSELevel(NoMMXSSE), AMD3DNowLevel(NoAMD3DNow),
773 HasAES(false) {
Eli Friedman872996c2008-08-20 02:34:37 +0000774 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner4b009652007-07-25 00:24:17 +0000775 }
776 virtual void getTargetBuiltins(const Builtin::Info *&Records,
777 unsigned &NumRecords) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000778 Records = BuiltinInfo;
779 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000780 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000781 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman872996c2008-08-20 02:34:37 +0000782 unsigned &NumNames) const {
783 Names = GCCRegNames;
784 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000785 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000786 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000787 unsigned &NumAliases) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000788 Aliases = GCCRegAliases;
789 NumAliases = llvm::array_lengthof(GCCRegAliases);
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000790 }
Anders Carlsson36834a72009-02-28 17:11:49 +0000791 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman872996c2008-08-20 02:34:37 +0000792 TargetInfo::ConstraintInfo &info) const;
793 virtual std::string convertConstraint(const char Constraint) const;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000794 virtual const char *getClobbers() const {
Eli Friedman872996c2008-08-20 02:34:37 +0000795 return "~{dirflag},~{fpsr},~{flags}";
796 }
Chris Lattner79682402009-03-20 15:52:06 +0000797 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000798 MacroBuilder &Builder) const;
Daniel Dunbar0838f962009-05-06 21:07:50 +0000799 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
800 const std::string &Name,
801 bool Enabled) const;
Mike Stump25cf7602009-09-09 15:08:12 +0000802 virtual void getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000803 llvm::StringMap<bool> &Features) const;
Daniel Dunbar4f7cd962009-12-19 03:30:57 +0000804 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Chris Lattner4b009652007-07-25 00:24:17 +0000805};
Chris Lattner7d6220c2009-03-02 22:20:04 +0000806
Mike Stump25cf7602009-09-09 15:08:12 +0000807void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000808 llvm::StringMap<bool> &Features) const {
Daniel Dunbar07181d72009-05-06 03:16:41 +0000809 // FIXME: This should not be here.
810 Features["3dnow"] = false;
811 Features["3dnowa"] = false;
812 Features["mmx"] = false;
813 Features["sse"] = false;
814 Features["sse2"] = false;
815 Features["sse3"] = false;
816 Features["ssse3"] = false;
817 Features["sse41"] = false;
818 Features["sse42"] = false;
Eric Christopher6c4e7872010-04-02 23:50:19 +0000819 Features["aes"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000820
Daniel Dunbar07181d72009-05-06 03:16:41 +0000821 // LLVM does not currently recognize this.
822 // Features["sse4a"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000823
Daniel Dunbar07181d72009-05-06 03:16:41 +0000824 // FIXME: This *really* should not be here.
825
826 // X86_64 always has SSE2.
827 if (PointerWidth == 64)
828 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
829
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000830 if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
831 CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
832 ;
833 else if (CPU == "pentium-mmx" || CPU == "pentium2")
834 setFeatureEnabled(Features, "mmx", true);
835 else if (CPU == "pentium3")
836 setFeatureEnabled(Features, "sse", true);
837 else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64")
838 setFeatureEnabled(Features, "sse2", true);
839 else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona")
840 setFeatureEnabled(Features, "sse3", true);
841 else if (CPU == "core2")
842 setFeatureEnabled(Features, "ssse3", true);
843 else if (CPU == "penryn") {
844 setFeatureEnabled(Features, "sse4", true);
845 Features["sse42"] = false;
846 } else if (CPU == "atom")
847 setFeatureEnabled(Features, "sse3", true);
Eric Christopher6c4e7872010-04-02 23:50:19 +0000848 else if (CPU == "corei7") {
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000849 setFeatureEnabled(Features, "sse4", true);
Eric Christopher6c4e7872010-04-02 23:50:19 +0000850 setFeatureEnabled(Features, "aes", true);
851 }
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000852 else if (CPU == "k6" || CPU == "winchip-c6")
853 setFeatureEnabled(Features, "mmx", true);
Mike Stump25cf7602009-09-09 15:08:12 +0000854 else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000855 CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
856 setFeatureEnabled(Features, "mmx", true);
857 setFeatureEnabled(Features, "3dnow", true);
858 } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
859 setFeatureEnabled(Features, "sse", true);
860 setFeatureEnabled(Features, "3dnowa", true);
861 } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
862 CPU == "athlon-fx") {
Mike Stump25cf7602009-09-09 15:08:12 +0000863 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000864 setFeatureEnabled(Features, "3dnowa", true);
865 } else if (CPU == "c3-2")
866 setFeatureEnabled(Features, "sse", true);
Daniel Dunbar07181d72009-05-06 03:16:41 +0000867}
868
Daniel Dunbar0838f962009-05-06 21:07:50 +0000869bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump25cf7602009-09-09 15:08:12 +0000870 const std::string &Name,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000871 bool Enabled) const {
Eric Christopher850e2012010-03-04 02:26:37 +0000872 // FIXME: This *really* should not be here. We need some way of translating
873 // options into llvm subtarget features.
874 if (!Features.count(Name) &&
875 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar0838f962009-05-06 21:07:50 +0000876 return false;
877
878 if (Enabled) {
879 if (Name == "mmx")
880 Features["mmx"] = true;
881 else if (Name == "sse")
882 Features["mmx"] = Features["sse"] = true;
883 else if (Name == "sse2")
884 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
885 else if (Name == "sse3")
Mike Stump25cf7602009-09-09 15:08:12 +0000886 Features["mmx"] = Features["sse"] = Features["sse2"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000887 Features["sse3"] = true;
888 else if (Name == "ssse3")
Mike Stump25cf7602009-09-09 15:08:12 +0000889 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000890 Features["ssse3"] = true;
Eric Christopher850e2012010-03-04 02:26:37 +0000891 else if (Name == "sse4" || Name == "sse4.2")
Mike Stump25cf7602009-09-09 15:08:12 +0000892 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000893 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Eric Christopher850e2012010-03-04 02:26:37 +0000894 else if (Name == "sse4.1")
895 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
896 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +0000897 else if (Name == "3dnow")
898 Features["3dnowa"] = true;
899 else if (Name == "3dnowa")
900 Features["3dnow"] = Features["3dnowa"] = true;
Eric Christopher6c4e7872010-04-02 23:50:19 +0000901 else if (Name == "aes")
902 Features["aes"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +0000903 } else {
904 if (Name == "mmx")
Mike Stump25cf7602009-09-09 15:08:12 +0000905 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000906 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
907 else if (Name == "sse")
Mike Stump25cf7602009-09-09 15:08:12 +0000908 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000909 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
910 else if (Name == "sse2")
Mike Stump25cf7602009-09-09 15:08:12 +0000911 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000912 Features["sse41"] = Features["sse42"] = false;
913 else if (Name == "sse3")
Mike Stump25cf7602009-09-09 15:08:12 +0000914 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000915 Features["sse42"] = false;
916 else if (Name == "ssse3")
917 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
918 else if (Name == "sse4")
919 Features["sse41"] = Features["sse42"] = false;
Eric Christopherd794f782010-03-04 02:31:44 +0000920 else if (Name == "sse4.2")
921 Features["sse42"] = false;
922 else if (Name == "sse4.1")
923 Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar0838f962009-05-06 21:07:50 +0000924 else if (Name == "3dnow")
925 Features["3dnow"] = Features["3dnowa"] = false;
926 else if (Name == "3dnowa")
927 Features["3dnowa"] = false;
Eric Christopher6c4e7872010-04-02 23:50:19 +0000928 else if (Name == "aes")
929 Features["aes"] = false;
Daniel Dunbar0838f962009-05-06 21:07:50 +0000930 }
931
932 return true;
933}
934
Daniel Dunbar07181d72009-05-06 03:16:41 +0000935/// HandleTargetOptions - Perform initialization based on the user
936/// configured set of features.
Daniel Dunbar4f7cd962009-12-19 03:30:57 +0000937void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar8dd8f262009-11-11 09:38:56 +0000938 // Remember the maximum enabled sselevel.
939 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
940 // Ignore disabled features.
941 if (Features[i][0] == '-')
942 continue;
943
Eric Christopher6c4e7872010-04-02 23:50:19 +0000944 if (Features[i].substr(1) == "aes") {
945 HasAES = true;
946 continue;
947 }
948
Daniel Dunbar8dd8f262009-11-11 09:38:56 +0000949 assert(Features[i][0] == '+' && "Invalid target feature!");
950 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
951 .Case("sse42", SSE42)
952 .Case("sse41", SSE41)
953 .Case("ssse3", SSSE3)
Nuno Lopes3a16d782010-03-12 10:20:09 +0000954 .Case("sse3", SSE3)
Daniel Dunbar8dd8f262009-11-11 09:38:56 +0000955 .Case("sse2", SSE2)
956 .Case("sse", SSE1)
957 .Case("mmx", MMX)
958 .Default(NoMMXSSE);
959 SSELevel = std::max(SSELevel, Level);
Anders Carlssone5e222f2010-01-27 03:47:49 +0000960
961 AMD3DNowEnum ThreeDNowLevel =
962 llvm::StringSwitch<AMD3DNowEnum>(Features[i].substr(1))
963 .Case("3dnowa", AMD3DNowAthlon)
964 .Case("3dnow", AMD3DNow)
965 .Default(NoAMD3DNow);
966
967 AMD3DNowLevel = std::max(AMD3DNowLevel, ThreeDNowLevel);
Daniel Dunbar8dd8f262009-11-11 09:38:56 +0000968 }
Chris Lattner7d6220c2009-03-02 22:20:04 +0000969}
Chris Lattnerbef1d722009-03-02 22:27:17 +0000970
971/// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
972/// that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +0000973void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000974 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +0000975 // Target identification.
976 if (PointerWidth == 64) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000977 Builder.defineMacro("_LP64");
978 Builder.defineMacro("__LP64__");
979 Builder.defineMacro("__amd64__");
980 Builder.defineMacro("__amd64");
981 Builder.defineMacro("__x86_64");
982 Builder.defineMacro("__x86_64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000983 } else {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000984 DefineStd(Builder, "i386", Opts);
Chris Lattnerbef1d722009-03-02 22:27:17 +0000985 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000986
Eric Christopher6c4e7872010-04-02 23:50:19 +0000987 if (HasAES)
988 Builder.defineMacro("__AES__");
989
Chris Lattnerbef1d722009-03-02 22:27:17 +0000990 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000991 Builder.defineMacro("__LITTLE_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000992
Chris Lattnerbef1d722009-03-02 22:27:17 +0000993 // Subtarget options.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000994 Builder.defineMacro("__nocona");
995 Builder.defineMacro("__nocona__");
996 Builder.defineMacro("__tune_nocona__");
997 Builder.defineMacro("__REGISTER_PREFIX__", "");
Chris Lattner715fe4c2009-03-02 22:40:39 +0000998
Chris Lattner25ac1c12009-04-19 17:32:33 +0000999 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1000 // functions in glibc header files that use FP Stack inline asm which the
1001 // backend can't deal with (PR879).
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001002 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001003
Chris Lattner715fe4c2009-03-02 22:40:39 +00001004 // Each case falls through to the previous one here.
1005 switch (SSELevel) {
1006 case SSE42:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001007 Builder.defineMacro("__SSE4_2__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001008 case SSE41:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001009 Builder.defineMacro("__SSE4_1__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001010 case SSSE3:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001011 Builder.defineMacro("__SSSE3__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001012 case SSE3:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001013 Builder.defineMacro("__SSE3__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001014 case SSE2:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001015 Builder.defineMacro("__SSE2__");
1016 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner715fe4c2009-03-02 22:40:39 +00001017 case SSE1:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001018 Builder.defineMacro("__SSE__");
1019 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Chris Lattner715fe4c2009-03-02 22:40:39 +00001020 case MMX:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001021 Builder.defineMacro("__MMX__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001022 case NoMMXSSE:
1023 break;
1024 }
Anders Carlssone5e222f2010-01-27 03:47:49 +00001025
1026 // Each case falls through to the previous one here.
1027 switch (AMD3DNowLevel) {
1028 case AMD3DNowAthlon:
1029 Builder.defineMacro("__3dNOW_A__");
1030 case AMD3DNow:
1031 Builder.defineMacro("__3dNOW__");
1032 case NoAMD3DNow:
1033 break;
1034 }
Chris Lattnerbef1d722009-03-02 22:27:17 +00001035}
Anton Korobeynikove7772382009-05-03 13:42:53 +00001036
1037
Eli Friedman872996c2008-08-20 02:34:37 +00001038bool
Anders Carlsson36834a72009-02-28 17:11:49 +00001039X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001040 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +00001041 switch (*Name) {
Eli Friedman872996c2008-08-20 02:34:37 +00001042 default: return false;
1043 case 'a': // eax.
1044 case 'b': // ebx.
1045 case 'c': // ecx.
1046 case 'd': // edx.
1047 case 'S': // esi.
1048 case 'D': // edi.
1049 case 'A': // edx:eax.
1050 case 't': // top of floating point stack.
1051 case 'u': // second from top of floating point stack.
1052 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson2285e622008-10-06 00:41:45 +00001053 case 'y': // Any MMX register.
Anders Carlssond2459f92008-10-06 19:17:39 +00001054 case 'x': // Any SSE register.
Eli Friedman872996c2008-08-20 02:34:37 +00001055 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Anton Korobeynikove7772382009-05-03 13:42:53 +00001056 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +00001057 // x86_64 instructions.
Anton Korobeynikove7772382009-05-03 13:42:53 +00001058 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +00001059 // x86_64 instructions.
Eli Friedman872996c2008-08-20 02:34:37 +00001060 case 'N': // unsigned 8-bit integer constant for use with in and out
1061 // instructions.
Eli Friedman7e17aed2009-06-08 20:45:44 +00001062 case 'R': // "legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001063 Info.setAllowsRegister();
Eli Friedman872996c2008-08-20 02:34:37 +00001064 return true;
1065 }
1066}
1067
1068std::string
1069X86TargetInfo::convertConstraint(const char Constraint) const {
1070 switch (Constraint) {
1071 case 'a': return std::string("{ax}");
1072 case 'b': return std::string("{bx}");
1073 case 'c': return std::string("{cx}");
1074 case 'd': return std::string("{dx}");
1075 case 'S': return std::string("{si}");
1076 case 'D': return std::string("{di}");
1077 case 't': // top of floating point stack.
1078 return std::string("{st}");
1079 case 'u': // second from top of floating point stack.
1080 return std::string("{st(1)}"); // second from top of floating point stack.
1081 default:
1082 return std::string(1, Constraint);
1083 }
1084}
Eli Friedman872996c2008-08-20 02:34:37 +00001085} // end anonymous namespace
Chris Lattner4b009652007-07-25 00:24:17 +00001086
1087namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001088// X86-32 generic target
1089class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +00001090public:
Eli Friedman872996c2008-08-20 02:34:37 +00001091 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1092 DoubleAlign = LongLongAlign = 32;
1093 LongDoubleWidth = 96;
1094 LongDoubleAlign = 32;
Eli Friedman2b161652008-08-21 00:13:15 +00001095 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1096 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001097 "a0:0:64-f80:32:32-n8:16:32";
Eli Friedman04ede302009-03-29 20:31:09 +00001098 SizeType = UnsignedInt;
1099 PtrDiffType = SignedInt;
1100 IntPtrType = SignedInt;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +00001101 RegParmMax = 3;
Eli Friedman872996c2008-08-20 02:34:37 +00001102 }
1103 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001104 return "typedef char* __builtin_va_list;";
Eli Friedman872996c2008-08-20 02:34:37 +00001105 }
Chris Lattneraa339182009-09-23 06:06:36 +00001106
1107 int getEHDataRegisterNumber(unsigned RegNo) const {
1108 if (RegNo == 0) return 0;
1109 if (RegNo == 1) return 2;
1110 return -1;
1111 }
Eli Friedman872996c2008-08-20 02:34:37 +00001112};
1113} // end anonymous namespace
1114
1115namespace {
Eli Friedman1c79f4b2009-07-05 18:47:56 +00001116class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
1117public:
1118 OpenBSDI386TargetInfo(const std::string& triple) :
1119 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
1120 SizeType = UnsignedLong;
1121 IntPtrType = SignedLong;
Eli Friedman96ada022009-07-05 22:31:18 +00001122 PtrDiffType = SignedLong;
Eli Friedman1c79f4b2009-07-05 18:47:56 +00001123 }
1124};
1125} // end anonymous namespace
1126
1127namespace {
Edwin Török36565e52009-06-30 17:10:35 +00001128class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman872996c2008-08-20 02:34:37 +00001129public:
Edwin Török36565e52009-06-30 17:10:35 +00001130 DarwinI386TargetInfo(const std::string& triple) :
1131 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman872996c2008-08-20 02:34:37 +00001132 LongDoubleWidth = 128;
1133 LongDoubleAlign = 128;
Eli Friedman04ede302009-03-29 20:31:09 +00001134 SizeType = UnsignedLong;
1135 IntPtrType = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +00001136 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1137 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001138 "a0:0:64-f80:128:128-n8:16:32";
Edwin Török2d98f9f2009-06-30 17:00:25 +00001139 }
1140
Eli Friedman872996c2008-08-20 02:34:37 +00001141};
Daniel Dunbar64c77a12009-06-29 20:52:51 +00001142} // end anonymous namespace
1143
1144namespace {
Eli Friedman23cb7912008-08-21 01:40:19 +00001145// x86-32 Windows target
1146class WindowsX86_32TargetInfo : public X86_32TargetInfo {
1147public:
1148 WindowsX86_32TargetInfo(const std::string& triple)
1149 : X86_32TargetInfo(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +00001150 TLSSupported = false;
Chris Lattnera8a69e12009-06-24 17:12:15 +00001151 WCharType = UnsignedShort;
Eli Friedmanb28055e2009-06-08 21:16:17 +00001152 DoubleAlign = LongLongAlign = 64;
1153 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 +00001154 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
1155 "v128:128:128-a0:0:64-f80:32:32-n8:16:32";
Eli Friedman23cb7912008-08-21 01:40:19 +00001156 }
Chris Lattner79682402009-03-20 15:52:06 +00001157 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001158 MacroBuilder &Builder) const {
1159 X86_32TargetInfo::getTargetDefines(Opts, Builder);
Eli Friedman23cb7912008-08-21 01:40:19 +00001160 // This list is based off of the the list of things MingW defines
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001161 Builder.defineMacro("_WIN32");
1162 DefineStd(Builder, "WIN32", Opts);
1163 DefineStd(Builder, "WINNT", Opts);
1164 Builder.defineMacro("_X86_");
Eli Friedman23cb7912008-08-21 01:40:19 +00001165 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001166};
1167} // end anonymous namespace
Eli Friedman6b6ca942009-06-08 06:11:14 +00001168
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001169namespace {
1170
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001171// x86-32 Windows Visual Studio target
1172class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
1173public:
1174 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
1175 : WindowsX86_32TargetInfo(triple) {
1176 }
1177 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001178 MacroBuilder &Builder) const {
1179 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001180 // The value of the following reflects processor type.
1181 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
1182 // We lost the original triple, so we use the default.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001183 Builder.defineMacro("_M_IX86", "600");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001184 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001185};
1186} // end anonymous namespace
1187
1188namespace {
1189// x86-32 MinGW target
1190class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
1191public:
1192 MinGWX86_32TargetInfo(const std::string& triple)
1193 : WindowsX86_32TargetInfo(triple) {
1194 }
1195 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001196 MacroBuilder &Builder) const {
1197 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
1198 Builder.defineMacro("__MSVCRT__");
1199 Builder.defineMacro("__MINGW32__");
1200 Builder.defineMacro("__declspec", "__declspec");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001201 }
1202};
1203} // end anonymous namespace
1204
1205namespace {
1206// x86-32 Cygwin target
1207class CygwinX86_32TargetInfo : public X86_32TargetInfo {
1208public:
1209 CygwinX86_32TargetInfo(const std::string& triple)
1210 : X86_32TargetInfo(triple) {
1211 TLSSupported = false;
1212 WCharType = UnsignedShort;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001213 DoubleAlign = LongLongAlign = 64;
1214 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1215 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001216 "a0:0:64-f80:32:32-n8:16:32";
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001217 }
1218 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001219 MacroBuilder &Builder) const {
1220 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1221 Builder.defineMacro("__CYGWIN__");
1222 Builder.defineMacro("__CYGWIN32__");
1223 DefineStd(Builder, "unix", Opts);
Eli Friedman6b6ca942009-06-08 06:11:14 +00001224 }
Eli Friedman23cb7912008-08-21 01:40:19 +00001225};
1226} // end anonymous namespace
1227
1228namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001229// x86-64 generic target
1230class X86_64TargetInfo : public X86TargetInfo {
1231public:
Chris Lattner79682402009-03-20 15:52:06 +00001232 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +00001233 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001234 LongDoubleWidth = 128;
1235 LongDoubleAlign = 128;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00001236 IntMaxType = SignedLong;
1237 UIntMaxType = UnsignedLong;
Eli Friedman38e31802009-07-01 03:36:11 +00001238 Int64Type = SignedLong;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +00001239 RegParmMax = 6;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00001240
Eli Friedman2b161652008-08-21 00:13:15 +00001241 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1242 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001243 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64";
Chris Lattner4b009652007-07-25 00:24:17 +00001244 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +00001245 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001246 return "typedef struct __va_list_tag {"
1247 " unsigned gp_offset;"
1248 " unsigned fp_offset;"
1249 " void* overflow_arg_area;"
1250 " void* reg_save_area;"
Eli Friedman3c79eee2009-07-03 00:45:06 +00001251 "} __va_list_tag;"
1252 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson7dd1c952007-11-24 23:38:12 +00001253 }
Chris Lattneraa339182009-09-23 06:06:36 +00001254
1255 int getEHDataRegisterNumber(unsigned RegNo) const {
1256 if (RegNo == 0) return 0;
1257 if (RegNo == 1) return 1;
1258 return -1;
1259 }
Eli Friedman872996c2008-08-20 02:34:37 +00001260};
1261} // end anonymous namespace
1262
1263namespace {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001264// x86-64 Windows target
1265class WindowsX86_64TargetInfo : public X86_64TargetInfo {
1266public:
1267 WindowsX86_64TargetInfo(const std::string& triple)
1268 : X86_64TargetInfo(triple) {
1269 TLSSupported = false;
1270 WCharType = UnsignedShort;
Mike Stump4da7a162009-10-08 23:00:00 +00001271 LongWidth = LongAlign = 32;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001272 DoubleAlign = LongLongAlign = 64;
1273 }
1274 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001275 MacroBuilder &Builder) const {
1276 X86_64TargetInfo::getTargetDefines(Opts, Builder);
1277 Builder.defineMacro("_WIN64");
1278 DefineStd(Builder, "WIN64", Opts);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001279 }
1280};
1281} // end anonymous namespace
1282
1283namespace {
1284// x86-64 Windows Visual Studio target
1285class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
1286public:
1287 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
1288 : WindowsX86_64TargetInfo(triple) {
1289 }
1290 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001291 MacroBuilder &Builder) const {
1292 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1293 Builder.defineMacro("_M_X64");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001294 }
1295 virtual const char *getVAListDeclaration() const {
1296 return "typedef char* va_list;";
1297 }
1298};
1299} // end anonymous namespace
1300
1301namespace {
1302// x86-64 MinGW target
1303class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
1304public:
1305 MinGWX86_64TargetInfo(const std::string& triple)
1306 : WindowsX86_64TargetInfo(triple) {
1307 }
1308 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001309 MacroBuilder &Builder) const {
1310 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1311 Builder.defineMacro("__MSVCRT__");
1312 Builder.defineMacro("__MINGW64__");
1313 Builder.defineMacro("__declspec");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001314 }
1315};
1316} // end anonymous namespace
1317
1318namespace {
Eli Friedman38e31802009-07-01 03:36:11 +00001319class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
1320public:
Mike Stump25cf7602009-09-09 15:08:12 +00001321 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman38e31802009-07-01 03:36:11 +00001322 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
1323 Int64Type = SignedLongLong;
1324 }
1325};
1326} // end anonymous namespace
1327
1328namespace {
Eli Friedman96ada022009-07-05 22:31:18 +00001329class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
1330public:
Mike Stump25cf7602009-09-09 15:08:12 +00001331 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman96ada022009-07-05 22:31:18 +00001332 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
1333 IntMaxType = SignedLongLong;
1334 UIntMaxType = UnsignedLongLong;
1335 Int64Type = SignedLongLong;
1336 }
1337};
1338} // end anonymous namespace
1339
1340namespace {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001341class ARMTargetInfo : public TargetInfo {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001342 // Possible FPU choices.
1343 enum FPUMode {
1344 NoFPU,
1345 VFP2FPU,
1346 VFP3FPU,
1347 NeonFPU
1348 };
1349
1350 static bool FPUModeIsVFP(FPUMode Mode) {
1351 return Mode >= VFP2FPU && Mode <= NeonFPU;
1352 }
1353
1354 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1355 static const char * const GCCRegNames[];
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001356
Daniel Dunbar33b40752009-12-18 18:42:37 +00001357 std::string ABI, CPU;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001358
1359 unsigned FPU : 3;
1360
Daniel Dunbar48075d82009-12-19 04:15:38 +00001361 unsigned IsThumb : 1;
1362
1363 // Initialized via features.
1364 unsigned SoftFloat : 1;
1365 unsigned SoftFloatABI : 1;
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001366
Chris Lattnerb4527522010-03-03 19:03:45 +00001367 static const Builtin::Info BuiltinInfo[];
1368
Chris Lattner9fd73612008-04-21 18:56:49 +00001369public:
Daniel Dunbarf0156562009-09-17 16:21:10 +00001370 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbar33b40752009-12-18 18:42:37 +00001371 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001372 {
Daniel Dunbarb9531632009-09-14 00:02:24 +00001373 SizeType = UnsignedInt;
1374 PtrDiffType = SignedInt;
Daniel Dunbarf0156562009-09-17 16:21:10 +00001375
Daniel Dunbar33b40752009-12-18 18:42:37 +00001376 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0a542ca2009-12-18 19:57:13 +00001377 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001378 if (IsThumb) {
1379 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1380 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001381 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001382 } else {
1383 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1384 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001385 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001386 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001387 }
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001388 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbarb9531632009-09-14 00:02:24 +00001389 virtual bool setABI(const std::string &Name) {
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001390 ABI = Name;
1391
Daniel Dunbarb9531632009-09-14 00:02:24 +00001392 // The defaults (above) are for AAPCS, check if we need to change them.
1393 //
1394 // FIXME: We need support for -meabi... we could just mangle it into the
1395 // name.
1396 if (Name == "apcs-gnu") {
Daniel Dunbarda94a772010-01-27 20:23:08 +00001397 DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
Daniel Dunbarb9531632009-09-14 00:02:24 +00001398 SizeType = UnsignedLong;
1399
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001400 if (IsThumb) {
1401 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1402 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001403 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001404 } else {
1405 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1406 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001407 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001408 }
1409
Daniel Dunbarb9531632009-09-14 00:02:24 +00001410 // FIXME: Override "preferred align" for double and long long.
1411 } else if (Name == "aapcs") {
1412 // FIXME: Enumerated types are variable width in straight AAPCS.
1413 } else if (Name == "aapcs-linux") {
1414 ;
1415 } else
1416 return false;
1417
1418 return true;
1419 }
Daniel Dunbar48075d82009-12-19 04:15:38 +00001420
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001421 void getDefaultFeatures(const std::string &CPU,
1422 llvm::StringMap<bool> &Features) const {
1423 // FIXME: This should not be here.
1424 Features["vfp2"] = false;
1425 Features["vfp3"] = false;
1426 Features["neon"] = false;
1427
1428 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
1429 Features["vfp2"] = true;
1430 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
1431 Features["neon"] = true;
1432 }
1433
Daniel Dunbar48075d82009-12-19 04:15:38 +00001434 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1435 const std::string &Name,
1436 bool Enabled) const {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001437 if (Name == "soft-float" || Name == "soft-float-abi") {
1438 Features[Name] = Enabled;
1439 } else if (Name == "vfp2" || Name == "vfp3" || Name == "neon") {
1440 // These effectively are a single option, reset them when any is enabled.
1441 if (Enabled)
1442 Features["vfp2"] = Features["vfp3"] = Features["neon"] = false;
1443 Features[Name] = Enabled;
1444 } else
Daniel Dunbar48075d82009-12-19 04:15:38 +00001445 return false;
1446
Daniel Dunbar48075d82009-12-19 04:15:38 +00001447 return true;
1448 }
1449
1450 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001451 FPU = NoFPU;
Daniel Dunbar48075d82009-12-19 04:15:38 +00001452 SoftFloat = SoftFloatABI = false;
1453 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
1454 if (Features[i] == "+soft-float")
1455 SoftFloat = true;
1456 else if (Features[i] == "+soft-float-abi")
1457 SoftFloatABI = true;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001458 else if (Features[i] == "+vfp2")
1459 FPU = VFP2FPU;
1460 else if (Features[i] == "+vfp3")
1461 FPU = VFP3FPU;
1462 else if (Features[i] == "+neon")
1463 FPU = NeonFPU;
Daniel Dunbar48075d82009-12-19 04:15:38 +00001464 }
1465
1466 // Remove front-end specific options which the backend handles differently.
1467 std::vector<std::string>::iterator it;
1468 it = std::find(Features.begin(), Features.end(), "+soft-float");
1469 if (it != Features.end())
1470 Features.erase(it);
1471 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
1472 if (it != Features.end())
1473 Features.erase(it);
1474 }
1475
Daniel Dunbar33b40752009-12-18 18:42:37 +00001476 static const char *getCPUDefineSuffix(llvm::StringRef Name) {
1477 return llvm::StringSwitch<const char*>(Name)
1478 .Cases("arm8", "arm810", "4")
1479 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
1480 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
1481 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
1482 .Case("ep9312", "4T")
1483 .Cases("arm10tdmi", "arm1020t", "5T")
1484 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
1485 .Case("arm926ej-s", "5TEJ")
1486 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
1487 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001488 .Case("arm1136j-s", "6J")
Daniel Dunbar33b40752009-12-18 18:42:37 +00001489 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001490 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbar33b40752009-12-18 18:42:37 +00001491 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
1492 .Cases("cortex-a8", "cortex-a9", "7A")
1493 .Default(0);
1494 }
1495 virtual bool setCPU(const std::string &Name) {
1496 if (!getCPUDefineSuffix(Name))
1497 return false;
1498
1499 CPU = Name;
1500 return true;
1501 }
Chris Lattner79682402009-03-20 15:52:06 +00001502 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001503 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00001504 // Target identification.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001505 Builder.defineMacro("__arm");
1506 Builder.defineMacro("__arm__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001507
Chris Lattnerbef1d722009-03-02 22:27:17 +00001508 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001509 Builder.defineMacro("__ARMEL__");
1510 Builder.defineMacro("__LITTLE_ENDIAN__");
1511 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001512
1513 llvm::StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001514 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001515
Mike Stumpf90a29f2009-04-08 02:07:04 +00001516 // Subtarget options.
Daniel Dunbarf0156562009-09-17 16:21:10 +00001517
Daniel Dunbar33b40752009-12-18 18:42:37 +00001518 // FIXME: It's more complicated than this and we don't really support
1519 // interworking.
1520 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001521 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001522
Daniel Dunbar33b40752009-12-18 18:42:37 +00001523 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001524 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001525
Daniel Dunbar48075d82009-12-19 04:15:38 +00001526 if (SoftFloat)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001527 Builder.defineMacro("__SOFTFP__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001528
1529 if (CPU == "xscale")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001530 Builder.defineMacro("__XSCALE__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001531
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001532 bool IsThumb2 = IsThumb && (CPUArch == "6T2" || CPUArch.startswith("7"));
Daniel Dunbarf0156562009-09-17 16:21:10 +00001533 if (IsThumb) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001534 Builder.defineMacro("__THUMBEL__");
1535 Builder.defineMacro("__thumb__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001536 if (IsThumb2)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001537 Builder.defineMacro("__thumb2__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001538 }
1539
1540 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001541 Builder.defineMacro("__APCS_32__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001542
1543 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001544 Builder.defineMacro("__VFP_FP__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001545
1546 // This only gets set when Neon instructions are actually available, unlike
1547 // the VFP define, hence the soft float and arch check. This is subtly
1548 // different from gcc, we follow the intent which was that it should be set
1549 // when Neon instructions are actually available.
1550 if (FPU == NeonFPU && !SoftFloat && IsThumb2)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001551 Builder.defineMacro("__ARM_NEON__");
Chris Lattner9fd73612008-04-21 18:56:49 +00001552 }
1553 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1554 unsigned &NumRecords) const {
Chris Lattnerb4527522010-03-03 19:03:45 +00001555 Records = BuiltinInfo;
1556 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner9fd73612008-04-21 18:56:49 +00001557 }
1558 virtual const char *getVAListDeclaration() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001559 return "typedef char* __builtin_va_list;";
Chris Lattner9fd73612008-04-21 18:56:49 +00001560 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001561 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001562 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001563 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001564 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001565 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001566 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001567 // FIXME: Check if this is complete
Anders Carlsson36834a72009-02-28 17:11:49 +00001568 switch (*Name) {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001569 default:
Nate Begeman222823a2008-04-22 05:03:19 +00001570 case 'l': // r0-r7
1571 case 'h': // r8-r15
1572 case 'w': // VFP Floating point register single precision
1573 case 'P': // VFP Floating point register double precision
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001574 Info.setAllowsRegister();
Nate Begeman222823a2008-04-22 05:03:19 +00001575 return true;
1576 }
Chris Lattner9fd73612008-04-21 18:56:49 +00001577 return false;
1578 }
1579 virtual const char *getClobbers() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001580 // FIXME: Is this really right?
Chris Lattner9fd73612008-04-21 18:56:49 +00001581 return "";
1582 }
1583};
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001584
1585const char * const ARMTargetInfo::GCCRegNames[] = {
1586 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1587 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1588};
1589
1590void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
1591 unsigned &NumNames) const {
1592 Names = GCCRegNames;
1593 NumNames = llvm::array_lengthof(GCCRegNames);
1594}
1595
1596const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
1597
1598 { { "a1" }, "r0" },
1599 { { "a2" }, "r1" },
1600 { { "a3" }, "r2" },
1601 { { "a4" }, "r3" },
1602 { { "v1" }, "r4" },
1603 { { "v2" }, "r5" },
1604 { { "v3" }, "r6" },
1605 { { "v4" }, "r7" },
1606 { { "v5" }, "r8" },
1607 { { "v6", "rfp" }, "r9" },
1608 { { "sl" }, "r10" },
1609 { { "fp" }, "r11" },
1610 { { "ip" }, "r12" },
1611 { { "sp" }, "r13" },
1612 { { "lr" }, "r14" },
1613 { { "pc" }, "r15" },
1614};
1615
1616void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1617 unsigned &NumAliases) const {
1618 Aliases = GCCRegAliases;
1619 NumAliases = llvm::array_lengthof(GCCRegAliases);
1620}
Chris Lattnerb4527522010-03-03 19:03:45 +00001621
1622const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
1623#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
1624#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
1625#include "clang/Basic/BuiltinsARM.def"
1626};
Chris Lattner9fd73612008-04-21 18:56:49 +00001627} // end anonymous namespace.
1628
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001629
1630namespace {
Mike Stump25cf7602009-09-09 15:08:12 +00001631class DarwinARMTargetInfo :
Edwin Török36565e52009-06-30 17:10:35 +00001632 public DarwinTargetInfo<ARMTargetInfo> {
1633protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +00001634 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001635 MacroBuilder &Builder) const {
Daniel Dunbareab96a22010-01-26 01:44:04 +00001636 getDarwinDefines(Builder, Opts, Triple);
Eli Friedman8f575172009-04-19 21:38:35 +00001637 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001638
Edwin Török36565e52009-06-30 17:10:35 +00001639public:
Mike Stump25cf7602009-09-09 15:08:12 +00001640 DarwinARMTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +00001641 : DarwinTargetInfo<ARMTargetInfo>(triple) {}
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001642};
1643} // end anonymous namespace.
1644
Chris Lattner4b009652007-07-25 00:24:17 +00001645namespace {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001646class SparcV8TargetInfo : public TargetInfo {
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001647 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1648 static const char * const GCCRegNames[];
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001649public:
Eli Friedmanff158dd2008-08-20 07:28:14 +00001650 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
1651 // FIXME: Support Sparc quad-precision long double?
Eli Friedman2b161652008-08-21 00:13:15 +00001652 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 +00001653 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedmanff158dd2008-08-20 07:28:14 +00001654 }
Chris Lattner79682402009-03-20 15:52:06 +00001655 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001656 MacroBuilder &Builder) const {
1657 DefineStd(Builder, "sparc", Opts);
1658 Builder.defineMacro("__sparcv8");
1659 Builder.defineMacro("__REGISTER_PREFIX__", "");
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001660 }
1661 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1662 unsigned &NumRecords) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001663 // FIXME: Implement!
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001664 }
1665 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001666 return "typedef void* __builtin_va_list;";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001667 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001668 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001669 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001670 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001671 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001672 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001673 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001674 // FIXME: Implement!
1675 return false;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001676 }
1677 virtual const char *getClobbers() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001678 // FIXME: Implement!
1679 return "";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001680 }
1681};
1682
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001683const char * const SparcV8TargetInfo::GCCRegNames[] = {
1684 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1685 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1686 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1687 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
1688};
1689
Anton Korobeynikove7772382009-05-03 13:42:53 +00001690void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001691 unsigned &NumNames) const {
1692 Names = GCCRegNames;
1693 NumNames = llvm::array_lengthof(GCCRegNames);
1694}
1695
1696const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikove7772382009-05-03 13:42:53 +00001697 { { "g0" }, "r0" },
1698 { { "g1" }, "r1" },
1699 { { "g2" }, "r2" },
1700 { { "g3" }, "r3" },
1701 { { "g4" }, "r4" },
1702 { { "g5" }, "r5" },
1703 { { "g6" }, "r6" },
1704 { { "g7" }, "r7" },
1705 { { "o0" }, "r8" },
1706 { { "o1" }, "r9" },
1707 { { "o2" }, "r10" },
1708 { { "o3" }, "r11" },
1709 { { "o4" }, "r12" },
1710 { { "o5" }, "r13" },
1711 { { "o6", "sp" }, "r14" },
1712 { { "o7" }, "r15" },
1713 { { "l0" }, "r16" },
1714 { { "l1" }, "r17" },
1715 { { "l2" }, "r18" },
1716 { { "l3" }, "r19" },
1717 { { "l4" }, "r20" },
1718 { { "l5" }, "r21" },
1719 { { "l6" }, "r22" },
1720 { { "l7" }, "r23" },
1721 { { "i0" }, "r24" },
1722 { { "i1" }, "r25" },
1723 { { "i2" }, "r26" },
1724 { { "i3" }, "r27" },
1725 { { "i4" }, "r28" },
1726 { { "i5" }, "r29" },
1727 { { "i6", "fp" }, "r30" },
1728 { { "i7" }, "r31" },
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001729};
1730
Anton Korobeynikove7772382009-05-03 13:42:53 +00001731void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001732 unsigned &NumAliases) const {
1733 Aliases = GCCRegAliases;
1734 NumAliases = llvm::array_lengthof(GCCRegAliases);
1735}
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001736} // end anonymous namespace.
1737
Eli Friedmanff158dd2008-08-20 07:28:14 +00001738namespace {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00001739class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
1740public:
1741 AuroraUXSparcV8TargetInfo(const std::string& triple) :
1742 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
1743 SizeType = UnsignedInt;
1744 PtrDiffType = SignedInt;
1745 }
1746};
Edwin Török36565e52009-06-30 17:10:35 +00001747class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001748public:
1749 SolarisSparcV8TargetInfo(const std::string& triple) :
Edwin Török36565e52009-06-30 17:10:35 +00001750 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedman7cca0982008-11-02 02:43:55 +00001751 SizeType = UnsignedInt;
1752 PtrDiffType = SignedInt;
Eli Friedmanff158dd2008-08-20 07:28:14 +00001753 }
1754};
1755} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +00001756
Chris Lattner85970f32008-05-08 05:58:21 +00001757namespace {
1758 class PIC16TargetInfo : public TargetInfo{
1759 public:
1760 PIC16TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +00001761 TLSSupported = false;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001762 IntWidth = 16;
1763 LongWidth = LongLongWidth = 32;
1764 PointerWidth = 16;
1765 IntAlign = 8;
1766 LongAlign = LongLongAlign = 8;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001767 PointerAlign = 8;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001768 SizeType = UnsignedInt;
1769 IntMaxType = SignedLong;
1770 UIntMaxType = UnsignedLong;
Chris Lattnerd9ef7242009-02-13 22:28:55 +00001771 IntPtrType = SignedShort;
Eli Friedman7cca0982008-11-02 02:43:55 +00001772 PtrDiffType = SignedInt;
Edward O'Callaghan14a70a32009-11-21 00:49:54 +00001773 SigAtomicType = SignedLong;
Sanjiv Guptaae8f1e82009-06-02 04:43:46 +00001774 FloatWidth = 32;
1775 FloatAlign = 32;
1776 DoubleWidth = 32;
1777 DoubleAlign = 32;
1778 LongDoubleWidth = 32;
1779 LongDoubleAlign = 32;
1780 FloatFormat = &llvm::APFloat::IEEEsingle;
1781 DoubleFormat = &llvm::APFloat::IEEEsingle;
1782 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner2e17d912009-11-07 18:59:41 +00001783 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 +00001784
Chris Lattner85970f32008-05-08 05:58:21 +00001785 }
Chris Lattner727b3c42008-05-09 06:08:39 +00001786 virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }
1787 virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }
Chris Lattner79682402009-03-20 15:52:06 +00001788 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001789 MacroBuilder &Builder) const {
1790 Builder.defineMacro("__pic16");
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00001791 Builder.defineMacro("__PIC16");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001792 Builder.defineMacro("rom", "__attribute__((address_space(1)))");
1793 Builder.defineMacro("ram", "__attribute__((address_space(0)))");
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00001794 Builder.defineMacro("__section(SectName)",
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00001795 "__attribute__((section(SectName)))");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001796 Builder.defineMacro("near",
Sanjiv Gupta09e95f02009-10-24 18:08:20 +00001797 "__attribute__((section(\"Address=NEAR\")))");
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00001798 Builder.defineMacro("__address(Addr)",
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00001799 "__attribute__((section(\"Address=\"#Addr)))");
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00001800 Builder.defineMacro("__config(conf)", "asm(\"CONFIG \"#conf)");
1801 Builder.defineMacro("__idlocs(value)", "asm(\"__IDLOCS \"#value)");
1802 Builder.defineMacro("interrupt",
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00001803 "__attribute__((section(\"interrupt=0x4\"))) \
1804 __attribute__((used))");
Chris Lattner85970f32008-05-08 05:58:21 +00001805 }
1806 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1807 unsigned &NumRecords) const {}
Mike Stump25cf7602009-09-09 15:08:12 +00001808 virtual const char *getVAListDeclaration() const {
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00001809 return "typedef char* __builtin_va_list;";
Daniel Dunbar2e967de2009-08-24 09:54:37 +00001810 }
1811 virtual const char *getClobbers() const {
1812 return "";
1813 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001814 virtual void getGCCRegNames(const char * const *&Names,
1815 unsigned &NumNames) const {}
1816 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner85970f32008-05-08 05:58:21 +00001817 TargetInfo::ConstraintInfo &info) const {
1818 return true;
1819 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001820 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner85970f32008-05-08 05:58:21 +00001821 unsigned &NumAliases) const {}
1822 virtual bool useGlobalsForAutomaticVariables() const {return true;}
1823 };
1824}
1825
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001826namespace {
1827 class MSP430TargetInfo : public TargetInfo {
1828 static const char * const GCCRegNames[];
1829 public:
1830 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
1831 TLSSupported = false;
Anton Korobeynikov2a6630a2010-01-30 12:55:11 +00001832 IntWidth = 16; IntAlign = 16;
1833 LongWidth = 32; LongLongWidth = 64;
1834 LongAlign = LongLongAlign = 16;
1835 PointerWidth = 16; PointerAlign = 16;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001836 SizeType = UnsignedInt;
1837 IntMaxType = SignedLong;
1838 UIntMaxType = UnsignedLong;
1839 IntPtrType = SignedShort;
1840 PtrDiffType = SignedInt;
Edward O'Callaghan14a70a32009-11-21 00:49:54 +00001841 SigAtomicType = SignedLong;
Anton Korobeynikov314713f2009-12-19 01:32:37 +00001842 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001843 }
1844 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001845 MacroBuilder &Builder) const {
1846 Builder.defineMacro("MSP430");
1847 Builder.defineMacro("__MSP430__");
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001848 // FIXME: defines for different 'flavours' of MCU
1849 }
1850 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1851 unsigned &NumRecords) const {
1852 // FIXME: Implement.
1853 Records = 0;
1854 NumRecords = 0;
1855 }
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001856 virtual void getGCCRegNames(const char * const *&Names,
1857 unsigned &NumNames) const;
1858 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1859 unsigned &NumAliases) const {
1860 // No aliases.
1861 Aliases = 0;
1862 NumAliases = 0;
1863 }
1864 virtual bool validateAsmConstraint(const char *&Name,
1865 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov174219b2009-10-15 23:17:13 +00001866 // No target constraints for now.
1867 return false;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001868 }
1869 virtual const char *getClobbers() const {
1870 // FIXME: Is this really right?
1871 return "";
1872 }
1873 virtual const char *getVAListDeclaration() const {
1874 // FIXME: implement
Anton Korobeynikovf5955592009-05-08 18:24:57 +00001875 return "typedef char* __builtin_va_list;";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001876 }
1877 };
1878
1879 const char * const MSP430TargetInfo::GCCRegNames[] = {
1880 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1881 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1882 };
1883
1884 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
1885 unsigned &NumNames) const {
1886 Names = GCCRegNames;
1887 NumNames = llvm::array_lengthof(GCCRegNames);
1888 }
1889}
1890
1891
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001892namespace {
1893 class SystemZTargetInfo : public TargetInfo {
1894 static const char * const GCCRegNames[];
1895 public:
1896 SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
1897 TLSSupported = false;
1898 IntWidth = IntAlign = 32;
1899 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
1900 PointerWidth = PointerAlign = 64;
Chris Lattner2e17d912009-11-07 18:59:41 +00001901 DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
1902 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001903 }
1904 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001905 MacroBuilder &Builder) const {
1906 Builder.defineMacro("__s390__");
1907 Builder.defineMacro("__s390x__");
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001908 }
1909 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1910 unsigned &NumRecords) const {
1911 // FIXME: Implement.
1912 Records = 0;
1913 NumRecords = 0;
1914 }
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001915
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001916 virtual void getGCCRegNames(const char * const *&Names,
1917 unsigned &NumNames) const;
1918 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1919 unsigned &NumAliases) const {
1920 // No aliases.
1921 Aliases = 0;
1922 NumAliases = 0;
1923 }
1924 virtual bool validateAsmConstraint(const char *&Name,
1925 TargetInfo::ConstraintInfo &info) const {
1926 // FIXME: implement
1927 return true;
1928 }
1929 virtual const char *getClobbers() const {
1930 // FIXME: Is this really right?
1931 return "";
1932 }
1933 virtual const char *getVAListDeclaration() const {
1934 // FIXME: implement
1935 return "typedef char* __builtin_va_list;";
1936 }
1937 };
1938
1939 const char * const SystemZTargetInfo::GCCRegNames[] = {
1940 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1941 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1942 };
1943
1944 void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
1945 unsigned &NumNames) const {
1946 Names = GCCRegNames;
1947 NumNames = llvm::array_lengthof(GCCRegNames);
1948 }
1949}
1950
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001951namespace {
1952 class BlackfinTargetInfo : public TargetInfo {
1953 static const char * const GCCRegNames[];
1954 public:
1955 BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
1956 TLSSupported = false;
1957 DoubleAlign = 32;
1958 LongLongAlign = 32;
1959 LongDoubleAlign = 32;
Chris Lattner2e17d912009-11-07 18:59:41 +00001960 DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001961 }
1962
1963 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001964 MacroBuilder &Builder) const {
1965 DefineStd(Builder, "bfin", Opts);
1966 DefineStd(Builder, "BFIN", Opts);
1967 Builder.defineMacro("__ADSPBLACKFIN__");
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001968 // FIXME: This one is really dependent on -mcpu
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001969 Builder.defineMacro("__ADSPLPBLACKFIN__");
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001970 // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
1971 }
1972
1973 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1974 unsigned &NumRecords) const {
1975 // FIXME: Implement.
1976 Records = 0;
1977 NumRecords = 0;
1978 }
1979
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001980 virtual void getGCCRegNames(const char * const *&Names,
1981 unsigned &NumNames) const;
1982
1983 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1984 unsigned &NumAliases) const {
1985 // No aliases.
1986 Aliases = 0;
1987 NumAliases = 0;
1988 }
1989
1990 virtual bool validateAsmConstraint(const char *&Name,
1991 TargetInfo::ConstraintInfo &Info) const {
1992 if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
1993 Info.setAllowsRegister();
1994 return true;
1995 }
1996 return false;
1997 }
1998
1999 virtual const char *getClobbers() const {
2000 return "";
2001 }
2002
2003 virtual const char *getVAListDeclaration() const {
2004 return "typedef char* __builtin_va_list;";
2005 }
2006 };
2007
2008 const char * const BlackfinTargetInfo::GCCRegNames[] = {
2009 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2010 "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
2011 "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
2012 "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
2013 "a0", "a1", "cc",
2014 "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
2015 "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
2016 };
2017
2018 void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
2019 unsigned &NumNames) const {
2020 Names = GCCRegNames;
2021 NumNames = llvm::array_lengthof(GCCRegNames);
2022 }
2023}
2024
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002025namespace {
2026
Mike Stump25cf7602009-09-09 15:08:12 +00002027 // LLVM and Clang cannot be used directly to output native binaries for
2028 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002029 // type and alignment information.
Mike Stump25cf7602009-09-09 15:08:12 +00002030 //
2031 // TCE uses the llvm bitcode as input and uses it for generating customized
2032 // target processor and program binary. TCE co-design environment is
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002033 // publicly available in http://tce.cs.tut.fi
2034
2035 class TCETargetInfo : public TargetInfo{
2036 public:
2037 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
2038 TLSSupported = false;
2039 IntWidth = 32;
2040 LongWidth = LongLongWidth = 32;
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002041 PointerWidth = 32;
2042 IntAlign = 32;
2043 LongAlign = LongLongAlign = 32;
2044 PointerAlign = 32;
2045 SizeType = UnsignedInt;
2046 IntMaxType = SignedLong;
2047 UIntMaxType = UnsignedLong;
2048 IntPtrType = SignedInt;
2049 PtrDiffType = SignedInt;
2050 FloatWidth = 32;
2051 FloatAlign = 32;
2052 DoubleWidth = 32;
2053 DoubleAlign = 32;
2054 LongDoubleWidth = 32;
2055 LongDoubleAlign = 32;
2056 FloatFormat = &llvm::APFloat::IEEEsingle;
2057 DoubleFormat = &llvm::APFloat::IEEEsingle;
2058 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner8a1db932010-03-04 21:07:38 +00002059 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
2060 "i16:16:32-i32:32:32-i64:32:32-"
2061 "f32:32:32-f64:64:64-v64:64:64-"
2062 "v128:128:128-a0:0:64-n32";
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002063 }
2064
2065 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002066 MacroBuilder &Builder) const {
2067 DefineStd(Builder, "tce", Opts);
2068 Builder.defineMacro("__TCE__");
2069 Builder.defineMacro("__TCE_V1__");
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002070 }
2071 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2072 unsigned &NumRecords) const {}
Daniel Dunbar2e967de2009-08-24 09:54:37 +00002073 virtual const char *getClobbers() const {
2074 return "";
2075 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002076 virtual const char *getVAListDeclaration() const {
2077 return "typedef void* __builtin_va_list;";
2078 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002079 virtual void getGCCRegNames(const char * const *&Names,
2080 unsigned &NumNames) const {}
2081 virtual bool validateAsmConstraint(const char *&Name,
2082 TargetInfo::ConstraintInfo &info) const {
2083 return true;
2084 }
2085 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2086 unsigned &NumAliases) const {}
2087 };
2088}
2089
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002090namespace {
2091class MipsTargetInfo : public TargetInfo {
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002092 std::string ABI, CPU;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002093 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2094 static const char * const GCCRegNames[];
2095public:
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002096 MipsTargetInfo(const std::string& triple) : TargetInfo(triple), ABI("o32") {
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002097 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2098 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2099 }
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002100 virtual const char *getABI() const { return ABI.c_str(); }
2101 virtual bool setABI(const std::string &Name) {
2102
2103 if ((Name == "o32") || (Name == "eabi")) {
2104 ABI = Name;
2105 return true;
2106 } else
2107 return false;
2108 }
2109 virtual bool setCPU(const std::string &Name) {
2110 CPU = Name;
2111 return true;
2112 }
2113 void getDefaultFeatures(const std::string &CPU,
2114 llvm::StringMap<bool> &Features) const {
2115 Features[ABI] = true;
2116 Features[CPU] = true;
2117 }
2118 virtual void getArchDefines(const LangOptions &Opts,
2119 MacroBuilder &Builder) const {
2120 if (ABI == "o32")
2121 Builder.defineMacro("__mips_o32");
2122 else if (ABI == "eabi")
2123 Builder.defineMacro("__mips_eabi");
2124 }
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002125 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002126 MacroBuilder &Builder) const {
2127 DefineStd(Builder, "mips", Opts);
2128 Builder.defineMacro("_mips");
2129 DefineStd(Builder, "MIPSEB", Opts);
2130 Builder.defineMacro("_MIPSEB");
2131 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002132 getArchDefines(Opts, Builder);
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002133 }
2134 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2135 unsigned &NumRecords) const {
2136 // FIXME: Implement!
2137 }
2138 virtual const char *getVAListDeclaration() const {
2139 return "typedef void* __builtin_va_list;";
2140 }
2141 virtual void getGCCRegNames(const char * const *&Names,
2142 unsigned &NumNames) const;
2143 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2144 unsigned &NumAliases) const;
2145 virtual bool validateAsmConstraint(const char *&Name,
2146 TargetInfo::ConstraintInfo &Info) const {
2147 switch (*Name) {
2148 default:
2149 case 'r': // CPU registers.
2150 case 'd': // Equivalent to "r" unless generating MIPS16 code.
2151 case 'y': // Equivalent to "r", backwards compatibility only.
2152 case 'f': // floating-point registers.
2153 Info.setAllowsRegister();
2154 return true;
2155 }
2156 return false;
2157 }
2158
2159 virtual const char *getClobbers() const {
2160 // FIXME: Implement!
2161 return "";
2162 }
2163};
2164
2165const char * const MipsTargetInfo::GCCRegNames[] = {
2166 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
2167 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
2168 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
2169 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
2170 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
2171 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
2172 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
2173 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
2174 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
2175 "$fcc5","$fcc6","$fcc7"
2176};
2177
2178void MipsTargetInfo::getGCCRegNames(const char * const *&Names,
2179 unsigned &NumNames) const {
2180 Names = GCCRegNames;
2181 NumNames = llvm::array_lengthof(GCCRegNames);
2182}
2183
2184const TargetInfo::GCCRegAlias MipsTargetInfo::GCCRegAliases[] = {
2185 { { "at" }, "$1" },
2186 { { "v0" }, "$2" },
2187 { { "v1" }, "$3" },
2188 { { "a0" }, "$4" },
2189 { { "a1" }, "$5" },
2190 { { "a2" }, "$6" },
2191 { { "a3" }, "$7" },
2192 { { "t0" }, "$8" },
2193 { { "t1" }, "$9" },
2194 { { "t2" }, "$10" },
2195 { { "t3" }, "$11" },
2196 { { "t4" }, "$12" },
2197 { { "t5" }, "$13" },
2198 { { "t6" }, "$14" },
2199 { { "t7" }, "$15" },
2200 { { "s0" }, "$16" },
2201 { { "s1" }, "$17" },
2202 { { "s2" }, "$18" },
2203 { { "s3" }, "$19" },
2204 { { "s4" }, "$20" },
2205 { { "s5" }, "$21" },
2206 { { "s6" }, "$22" },
2207 { { "s7" }, "$23" },
2208 { { "t8" }, "$24" },
2209 { { "t9" }, "$25" },
2210 { { "k0" }, "$26" },
2211 { { "k1" }, "$27" },
2212 { { "gp" }, "$28" },
2213 { { "sp" }, "$29" },
2214 { { "fp" }, "$30" },
2215 { { "ra" }, "$31" }
2216};
2217
2218void MipsTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2219 unsigned &NumAliases) const {
2220 Aliases = GCCRegAliases;
2221 NumAliases = llvm::array_lengthof(GCCRegAliases);
2222}
2223} // end anonymous namespace.
2224
2225namespace {
2226class MipselTargetInfo : public MipsTargetInfo {
2227public:
2228 MipselTargetInfo(const std::string& triple) : MipsTargetInfo(triple) {
2229 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2230 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2231 }
2232
2233 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002234 MacroBuilder &Builder) const;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002235};
2236
2237void MipselTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002238 MacroBuilder &Builder) const {
2239 DefineStd(Builder, "mips", Opts);
2240 Builder.defineMacro("_mips");
2241 DefineStd(Builder, "MIPSEL", Opts);
2242 Builder.defineMacro("_MIPSEL");
2243 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002244 getArchDefines(Opts, Builder);
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002245}
2246} // end anonymous namespace.
2247
Chris Lattner4b009652007-07-25 00:24:17 +00002248//===----------------------------------------------------------------------===//
2249// Driver code
2250//===----------------------------------------------------------------------===//
2251
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002252static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002253 llvm::Triple Triple(T);
2254 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002255
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002256 switch (Triple.getArch()) {
2257 default:
2258 return NULL;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002259
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002260 case llvm::Triple::arm:
Daniel Dunbar3f361b52009-09-11 01:14:50 +00002261 case llvm::Triple::thumb:
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002262 switch (os) {
2263 case llvm::Triple::Darwin:
Eli Friedman2b161652008-08-21 00:13:15 +00002264 return new DarwinARMTargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002265 case llvm::Triple::FreeBSD:
Edwin Török36565e52009-06-30 17:10:35 +00002266 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002267 default:
2268 return new ARMTargetInfo(T);
2269 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002270
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002271 case llvm::Triple::bfin:
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002272 return new BlackfinTargetInfo(T);
2273
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002274 case llvm::Triple::msp430:
2275 return new MSP430TargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002276
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002277 case llvm::Triple::mips:
2278 if (os == llvm::Triple::Psp)
2279 return new PSPTargetInfo<MipsTargetInfo>(T);
2280 if (os == llvm::Triple::Linux)
2281 return new LinuxTargetInfo<MipsTargetInfo>(T);
2282 return new MipsTargetInfo(T);
2283
2284 case llvm::Triple::mipsel:
2285 if (os == llvm::Triple::Psp)
2286 return new PSPTargetInfo<MipselTargetInfo>(T);
2287 if (os == llvm::Triple::Linux)
2288 return new LinuxTargetInfo<MipselTargetInfo>(T);
2289 return new MipselTargetInfo(T);
2290
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002291 case llvm::Triple::pic16:
2292 return new PIC16TargetInfo(T);
2293
2294 case llvm::Triple::ppc:
2295 if (os == llvm::Triple::Darwin)
2296 return new DarwinTargetInfo<PPCTargetInfo>(T);
Chris Lattnerf8030412010-02-16 18:14:57 +00002297 else if (os == llvm::Triple::FreeBSD)
2298 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002299 return new PPC32TargetInfo(T);
2300
2301 case llvm::Triple::ppc64:
2302 if (os == llvm::Triple::Darwin)
2303 return new DarwinTargetInfo<PPC64TargetInfo>(T);
John Thompsoned7bdbc2009-11-19 17:18:50 +00002304 else if (os == llvm::Triple::Lv2)
2305 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Chris Lattnerf8030412010-02-16 18:14:57 +00002306 else if (os == llvm::Triple::FreeBSD)
2307 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002308 return new PPC64TargetInfo(T);
2309
Chris Lattner2c026472010-03-06 21:21:27 +00002310 case llvm::Triple::mblaze:
2311 return new MBlazeTargetInfo(T);
2312
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002313 case llvm::Triple::sparc:
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002314 if (os == llvm::Triple::AuroraUX)
2315 return new AuroraUXSparcV8TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002316 if (os == llvm::Triple::Solaris)
2317 return new SolarisSparcV8TargetInfo(T);
2318 return new SparcV8TargetInfo(T);
2319
John Thompsoned7bdbc2009-11-19 17:18:50 +00002320 // FIXME: Need a real SPU target.
2321 case llvm::Triple::cellspu:
2322 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
2323
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002324 case llvm::Triple::systemz:
2325 return new SystemZTargetInfo(T);
2326
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002327 case llvm::Triple::tce:
2328 return new TCETargetInfo(T);
2329
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002330 case llvm::Triple::x86:
2331 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002332 case llvm::Triple::AuroraUX:
2333 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002334 case llvm::Triple::Darwin:
2335 return new DarwinI386TargetInfo(T);
2336 case llvm::Triple::Linux:
2337 return new LinuxTargetInfo<X86_32TargetInfo>(T);
2338 case llvm::Triple::DragonFly:
2339 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
2340 case llvm::Triple::NetBSD:
2341 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
2342 case llvm::Triple::OpenBSD:
2343 return new OpenBSDI386TargetInfo(T);
2344 case llvm::Triple::FreeBSD:
2345 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
2346 case llvm::Triple::Solaris:
2347 return new SolarisTargetInfo<X86_32TargetInfo>(T);
2348 case llvm::Triple::Cygwin:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002349 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002350 case llvm::Triple::MinGW32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002351 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002352 case llvm::Triple::Win32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002353 return new VisualStudioWindowsX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002354 default:
2355 return new X86_32TargetInfo(T);
2356 }
2357
2358 case llvm::Triple::x86_64:
2359 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002360 case llvm::Triple::AuroraUX:
2361 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002362 case llvm::Triple::Darwin:
2363 return new DarwinX86_64TargetInfo(T);
2364 case llvm::Triple::Linux:
2365 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner1eac0812010-01-09 05:41:14 +00002366 case llvm::Triple::DragonFly:
2367 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002368 case llvm::Triple::NetBSD:
2369 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
2370 case llvm::Triple::OpenBSD:
2371 return new OpenBSDX86_64TargetInfo(T);
2372 case llvm::Triple::FreeBSD:
2373 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
2374 case llvm::Triple::Solaris:
2375 return new SolarisTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002376 case llvm::Triple::MinGW64:
2377 return new MinGWX86_64TargetInfo(T);
2378 case llvm::Triple::Win32: // This is what Triple.h supports now.
2379 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002380 default:
2381 return new X86_64TargetInfo(T);
2382 }
2383 }
Chris Lattner4b009652007-07-25 00:24:17 +00002384}
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002385
2386/// CreateTargetInfo - Return the target info object for the specified target
2387/// triple.
2388TargetInfo *TargetInfo::CreateTargetInfo(Diagnostic &Diags,
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002389 TargetOptions &Opts) {
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002390 llvm::Triple Triple(Opts.Triple);
2391
2392 // Construct the target
2393 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
2394 if (!Target) {
2395 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
2396 return 0;
2397 }
2398
Daniel Dunbar33b40752009-12-18 18:42:37 +00002399 // Set the target CPU if specified.
2400 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
2401 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
2402 return 0;
2403 }
2404
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002405 // Set the target ABI if specified.
2406 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
2407 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
2408 return 0;
2409 }
2410
2411 // Compute the default target features, we need the target to handle this
2412 // because features may have dependencies on one another.
2413 llvm::StringMap<bool> Features;
2414 Target->getDefaultFeatures(Opts.CPU, Features);
2415
2416 // Apply the user specified deltas.
2417 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
2418 ie = Opts.Features.end(); it != ie; ++it) {
2419 const char *Name = it->c_str();
2420
2421 // Apply the feature via the target.
2422 if ((Name[0] != '-' && Name[0] != '+') ||
2423 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
2424 Diags.Report(diag::err_target_invalid_feature) << Name;
2425 return 0;
2426 }
2427 }
2428
2429 // Add the features to the compile options.
2430 //
2431 // FIXME: If we are completely confident that we have the right set, we only
2432 // need to pass the minuses.
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002433 Opts.Features.clear();
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002434 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
2435 ie = Features.end(); it != ie; ++it)
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002436 Opts.Features.push_back(std::string(it->second ? "+" : "-") + it->first());
2437 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002438
2439 return Target.take();
2440}