blob: 3b226d0cdc52bb7ecffe1ba9798bc3a0095e784a [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.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000295 Builder.defineMacro("__PPU__");
296 Builder.defineMacro("__CELLOS_LV2__");
297 Builder.defineMacro("__ELF__");
298 Builder.defineMacro("__LP32__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000299 }
300public:
301 PS3PPUTargetInfo(const std::string& triple)
302 : OSTargetInfo<Target>(triple) {
303 this->UserLabelPrefix = "";
John Thompson4c3bd3f2009-12-18 14:21:08 +0000304 this->LongWidth = this->LongAlign = this->PointerWidth = this->PointerAlign = 32;
305 this->SizeType = TargetInfo::UnsignedInt;
John Thompsoned7bdbc2009-11-19 17:18:50 +0000306 }
307};
308
309// FIXME: Need a real SPU target.
310// PS3 SPU Target
311template<typename Target>
312class PS3SPUTargetInfo : public OSTargetInfo<Target> {
313protected:
314 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000315 MacroBuilder &Builder) const {
John Thompsoned7bdbc2009-11-19 17:18:50 +0000316 // PS3 PPU defines.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000317 Builder.defineMacro("__SPU__");
318 Builder.defineMacro("__ELF__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000319 }
320public:
321 PS3SPUTargetInfo(const std::string& triple)
322 : OSTargetInfo<Target>(triple) {
323 this->UserLabelPrefix = "";
324 }
325};
326
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +0000327// AuroraUX target
328template<typename Target>
329class AuroraUXTargetInfo : public OSTargetInfo<Target> {
330protected:
331 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000332 MacroBuilder &Builder) const {
333 DefineStd(Builder, "sun", Opts);
334 DefineStd(Builder, "unix", Opts);
335 Builder.defineMacro("__ELF__");
336 Builder.defineMacro("__svr4__");
337 Builder.defineMacro("__SVR4");
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +0000338 }
339public:
340 AuroraUXTargetInfo(const std::string& triple)
341 : OSTargetInfo<Target>(triple) {
342 this->UserLabelPrefix = "";
343 this->WCharType = this->SignedLong;
344 // FIXME: WIntType should be SignedLong
345 }
346};
347
Edwin Török36565e52009-06-30 17:10:35 +0000348// Solaris target
349template<typename Target>
350class SolarisTargetInfo : public OSTargetInfo<Target> {
351protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000352 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000353 MacroBuilder &Builder) const {
354 DefineStd(Builder, "sun", Opts);
355 DefineStd(Builder, "unix", Opts);
356 Builder.defineMacro("__ELF__");
357 Builder.defineMacro("__svr4__");
358 Builder.defineMacro("__SVR4");
Edwin Török36565e52009-06-30 17:10:35 +0000359 }
360public:
Mike Stump25cf7602009-09-09 15:08:12 +0000361 SolarisTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +0000362 : OSTargetInfo<Target>(triple) {
363 this->UserLabelPrefix = "";
364 this->WCharType = this->SignedLong;
365 // FIXME: WIntType should be SignedLong
366 }
367};
Mike Stump25cf7602009-09-09 15:08:12 +0000368} // end anonymous namespace.
Edwin Török36565e52009-06-30 17:10:35 +0000369
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000370//===----------------------------------------------------------------------===//
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000371// Specific target implementations.
372//===----------------------------------------------------------------------===//
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000373
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000374namespace {
375// PPC abstract base class
376class PPCTargetInfo : public TargetInfo {
377 static const Builtin::Info BuiltinInfo[];
378 static const char * const GCCRegNames[];
379 static const TargetInfo::GCCRegAlias GCCRegAliases[];
380
381public:
Eli Friedmand9389be2009-06-05 07:05:05 +0000382 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
383
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000384 virtual void getTargetBuiltins(const Builtin::Info *&Records,
385 unsigned &NumRecords) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000386 Records = BuiltinInfo;
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000387 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000388 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000389
Chris Lattner79682402009-03-20 15:52:06 +0000390 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000391 MacroBuilder &Builder) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000392
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000393 virtual const char *getVAListDeclaration() const {
Chris Lattnera07708f2008-10-27 01:11:29 +0000394 return "typedef char* __builtin_va_list;";
395 // This is the right definition for ABI/V4: System V.4/eabi.
396 /*return "typedef struct __va_list_tag {"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000397 " unsigned char gpr;"
398 " unsigned char fpr;"
399 " unsigned short reserved;"
400 " void* overflow_arg_area;"
401 " void* reg_save_area;"
Chris Lattnera07708f2008-10-27 01:11:29 +0000402 "} __builtin_va_list[1];";*/
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000403 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000404 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000405 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000406 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000407 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +0000408 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000409 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +0000410 switch (*Name) {
Anders Carlsson4ce42302007-11-27 04:11:28 +0000411 default: return false;
412 case 'O': // Zero
413 return true;
414 case 'b': // Base register
415 case 'f': // Floating point register
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000416 Info.setAllowsRegister();
Anders Carlsson4ce42302007-11-27 04:11:28 +0000417 return true;
418 }
419 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000420 virtual const char *getClobbers() const {
421 return "";
Anders Carlsson4ce42302007-11-27 04:11:28 +0000422 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000423};
Anders Carlsson4ce42302007-11-27 04:11:28 +0000424
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000425const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000426#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
427#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000428#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000429};
Anton Korobeynikove7772382009-05-03 13:42:53 +0000430
431
Chris Lattnerbef1d722009-03-02 22:27:17 +0000432/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
433/// #defines that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +0000434void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000435 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +0000436 // Target identification.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000437 Builder.defineMacro("__ppc__");
438 Builder.defineMacro("_ARCH_PPC");
Chris Lattnerf8030412010-02-16 18:14:57 +0000439 Builder.defineMacro("__powerpc__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000440 Builder.defineMacro("__POWERPC__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000441 if (PointerWidth == 64) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000442 Builder.defineMacro("_ARCH_PPC64");
443 Builder.defineMacro("_LP64");
444 Builder.defineMacro("__LP64__");
Chris Lattnerf8030412010-02-16 18:14:57 +0000445 Builder.defineMacro("__powerpc64__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000446 Builder.defineMacro("__ppc64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000447 } else {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000448 Builder.defineMacro("__ppc__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000449 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000450
Chris Lattnerbef1d722009-03-02 22:27:17 +0000451 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000452 Builder.defineMacro("_BIG_ENDIAN");
453 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000454
Chris Lattnerbef1d722009-03-02 22:27:17 +0000455 // Subtarget options.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000456 Builder.defineMacro("__NATURAL_ALIGNMENT__");
457 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000458
Chris Lattnerbef1d722009-03-02 22:27:17 +0000459 // FIXME: Should be controlled by command line option.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000460 Builder.defineMacro("__LONG_DOUBLE_128__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000461
462 if (Opts.AltiVec) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000463 Builder.defineMacro("__VEC__", "10206");
464 Builder.defineMacro("__ALTIVEC__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000465 }
Chris Lattnerbef1d722009-03-02 22:27:17 +0000466}
467
Chris Lattner9fd73612008-04-21 18:56:49 +0000468
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000469const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattner14d2bb72009-09-16 05:05:27 +0000470 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
471 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
472 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
473 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
474 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
475 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
476 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
477 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000478 "mq", "lr", "ctr", "ap",
Chris Lattner14d2bb72009-09-16 05:05:27 +0000479 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000480 "xer",
Chris Lattner14d2bb72009-09-16 05:05:27 +0000481 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
482 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
483 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
484 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000485 "vrsave", "vscr",
486 "spe_acc", "spefscr",
487 "sfp"
488};
Chris Lattner4b009652007-07-25 00:24:17 +0000489
Anton Korobeynikove7772382009-05-03 13:42:53 +0000490void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000491 unsigned &NumNames) const {
492 Names = GCCRegNames;
493 NumNames = llvm::array_lengthof(GCCRegNames);
494}
Chris Lattner4b009652007-07-25 00:24:17 +0000495
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000496const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
497 // While some of these aliases do map to different registers
498 // they still share the same register name.
Daniel Dunbar40b774e2009-09-17 07:03:19 +0000499 { { "0" }, "r0" },
500 { { "1"}, "r1" },
501 { { "2" }, "r2" },
502 { { "3" }, "r3" },
503 { { "4" }, "r4" },
504 { { "5" }, "r5" },
505 { { "6" }, "r6" },
506 { { "7" }, "r7" },
507 { { "8" }, "r8" },
508 { { "9" }, "r9" },
509 { { "10" }, "r10" },
510 { { "11" }, "r11" },
511 { { "12" }, "r12" },
512 { { "13" }, "r13" },
513 { { "14" }, "r14" },
514 { { "15" }, "r15" },
515 { { "16" }, "r16" },
516 { { "17" }, "r17" },
517 { { "18" }, "r18" },
518 { { "19" }, "r19" },
519 { { "20" }, "r20" },
520 { { "21" }, "r21" },
521 { { "22" }, "r22" },
522 { { "23" }, "r23" },
523 { { "24" }, "r24" },
524 { { "25" }, "r25" },
525 { { "26" }, "r26" },
526 { { "27" }, "r27" },
527 { { "28" }, "r28" },
528 { { "29" }, "r29" },
529 { { "30" }, "r30" },
530 { { "31" }, "r31" },
531 { { "fr0" }, "f0" },
532 { { "fr1" }, "f1" },
533 { { "fr2" }, "f2" },
534 { { "fr3" }, "f3" },
535 { { "fr4" }, "f4" },
536 { { "fr5" }, "f5" },
537 { { "fr6" }, "f6" },
538 { { "fr7" }, "f7" },
539 { { "fr8" }, "f8" },
540 { { "fr9" }, "f9" },
Mike Stump369c21c2009-09-17 21:15:00 +0000541 { { "fr10" }, "f10" },
Daniel Dunbar40b774e2009-09-17 07:03:19 +0000542 { { "fr11" }, "f11" },
543 { { "fr12" }, "f12" },
544 { { "fr13" }, "f13" },
545 { { "fr14" }, "f14" },
546 { { "fr15" }, "f15" },
547 { { "fr16" }, "f16" },
548 { { "fr17" }, "f17" },
549 { { "fr18" }, "f18" },
550 { { "fr19" }, "f19" },
551 { { "fr20" }, "f20" },
552 { { "fr21" }, "f21" },
553 { { "fr22" }, "f22" },
554 { { "fr23" }, "f23" },
555 { { "fr24" }, "f24" },
556 { { "fr25" }, "f25" },
557 { { "fr26" }, "f26" },
558 { { "fr27" }, "f27" },
559 { { "fr28" }, "f28" },
560 { { "fr29" }, "f29" },
561 { { "fr30" }, "f30" },
562 { { "fr31" }, "f31" },
563 { { "cc" }, "cr0" },
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000564};
565
Anton Korobeynikove7772382009-05-03 13:42:53 +0000566void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000567 unsigned &NumAliases) const {
568 Aliases = GCCRegAliases;
569 NumAliases = llvm::array_lengthof(GCCRegAliases);
570}
571} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +0000572
573namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000574class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000575public:
Chris Lattnerf8030412010-02-16 18:14:57 +0000576 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedman2b161652008-08-21 00:13:15 +0000577 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 +0000578 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnerf8030412010-02-16 18:14:57 +0000579
580 if (getTriple().getOS() == llvm::Triple::FreeBSD)
581 this->SizeType = TargetInfo::UnsignedInt;
Eli Friedman2b161652008-08-21 00:13:15 +0000582 }
Chris Lattner4b009652007-07-25 00:24:17 +0000583};
584} // end anonymous namespace.
585
586namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000587class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000588public:
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000589 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +0000590 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman38e31802009-07-01 03:36:11 +0000591 IntMaxType = SignedLong;
592 UIntMaxType = UnsignedLong;
593 Int64Type = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +0000594 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 +0000595 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnere5fde952008-05-09 06:17:04 +0000596 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000597};
598} // end anonymous namespace.
599
Chris Lattner4b009652007-07-25 00:24:17 +0000600namespace {
Chris Lattner2c026472010-03-06 21:21:27 +0000601// MBlaze abstract base class
602class MBlazeTargetInfo : public TargetInfo {
603 static const char * const GCCRegNames[];
604 static const TargetInfo::GCCRegAlias GCCRegAliases[];
605
606public:
607 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
608 DescriptionString = "E-p:32:32-i8:8:8-i16:16:16-i64:32:32-f64:32:32-"
609 "v64:32:32-v128:32:32-n32";
610 }
611
612 virtual void getTargetBuiltins(const Builtin::Info *&Records,
613 unsigned &NumRecords) const {
614 // FIXME: Implement.
615 Records = 0;
616 NumRecords = 0;
617 }
618
619 virtual void getTargetDefines(const LangOptions &Opts,
620 MacroBuilder &Builder) const;
621
622 virtual const char *getVAListDeclaration() const {
623 return "typedef char* __builtin_va_list;";
624 }
625 virtual const char *getTargetPrefix() const {
626 return "mblaze";
627 }
628 virtual void getGCCRegNames(const char * const *&Names,
629 unsigned &NumNames) const;
630 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
631 unsigned &NumAliases) const;
632 virtual bool validateAsmConstraint(const char *&Name,
633 TargetInfo::ConstraintInfo &Info) const {
634 switch (*Name) {
635 default: return false;
636 case 'O': // Zero
637 return true;
638 case 'b': // Base register
639 case 'f': // Floating point register
640 Info.setAllowsRegister();
641 return true;
642 }
643 }
644 virtual const char *getClobbers() const {
645 return "";
646 }
647};
648
649/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
650/// #defines that are not tied to a specific subtarget.
651void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
652 MacroBuilder &Builder) const {
653 // Target identification.
654 Builder.defineMacro("__microblaze__");
655 Builder.defineMacro("_ARCH_MICROBLAZE");
656 Builder.defineMacro("__MICROBLAZE__");
657
658 // Target properties.
659 Builder.defineMacro("_BIG_ENDIAN");
660 Builder.defineMacro("__BIG_ENDIAN__");
661
662 // Subtarget options.
663 Builder.defineMacro("__REGISTER_PREFIX__", "");
664}
665
666
667const char * const MBlazeTargetInfo::GCCRegNames[] = {
668 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
669 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
670 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
671 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
672 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
673 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
674 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
675 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
676 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
677 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
678};
679
680void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
681 unsigned &NumNames) const {
682 Names = GCCRegNames;
683 NumNames = llvm::array_lengthof(GCCRegNames);
684}
685
686const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
687 { {"f0"}, "r0" },
688 { {"f1"}, "r1" },
689 { {"f2"}, "r2" },
690 { {"f3"}, "r3" },
691 { {"f4"}, "r4" },
692 { {"f5"}, "r5" },
693 { {"f6"}, "r6" },
694 { {"f7"}, "r7" },
695 { {"f8"}, "r8" },
696 { {"f9"}, "r9" },
697 { {"f10"}, "r10" },
698 { {"f11"}, "r11" },
699 { {"f12"}, "r12" },
700 { {"f13"}, "r13" },
701 { {"f14"}, "r14" },
702 { {"f15"}, "r15" },
703 { {"f16"}, "r16" },
704 { {"f17"}, "r17" },
705 { {"f18"}, "r18" },
706 { {"f19"}, "r19" },
707 { {"f20"}, "r20" },
708 { {"f21"}, "r21" },
709 { {"f22"}, "r22" },
710 { {"f23"}, "r23" },
711 { {"f24"}, "r24" },
712 { {"f25"}, "r25" },
713 { {"f26"}, "r26" },
714 { {"f27"}, "r27" },
715 { {"f28"}, "r28" },
716 { {"f29"}, "r29" },
717 { {"f30"}, "r30" },
718 { {"f31"}, "r31" },
719};
720
721void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
722 unsigned &NumAliases) const {
723 Aliases = GCCRegAliases;
724 NumAliases = llvm::array_lengthof(GCCRegAliases);
725}
726} // end anonymous namespace.
727
728namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000729// Namespace for x86 abstract base class
730const Builtin::Info BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000731#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
732#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000733#include "clang/Basic/BuiltinsX86.def"
Eli Friedman872996c2008-08-20 02:34:37 +0000734};
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000735
Nuno Lopesad1010d2009-12-23 17:49:57 +0000736static const char* const GCCRegNames[] = {
Eli Friedman872996c2008-08-20 02:34:37 +0000737 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
738 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
739 "argp", "flags", "fspr", "dirflag", "frame",
740 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
741 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
742 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
743 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
744};
745
746const TargetInfo::GCCRegAlias GCCRegAliases[] = {
747 { { "al", "ah", "eax", "rax" }, "ax" },
748 { { "bl", "bh", "ebx", "rbx" }, "bx" },
749 { { "cl", "ch", "ecx", "rcx" }, "cx" },
750 { { "dl", "dh", "edx", "rdx" }, "dx" },
751 { { "esi", "rsi" }, "si" },
752 { { "edi", "rdi" }, "di" },
753 { { "esp", "rsp" }, "sp" },
754 { { "ebp", "rbp" }, "bp" },
755};
756
757// X86 target abstract base class; x86-32 and x86-64 are very close, so
758// most of the implementation can be shared.
759class X86TargetInfo : public TargetInfo {
Chris Lattner715fe4c2009-03-02 22:40:39 +0000760 enum X86SSEEnum {
761 NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
762 } SSELevel;
Anders Carlssone5e222f2010-01-27 03:47:49 +0000763 enum AMD3DNowEnum {
764 NoAMD3DNow, AMD3DNow, AMD3DNowAthlon
765 } AMD3DNowLevel;
766
Eli Friedman872996c2008-08-20 02:34:37 +0000767public:
Anton Korobeynikove7772382009-05-03 13:42:53 +0000768 X86TargetInfo(const std::string& triple)
Anders Carlssone5e222f2010-01-27 03:47:49 +0000769 : TargetInfo(triple), SSELevel(NoMMXSSE), AMD3DNowLevel(NoAMD3DNow) {
Eli Friedman872996c2008-08-20 02:34:37 +0000770 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner4b009652007-07-25 00:24:17 +0000771 }
772 virtual void getTargetBuiltins(const Builtin::Info *&Records,
773 unsigned &NumRecords) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000774 Records = BuiltinInfo;
775 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000776 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000777 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman872996c2008-08-20 02:34:37 +0000778 unsigned &NumNames) const {
779 Names = GCCRegNames;
780 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000781 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000782 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000783 unsigned &NumAliases) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000784 Aliases = GCCRegAliases;
785 NumAliases = llvm::array_lengthof(GCCRegAliases);
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000786 }
Anders Carlsson36834a72009-02-28 17:11:49 +0000787 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman872996c2008-08-20 02:34:37 +0000788 TargetInfo::ConstraintInfo &info) const;
789 virtual std::string convertConstraint(const char Constraint) const;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000790 virtual const char *getClobbers() const {
Eli Friedman872996c2008-08-20 02:34:37 +0000791 return "~{dirflag},~{fpsr},~{flags}";
792 }
Chris Lattner79682402009-03-20 15:52:06 +0000793 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000794 MacroBuilder &Builder) const;
Daniel Dunbar0838f962009-05-06 21:07:50 +0000795 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
796 const std::string &Name,
797 bool Enabled) const;
Mike Stump25cf7602009-09-09 15:08:12 +0000798 virtual void getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000799 llvm::StringMap<bool> &Features) const;
Daniel Dunbar4f7cd962009-12-19 03:30:57 +0000800 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Chris Lattner4b009652007-07-25 00:24:17 +0000801};
Chris Lattner7d6220c2009-03-02 22:20:04 +0000802
Mike Stump25cf7602009-09-09 15:08:12 +0000803void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000804 llvm::StringMap<bool> &Features) const {
Daniel Dunbar07181d72009-05-06 03:16:41 +0000805 // FIXME: This should not be here.
806 Features["3dnow"] = false;
807 Features["3dnowa"] = false;
808 Features["mmx"] = false;
809 Features["sse"] = false;
810 Features["sse2"] = false;
811 Features["sse3"] = false;
812 Features["ssse3"] = false;
813 Features["sse41"] = false;
814 Features["sse42"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000815
Daniel Dunbar07181d72009-05-06 03:16:41 +0000816 // LLVM does not currently recognize this.
817 // Features["sse4a"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000818
Daniel Dunbar07181d72009-05-06 03:16:41 +0000819 // FIXME: This *really* should not be here.
820
821 // X86_64 always has SSE2.
822 if (PointerWidth == 64)
823 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
824
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000825 if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
826 CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
827 ;
828 else if (CPU == "pentium-mmx" || CPU == "pentium2")
829 setFeatureEnabled(Features, "mmx", true);
830 else if (CPU == "pentium3")
831 setFeatureEnabled(Features, "sse", true);
832 else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64")
833 setFeatureEnabled(Features, "sse2", true);
834 else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona")
835 setFeatureEnabled(Features, "sse3", true);
836 else if (CPU == "core2")
837 setFeatureEnabled(Features, "ssse3", true);
838 else if (CPU == "penryn") {
839 setFeatureEnabled(Features, "sse4", true);
840 Features["sse42"] = false;
841 } else if (CPU == "atom")
842 setFeatureEnabled(Features, "sse3", true);
843 else if (CPU == "corei7")
844 setFeatureEnabled(Features, "sse4", true);
845 else if (CPU == "k6" || CPU == "winchip-c6")
846 setFeatureEnabled(Features, "mmx", true);
Mike Stump25cf7602009-09-09 15:08:12 +0000847 else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000848 CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
849 setFeatureEnabled(Features, "mmx", true);
850 setFeatureEnabled(Features, "3dnow", true);
851 } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
852 setFeatureEnabled(Features, "sse", true);
853 setFeatureEnabled(Features, "3dnowa", true);
854 } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
855 CPU == "athlon-fx") {
Mike Stump25cf7602009-09-09 15:08:12 +0000856 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000857 setFeatureEnabled(Features, "3dnowa", true);
858 } else if (CPU == "c3-2")
859 setFeatureEnabled(Features, "sse", true);
Daniel Dunbar07181d72009-05-06 03:16:41 +0000860}
861
Daniel Dunbar0838f962009-05-06 21:07:50 +0000862bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump25cf7602009-09-09 15:08:12 +0000863 const std::string &Name,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000864 bool Enabled) const {
Eric Christopher850e2012010-03-04 02:26:37 +0000865 // FIXME: This *really* should not be here. We need some way of translating
866 // options into llvm subtarget features.
867 if (!Features.count(Name) &&
868 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar0838f962009-05-06 21:07:50 +0000869 return false;
870
871 if (Enabled) {
872 if (Name == "mmx")
873 Features["mmx"] = true;
874 else if (Name == "sse")
875 Features["mmx"] = Features["sse"] = true;
876 else if (Name == "sse2")
877 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
878 else if (Name == "sse3")
Mike Stump25cf7602009-09-09 15:08:12 +0000879 Features["mmx"] = Features["sse"] = Features["sse2"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000880 Features["sse3"] = true;
881 else if (Name == "ssse3")
Mike Stump25cf7602009-09-09 15:08:12 +0000882 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000883 Features["ssse3"] = true;
Eric Christopher850e2012010-03-04 02:26:37 +0000884 else if (Name == "sse4" || Name == "sse4.2")
Mike Stump25cf7602009-09-09 15:08:12 +0000885 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000886 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Eric Christopher850e2012010-03-04 02:26:37 +0000887 else if (Name == "sse4.1")
888 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
889 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +0000890 else if (Name == "3dnow")
891 Features["3dnowa"] = true;
892 else if (Name == "3dnowa")
893 Features["3dnow"] = Features["3dnowa"] = true;
894 } else {
895 if (Name == "mmx")
Mike Stump25cf7602009-09-09 15:08:12 +0000896 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000897 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
898 else if (Name == "sse")
Mike Stump25cf7602009-09-09 15:08:12 +0000899 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000900 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
901 else if (Name == "sse2")
Mike Stump25cf7602009-09-09 15:08:12 +0000902 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000903 Features["sse41"] = Features["sse42"] = false;
904 else if (Name == "sse3")
Mike Stump25cf7602009-09-09 15:08:12 +0000905 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000906 Features["sse42"] = false;
907 else if (Name == "ssse3")
908 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
909 else if (Name == "sse4")
910 Features["sse41"] = Features["sse42"] = false;
Eric Christopherd794f782010-03-04 02:31:44 +0000911 else if (Name == "sse4.2")
912 Features["sse42"] = false;
913 else if (Name == "sse4.1")
914 Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar0838f962009-05-06 21:07:50 +0000915 else if (Name == "3dnow")
916 Features["3dnow"] = Features["3dnowa"] = false;
917 else if (Name == "3dnowa")
918 Features["3dnowa"] = false;
919 }
920
921 return true;
922}
923
Daniel Dunbar07181d72009-05-06 03:16:41 +0000924/// HandleTargetOptions - Perform initialization based on the user
925/// configured set of features.
Daniel Dunbar4f7cd962009-12-19 03:30:57 +0000926void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar8dd8f262009-11-11 09:38:56 +0000927 // Remember the maximum enabled sselevel.
928 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
929 // Ignore disabled features.
930 if (Features[i][0] == '-')
931 continue;
932
933 assert(Features[i][0] == '+' && "Invalid target feature!");
934 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
935 .Case("sse42", SSE42)
936 .Case("sse41", SSE41)
937 .Case("ssse3", SSSE3)
938 .Case("sse2", SSE2)
939 .Case("sse", SSE1)
940 .Case("mmx", MMX)
941 .Default(NoMMXSSE);
942 SSELevel = std::max(SSELevel, Level);
Anders Carlssone5e222f2010-01-27 03:47:49 +0000943
944 AMD3DNowEnum ThreeDNowLevel =
945 llvm::StringSwitch<AMD3DNowEnum>(Features[i].substr(1))
946 .Case("3dnowa", AMD3DNowAthlon)
947 .Case("3dnow", AMD3DNow)
948 .Default(NoAMD3DNow);
949
950 AMD3DNowLevel = std::max(AMD3DNowLevel, ThreeDNowLevel);
Daniel Dunbar8dd8f262009-11-11 09:38:56 +0000951 }
Chris Lattner7d6220c2009-03-02 22:20:04 +0000952}
Chris Lattnerbef1d722009-03-02 22:27:17 +0000953
954/// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
955/// that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +0000956void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000957 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +0000958 // Target identification.
959 if (PointerWidth == 64) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000960 Builder.defineMacro("_LP64");
961 Builder.defineMacro("__LP64__");
962 Builder.defineMacro("__amd64__");
963 Builder.defineMacro("__amd64");
964 Builder.defineMacro("__x86_64");
965 Builder.defineMacro("__x86_64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000966 } else {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000967 DefineStd(Builder, "i386", Opts);
Chris Lattnerbef1d722009-03-02 22:27:17 +0000968 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000969
Chris Lattnerbef1d722009-03-02 22:27:17 +0000970 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000971 Builder.defineMacro("__LITTLE_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000972
Chris Lattnerbef1d722009-03-02 22:27:17 +0000973 // Subtarget options.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000974 Builder.defineMacro("__nocona");
975 Builder.defineMacro("__nocona__");
976 Builder.defineMacro("__tune_nocona__");
977 Builder.defineMacro("__REGISTER_PREFIX__", "");
Chris Lattner715fe4c2009-03-02 22:40:39 +0000978
Chris Lattner25ac1c12009-04-19 17:32:33 +0000979 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
980 // functions in glibc header files that use FP Stack inline asm which the
981 // backend can't deal with (PR879).
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000982 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000983
Chris Lattner715fe4c2009-03-02 22:40:39 +0000984 // Each case falls through to the previous one here.
985 switch (SSELevel) {
986 case SSE42:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000987 Builder.defineMacro("__SSE4_2__");
Chris Lattner715fe4c2009-03-02 22:40:39 +0000988 case SSE41:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000989 Builder.defineMacro("__SSE4_1__");
Chris Lattner715fe4c2009-03-02 22:40:39 +0000990 case SSSE3:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000991 Builder.defineMacro("__SSSE3__");
Chris Lattner715fe4c2009-03-02 22:40:39 +0000992 case SSE3:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000993 Builder.defineMacro("__SSE3__");
Chris Lattner715fe4c2009-03-02 22:40:39 +0000994 case SSE2:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000995 Builder.defineMacro("__SSE2__");
996 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner715fe4c2009-03-02 22:40:39 +0000997 case SSE1:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000998 Builder.defineMacro("__SSE__");
999 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Chris Lattner715fe4c2009-03-02 22:40:39 +00001000 case MMX:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001001 Builder.defineMacro("__MMX__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001002 case NoMMXSSE:
1003 break;
1004 }
Anders Carlssone5e222f2010-01-27 03:47:49 +00001005
1006 // Each case falls through to the previous one here.
1007 switch (AMD3DNowLevel) {
1008 case AMD3DNowAthlon:
1009 Builder.defineMacro("__3dNOW_A__");
1010 case AMD3DNow:
1011 Builder.defineMacro("__3dNOW__");
1012 case NoAMD3DNow:
1013 break;
1014 }
Chris Lattnerbef1d722009-03-02 22:27:17 +00001015}
Anton Korobeynikove7772382009-05-03 13:42:53 +00001016
1017
Eli Friedman872996c2008-08-20 02:34:37 +00001018bool
Anders Carlsson36834a72009-02-28 17:11:49 +00001019X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001020 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +00001021 switch (*Name) {
Eli Friedman872996c2008-08-20 02:34:37 +00001022 default: return false;
1023 case 'a': // eax.
1024 case 'b': // ebx.
1025 case 'c': // ecx.
1026 case 'd': // edx.
1027 case 'S': // esi.
1028 case 'D': // edi.
1029 case 'A': // edx:eax.
1030 case 't': // top of floating point stack.
1031 case 'u': // second from top of floating point stack.
1032 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson2285e622008-10-06 00:41:45 +00001033 case 'y': // Any MMX register.
Anders Carlssond2459f92008-10-06 19:17:39 +00001034 case 'x': // Any SSE register.
Eli Friedman872996c2008-08-20 02:34:37 +00001035 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Anton Korobeynikove7772382009-05-03 13:42:53 +00001036 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +00001037 // x86_64 instructions.
Anton Korobeynikove7772382009-05-03 13:42:53 +00001038 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +00001039 // x86_64 instructions.
Eli Friedman872996c2008-08-20 02:34:37 +00001040 case 'N': // unsigned 8-bit integer constant for use with in and out
1041 // instructions.
Eli Friedman7e17aed2009-06-08 20:45:44 +00001042 case 'R': // "legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001043 Info.setAllowsRegister();
Eli Friedman872996c2008-08-20 02:34:37 +00001044 return true;
1045 }
1046}
1047
1048std::string
1049X86TargetInfo::convertConstraint(const char Constraint) const {
1050 switch (Constraint) {
1051 case 'a': return std::string("{ax}");
1052 case 'b': return std::string("{bx}");
1053 case 'c': return std::string("{cx}");
1054 case 'd': return std::string("{dx}");
1055 case 'S': return std::string("{si}");
1056 case 'D': return std::string("{di}");
1057 case 't': // top of floating point stack.
1058 return std::string("{st}");
1059 case 'u': // second from top of floating point stack.
1060 return std::string("{st(1)}"); // second from top of floating point stack.
1061 default:
1062 return std::string(1, Constraint);
1063 }
1064}
Eli Friedman872996c2008-08-20 02:34:37 +00001065} // end anonymous namespace
Chris Lattner4b009652007-07-25 00:24:17 +00001066
1067namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001068// X86-32 generic target
1069class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +00001070public:
Eli Friedman872996c2008-08-20 02:34:37 +00001071 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1072 DoubleAlign = LongLongAlign = 32;
1073 LongDoubleWidth = 96;
1074 LongDoubleAlign = 32;
Eli Friedman2b161652008-08-21 00:13:15 +00001075 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1076 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001077 "a0:0:64-f80:32:32-n8:16:32";
Eli Friedman04ede302009-03-29 20:31:09 +00001078 SizeType = UnsignedInt;
1079 PtrDiffType = SignedInt;
1080 IntPtrType = SignedInt;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +00001081 RegParmMax = 3;
Eli Friedman872996c2008-08-20 02:34:37 +00001082 }
1083 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001084 return "typedef char* __builtin_va_list;";
Eli Friedman872996c2008-08-20 02:34:37 +00001085 }
Chris Lattneraa339182009-09-23 06:06:36 +00001086
1087 int getEHDataRegisterNumber(unsigned RegNo) const {
1088 if (RegNo == 0) return 0;
1089 if (RegNo == 1) return 2;
1090 return -1;
1091 }
Eli Friedman872996c2008-08-20 02:34:37 +00001092};
1093} // end anonymous namespace
1094
1095namespace {
Eli Friedman1c79f4b2009-07-05 18:47:56 +00001096class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
1097public:
1098 OpenBSDI386TargetInfo(const std::string& triple) :
1099 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
1100 SizeType = UnsignedLong;
1101 IntPtrType = SignedLong;
Eli Friedman96ada022009-07-05 22:31:18 +00001102 PtrDiffType = SignedLong;
Eli Friedman1c79f4b2009-07-05 18:47:56 +00001103 }
1104};
1105} // end anonymous namespace
1106
1107namespace {
Edwin Török36565e52009-06-30 17:10:35 +00001108class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman872996c2008-08-20 02:34:37 +00001109public:
Edwin Török36565e52009-06-30 17:10:35 +00001110 DarwinI386TargetInfo(const std::string& triple) :
1111 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman872996c2008-08-20 02:34:37 +00001112 LongDoubleWidth = 128;
1113 LongDoubleAlign = 128;
Eli Friedman04ede302009-03-29 20:31:09 +00001114 SizeType = UnsignedLong;
1115 IntPtrType = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +00001116 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1117 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001118 "a0:0:64-f80:128:128-n8:16:32";
Edwin Török2d98f9f2009-06-30 17:00:25 +00001119 }
1120
Eli Friedman872996c2008-08-20 02:34:37 +00001121};
Daniel Dunbar64c77a12009-06-29 20:52:51 +00001122} // end anonymous namespace
1123
1124namespace {
Eli Friedman23cb7912008-08-21 01:40:19 +00001125// x86-32 Windows target
1126class WindowsX86_32TargetInfo : public X86_32TargetInfo {
1127public:
1128 WindowsX86_32TargetInfo(const std::string& triple)
1129 : X86_32TargetInfo(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +00001130 TLSSupported = false;
Chris Lattnera8a69e12009-06-24 17:12:15 +00001131 WCharType = UnsignedShort;
Eli Friedmanb28055e2009-06-08 21:16:17 +00001132 DoubleAlign = LongLongAlign = 64;
1133 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 +00001134 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
1135 "v128:128:128-a0:0:64-f80:32:32-n8:16:32";
Eli Friedman23cb7912008-08-21 01:40:19 +00001136 }
Chris Lattner79682402009-03-20 15:52:06 +00001137 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001138 MacroBuilder &Builder) const {
1139 X86_32TargetInfo::getTargetDefines(Opts, Builder);
Eli Friedman23cb7912008-08-21 01:40:19 +00001140 // This list is based off of the the list of things MingW defines
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001141 Builder.defineMacro("_WIN32");
1142 DefineStd(Builder, "WIN32", Opts);
1143 DefineStd(Builder, "WINNT", Opts);
1144 Builder.defineMacro("_X86_");
Eli Friedman23cb7912008-08-21 01:40:19 +00001145 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001146};
1147} // end anonymous namespace
Eli Friedman6b6ca942009-06-08 06:11:14 +00001148
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001149namespace {
1150
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001151// x86-32 Windows Visual Studio target
1152class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
1153public:
1154 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
1155 : WindowsX86_32TargetInfo(triple) {
1156 }
1157 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001158 MacroBuilder &Builder) const {
1159 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001160 // The value of the following reflects processor type.
1161 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
1162 // We lost the original triple, so we use the default.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001163 Builder.defineMacro("_M_IX86", "600");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001164 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001165};
1166} // end anonymous namespace
1167
1168namespace {
1169// x86-32 MinGW target
1170class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
1171public:
1172 MinGWX86_32TargetInfo(const std::string& triple)
1173 : WindowsX86_32TargetInfo(triple) {
1174 }
1175 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001176 MacroBuilder &Builder) const {
1177 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
1178 Builder.defineMacro("__MSVCRT__");
1179 Builder.defineMacro("__MINGW32__");
1180 Builder.defineMacro("__declspec", "__declspec");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001181 }
1182};
1183} // end anonymous namespace
1184
1185namespace {
1186// x86-32 Cygwin target
1187class CygwinX86_32TargetInfo : public X86_32TargetInfo {
1188public:
1189 CygwinX86_32TargetInfo(const std::string& triple)
1190 : X86_32TargetInfo(triple) {
1191 TLSSupported = false;
1192 WCharType = UnsignedShort;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001193 DoubleAlign = LongLongAlign = 64;
1194 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1195 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001196 "a0:0:64-f80:32:32-n8:16:32";
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001197 }
1198 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001199 MacroBuilder &Builder) const {
1200 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1201 Builder.defineMacro("__CYGWIN__");
1202 Builder.defineMacro("__CYGWIN32__");
1203 DefineStd(Builder, "unix", Opts);
Eli Friedman6b6ca942009-06-08 06:11:14 +00001204 }
Eli Friedman23cb7912008-08-21 01:40:19 +00001205};
1206} // end anonymous namespace
1207
1208namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001209// x86-64 generic target
1210class X86_64TargetInfo : public X86TargetInfo {
1211public:
Chris Lattner79682402009-03-20 15:52:06 +00001212 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +00001213 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001214 LongDoubleWidth = 128;
1215 LongDoubleAlign = 128;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00001216 IntMaxType = SignedLong;
1217 UIntMaxType = UnsignedLong;
Eli Friedman38e31802009-07-01 03:36:11 +00001218 Int64Type = SignedLong;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +00001219 RegParmMax = 6;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00001220
Eli Friedman2b161652008-08-21 00:13:15 +00001221 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1222 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001223 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64";
Chris Lattner4b009652007-07-25 00:24:17 +00001224 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +00001225 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001226 return "typedef struct __va_list_tag {"
1227 " unsigned gp_offset;"
1228 " unsigned fp_offset;"
1229 " void* overflow_arg_area;"
1230 " void* reg_save_area;"
Eli Friedman3c79eee2009-07-03 00:45:06 +00001231 "} __va_list_tag;"
1232 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson7dd1c952007-11-24 23:38:12 +00001233 }
Chris Lattneraa339182009-09-23 06:06:36 +00001234
1235 int getEHDataRegisterNumber(unsigned RegNo) const {
1236 if (RegNo == 0) return 0;
1237 if (RegNo == 1) return 1;
1238 return -1;
1239 }
Eli Friedman872996c2008-08-20 02:34:37 +00001240};
1241} // end anonymous namespace
1242
1243namespace {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001244// x86-64 Windows target
1245class WindowsX86_64TargetInfo : public X86_64TargetInfo {
1246public:
1247 WindowsX86_64TargetInfo(const std::string& triple)
1248 : X86_64TargetInfo(triple) {
1249 TLSSupported = false;
1250 WCharType = UnsignedShort;
Mike Stump4da7a162009-10-08 23:00:00 +00001251 LongWidth = LongAlign = 32;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001252 DoubleAlign = LongLongAlign = 64;
1253 }
1254 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001255 MacroBuilder &Builder) const {
1256 X86_64TargetInfo::getTargetDefines(Opts, Builder);
1257 Builder.defineMacro("_WIN64");
1258 DefineStd(Builder, "WIN64", Opts);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001259 }
1260};
1261} // end anonymous namespace
1262
1263namespace {
1264// x86-64 Windows Visual Studio target
1265class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
1266public:
1267 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
1268 : WindowsX86_64TargetInfo(triple) {
1269 }
1270 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001271 MacroBuilder &Builder) const {
1272 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1273 Builder.defineMacro("_M_X64");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001274 }
1275 virtual const char *getVAListDeclaration() const {
1276 return "typedef char* va_list;";
1277 }
1278};
1279} // end anonymous namespace
1280
1281namespace {
1282// x86-64 MinGW target
1283class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
1284public:
1285 MinGWX86_64TargetInfo(const std::string& triple)
1286 : WindowsX86_64TargetInfo(triple) {
1287 }
1288 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001289 MacroBuilder &Builder) const {
1290 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1291 Builder.defineMacro("__MSVCRT__");
1292 Builder.defineMacro("__MINGW64__");
1293 Builder.defineMacro("__declspec");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001294 }
1295};
1296} // end anonymous namespace
1297
1298namespace {
Eli Friedman38e31802009-07-01 03:36:11 +00001299class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
1300public:
Mike Stump25cf7602009-09-09 15:08:12 +00001301 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman38e31802009-07-01 03:36:11 +00001302 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
1303 Int64Type = SignedLongLong;
1304 }
1305};
1306} // end anonymous namespace
1307
1308namespace {
Eli Friedman96ada022009-07-05 22:31:18 +00001309class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
1310public:
Mike Stump25cf7602009-09-09 15:08:12 +00001311 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman96ada022009-07-05 22:31:18 +00001312 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
1313 IntMaxType = SignedLongLong;
1314 UIntMaxType = UnsignedLongLong;
1315 Int64Type = SignedLongLong;
1316 }
1317};
1318} // end anonymous namespace
1319
1320namespace {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001321class ARMTargetInfo : public TargetInfo {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001322 // Possible FPU choices.
1323 enum FPUMode {
1324 NoFPU,
1325 VFP2FPU,
1326 VFP3FPU,
1327 NeonFPU
1328 };
1329
1330 static bool FPUModeIsVFP(FPUMode Mode) {
1331 return Mode >= VFP2FPU && Mode <= NeonFPU;
1332 }
1333
1334 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1335 static const char * const GCCRegNames[];
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001336
Daniel Dunbar33b40752009-12-18 18:42:37 +00001337 std::string ABI, CPU;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001338
1339 unsigned FPU : 3;
1340
Daniel Dunbar48075d82009-12-19 04:15:38 +00001341 unsigned IsThumb : 1;
1342
1343 // Initialized via features.
1344 unsigned SoftFloat : 1;
1345 unsigned SoftFloatABI : 1;
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001346
Chris Lattnerb4527522010-03-03 19:03:45 +00001347 static const Builtin::Info BuiltinInfo[];
1348
Chris Lattner9fd73612008-04-21 18:56:49 +00001349public:
Daniel Dunbarf0156562009-09-17 16:21:10 +00001350 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbar33b40752009-12-18 18:42:37 +00001351 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001352 {
Daniel Dunbarb9531632009-09-14 00:02:24 +00001353 SizeType = UnsignedInt;
1354 PtrDiffType = SignedInt;
Daniel Dunbarf0156562009-09-17 16:21:10 +00001355
Daniel Dunbar33b40752009-12-18 18:42:37 +00001356 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0a542ca2009-12-18 19:57:13 +00001357 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001358 if (IsThumb) {
1359 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1360 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001361 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001362 } else {
1363 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1364 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001365 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001366 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001367 }
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001368 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbarb9531632009-09-14 00:02:24 +00001369 virtual bool setABI(const std::string &Name) {
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001370 ABI = Name;
1371
Daniel Dunbarb9531632009-09-14 00:02:24 +00001372 // The defaults (above) are for AAPCS, check if we need to change them.
1373 //
1374 // FIXME: We need support for -meabi... we could just mangle it into the
1375 // name.
1376 if (Name == "apcs-gnu") {
Daniel Dunbarda94a772010-01-27 20:23:08 +00001377 DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
Daniel Dunbarb9531632009-09-14 00:02:24 +00001378 SizeType = UnsignedLong;
1379
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001380 if (IsThumb) {
1381 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1382 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001383 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001384 } else {
1385 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1386 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001387 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001388 }
1389
Daniel Dunbarb9531632009-09-14 00:02:24 +00001390 // FIXME: Override "preferred align" for double and long long.
1391 } else if (Name == "aapcs") {
1392 // FIXME: Enumerated types are variable width in straight AAPCS.
1393 } else if (Name == "aapcs-linux") {
1394 ;
1395 } else
1396 return false;
1397
1398 return true;
1399 }
Daniel Dunbar48075d82009-12-19 04:15:38 +00001400
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001401 void getDefaultFeatures(const std::string &CPU,
1402 llvm::StringMap<bool> &Features) const {
1403 // FIXME: This should not be here.
1404 Features["vfp2"] = false;
1405 Features["vfp3"] = false;
1406 Features["neon"] = false;
1407
1408 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
1409 Features["vfp2"] = true;
1410 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
1411 Features["neon"] = true;
1412 }
1413
Daniel Dunbar48075d82009-12-19 04:15:38 +00001414 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1415 const std::string &Name,
1416 bool Enabled) const {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001417 if (Name == "soft-float" || Name == "soft-float-abi") {
1418 Features[Name] = Enabled;
1419 } else if (Name == "vfp2" || Name == "vfp3" || Name == "neon") {
1420 // These effectively are a single option, reset them when any is enabled.
1421 if (Enabled)
1422 Features["vfp2"] = Features["vfp3"] = Features["neon"] = false;
1423 Features[Name] = Enabled;
1424 } else
Daniel Dunbar48075d82009-12-19 04:15:38 +00001425 return false;
1426
Daniel Dunbar48075d82009-12-19 04:15:38 +00001427 return true;
1428 }
1429
1430 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001431 FPU = NoFPU;
Daniel Dunbar48075d82009-12-19 04:15:38 +00001432 SoftFloat = SoftFloatABI = false;
1433 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
1434 if (Features[i] == "+soft-float")
1435 SoftFloat = true;
1436 else if (Features[i] == "+soft-float-abi")
1437 SoftFloatABI = true;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001438 else if (Features[i] == "+vfp2")
1439 FPU = VFP2FPU;
1440 else if (Features[i] == "+vfp3")
1441 FPU = VFP3FPU;
1442 else if (Features[i] == "+neon")
1443 FPU = NeonFPU;
Daniel Dunbar48075d82009-12-19 04:15:38 +00001444 }
1445
1446 // Remove front-end specific options which the backend handles differently.
1447 std::vector<std::string>::iterator it;
1448 it = std::find(Features.begin(), Features.end(), "+soft-float");
1449 if (it != Features.end())
1450 Features.erase(it);
1451 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
1452 if (it != Features.end())
1453 Features.erase(it);
1454 }
1455
Daniel Dunbar33b40752009-12-18 18:42:37 +00001456 static const char *getCPUDefineSuffix(llvm::StringRef Name) {
1457 return llvm::StringSwitch<const char*>(Name)
1458 .Cases("arm8", "arm810", "4")
1459 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
1460 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
1461 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
1462 .Case("ep9312", "4T")
1463 .Cases("arm10tdmi", "arm1020t", "5T")
1464 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
1465 .Case("arm926ej-s", "5TEJ")
1466 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
1467 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001468 .Case("arm1136j-s", "6J")
Daniel Dunbar33b40752009-12-18 18:42:37 +00001469 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001470 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbar33b40752009-12-18 18:42:37 +00001471 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
1472 .Cases("cortex-a8", "cortex-a9", "7A")
1473 .Default(0);
1474 }
1475 virtual bool setCPU(const std::string &Name) {
1476 if (!getCPUDefineSuffix(Name))
1477 return false;
1478
1479 CPU = Name;
1480 return true;
1481 }
Chris Lattner79682402009-03-20 15:52:06 +00001482 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001483 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00001484 // Target identification.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001485 Builder.defineMacro("__arm");
1486 Builder.defineMacro("__arm__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001487
Chris Lattnerbef1d722009-03-02 22:27:17 +00001488 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001489 Builder.defineMacro("__ARMEL__");
1490 Builder.defineMacro("__LITTLE_ENDIAN__");
1491 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001492
1493 llvm::StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001494 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001495
Mike Stumpf90a29f2009-04-08 02:07:04 +00001496 // Subtarget options.
Daniel Dunbarf0156562009-09-17 16:21:10 +00001497
Daniel Dunbar33b40752009-12-18 18:42:37 +00001498 // FIXME: It's more complicated than this and we don't really support
1499 // interworking.
1500 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001501 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001502
Daniel Dunbar33b40752009-12-18 18:42:37 +00001503 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001504 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001505
Daniel Dunbar48075d82009-12-19 04:15:38 +00001506 if (SoftFloat)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001507 Builder.defineMacro("__SOFTFP__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001508
1509 if (CPU == "xscale")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001510 Builder.defineMacro("__XSCALE__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001511
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001512 bool IsThumb2 = IsThumb && (CPUArch == "6T2" || CPUArch.startswith("7"));
Daniel Dunbarf0156562009-09-17 16:21:10 +00001513 if (IsThumb) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001514 Builder.defineMacro("__THUMBEL__");
1515 Builder.defineMacro("__thumb__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001516 if (IsThumb2)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001517 Builder.defineMacro("__thumb2__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001518 }
1519
1520 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001521 Builder.defineMacro("__APCS_32__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001522
1523 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001524 Builder.defineMacro("__VFP_FP__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001525
1526 // This only gets set when Neon instructions are actually available, unlike
1527 // the VFP define, hence the soft float and arch check. This is subtly
1528 // different from gcc, we follow the intent which was that it should be set
1529 // when Neon instructions are actually available.
1530 if (FPU == NeonFPU && !SoftFloat && IsThumb2)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001531 Builder.defineMacro("__ARM_NEON__");
Chris Lattner9fd73612008-04-21 18:56:49 +00001532 }
1533 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1534 unsigned &NumRecords) const {
Chris Lattnerb4527522010-03-03 19:03:45 +00001535 Records = BuiltinInfo;
1536 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner9fd73612008-04-21 18:56:49 +00001537 }
1538 virtual const char *getVAListDeclaration() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001539 return "typedef char* __builtin_va_list;";
Chris Lattner9fd73612008-04-21 18:56:49 +00001540 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001541 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001542 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001543 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001544 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001545 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001546 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001547 // FIXME: Check if this is complete
Anders Carlsson36834a72009-02-28 17:11:49 +00001548 switch (*Name) {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001549 default:
Nate Begeman222823a2008-04-22 05:03:19 +00001550 case 'l': // r0-r7
1551 case 'h': // r8-r15
1552 case 'w': // VFP Floating point register single precision
1553 case 'P': // VFP Floating point register double precision
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001554 Info.setAllowsRegister();
Nate Begeman222823a2008-04-22 05:03:19 +00001555 return true;
1556 }
Chris Lattner9fd73612008-04-21 18:56:49 +00001557 return false;
1558 }
1559 virtual const char *getClobbers() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001560 // FIXME: Is this really right?
Chris Lattner9fd73612008-04-21 18:56:49 +00001561 return "";
1562 }
1563};
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001564
1565const char * const ARMTargetInfo::GCCRegNames[] = {
1566 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1567 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1568};
1569
1570void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
1571 unsigned &NumNames) const {
1572 Names = GCCRegNames;
1573 NumNames = llvm::array_lengthof(GCCRegNames);
1574}
1575
1576const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
1577
1578 { { "a1" }, "r0" },
1579 { { "a2" }, "r1" },
1580 { { "a3" }, "r2" },
1581 { { "a4" }, "r3" },
1582 { { "v1" }, "r4" },
1583 { { "v2" }, "r5" },
1584 { { "v3" }, "r6" },
1585 { { "v4" }, "r7" },
1586 { { "v5" }, "r8" },
1587 { { "v6", "rfp" }, "r9" },
1588 { { "sl" }, "r10" },
1589 { { "fp" }, "r11" },
1590 { { "ip" }, "r12" },
1591 { { "sp" }, "r13" },
1592 { { "lr" }, "r14" },
1593 { { "pc" }, "r15" },
1594};
1595
1596void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1597 unsigned &NumAliases) const {
1598 Aliases = GCCRegAliases;
1599 NumAliases = llvm::array_lengthof(GCCRegAliases);
1600}
Chris Lattnerb4527522010-03-03 19:03:45 +00001601
1602const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
1603#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
1604#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
1605#include "clang/Basic/BuiltinsARM.def"
1606};
Chris Lattner9fd73612008-04-21 18:56:49 +00001607} // end anonymous namespace.
1608
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001609
1610namespace {
Mike Stump25cf7602009-09-09 15:08:12 +00001611class DarwinARMTargetInfo :
Edwin Török36565e52009-06-30 17:10:35 +00001612 public DarwinTargetInfo<ARMTargetInfo> {
1613protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +00001614 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001615 MacroBuilder &Builder) const {
Daniel Dunbareab96a22010-01-26 01:44:04 +00001616 getDarwinDefines(Builder, Opts, Triple);
Eli Friedman8f575172009-04-19 21:38:35 +00001617 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001618
Edwin Török36565e52009-06-30 17:10:35 +00001619public:
Mike Stump25cf7602009-09-09 15:08:12 +00001620 DarwinARMTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +00001621 : DarwinTargetInfo<ARMTargetInfo>(triple) {}
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001622};
1623} // end anonymous namespace.
1624
Chris Lattner4b009652007-07-25 00:24:17 +00001625namespace {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001626class SparcV8TargetInfo : public TargetInfo {
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001627 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1628 static const char * const GCCRegNames[];
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001629public:
Eli Friedmanff158dd2008-08-20 07:28:14 +00001630 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
1631 // FIXME: Support Sparc quad-precision long double?
Eli Friedman2b161652008-08-21 00:13:15 +00001632 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 +00001633 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedmanff158dd2008-08-20 07:28:14 +00001634 }
Chris Lattner79682402009-03-20 15:52:06 +00001635 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001636 MacroBuilder &Builder) const {
1637 DefineStd(Builder, "sparc", Opts);
1638 Builder.defineMacro("__sparcv8");
1639 Builder.defineMacro("__REGISTER_PREFIX__", "");
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001640 }
1641 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1642 unsigned &NumRecords) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001643 // FIXME: Implement!
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001644 }
1645 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001646 return "typedef void* __builtin_va_list;";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001647 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001648 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001649 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001650 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001651 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001652 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001653 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001654 // FIXME: Implement!
1655 return false;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001656 }
1657 virtual const char *getClobbers() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001658 // FIXME: Implement!
1659 return "";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001660 }
1661};
1662
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001663const char * const SparcV8TargetInfo::GCCRegNames[] = {
1664 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1665 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1666 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1667 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
1668};
1669
Anton Korobeynikove7772382009-05-03 13:42:53 +00001670void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001671 unsigned &NumNames) const {
1672 Names = GCCRegNames;
1673 NumNames = llvm::array_lengthof(GCCRegNames);
1674}
1675
1676const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikove7772382009-05-03 13:42:53 +00001677 { { "g0" }, "r0" },
1678 { { "g1" }, "r1" },
1679 { { "g2" }, "r2" },
1680 { { "g3" }, "r3" },
1681 { { "g4" }, "r4" },
1682 { { "g5" }, "r5" },
1683 { { "g6" }, "r6" },
1684 { { "g7" }, "r7" },
1685 { { "o0" }, "r8" },
1686 { { "o1" }, "r9" },
1687 { { "o2" }, "r10" },
1688 { { "o3" }, "r11" },
1689 { { "o4" }, "r12" },
1690 { { "o5" }, "r13" },
1691 { { "o6", "sp" }, "r14" },
1692 { { "o7" }, "r15" },
1693 { { "l0" }, "r16" },
1694 { { "l1" }, "r17" },
1695 { { "l2" }, "r18" },
1696 { { "l3" }, "r19" },
1697 { { "l4" }, "r20" },
1698 { { "l5" }, "r21" },
1699 { { "l6" }, "r22" },
1700 { { "l7" }, "r23" },
1701 { { "i0" }, "r24" },
1702 { { "i1" }, "r25" },
1703 { { "i2" }, "r26" },
1704 { { "i3" }, "r27" },
1705 { { "i4" }, "r28" },
1706 { { "i5" }, "r29" },
1707 { { "i6", "fp" }, "r30" },
1708 { { "i7" }, "r31" },
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001709};
1710
Anton Korobeynikove7772382009-05-03 13:42:53 +00001711void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001712 unsigned &NumAliases) const {
1713 Aliases = GCCRegAliases;
1714 NumAliases = llvm::array_lengthof(GCCRegAliases);
1715}
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001716} // end anonymous namespace.
1717
Eli Friedmanff158dd2008-08-20 07:28:14 +00001718namespace {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00001719class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
1720public:
1721 AuroraUXSparcV8TargetInfo(const std::string& triple) :
1722 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
1723 SizeType = UnsignedInt;
1724 PtrDiffType = SignedInt;
1725 }
1726};
Edwin Török36565e52009-06-30 17:10:35 +00001727class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001728public:
1729 SolarisSparcV8TargetInfo(const std::string& triple) :
Edwin Török36565e52009-06-30 17:10:35 +00001730 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedman7cca0982008-11-02 02:43:55 +00001731 SizeType = UnsignedInt;
1732 PtrDiffType = SignedInt;
Eli Friedmanff158dd2008-08-20 07:28:14 +00001733 }
1734};
1735} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +00001736
Chris Lattner85970f32008-05-08 05:58:21 +00001737namespace {
1738 class PIC16TargetInfo : public TargetInfo{
1739 public:
1740 PIC16TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +00001741 TLSSupported = false;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001742 IntWidth = 16;
1743 LongWidth = LongLongWidth = 32;
1744 PointerWidth = 16;
1745 IntAlign = 8;
1746 LongAlign = LongLongAlign = 8;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001747 PointerAlign = 8;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001748 SizeType = UnsignedInt;
1749 IntMaxType = SignedLong;
1750 UIntMaxType = UnsignedLong;
Chris Lattnerd9ef7242009-02-13 22:28:55 +00001751 IntPtrType = SignedShort;
Eli Friedman7cca0982008-11-02 02:43:55 +00001752 PtrDiffType = SignedInt;
Edward O'Callaghan14a70a32009-11-21 00:49:54 +00001753 SigAtomicType = SignedLong;
Sanjiv Guptaae8f1e82009-06-02 04:43:46 +00001754 FloatWidth = 32;
1755 FloatAlign = 32;
1756 DoubleWidth = 32;
1757 DoubleAlign = 32;
1758 LongDoubleWidth = 32;
1759 LongDoubleAlign = 32;
1760 FloatFormat = &llvm::APFloat::IEEEsingle;
1761 DoubleFormat = &llvm::APFloat::IEEEsingle;
1762 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner2e17d912009-11-07 18:59:41 +00001763 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 +00001764
Chris Lattner85970f32008-05-08 05:58:21 +00001765 }
Chris Lattner727b3c42008-05-09 06:08:39 +00001766 virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }
1767 virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }
Chris Lattner79682402009-03-20 15:52:06 +00001768 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001769 MacroBuilder &Builder) const {
1770 Builder.defineMacro("__pic16");
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00001771 Builder.defineMacro("__PIC16");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001772 Builder.defineMacro("rom", "__attribute__((address_space(1)))");
1773 Builder.defineMacro("ram", "__attribute__((address_space(0)))");
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00001774 Builder.defineMacro("__section(SectName)",
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00001775 "__attribute__((section(SectName)))");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001776 Builder.defineMacro("near",
Sanjiv Gupta09e95f02009-10-24 18:08:20 +00001777 "__attribute__((section(\"Address=NEAR\")))");
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00001778 Builder.defineMacro("__address(Addr)",
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00001779 "__attribute__((section(\"Address=\"#Addr)))");
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00001780 Builder.defineMacro("__config(conf)", "asm(\"CONFIG \"#conf)");
1781 Builder.defineMacro("__idlocs(value)", "asm(\"__IDLOCS \"#value)");
1782 Builder.defineMacro("interrupt",
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00001783 "__attribute__((section(\"interrupt=0x4\"))) \
1784 __attribute__((used))");
Chris Lattner85970f32008-05-08 05:58:21 +00001785 }
1786 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1787 unsigned &NumRecords) const {}
Mike Stump25cf7602009-09-09 15:08:12 +00001788 virtual const char *getVAListDeclaration() const {
Sanjiv Gupta2362b4c2010-02-16 03:37:11 +00001789 return "typedef char* __builtin_va_list;";
Daniel Dunbar2e967de2009-08-24 09:54:37 +00001790 }
1791 virtual const char *getClobbers() const {
1792 return "";
1793 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001794 virtual void getGCCRegNames(const char * const *&Names,
1795 unsigned &NumNames) const {}
1796 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner85970f32008-05-08 05:58:21 +00001797 TargetInfo::ConstraintInfo &info) const {
1798 return true;
1799 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001800 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner85970f32008-05-08 05:58:21 +00001801 unsigned &NumAliases) const {}
1802 virtual bool useGlobalsForAutomaticVariables() const {return true;}
1803 };
1804}
1805
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001806namespace {
1807 class MSP430TargetInfo : public TargetInfo {
1808 static const char * const GCCRegNames[];
1809 public:
1810 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
1811 TLSSupported = false;
Anton Korobeynikov2a6630a2010-01-30 12:55:11 +00001812 IntWidth = 16; IntAlign = 16;
1813 LongWidth = 32; LongLongWidth = 64;
1814 LongAlign = LongLongAlign = 16;
1815 PointerWidth = 16; PointerAlign = 16;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001816 SizeType = UnsignedInt;
1817 IntMaxType = SignedLong;
1818 UIntMaxType = UnsignedLong;
1819 IntPtrType = SignedShort;
1820 PtrDiffType = SignedInt;
Edward O'Callaghan14a70a32009-11-21 00:49:54 +00001821 SigAtomicType = SignedLong;
Anton Korobeynikov314713f2009-12-19 01:32:37 +00001822 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001823 }
1824 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001825 MacroBuilder &Builder) const {
1826 Builder.defineMacro("MSP430");
1827 Builder.defineMacro("__MSP430__");
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001828 // FIXME: defines for different 'flavours' of MCU
1829 }
1830 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1831 unsigned &NumRecords) const {
1832 // FIXME: Implement.
1833 Records = 0;
1834 NumRecords = 0;
1835 }
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001836 virtual void getGCCRegNames(const char * const *&Names,
1837 unsigned &NumNames) const;
1838 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1839 unsigned &NumAliases) const {
1840 // No aliases.
1841 Aliases = 0;
1842 NumAliases = 0;
1843 }
1844 virtual bool validateAsmConstraint(const char *&Name,
1845 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov174219b2009-10-15 23:17:13 +00001846 // No target constraints for now.
1847 return false;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001848 }
1849 virtual const char *getClobbers() const {
1850 // FIXME: Is this really right?
1851 return "";
1852 }
1853 virtual const char *getVAListDeclaration() const {
1854 // FIXME: implement
Anton Korobeynikovf5955592009-05-08 18:24:57 +00001855 return "typedef char* __builtin_va_list;";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001856 }
1857 };
1858
1859 const char * const MSP430TargetInfo::GCCRegNames[] = {
1860 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1861 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1862 };
1863
1864 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
1865 unsigned &NumNames) const {
1866 Names = GCCRegNames;
1867 NumNames = llvm::array_lengthof(GCCRegNames);
1868 }
1869}
1870
1871
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001872namespace {
1873 class SystemZTargetInfo : public TargetInfo {
1874 static const char * const GCCRegNames[];
1875 public:
1876 SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
1877 TLSSupported = false;
1878 IntWidth = IntAlign = 32;
1879 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
1880 PointerWidth = PointerAlign = 64;
Chris Lattner2e17d912009-11-07 18:59:41 +00001881 DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
1882 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001883 }
1884 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001885 MacroBuilder &Builder) const {
1886 Builder.defineMacro("__s390__");
1887 Builder.defineMacro("__s390x__");
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001888 }
1889 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1890 unsigned &NumRecords) const {
1891 // FIXME: Implement.
1892 Records = 0;
1893 NumRecords = 0;
1894 }
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001895
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001896 virtual void getGCCRegNames(const char * const *&Names,
1897 unsigned &NumNames) const;
1898 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1899 unsigned &NumAliases) const {
1900 // No aliases.
1901 Aliases = 0;
1902 NumAliases = 0;
1903 }
1904 virtual bool validateAsmConstraint(const char *&Name,
1905 TargetInfo::ConstraintInfo &info) const {
1906 // FIXME: implement
1907 return true;
1908 }
1909 virtual const char *getClobbers() const {
1910 // FIXME: Is this really right?
1911 return "";
1912 }
1913 virtual const char *getVAListDeclaration() const {
1914 // FIXME: implement
1915 return "typedef char* __builtin_va_list;";
1916 }
1917 };
1918
1919 const char * const SystemZTargetInfo::GCCRegNames[] = {
1920 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1921 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1922 };
1923
1924 void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
1925 unsigned &NumNames) const {
1926 Names = GCCRegNames;
1927 NumNames = llvm::array_lengthof(GCCRegNames);
1928 }
1929}
1930
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001931namespace {
1932 class BlackfinTargetInfo : public TargetInfo {
1933 static const char * const GCCRegNames[];
1934 public:
1935 BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
1936 TLSSupported = false;
1937 DoubleAlign = 32;
1938 LongLongAlign = 32;
1939 LongDoubleAlign = 32;
Chris Lattner2e17d912009-11-07 18:59:41 +00001940 DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001941 }
1942
1943 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001944 MacroBuilder &Builder) const {
1945 DefineStd(Builder, "bfin", Opts);
1946 DefineStd(Builder, "BFIN", Opts);
1947 Builder.defineMacro("__ADSPBLACKFIN__");
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001948 // FIXME: This one is really dependent on -mcpu
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001949 Builder.defineMacro("__ADSPLPBLACKFIN__");
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001950 // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
1951 }
1952
1953 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1954 unsigned &NumRecords) const {
1955 // FIXME: Implement.
1956 Records = 0;
1957 NumRecords = 0;
1958 }
1959
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001960 virtual void getGCCRegNames(const char * const *&Names,
1961 unsigned &NumNames) const;
1962
1963 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1964 unsigned &NumAliases) const {
1965 // No aliases.
1966 Aliases = 0;
1967 NumAliases = 0;
1968 }
1969
1970 virtual bool validateAsmConstraint(const char *&Name,
1971 TargetInfo::ConstraintInfo &Info) const {
1972 if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
1973 Info.setAllowsRegister();
1974 return true;
1975 }
1976 return false;
1977 }
1978
1979 virtual const char *getClobbers() const {
1980 return "";
1981 }
1982
1983 virtual const char *getVAListDeclaration() const {
1984 return "typedef char* __builtin_va_list;";
1985 }
1986 };
1987
1988 const char * const BlackfinTargetInfo::GCCRegNames[] = {
1989 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1990 "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
1991 "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
1992 "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
1993 "a0", "a1", "cc",
1994 "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
1995 "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
1996 };
1997
1998 void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
1999 unsigned &NumNames) const {
2000 Names = GCCRegNames;
2001 NumNames = llvm::array_lengthof(GCCRegNames);
2002 }
2003}
2004
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002005namespace {
2006
Mike Stump25cf7602009-09-09 15:08:12 +00002007 // LLVM and Clang cannot be used directly to output native binaries for
2008 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002009 // type and alignment information.
Mike Stump25cf7602009-09-09 15:08:12 +00002010 //
2011 // TCE uses the llvm bitcode as input and uses it for generating customized
2012 // target processor and program binary. TCE co-design environment is
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002013 // publicly available in http://tce.cs.tut.fi
2014
2015 class TCETargetInfo : public TargetInfo{
2016 public:
2017 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
2018 TLSSupported = false;
2019 IntWidth = 32;
2020 LongWidth = LongLongWidth = 32;
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002021 PointerWidth = 32;
2022 IntAlign = 32;
2023 LongAlign = LongLongAlign = 32;
2024 PointerAlign = 32;
2025 SizeType = UnsignedInt;
2026 IntMaxType = SignedLong;
2027 UIntMaxType = UnsignedLong;
2028 IntPtrType = SignedInt;
2029 PtrDiffType = SignedInt;
2030 FloatWidth = 32;
2031 FloatAlign = 32;
2032 DoubleWidth = 32;
2033 DoubleAlign = 32;
2034 LongDoubleWidth = 32;
2035 LongDoubleAlign = 32;
2036 FloatFormat = &llvm::APFloat::IEEEsingle;
2037 DoubleFormat = &llvm::APFloat::IEEEsingle;
2038 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner8a1db932010-03-04 21:07:38 +00002039 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
2040 "i16:16:32-i32:32:32-i64:32:32-"
2041 "f32:32:32-f64:64:64-v64:64:64-"
2042 "v128:128:128-a0:0:64-n32";
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002043 }
2044
2045 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002046 MacroBuilder &Builder) const {
2047 DefineStd(Builder, "tce", Opts);
2048 Builder.defineMacro("__TCE__");
2049 Builder.defineMacro("__TCE_V1__");
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002050 }
2051 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2052 unsigned &NumRecords) const {}
Daniel Dunbar2e967de2009-08-24 09:54:37 +00002053 virtual const char *getClobbers() const {
2054 return "";
2055 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002056 virtual const char *getVAListDeclaration() const {
2057 return "typedef void* __builtin_va_list;";
2058 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002059 virtual void getGCCRegNames(const char * const *&Names,
2060 unsigned &NumNames) const {}
2061 virtual bool validateAsmConstraint(const char *&Name,
2062 TargetInfo::ConstraintInfo &info) const {
2063 return true;
2064 }
2065 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2066 unsigned &NumAliases) const {}
2067 };
2068}
2069
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002070namespace {
2071class MipsTargetInfo : public TargetInfo {
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002072 std::string ABI, CPU;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002073 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2074 static const char * const GCCRegNames[];
2075public:
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002076 MipsTargetInfo(const std::string& triple) : TargetInfo(triple), ABI("o32") {
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002077 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2078 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2079 }
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002080 virtual const char *getABI() const { return ABI.c_str(); }
2081 virtual bool setABI(const std::string &Name) {
2082
2083 if ((Name == "o32") || (Name == "eabi")) {
2084 ABI = Name;
2085 return true;
2086 } else
2087 return false;
2088 }
2089 virtual bool setCPU(const std::string &Name) {
2090 CPU = Name;
2091 return true;
2092 }
2093 void getDefaultFeatures(const std::string &CPU,
2094 llvm::StringMap<bool> &Features) const {
2095 Features[ABI] = true;
2096 Features[CPU] = true;
2097 }
2098 virtual void getArchDefines(const LangOptions &Opts,
2099 MacroBuilder &Builder) const {
2100 if (ABI == "o32")
2101 Builder.defineMacro("__mips_o32");
2102 else if (ABI == "eabi")
2103 Builder.defineMacro("__mips_eabi");
2104 }
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002105 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002106 MacroBuilder &Builder) const {
2107 DefineStd(Builder, "mips", Opts);
2108 Builder.defineMacro("_mips");
2109 DefineStd(Builder, "MIPSEB", Opts);
2110 Builder.defineMacro("_MIPSEB");
2111 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002112 getArchDefines(Opts, Builder);
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002113 }
2114 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2115 unsigned &NumRecords) const {
2116 // FIXME: Implement!
2117 }
2118 virtual const char *getVAListDeclaration() const {
2119 return "typedef void* __builtin_va_list;";
2120 }
2121 virtual void getGCCRegNames(const char * const *&Names,
2122 unsigned &NumNames) const;
2123 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2124 unsigned &NumAliases) const;
2125 virtual bool validateAsmConstraint(const char *&Name,
2126 TargetInfo::ConstraintInfo &Info) const {
2127 switch (*Name) {
2128 default:
2129 case 'r': // CPU registers.
2130 case 'd': // Equivalent to "r" unless generating MIPS16 code.
2131 case 'y': // Equivalent to "r", backwards compatibility only.
2132 case 'f': // floating-point registers.
2133 Info.setAllowsRegister();
2134 return true;
2135 }
2136 return false;
2137 }
2138
2139 virtual const char *getClobbers() const {
2140 // FIXME: Implement!
2141 return "";
2142 }
2143};
2144
2145const char * const MipsTargetInfo::GCCRegNames[] = {
2146 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
2147 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
2148 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
2149 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
2150 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
2151 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
2152 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
2153 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
2154 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
2155 "$fcc5","$fcc6","$fcc7"
2156};
2157
2158void MipsTargetInfo::getGCCRegNames(const char * const *&Names,
2159 unsigned &NumNames) const {
2160 Names = GCCRegNames;
2161 NumNames = llvm::array_lengthof(GCCRegNames);
2162}
2163
2164const TargetInfo::GCCRegAlias MipsTargetInfo::GCCRegAliases[] = {
2165 { { "at" }, "$1" },
2166 { { "v0" }, "$2" },
2167 { { "v1" }, "$3" },
2168 { { "a0" }, "$4" },
2169 { { "a1" }, "$5" },
2170 { { "a2" }, "$6" },
2171 { { "a3" }, "$7" },
2172 { { "t0" }, "$8" },
2173 { { "t1" }, "$9" },
2174 { { "t2" }, "$10" },
2175 { { "t3" }, "$11" },
2176 { { "t4" }, "$12" },
2177 { { "t5" }, "$13" },
2178 { { "t6" }, "$14" },
2179 { { "t7" }, "$15" },
2180 { { "s0" }, "$16" },
2181 { { "s1" }, "$17" },
2182 { { "s2" }, "$18" },
2183 { { "s3" }, "$19" },
2184 { { "s4" }, "$20" },
2185 { { "s5" }, "$21" },
2186 { { "s6" }, "$22" },
2187 { { "s7" }, "$23" },
2188 { { "t8" }, "$24" },
2189 { { "t9" }, "$25" },
2190 { { "k0" }, "$26" },
2191 { { "k1" }, "$27" },
2192 { { "gp" }, "$28" },
2193 { { "sp" }, "$29" },
2194 { { "fp" }, "$30" },
2195 { { "ra" }, "$31" }
2196};
2197
2198void MipsTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2199 unsigned &NumAliases) const {
2200 Aliases = GCCRegAliases;
2201 NumAliases = llvm::array_lengthof(GCCRegAliases);
2202}
2203} // end anonymous namespace.
2204
2205namespace {
2206class MipselTargetInfo : public MipsTargetInfo {
2207public:
2208 MipselTargetInfo(const std::string& triple) : MipsTargetInfo(triple) {
2209 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2210 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2211 }
2212
2213 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002214 MacroBuilder &Builder) const;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002215};
2216
2217void MipselTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002218 MacroBuilder &Builder) const {
2219 DefineStd(Builder, "mips", Opts);
2220 Builder.defineMacro("_mips");
2221 DefineStd(Builder, "MIPSEL", Opts);
2222 Builder.defineMacro("_MIPSEL");
2223 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002224 getArchDefines(Opts, Builder);
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002225}
2226} // end anonymous namespace.
2227
Chris Lattner4b009652007-07-25 00:24:17 +00002228//===----------------------------------------------------------------------===//
2229// Driver code
2230//===----------------------------------------------------------------------===//
2231
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002232static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002233 llvm::Triple Triple(T);
2234 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002235
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002236 switch (Triple.getArch()) {
2237 default:
2238 return NULL;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002239
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002240 case llvm::Triple::arm:
Daniel Dunbar3f361b52009-09-11 01:14:50 +00002241 case llvm::Triple::thumb:
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002242 switch (os) {
2243 case llvm::Triple::Darwin:
Eli Friedman2b161652008-08-21 00:13:15 +00002244 return new DarwinARMTargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002245 case llvm::Triple::FreeBSD:
Edwin Török36565e52009-06-30 17:10:35 +00002246 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002247 default:
2248 return new ARMTargetInfo(T);
2249 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002250
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002251 case llvm::Triple::bfin:
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002252 return new BlackfinTargetInfo(T);
2253
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002254 case llvm::Triple::msp430:
2255 return new MSP430TargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002256
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002257 case llvm::Triple::mips:
2258 if (os == llvm::Triple::Psp)
2259 return new PSPTargetInfo<MipsTargetInfo>(T);
2260 if (os == llvm::Triple::Linux)
2261 return new LinuxTargetInfo<MipsTargetInfo>(T);
2262 return new MipsTargetInfo(T);
2263
2264 case llvm::Triple::mipsel:
2265 if (os == llvm::Triple::Psp)
2266 return new PSPTargetInfo<MipselTargetInfo>(T);
2267 if (os == llvm::Triple::Linux)
2268 return new LinuxTargetInfo<MipselTargetInfo>(T);
2269 return new MipselTargetInfo(T);
2270
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002271 case llvm::Triple::pic16:
2272 return new PIC16TargetInfo(T);
2273
2274 case llvm::Triple::ppc:
2275 if (os == llvm::Triple::Darwin)
2276 return new DarwinTargetInfo<PPCTargetInfo>(T);
Chris Lattnerf8030412010-02-16 18:14:57 +00002277 else if (os == llvm::Triple::FreeBSD)
2278 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002279 return new PPC32TargetInfo(T);
2280
2281 case llvm::Triple::ppc64:
2282 if (os == llvm::Triple::Darwin)
2283 return new DarwinTargetInfo<PPC64TargetInfo>(T);
John Thompsoned7bdbc2009-11-19 17:18:50 +00002284 else if (os == llvm::Triple::Lv2)
2285 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Chris Lattnerf8030412010-02-16 18:14:57 +00002286 else if (os == llvm::Triple::FreeBSD)
2287 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002288 return new PPC64TargetInfo(T);
2289
Chris Lattner2c026472010-03-06 21:21:27 +00002290 case llvm::Triple::mblaze:
2291 return new MBlazeTargetInfo(T);
2292
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002293 case llvm::Triple::sparc:
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002294 if (os == llvm::Triple::AuroraUX)
2295 return new AuroraUXSparcV8TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002296 if (os == llvm::Triple::Solaris)
2297 return new SolarisSparcV8TargetInfo(T);
2298 return new SparcV8TargetInfo(T);
2299
John Thompsoned7bdbc2009-11-19 17:18:50 +00002300 // FIXME: Need a real SPU target.
2301 case llvm::Triple::cellspu:
2302 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
2303
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002304 case llvm::Triple::systemz:
2305 return new SystemZTargetInfo(T);
2306
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002307 case llvm::Triple::tce:
2308 return new TCETargetInfo(T);
2309
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002310 case llvm::Triple::x86:
2311 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002312 case llvm::Triple::AuroraUX:
2313 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002314 case llvm::Triple::Darwin:
2315 return new DarwinI386TargetInfo(T);
2316 case llvm::Triple::Linux:
2317 return new LinuxTargetInfo<X86_32TargetInfo>(T);
2318 case llvm::Triple::DragonFly:
2319 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
2320 case llvm::Triple::NetBSD:
2321 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
2322 case llvm::Triple::OpenBSD:
2323 return new OpenBSDI386TargetInfo(T);
2324 case llvm::Triple::FreeBSD:
2325 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
2326 case llvm::Triple::Solaris:
2327 return new SolarisTargetInfo<X86_32TargetInfo>(T);
2328 case llvm::Triple::Cygwin:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002329 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002330 case llvm::Triple::MinGW32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002331 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002332 case llvm::Triple::Win32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002333 return new VisualStudioWindowsX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002334 default:
2335 return new X86_32TargetInfo(T);
2336 }
2337
2338 case llvm::Triple::x86_64:
2339 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002340 case llvm::Triple::AuroraUX:
2341 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002342 case llvm::Triple::Darwin:
2343 return new DarwinX86_64TargetInfo(T);
2344 case llvm::Triple::Linux:
2345 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner1eac0812010-01-09 05:41:14 +00002346 case llvm::Triple::DragonFly:
2347 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002348 case llvm::Triple::NetBSD:
2349 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
2350 case llvm::Triple::OpenBSD:
2351 return new OpenBSDX86_64TargetInfo(T);
2352 case llvm::Triple::FreeBSD:
2353 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
2354 case llvm::Triple::Solaris:
2355 return new SolarisTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002356 case llvm::Triple::MinGW64:
2357 return new MinGWX86_64TargetInfo(T);
2358 case llvm::Triple::Win32: // This is what Triple.h supports now.
2359 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002360 default:
2361 return new X86_64TargetInfo(T);
2362 }
2363 }
Chris Lattner4b009652007-07-25 00:24:17 +00002364}
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002365
2366/// CreateTargetInfo - Return the target info object for the specified target
2367/// triple.
2368TargetInfo *TargetInfo::CreateTargetInfo(Diagnostic &Diags,
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002369 TargetOptions &Opts) {
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002370 llvm::Triple Triple(Opts.Triple);
2371
2372 // Construct the target
2373 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
2374 if (!Target) {
2375 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
2376 return 0;
2377 }
2378
Daniel Dunbar33b40752009-12-18 18:42:37 +00002379 // Set the target CPU if specified.
2380 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
2381 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
2382 return 0;
2383 }
2384
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002385 // Set the target ABI if specified.
2386 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
2387 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
2388 return 0;
2389 }
2390
2391 // Compute the default target features, we need the target to handle this
2392 // because features may have dependencies on one another.
2393 llvm::StringMap<bool> Features;
2394 Target->getDefaultFeatures(Opts.CPU, Features);
2395
2396 // Apply the user specified deltas.
2397 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
2398 ie = Opts.Features.end(); it != ie; ++it) {
2399 const char *Name = it->c_str();
2400
2401 // Apply the feature via the target.
2402 if ((Name[0] != '-' && Name[0] != '+') ||
2403 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
2404 Diags.Report(diag::err_target_invalid_feature) << Name;
2405 return 0;
2406 }
2407 }
2408
2409 // Add the features to the compile options.
2410 //
2411 // FIXME: If we are completely confident that we have the right set, we only
2412 // need to pass the minuses.
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002413 Opts.Features.clear();
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002414 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
2415 ie = Features.end(); it != ie; ++it)
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002416 Opts.Features.push_back(std::string(it->second ? "+" : "-") + it->first());
2417 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002418
2419 return Target.take();
2420}