blob: 0bab0d247c49b8c7abbcb6bf6e1794a5e39dd249 [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"
Dale Johannesen8fa024c2010-10-29 23:24:33 +000029#include "llvm/Type.h"
Benjamin Kramerf8a85782010-01-09 18:20:57 +000030#include <algorithm>
Chris Lattner4b009652007-07-25 00:24:17 +000031using namespace clang;
32
Chris Lattner4b009652007-07-25 00:24:17 +000033//===----------------------------------------------------------------------===//
34// Common code shared among targets.
35//===----------------------------------------------------------------------===//
36
Chris Lattnerc345a802009-03-20 16:06:38 +000037/// DefineStd - Define a macro name and standard variants. For example if
38/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
39/// when in GNU mode.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000040static void DefineStd(MacroBuilder &Builder, llvm::StringRef MacroName,
Chris Lattnerc345a802009-03-20 16:06:38 +000041 const LangOptions &Opts) {
42 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikove7772382009-05-03 13:42:53 +000043
Chris Lattnerc345a802009-03-20 16:06:38 +000044 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
45 // in the user's namespace.
46 if (Opts.GNUMode)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000047 Builder.defineMacro(MacroName);
Anton Korobeynikove7772382009-05-03 13:42:53 +000048
Chris Lattnerc345a802009-03-20 16:06:38 +000049 // Define __unix.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000050 Builder.defineMacro("__" + MacroName);
Anton Korobeynikove7772382009-05-03 13:42:53 +000051
Chris Lattnerc345a802009-03-20 16:06:38 +000052 // Define __unix__.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000053 Builder.defineMacro("__" + MacroName + "__");
Chris Lattnerc345a802009-03-20 16:06:38 +000054}
55
Chris Lattnerbd00eb82008-10-05 21:50:58 +000056//===----------------------------------------------------------------------===//
57// Defines specific to certain operating systems.
58//===----------------------------------------------------------------------===//
Chris Lattner43954312009-08-10 19:03:04 +000059
Edwin Török36565e52009-06-30 17:10:35 +000060namespace {
Douglas Gregor937331f2009-07-01 15:12:53 +000061template<typename TgtInfo>
62class OSTargetInfo : public TgtInfo {
Edwin Török36565e52009-06-30 17:10:35 +000063protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +000064 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000065 MacroBuilder &Builder) const=0;
Edwin Török36565e52009-06-30 17:10:35 +000066public:
Douglas Gregor937331f2009-07-01 15:12:53 +000067 OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
Edwin Török36565e52009-06-30 17:10:35 +000068 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000069 MacroBuilder &Builder) const {
70 TgtInfo::getTargetDefines(Opts, Builder);
71 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Edwin Török2d98f9f2009-06-30 17:00:25 +000072 }
Edwin Török36565e52009-06-30 17:10:35 +000073
74};
Chris Lattnerf54f2212009-08-12 06:24:27 +000075} // end anonymous namespace
Edwin Török2d98f9f2009-06-30 17:00:25 +000076
Chris Lattner43954312009-08-10 19:03:04 +000077
Daniel Dunbareab96a22010-01-26 01:44:04 +000078static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
79 const llvm::Triple &Triple) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000080 Builder.defineMacro("__APPLE_CC__", "5621");
81 Builder.defineMacro("__APPLE__");
82 Builder.defineMacro("__MACH__");
83 Builder.defineMacro("OBJC_NEW_PROPERTIES");
Anton Korobeynikove7772382009-05-03 13:42:53 +000084
Chris Lattner8181e622009-04-07 16:50:40 +000085 // __weak is always defined, for use in blocks and with objc pointers.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000086 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikove7772382009-05-03 13:42:53 +000087
Chris Lattner8181e622009-04-07 16:50:40 +000088 // Darwin defines __strong even in C mode (just to nothing).
89 if (!Opts.ObjC1 || Opts.getGCMode() == LangOptions::NonGC)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000090 Builder.defineMacro("__strong", "");
Chris Lattner8181e622009-04-07 16:50:40 +000091 else
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000092 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
Eli Friedmaneff0a422009-06-04 23:00:29 +000093
94 if (Opts.Static)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000095 Builder.defineMacro("__STATIC__");
Eli Friedmaneff0a422009-06-04 23:00:29 +000096 else
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000097 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +000098
99 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000100 Builder.defineMacro("_REENTRANT");
Daniel Dunbar93f64532009-04-10 19:52:24 +0000101
Daniel Dunbareab96a22010-01-26 01:44:04 +0000102 // Get the OS version number from the triple.
Daniel Dunbar93f64532009-04-10 19:52:24 +0000103 unsigned Maj, Min, Rev;
Mike Stump25cf7602009-09-09 15:08:12 +0000104
Daniel Dunbareab96a22010-01-26 01:44:04 +0000105 // If no version was given, default to to 10.4.0, for simplifying tests.
106 if (Triple.getOSName() == "darwin") {
107 Min = Rev = 0;
108 Maj = 8;
109 } else
110 Triple.getDarwinNumber(Maj, Min, Rev);
111
112 // Set the appropriate OS version define.
113 if (Triple.getEnvironmentName() == "iphoneos") {
114 assert(Maj < 10 && Min < 99 && Rev < 99 && "Invalid version!");
115 char Str[6];
116 Str[0] = '0' + Maj;
117 Str[1] = '0' + (Min / 10);
118 Str[2] = '0' + (Min % 10);
119 Str[3] = '0' + (Rev / 10);
120 Str[4] = '0' + (Rev % 10);
121 Str[5] = '\0';
122 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
123 } else {
124 // For historical reasons that make little sense, the version passed here is
125 // the "darwin" version, which drops the 10 and offsets by 4.
126 Rev = Min;
127 Min = Maj - 4;
128 Maj = 10;
129
130 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
131 assert(Maj < 99 && Min < 10 && Rev < 10 && "Invalid version!");
132 char Str[5];
133 Str[0] = '0' + (Maj / 10);
134 Str[1] = '0' + (Maj % 10);
135 Str[2] = '0' + Min;
136 Str[3] = '0' + Rev;
137 Str[4] = '\0';
138 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar93f64532009-04-10 19:52:24 +0000139 }
Eli Friedman872996c2008-08-20 02:34:37 +0000140}
Chris Lattner4b009652007-07-25 00:24:17 +0000141
Chris Lattner43954312009-08-10 19:03:04 +0000142namespace {
Edwin Török36565e52009-06-30 17:10:35 +0000143template<typename Target>
144class DarwinTargetInfo : public OSTargetInfo<Target> {
145protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000146 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000147 MacroBuilder &Builder) const {
Daniel Dunbareab96a22010-01-26 01:44:04 +0000148 getDarwinDefines(Builder, Opts, Triple);
Edwin Török36565e52009-06-30 17:10:35 +0000149 }
Mike Stump25cf7602009-09-09 15:08:12 +0000150
Edwin Török36565e52009-06-30 17:10:35 +0000151public:
152 DarwinTargetInfo(const std::string& triple) :
153 OSTargetInfo<Target>(triple) {
Eric Christopherd109c622010-06-25 19:04:52 +0000154 this->TLSSupported = llvm::Triple(triple).getDarwinMajorNumber() > 10;
Edwin Török36565e52009-06-30 17:10:35 +0000155 }
156
Anders Carlsson41f80b52010-01-30 18:33:31 +0000157 virtual std::string isValidSectionSpecifier(llvm::StringRef SR) const {
Chris Lattner43954312009-08-10 19:03:04 +0000158 // Let MCSectionMachO validate this.
159 llvm::StringRef Segment, Section;
160 unsigned TAA, StubSize;
161 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
162 TAA, StubSize);
163 }
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000164
Anders Carlsson608b5792010-06-08 22:47:50 +0000165 virtual const char *getStaticInitSectionSpecifier() const {
166 // FIXME: We should return 0 when building kexts.
167 return "__TEXT,__StaticInit,regular,pure_instructions";
168 }
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000169
Edwin Török36565e52009-06-30 17:10:35 +0000170};
171
Chris Lattner43954312009-08-10 19:03:04 +0000172
Edwin Török36565e52009-06-30 17:10:35 +0000173// DragonFlyBSD Target
174template<typename Target>
175class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
176protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000177 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000178 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000179 // DragonFly defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000180 Builder.defineMacro("__DragonFly__");
181 Builder.defineMacro("__DragonFly_cc_version", "100001");
182 Builder.defineMacro("__ELF__");
183 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
184 Builder.defineMacro("__tune_i386__");
185 DefineStd(Builder, "unix", Opts);
Edwin Török36565e52009-06-30 17:10:35 +0000186 }
187public:
Mike Stump25cf7602009-09-09 15:08:12 +0000188 DragonFlyBSDTargetInfo(const std::string &triple)
Edwin Török36565e52009-06-30 17:10:35 +0000189 : OSTargetInfo<Target>(triple) {}
190};
191
192// FreeBSD Target
193template<typename Target>
194class FreeBSDTargetInfo : public OSTargetInfo<Target> {
195protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000196 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000197 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000198 // FreeBSD defines; list based off of gcc output
199
Daniel Dunbar608b3882009-08-24 09:10:05 +0000200 // FIXME: Move version number handling to llvm::Triple.
Benjamin Kramereaa3c702010-01-30 19:55:01 +0000201 llvm::StringRef Release = Triple.getOSName().substr(strlen("freebsd"), 1);
Edwin Török36565e52009-06-30 17:10:35 +0000202
Benjamin Kramereaa3c702010-01-30 19:55:01 +0000203 Builder.defineMacro("__FreeBSD__", Release);
204 Builder.defineMacro("__FreeBSD_cc_version", Release + "00001");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000205 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
206 DefineStd(Builder, "unix", Opts);
207 Builder.defineMacro("__ELF__");
Edwin Török36565e52009-06-30 17:10:35 +0000208 }
209public:
Mike Stump25cf7602009-09-09 15:08:12 +0000210 FreeBSDTargetInfo(const std::string &triple)
Duncan Sandscd2cb662009-07-08 13:55:08 +0000211 : OSTargetInfo<Target>(triple) {
212 this->UserLabelPrefix = "";
213 }
Edwin Török36565e52009-06-30 17:10:35 +0000214};
215
Chris Lattner6f4bed52010-07-07 16:01:42 +0000216// Minix Target
217template<typename Target>
218class MinixTargetInfo : public OSTargetInfo<Target> {
219protected:
220 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
221 MacroBuilder &Builder) const {
222 // Minix defines
223
224 Builder.defineMacro("__minix", "3");
225 Builder.defineMacro("_EM_WSIZE", "4");
226 Builder.defineMacro("_EM_PSIZE", "4");
227 Builder.defineMacro("_EM_SSIZE", "2");
228 Builder.defineMacro("_EM_LSIZE", "4");
229 Builder.defineMacro("_EM_FSIZE", "4");
230 Builder.defineMacro("_EM_DSIZE", "8");
231 DefineStd(Builder, "unix", Opts);
232 }
233public:
234 MinixTargetInfo(const std::string &triple)
235 : OSTargetInfo<Target>(triple) {
236 this->UserLabelPrefix = "";
237 }
238};
239
Edwin Török36565e52009-06-30 17:10:35 +0000240// Linux target
241template<typename Target>
242class LinuxTargetInfo : public OSTargetInfo<Target> {
243protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000244 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000245 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000246 // Linux defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000247 DefineStd(Builder, "unix", Opts);
248 DefineStd(Builder, "linux", Opts);
249 Builder.defineMacro("__gnu_linux__");
250 Builder.defineMacro("__ELF__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000251 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000252 Builder.defineMacro("_REENTRANT");
Douglas Gregor9b22a172010-04-21 05:52:38 +0000253 if (Opts.CPlusPlus)
254 Builder.defineMacro("_GNU_SOURCE");
Edwin Török36565e52009-06-30 17:10:35 +0000255 }
256public:
Mike Stump25cf7602009-09-09 15:08:12 +0000257 LinuxTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +0000258 : OSTargetInfo<Target>(triple) {
259 this->UserLabelPrefix = "";
260 }
261};
262
Chris Lattner25fff082009-07-13 20:29:08 +0000263// NetBSD Target
264template<typename Target>
265class NetBSDTargetInfo : public OSTargetInfo<Target> {
266protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000267 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000268 MacroBuilder &Builder) const {
Chris Lattner25fff082009-07-13 20:29:08 +0000269 // NetBSD defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000270 Builder.defineMacro("__NetBSD__");
271 Builder.defineMacro("__unix__");
272 Builder.defineMacro("__ELF__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000273 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000274 Builder.defineMacro("_POSIX_THREADS");
Chris Lattner25fff082009-07-13 20:29:08 +0000275 }
276public:
Mike Stump25cf7602009-09-09 15:08:12 +0000277 NetBSDTargetInfo(const std::string &triple)
Chris Lattner25fff082009-07-13 20:29:08 +0000278 : OSTargetInfo<Target>(triple) {
279 this->UserLabelPrefix = "";
280 }
281};
282
Edwin Török36565e52009-06-30 17:10:35 +0000283// OpenBSD Target
284template<typename Target>
285class OpenBSDTargetInfo : public OSTargetInfo<Target> {
286protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000287 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000288 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000289 // OpenBSD defines; list based off of gcc output
290
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000291 Builder.defineMacro("__OpenBSD__");
292 DefineStd(Builder, "unix", Opts);
293 Builder.defineMacro("__ELF__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000294 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000295 Builder.defineMacro("_POSIX_THREADS");
Edwin Török36565e52009-06-30 17:10:35 +0000296 }
297public:
Mike Stump25cf7602009-09-09 15:08:12 +0000298 OpenBSDTargetInfo(const std::string &triple)
Edwin Török36565e52009-06-30 17:10:35 +0000299 : OSTargetInfo<Target>(triple) {}
300};
301
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000302// PSP Target
303template<typename Target>
304class PSPTargetInfo : public OSTargetInfo<Target> {
305protected:
306 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000307 MacroBuilder &Builder) const {
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000308 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000309 Builder.defineMacro("PSP");
310 Builder.defineMacro("_PSP");
311 Builder.defineMacro("__psp__");
312 Builder.defineMacro("__ELF__");
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000313 }
314public:
315 PSPTargetInfo(const std::string& triple)
316 : OSTargetInfo<Target>(triple) {
317 this->UserLabelPrefix = "";
318 }
319};
320
John Thompsoned7bdbc2009-11-19 17:18:50 +0000321// PS3 PPU Target
322template<typename Target>
323class PS3PPUTargetInfo : public OSTargetInfo<Target> {
324protected:
325 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000326 MacroBuilder &Builder) const {
John Thompsoned7bdbc2009-11-19 17:18:50 +0000327 // PS3 PPU defines.
John Thompsonfdd2fc32010-03-25 16:18:32 +0000328 Builder.defineMacro("__PPC__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000329 Builder.defineMacro("__PPU__");
330 Builder.defineMacro("__CELLOS_LV2__");
331 Builder.defineMacro("__ELF__");
332 Builder.defineMacro("__LP32__");
John Thompson1deeb9f2010-06-24 22:44:13 +0000333 Builder.defineMacro("_ARCH_PPC64");
334 Builder.defineMacro("__powerpc64__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000335 }
336public:
337 PS3PPUTargetInfo(const std::string& triple)
338 : OSTargetInfo<Target>(triple) {
339 this->UserLabelPrefix = "";
John Thompson4c3bd3f2009-12-18 14:21:08 +0000340 this->LongWidth = this->LongAlign = this->PointerWidth = this->PointerAlign = 32;
John Thompson1deeb9f2010-06-24 22:44:13 +0000341 this->IntMaxType = TargetInfo::SignedLongLong;
342 this->UIntMaxType = TargetInfo::UnsignedLongLong;
343 this->Int64Type = TargetInfo::SignedLongLong;
John Thompson4c3bd3f2009-12-18 14:21:08 +0000344 this->SizeType = TargetInfo::UnsignedInt;
John Thompson1deeb9f2010-06-24 22:44:13 +0000345 this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
346 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompsoned7bdbc2009-11-19 17:18:50 +0000347 }
348};
349
350// FIXME: Need a real SPU target.
351// PS3 SPU Target
352template<typename Target>
353class PS3SPUTargetInfo : public OSTargetInfo<Target> {
354protected:
355 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000356 MacroBuilder &Builder) const {
John Thompsoned7bdbc2009-11-19 17:18:50 +0000357 // PS3 PPU defines.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000358 Builder.defineMacro("__SPU__");
359 Builder.defineMacro("__ELF__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000360 }
361public:
362 PS3SPUTargetInfo(const std::string& triple)
363 : OSTargetInfo<Target>(triple) {
364 this->UserLabelPrefix = "";
365 }
366};
367
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +0000368// AuroraUX target
369template<typename Target>
370class AuroraUXTargetInfo : public OSTargetInfo<Target> {
371protected:
372 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000373 MacroBuilder &Builder) const {
374 DefineStd(Builder, "sun", Opts);
375 DefineStd(Builder, "unix", Opts);
376 Builder.defineMacro("__ELF__");
377 Builder.defineMacro("__svr4__");
378 Builder.defineMacro("__SVR4");
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +0000379 }
380public:
381 AuroraUXTargetInfo(const std::string& triple)
382 : OSTargetInfo<Target>(triple) {
383 this->UserLabelPrefix = "";
384 this->WCharType = this->SignedLong;
385 // FIXME: WIntType should be SignedLong
386 }
387};
388
Edwin Török36565e52009-06-30 17:10:35 +0000389// Solaris target
390template<typename Target>
391class SolarisTargetInfo : public OSTargetInfo<Target> {
392protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000393 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000394 MacroBuilder &Builder) const {
395 DefineStd(Builder, "sun", Opts);
396 DefineStd(Builder, "unix", Opts);
397 Builder.defineMacro("__ELF__");
398 Builder.defineMacro("__svr4__");
399 Builder.defineMacro("__SVR4");
Edwin Török36565e52009-06-30 17:10:35 +0000400 }
401public:
Mike Stump25cf7602009-09-09 15:08:12 +0000402 SolarisTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +0000403 : OSTargetInfo<Target>(triple) {
404 this->UserLabelPrefix = "";
405 this->WCharType = this->SignedLong;
406 // FIXME: WIntType should be SignedLong
407 }
408};
Michael J. Spencer01e70082010-10-21 05:21:48 +0000409
410// Windows target
411template<typename Target>
412class WindowsTargetInfo : public OSTargetInfo<Target> {
413protected:
414 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
415 MacroBuilder &Builder) const {
Michael J. Spencer4fb461c2010-10-21 08:22:51 +0000416 Builder.defineMacro("_WIN32");
417 }
418 void getVisualStudioDefines(const LangOptions &Opts,
419 MacroBuilder &Builder) const {
Michael J. Spencer01e70082010-10-21 05:21:48 +0000420 if (Opts.CPlusPlus) {
421 if (Opts.RTTI)
422 Builder.defineMacro("_CPPRTTI");
423
424 if (Opts.Exceptions)
425 Builder.defineMacro("_CPPUNWIND");
426 }
427
428 if (!Opts.CharIsSigned)
429 Builder.defineMacro("_CHAR_UNSIGNED");
430
431 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
432 // but it works for now.
433 if (Opts.POSIXThreads)
434 Builder.defineMacro("_MT");
Michael J. Spencer4fb461c2010-10-21 08:22:51 +0000435
Michael J. Spencer01e70082010-10-21 05:21:48 +0000436 if (Opts.MSCVersion != 0)
437 Builder.defineMacro("_MSC_VER", llvm::Twine(Opts.MSCVersion));
438
439 if (Opts.Microsoft) {
440 Builder.defineMacro("_MSC_EXTENSIONS");
441
442 if (Opts.CPlusPlus0x) {
443 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
444 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
445 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
446 }
447 }
448
449 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencer01e70082010-10-21 05:21:48 +0000450 }
451
Michael J. Spencer01e70082010-10-21 05:21:48 +0000452public:
453 WindowsTargetInfo(const std::string &triple)
454 : OSTargetInfo<Target>(triple) {}
455};
456
Mike Stump25cf7602009-09-09 15:08:12 +0000457} // end anonymous namespace.
Edwin Török36565e52009-06-30 17:10:35 +0000458
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000459//===----------------------------------------------------------------------===//
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000460// Specific target implementations.
461//===----------------------------------------------------------------------===//
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000462
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000463namespace {
464// PPC abstract base class
465class PPCTargetInfo : public TargetInfo {
466 static const Builtin::Info BuiltinInfo[];
467 static const char * const GCCRegNames[];
468 static const TargetInfo::GCCRegAlias GCCRegAliases[];
469
470public:
Eli Friedmand9389be2009-06-05 07:05:05 +0000471 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
472
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000473 virtual void getTargetBuiltins(const Builtin::Info *&Records,
474 unsigned &NumRecords) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000475 Records = BuiltinInfo;
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000476 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000477 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000478
Chris Lattner79682402009-03-20 15:52:06 +0000479 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000480 MacroBuilder &Builder) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000481
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000482 virtual const char *getVAListDeclaration() const {
Chris Lattnera07708f2008-10-27 01:11:29 +0000483 return "typedef char* __builtin_va_list;";
484 // This is the right definition for ABI/V4: System V.4/eabi.
485 /*return "typedef struct __va_list_tag {"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000486 " unsigned char gpr;"
487 " unsigned char fpr;"
488 " unsigned short reserved;"
489 " void* overflow_arg_area;"
490 " void* reg_save_area;"
Chris Lattnera07708f2008-10-27 01:11:29 +0000491 "} __builtin_va_list[1];";*/
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000492 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000493 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000494 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000495 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000496 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +0000497 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000498 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +0000499 switch (*Name) {
Anders Carlsson4ce42302007-11-27 04:11:28 +0000500 default: return false;
501 case 'O': // Zero
John Thompson1deeb9f2010-06-24 22:44:13 +0000502 break;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000503 case 'b': // Base register
504 case 'f': // Floating point register
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000505 Info.setAllowsRegister();
John Thompson1deeb9f2010-06-24 22:44:13 +0000506 break;
507 // FIXME: The following are added to allow parsing.
508 // I just took a guess at what the actions should be.
509 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000510 case 'd': // Floating point register (containing 64-bit value)
John Thompson1deeb9f2010-06-24 22:44:13 +0000511 case 'v': // Altivec vector register
512 Info.setAllowsRegister();
513 break;
514 case 'w':
515 switch (Name[1]) {
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000516 case 'd':// VSX vector register to hold vector double data
517 case 'f':// VSX vector register to hold vector float data
518 case 's':// VSX vector register to hold scalar float data
519 case 'a':// Any VSX register
John Thompson1deeb9f2010-06-24 22:44:13 +0000520 break;
521 default:
522 return false;
523 }
524 Info.setAllowsRegister();
525 Name++; // Skip over 'w'.
526 break;
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000527 case 'h': // `MQ', `CTR', or `LINK' register
528 case 'q': // `MQ' register
529 case 'c': // `CTR' register
530 case 'l': // `LINK' register
531 case 'x': // `CR' register (condition register) number 0
532 case 'y': // `CR' register (condition register)
533 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson1deeb9f2010-06-24 22:44:13 +0000534 Info.setAllowsRegister();
535 break;
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000536 case 'I': // Signed 16-bit constant
John Thompson1deeb9f2010-06-24 22:44:13 +0000537 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000538 // (use `L' instead for SImode constants)
539 case 'K': // Unsigned 16-bit constant
540 case 'L': // Signed 16-bit constant shifted left 16 bits
541 case 'M': // Constant larger than 31
542 case 'N': // Exact power of 2
543 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson1deeb9f2010-06-24 22:44:13 +0000544 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000545 // register with one instruction per word
John Thompson1deeb9f2010-06-24 22:44:13 +0000546 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000547 // into a register using three instructions
John Thompson1deeb9f2010-06-24 22:44:13 +0000548 break;
549 case 'm': // Memory operand. Note that on PowerPC targets, m can
550 // include addresses that update the base register. It
551 // is therefore only safe to use `m' in an asm statement
552 // if that asm statement accesses the operand exactly once.
553 // The asm statement must also use `%U<opno>' as a
Sebastian Redl097ce222010-08-17 22:42:34 +0000554 // placeholder for the "update" flag in the corresponding
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000555 // load or store instruction. For example:
John Thompson1deeb9f2010-06-24 22:44:13 +0000556 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000557 // is correct but:
John Thompson1deeb9f2010-06-24 22:44:13 +0000558 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
559 // is not. Use es rather than m if you don't want the base
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000560 // register to be updated.
561 case 'e':
John Thompsone0a39472010-06-25 00:02:05 +0000562 if (Name[1] != 's')
563 return false;
Sebastian Redl097ce222010-08-17 22:42:34 +0000564 // es: A "stable" memory operand; that is, one which does not
John Thompson1deeb9f2010-06-24 22:44:13 +0000565 // include any automodification of the base register. Unlike
566 // `m', this constraint can be used in asm statements that
567 // might access the operand several times, or that might not
John Thompsone0a39472010-06-25 00:02:05 +0000568 // access it at all.
John Thompson1deeb9f2010-06-24 22:44:13 +0000569 Info.setAllowsMemory();
John Thompsone0a39472010-06-25 00:02:05 +0000570 Name++; // Skip over 'e'.
John Thompson1deeb9f2010-06-24 22:44:13 +0000571 break;
572 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000573 // usually better to use `m' or `es' in asm statements)
John Thompson1deeb9f2010-06-24 22:44:13 +0000574 case 'Z': // Memory operand that is an indexed or indirect from a
575 // register (it is usually better to use `m' or `es' in
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000576 // asm statements)
John Thompson1deeb9f2010-06-24 22:44:13 +0000577 Info.setAllowsMemory();
578 Info.setAllowsRegister();
579 break;
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000580 case 'R': // AIX TOC entry
John Thompson1deeb9f2010-06-24 22:44:13 +0000581 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000582 // register (`p' is preferable for asm statements)
583 case 'S': // Constant suitable as a 64-bit mask operand
584 case 'T': // Constant suitable as a 32-bit mask operand
585 case 'U': // System V Release 4 small data area reference
John Thompson1deeb9f2010-06-24 22:44:13 +0000586 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000587 // instructions
588 case 'W': // Vector constant that does not require memory
589 case 'j': // Vector constant that is all zeros.
John Thompson1deeb9f2010-06-24 22:44:13 +0000590 break;
591 // End FIXME.
Anders Carlsson4ce42302007-11-27 04:11:28 +0000592 }
John Thompson1deeb9f2010-06-24 22:44:13 +0000593 return true;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000594 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000595 virtual const char *getClobbers() const {
596 return "";
Anders Carlsson4ce42302007-11-27 04:11:28 +0000597 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000598};
Anders Carlsson4ce42302007-11-27 04:11:28 +0000599
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000600const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000601#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
602#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000603#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000604};
Anton Korobeynikove7772382009-05-03 13:42:53 +0000605
606
Chris Lattnerbef1d722009-03-02 22:27:17 +0000607/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
608/// #defines that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +0000609void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000610 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +0000611 // Target identification.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000612 Builder.defineMacro("__ppc__");
613 Builder.defineMacro("_ARCH_PPC");
Chris Lattnerf8030412010-02-16 18:14:57 +0000614 Builder.defineMacro("__powerpc__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000615 Builder.defineMacro("__POWERPC__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000616 if (PointerWidth == 64) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000617 Builder.defineMacro("_ARCH_PPC64");
618 Builder.defineMacro("_LP64");
619 Builder.defineMacro("__LP64__");
Chris Lattnerf8030412010-02-16 18:14:57 +0000620 Builder.defineMacro("__powerpc64__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000621 Builder.defineMacro("__ppc64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000622 } else {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000623 Builder.defineMacro("__ppc__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000624 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000625
Chris Lattnerbef1d722009-03-02 22:27:17 +0000626 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000627 Builder.defineMacro("_BIG_ENDIAN");
628 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000629
Chris Lattnerbef1d722009-03-02 22:27:17 +0000630 // Subtarget options.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000631 Builder.defineMacro("__NATURAL_ALIGNMENT__");
632 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000633
Chris Lattnerbef1d722009-03-02 22:27:17 +0000634 // FIXME: Should be controlled by command line option.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000635 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000636
John Thompsoned7bdbc2009-11-19 17:18:50 +0000637 if (Opts.AltiVec) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000638 Builder.defineMacro("__VEC__", "10206");
639 Builder.defineMacro("__ALTIVEC__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000640 }
Chris Lattnerbef1d722009-03-02 22:27:17 +0000641}
642
Chris Lattner9fd73612008-04-21 18:56:49 +0000643
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000644const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattner14d2bb72009-09-16 05:05:27 +0000645 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
646 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
647 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
648 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
649 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
650 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
651 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
652 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000653 "mq", "lr", "ctr", "ap",
Chris Lattner14d2bb72009-09-16 05:05:27 +0000654 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000655 "xer",
Chris Lattner14d2bb72009-09-16 05:05:27 +0000656 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
657 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
658 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
659 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000660 "vrsave", "vscr",
661 "spe_acc", "spefscr",
662 "sfp"
663};
Chris Lattner4b009652007-07-25 00:24:17 +0000664
Anton Korobeynikove7772382009-05-03 13:42:53 +0000665void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000666 unsigned &NumNames) const {
667 Names = GCCRegNames;
668 NumNames = llvm::array_lengthof(GCCRegNames);
669}
Chris Lattner4b009652007-07-25 00:24:17 +0000670
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000671const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
672 // While some of these aliases do map to different registers
673 // they still share the same register name.
Daniel Dunbar40b774e2009-09-17 07:03:19 +0000674 { { "0" }, "r0" },
675 { { "1"}, "r1" },
676 { { "2" }, "r2" },
677 { { "3" }, "r3" },
678 { { "4" }, "r4" },
679 { { "5" }, "r5" },
680 { { "6" }, "r6" },
681 { { "7" }, "r7" },
682 { { "8" }, "r8" },
683 { { "9" }, "r9" },
684 { { "10" }, "r10" },
685 { { "11" }, "r11" },
686 { { "12" }, "r12" },
687 { { "13" }, "r13" },
688 { { "14" }, "r14" },
689 { { "15" }, "r15" },
690 { { "16" }, "r16" },
691 { { "17" }, "r17" },
692 { { "18" }, "r18" },
693 { { "19" }, "r19" },
694 { { "20" }, "r20" },
695 { { "21" }, "r21" },
696 { { "22" }, "r22" },
697 { { "23" }, "r23" },
698 { { "24" }, "r24" },
699 { { "25" }, "r25" },
700 { { "26" }, "r26" },
701 { { "27" }, "r27" },
702 { { "28" }, "r28" },
703 { { "29" }, "r29" },
704 { { "30" }, "r30" },
705 { { "31" }, "r31" },
706 { { "fr0" }, "f0" },
707 { { "fr1" }, "f1" },
708 { { "fr2" }, "f2" },
709 { { "fr3" }, "f3" },
710 { { "fr4" }, "f4" },
711 { { "fr5" }, "f5" },
712 { { "fr6" }, "f6" },
713 { { "fr7" }, "f7" },
714 { { "fr8" }, "f8" },
715 { { "fr9" }, "f9" },
Mike Stump369c21c2009-09-17 21:15:00 +0000716 { { "fr10" }, "f10" },
Daniel Dunbar40b774e2009-09-17 07:03:19 +0000717 { { "fr11" }, "f11" },
718 { { "fr12" }, "f12" },
719 { { "fr13" }, "f13" },
720 { { "fr14" }, "f14" },
721 { { "fr15" }, "f15" },
722 { { "fr16" }, "f16" },
723 { { "fr17" }, "f17" },
724 { { "fr18" }, "f18" },
725 { { "fr19" }, "f19" },
726 { { "fr20" }, "f20" },
727 { { "fr21" }, "f21" },
728 { { "fr22" }, "f22" },
729 { { "fr23" }, "f23" },
730 { { "fr24" }, "f24" },
731 { { "fr25" }, "f25" },
732 { { "fr26" }, "f26" },
733 { { "fr27" }, "f27" },
734 { { "fr28" }, "f28" },
735 { { "fr29" }, "f29" },
736 { { "fr30" }, "f30" },
737 { { "fr31" }, "f31" },
738 { { "cc" }, "cr0" },
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000739};
740
Anton Korobeynikove7772382009-05-03 13:42:53 +0000741void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000742 unsigned &NumAliases) const {
743 Aliases = GCCRegAliases;
744 NumAliases = llvm::array_lengthof(GCCRegAliases);
745}
746} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +0000747
748namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000749class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000750public:
Chris Lattnerf8030412010-02-16 18:14:57 +0000751 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedman2b161652008-08-21 00:13:15 +0000752 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 +0000753 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnerf8030412010-02-16 18:14:57 +0000754
755 if (getTriple().getOS() == llvm::Triple::FreeBSD)
756 this->SizeType = TargetInfo::UnsignedInt;
Eli Friedman2b161652008-08-21 00:13:15 +0000757 }
Chris Lattner4b009652007-07-25 00:24:17 +0000758};
759} // end anonymous namespace.
760
761namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000762class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000763public:
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000764 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +0000765 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman38e31802009-07-01 03:36:11 +0000766 IntMaxType = SignedLong;
767 UIntMaxType = UnsignedLong;
768 Int64Type = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +0000769 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 +0000770 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnere5fde952008-05-09 06:17:04 +0000771 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000772};
773} // end anonymous namespace.
774
Daniel Dunbar6501cab2010-05-30 00:07:30 +0000775
776namespace {
777class DarwinPPCTargetInfo :
778 public DarwinTargetInfo<PPCTargetInfo> {
779public:
780 DarwinPPCTargetInfo(const std::string& triple)
781 : DarwinTargetInfo<PPCTargetInfo>(triple) {
782 HasAlignMac68kSupport = true;
783 }
784};
785
786class DarwinPPC64TargetInfo :
787 public DarwinTargetInfo<PPC64TargetInfo> {
788public:
789 DarwinPPC64TargetInfo(const std::string& triple)
790 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
791 HasAlignMac68kSupport = true;
792 }
793};
794} // end anonymous namespace.
795
Chris Lattner4b009652007-07-25 00:24:17 +0000796namespace {
Chris Lattner2c026472010-03-06 21:21:27 +0000797// MBlaze abstract base class
798class MBlazeTargetInfo : public TargetInfo {
799 static const char * const GCCRegNames[];
800 static const TargetInfo::GCCRegAlias GCCRegAliases[];
801
802public:
803 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
804 DescriptionString = "E-p:32:32-i8:8:8-i16:16:16-i64:32:32-f64:32:32-"
805 "v64:32:32-v128:32:32-n32";
806 }
807
808 virtual void getTargetBuiltins(const Builtin::Info *&Records,
809 unsigned &NumRecords) const {
810 // FIXME: Implement.
811 Records = 0;
812 NumRecords = 0;
813 }
814
815 virtual void getTargetDefines(const LangOptions &Opts,
816 MacroBuilder &Builder) const;
817
818 virtual const char *getVAListDeclaration() const {
819 return "typedef char* __builtin_va_list;";
820 }
821 virtual const char *getTargetPrefix() const {
822 return "mblaze";
823 }
824 virtual void getGCCRegNames(const char * const *&Names,
825 unsigned &NumNames) const;
826 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
827 unsigned &NumAliases) const;
828 virtual bool validateAsmConstraint(const char *&Name,
829 TargetInfo::ConstraintInfo &Info) const {
830 switch (*Name) {
831 default: return false;
832 case 'O': // Zero
833 return true;
834 case 'b': // Base register
835 case 'f': // Floating point register
836 Info.setAllowsRegister();
837 return true;
838 }
839 }
840 virtual const char *getClobbers() const {
841 return "";
842 }
843};
844
845/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
846/// #defines that are not tied to a specific subtarget.
847void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
848 MacroBuilder &Builder) const {
849 // Target identification.
850 Builder.defineMacro("__microblaze__");
851 Builder.defineMacro("_ARCH_MICROBLAZE");
852 Builder.defineMacro("__MICROBLAZE__");
853
854 // Target properties.
855 Builder.defineMacro("_BIG_ENDIAN");
856 Builder.defineMacro("__BIG_ENDIAN__");
857
858 // Subtarget options.
859 Builder.defineMacro("__REGISTER_PREFIX__", "");
860}
861
862
863const char * const MBlazeTargetInfo::GCCRegNames[] = {
864 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
865 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
866 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
867 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
868 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
869 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
870 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
871 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
872 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
873 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
874};
875
876void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
877 unsigned &NumNames) const {
878 Names = GCCRegNames;
879 NumNames = llvm::array_lengthof(GCCRegNames);
880}
881
882const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
883 { {"f0"}, "r0" },
884 { {"f1"}, "r1" },
885 { {"f2"}, "r2" },
886 { {"f3"}, "r3" },
887 { {"f4"}, "r4" },
888 { {"f5"}, "r5" },
889 { {"f6"}, "r6" },
890 { {"f7"}, "r7" },
891 { {"f8"}, "r8" },
892 { {"f9"}, "r9" },
893 { {"f10"}, "r10" },
894 { {"f11"}, "r11" },
895 { {"f12"}, "r12" },
896 { {"f13"}, "r13" },
897 { {"f14"}, "r14" },
898 { {"f15"}, "r15" },
899 { {"f16"}, "r16" },
900 { {"f17"}, "r17" },
901 { {"f18"}, "r18" },
902 { {"f19"}, "r19" },
903 { {"f20"}, "r20" },
904 { {"f21"}, "r21" },
905 { {"f22"}, "r22" },
906 { {"f23"}, "r23" },
907 { {"f24"}, "r24" },
908 { {"f25"}, "r25" },
909 { {"f26"}, "r26" },
910 { {"f27"}, "r27" },
911 { {"f28"}, "r28" },
912 { {"f29"}, "r29" },
913 { {"f30"}, "r30" },
914 { {"f31"}, "r31" },
915};
916
917void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
918 unsigned &NumAliases) const {
919 Aliases = GCCRegAliases;
920 NumAliases = llvm::array_lengthof(GCCRegAliases);
921}
922} // end anonymous namespace.
923
924namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000925// Namespace for x86 abstract base class
926const Builtin::Info BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000927#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
928#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000929#include "clang/Basic/BuiltinsX86.def"
Eli Friedman872996c2008-08-20 02:34:37 +0000930};
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000931
Nuno Lopesad1010d2009-12-23 17:49:57 +0000932static const char* const GCCRegNames[] = {
Eli Friedman872996c2008-08-20 02:34:37 +0000933 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
934 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
935 "argp", "flags", "fspr", "dirflag", "frame",
936 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
937 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
938 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
939 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
940};
941
942const TargetInfo::GCCRegAlias GCCRegAliases[] = {
943 { { "al", "ah", "eax", "rax" }, "ax" },
944 { { "bl", "bh", "ebx", "rbx" }, "bx" },
945 { { "cl", "ch", "ecx", "rcx" }, "cx" },
946 { { "dl", "dh", "edx", "rdx" }, "dx" },
947 { { "esi", "rsi" }, "si" },
948 { { "edi", "rdi" }, "di" },
949 { { "esp", "rsp" }, "sp" },
950 { { "ebp", "rbp" }, "bp" },
951};
952
953// X86 target abstract base class; x86-32 and x86-64 are very close, so
954// most of the implementation can be shared.
955class X86TargetInfo : public TargetInfo {
Chris Lattner715fe4c2009-03-02 22:40:39 +0000956 enum X86SSEEnum {
957 NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
958 } SSELevel;
Anders Carlssone5e222f2010-01-27 03:47:49 +0000959 enum AMD3DNowEnum {
960 NoAMD3DNow, AMD3DNow, AMD3DNowAthlon
961 } AMD3DNowLevel;
962
Eric Christopher6c4e7872010-04-02 23:50:19 +0000963 bool HasAES;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +0000964 bool HasAVX;
965
Eli Friedman872996c2008-08-20 02:34:37 +0000966public:
Anton Korobeynikove7772382009-05-03 13:42:53 +0000967 X86TargetInfo(const std::string& triple)
Eric Christopher6c4e7872010-04-02 23:50:19 +0000968 : TargetInfo(triple), SSELevel(NoMMXSSE), AMD3DNowLevel(NoAMD3DNow),
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +0000969 HasAES(false), HasAVX(false) {
Eli Friedman872996c2008-08-20 02:34:37 +0000970 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner4b009652007-07-25 00:24:17 +0000971 }
972 virtual void getTargetBuiltins(const Builtin::Info *&Records,
973 unsigned &NumRecords) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000974 Records = BuiltinInfo;
975 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000976 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000977 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman872996c2008-08-20 02:34:37 +0000978 unsigned &NumNames) const {
979 Names = GCCRegNames;
980 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000981 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000982 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000983 unsigned &NumAliases) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000984 Aliases = GCCRegAliases;
985 NumAliases = llvm::array_lengthof(GCCRegAliases);
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000986 }
Anders Carlsson36834a72009-02-28 17:11:49 +0000987 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman872996c2008-08-20 02:34:37 +0000988 TargetInfo::ConstraintInfo &info) const;
Dale Johannesen3a161e52010-10-29 23:12:32 +0000989 virtual const llvm::Type* adjustInlineAsmType(std::string& Constraint,
990 const llvm::Type* Ty,
991 llvm::LLVMContext& Context) const;
Eli Friedman872996c2008-08-20 02:34:37 +0000992 virtual std::string convertConstraint(const char Constraint) const;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000993 virtual const char *getClobbers() const {
Eli Friedman872996c2008-08-20 02:34:37 +0000994 return "~{dirflag},~{fpsr},~{flags}";
995 }
Chris Lattner79682402009-03-20 15:52:06 +0000996 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000997 MacroBuilder &Builder) const;
Daniel Dunbar0838f962009-05-06 21:07:50 +0000998 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
999 const std::string &Name,
1000 bool Enabled) const;
Mike Stump25cf7602009-09-09 15:08:12 +00001001 virtual void getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +00001002 llvm::StringMap<bool> &Features) const;
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00001003 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Chris Lattner4b009652007-07-25 00:24:17 +00001004};
Chris Lattner7d6220c2009-03-02 22:20:04 +00001005
Mike Stump25cf7602009-09-09 15:08:12 +00001006void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +00001007 llvm::StringMap<bool> &Features) const {
Daniel Dunbar07181d72009-05-06 03:16:41 +00001008 // FIXME: This should not be here.
1009 Features["3dnow"] = false;
1010 Features["3dnowa"] = false;
1011 Features["mmx"] = false;
1012 Features["sse"] = false;
1013 Features["sse2"] = false;
1014 Features["sse3"] = false;
1015 Features["ssse3"] = false;
1016 Features["sse41"] = false;
1017 Features["sse42"] = false;
Eric Christopher6c4e7872010-04-02 23:50:19 +00001018 Features["aes"] = false;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001019 Features["avx"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001020
Daniel Dunbar07181d72009-05-06 03:16:41 +00001021 // LLVM does not currently recognize this.
1022 // Features["sse4a"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001023
Daniel Dunbar07181d72009-05-06 03:16:41 +00001024 // FIXME: This *really* should not be here.
1025
1026 // X86_64 always has SSE2.
1027 if (PointerWidth == 64)
1028 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1029
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001030 if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
1031 CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
1032 ;
1033 else if (CPU == "pentium-mmx" || CPU == "pentium2")
1034 setFeatureEnabled(Features, "mmx", true);
1035 else if (CPU == "pentium3")
1036 setFeatureEnabled(Features, "sse", true);
1037 else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64")
1038 setFeatureEnabled(Features, "sse2", true);
1039 else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona")
1040 setFeatureEnabled(Features, "sse3", true);
1041 else if (CPU == "core2")
1042 setFeatureEnabled(Features, "ssse3", true);
1043 else if (CPU == "penryn") {
1044 setFeatureEnabled(Features, "sse4", true);
1045 Features["sse42"] = false;
1046 } else if (CPU == "atom")
1047 setFeatureEnabled(Features, "sse3", true);
Eric Christopher6c4e7872010-04-02 23:50:19 +00001048 else if (CPU == "corei7") {
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001049 setFeatureEnabled(Features, "sse4", true);
Eric Christopher6c4e7872010-04-02 23:50:19 +00001050 setFeatureEnabled(Features, "aes", true);
1051 }
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001052 else if (CPU == "k6" || CPU == "winchip-c6")
1053 setFeatureEnabled(Features, "mmx", true);
Mike Stump25cf7602009-09-09 15:08:12 +00001054 else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001055 CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
1056 setFeatureEnabled(Features, "mmx", true);
1057 setFeatureEnabled(Features, "3dnow", true);
1058 } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
1059 setFeatureEnabled(Features, "sse", true);
1060 setFeatureEnabled(Features, "3dnowa", true);
1061 } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
1062 CPU == "athlon-fx") {
Mike Stump25cf7602009-09-09 15:08:12 +00001063 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001064 setFeatureEnabled(Features, "3dnowa", true);
1065 } else if (CPU == "c3-2")
1066 setFeatureEnabled(Features, "sse", true);
Daniel Dunbar07181d72009-05-06 03:16:41 +00001067}
1068
Daniel Dunbar0838f962009-05-06 21:07:50 +00001069bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump25cf7602009-09-09 15:08:12 +00001070 const std::string &Name,
Daniel Dunbar0838f962009-05-06 21:07:50 +00001071 bool Enabled) const {
Eric Christopher850e2012010-03-04 02:26:37 +00001072 // FIXME: This *really* should not be here. We need some way of translating
1073 // options into llvm subtarget features.
1074 if (!Features.count(Name) &&
1075 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar0838f962009-05-06 21:07:50 +00001076 return false;
1077
1078 if (Enabled) {
1079 if (Name == "mmx")
1080 Features["mmx"] = true;
1081 else if (Name == "sse")
1082 Features["mmx"] = Features["sse"] = true;
1083 else if (Name == "sse2")
1084 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
1085 else if (Name == "sse3")
Mike Stump25cf7602009-09-09 15:08:12 +00001086 Features["mmx"] = Features["sse"] = Features["sse2"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001087 Features["sse3"] = true;
1088 else if (Name == "ssse3")
Mike Stump25cf7602009-09-09 15:08:12 +00001089 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001090 Features["ssse3"] = true;
Eric Christopher850e2012010-03-04 02:26:37 +00001091 else if (Name == "sse4" || Name == "sse4.2")
Mike Stump25cf7602009-09-09 15:08:12 +00001092 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001093 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Eric Christopher850e2012010-03-04 02:26:37 +00001094 else if (Name == "sse4.1")
1095 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1096 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001097 else if (Name == "3dnow")
1098 Features["3dnowa"] = true;
1099 else if (Name == "3dnowa")
1100 Features["3dnow"] = Features["3dnowa"] = true;
Eric Christopher6c4e7872010-04-02 23:50:19 +00001101 else if (Name == "aes")
1102 Features["aes"] = true;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001103 else if (Name == "avx")
1104 Features["avx"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001105 } else {
1106 if (Name == "mmx")
Mike Stump25cf7602009-09-09 15:08:12 +00001107 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001108 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1109 else if (Name == "sse")
Mike Stump25cf7602009-09-09 15:08:12 +00001110 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001111 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1112 else if (Name == "sse2")
Mike Stump25cf7602009-09-09 15:08:12 +00001113 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001114 Features["sse41"] = Features["sse42"] = false;
1115 else if (Name == "sse3")
Mike Stump25cf7602009-09-09 15:08:12 +00001116 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001117 Features["sse42"] = false;
1118 else if (Name == "ssse3")
1119 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1120 else if (Name == "sse4")
1121 Features["sse41"] = Features["sse42"] = false;
Eric Christopherd794f782010-03-04 02:31:44 +00001122 else if (Name == "sse4.2")
1123 Features["sse42"] = false;
1124 else if (Name == "sse4.1")
1125 Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001126 else if (Name == "3dnow")
1127 Features["3dnow"] = Features["3dnowa"] = false;
1128 else if (Name == "3dnowa")
1129 Features["3dnowa"] = false;
Eric Christopher6c4e7872010-04-02 23:50:19 +00001130 else if (Name == "aes")
1131 Features["aes"] = false;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001132 else if (Name == "avx")
1133 Features["avx"] = false;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001134 }
1135
1136 return true;
1137}
1138
Daniel Dunbar07181d72009-05-06 03:16:41 +00001139/// HandleTargetOptions - Perform initialization based on the user
1140/// configured set of features.
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00001141void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001142 // Remember the maximum enabled sselevel.
1143 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1144 // Ignore disabled features.
1145 if (Features[i][0] == '-')
1146 continue;
1147
Eric Christopher6c4e7872010-04-02 23:50:19 +00001148 if (Features[i].substr(1) == "aes") {
1149 HasAES = true;
1150 continue;
1151 }
1152
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001153 // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1154 // For now let it be enabled together with other SSE levels.
1155 if (Features[i].substr(1) == "avx") {
1156 HasAVX = true;
1157 continue;
1158 }
1159
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001160 assert(Features[i][0] == '+' && "Invalid target feature!");
1161 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1162 .Case("sse42", SSE42)
1163 .Case("sse41", SSE41)
1164 .Case("ssse3", SSSE3)
Nuno Lopes3a16d782010-03-12 10:20:09 +00001165 .Case("sse3", SSE3)
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001166 .Case("sse2", SSE2)
1167 .Case("sse", SSE1)
1168 .Case("mmx", MMX)
1169 .Default(NoMMXSSE);
1170 SSELevel = std::max(SSELevel, Level);
Michael J. Spencerd5513a32010-10-21 03:16:25 +00001171
1172 AMD3DNowEnum ThreeDNowLevel =
Anders Carlssone5e222f2010-01-27 03:47:49 +00001173 llvm::StringSwitch<AMD3DNowEnum>(Features[i].substr(1))
1174 .Case("3dnowa", AMD3DNowAthlon)
1175 .Case("3dnow", AMD3DNow)
1176 .Default(NoAMD3DNow);
Michael J. Spencerd5513a32010-10-21 03:16:25 +00001177
Anders Carlssone5e222f2010-01-27 03:47:49 +00001178 AMD3DNowLevel = std::max(AMD3DNowLevel, ThreeDNowLevel);
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001179 }
Chris Lattner7d6220c2009-03-02 22:20:04 +00001180}
Chris Lattnerbef1d722009-03-02 22:27:17 +00001181
1182/// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
1183/// that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +00001184void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001185 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00001186 // Target identification.
1187 if (PointerWidth == 64) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001188 Builder.defineMacro("_LP64");
1189 Builder.defineMacro("__LP64__");
1190 Builder.defineMacro("__amd64__");
1191 Builder.defineMacro("__amd64");
1192 Builder.defineMacro("__x86_64");
1193 Builder.defineMacro("__x86_64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +00001194 } else {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001195 DefineStd(Builder, "i386", Opts);
Chris Lattnerbef1d722009-03-02 22:27:17 +00001196 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001197
Eric Christopher6c4e7872010-04-02 23:50:19 +00001198 if (HasAES)
1199 Builder.defineMacro("__AES__");
1200
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001201 if (HasAVX)
1202 Builder.defineMacro("__AVX__");
1203
Chris Lattnerbef1d722009-03-02 22:27:17 +00001204 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001205 Builder.defineMacro("__LITTLE_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001206
Chris Lattnerbef1d722009-03-02 22:27:17 +00001207 // Subtarget options.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001208 Builder.defineMacro("__nocona");
1209 Builder.defineMacro("__nocona__");
1210 Builder.defineMacro("__tune_nocona__");
1211 Builder.defineMacro("__REGISTER_PREFIX__", "");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001212
Chris Lattner25ac1c12009-04-19 17:32:33 +00001213 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1214 // functions in glibc header files that use FP Stack inline asm which the
1215 // backend can't deal with (PR879).
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001216 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001217
Chris Lattner715fe4c2009-03-02 22:40:39 +00001218 // Each case falls through to the previous one here.
1219 switch (SSELevel) {
1220 case SSE42:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001221 Builder.defineMacro("__SSE4_2__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001222 case SSE41:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001223 Builder.defineMacro("__SSE4_1__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001224 case SSSE3:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001225 Builder.defineMacro("__SSSE3__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001226 case SSE3:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001227 Builder.defineMacro("__SSE3__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001228 case SSE2:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001229 Builder.defineMacro("__SSE2__");
1230 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner715fe4c2009-03-02 22:40:39 +00001231 case SSE1:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001232 Builder.defineMacro("__SSE__");
1233 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Chris Lattner715fe4c2009-03-02 22:40:39 +00001234 case MMX:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001235 Builder.defineMacro("__MMX__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001236 case NoMMXSSE:
1237 break;
1238 }
Michael J. Spencer3d796932010-10-18 07:10:59 +00001239
Michael J. Spencer01e70082010-10-21 05:21:48 +00001240 if (Opts.Microsoft && PointerWidth == 32) {
Michael J. Spencer01e70082010-10-21 05:21:48 +00001241 switch (SSELevel) {
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00001242 case SSE42:
1243 case SSE41:
1244 case SSSE3:
1245 case SSE3:
Michael J. Spencer01e70082010-10-21 05:21:48 +00001246 case SSE2:
1247 Builder.defineMacro("_M_IX86_FP", llvm::Twine(2));
1248 break;
1249 case SSE1:
1250 Builder.defineMacro("_M_IX86_FP", llvm::Twine(1));
1251 break;
1252 default:
1253 Builder.defineMacro("_M_IX86_FP", llvm::Twine(0));
1254 }
1255 }
1256
Anders Carlssone5e222f2010-01-27 03:47:49 +00001257 // Each case falls through to the previous one here.
1258 switch (AMD3DNowLevel) {
1259 case AMD3DNowAthlon:
1260 Builder.defineMacro("__3dNOW_A__");
1261 case AMD3DNow:
1262 Builder.defineMacro("__3dNOW__");
1263 case NoAMD3DNow:
1264 break;
1265 }
Chris Lattnerbef1d722009-03-02 22:27:17 +00001266}
Anton Korobeynikove7772382009-05-03 13:42:53 +00001267
1268
Eli Friedman872996c2008-08-20 02:34:37 +00001269bool
Anders Carlsson36834a72009-02-28 17:11:49 +00001270X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001271 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +00001272 switch (*Name) {
Eli Friedman872996c2008-08-20 02:34:37 +00001273 default: return false;
Dale Johanneseneba819a2010-08-24 22:33:12 +00001274 case 'Y': // first letter of a pair:
1275 switch (*(Name+1)) {
1276 default: return false;
1277 case '0': // First SSE register.
1278 case 't': // Any SSE register, when SSE2 is enabled.
1279 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
1280 case 'm': // any MMX register, when inter-unit moves enabled.
1281 break; // falls through to setAllowsRegister.
1282 }
Eli Friedman872996c2008-08-20 02:34:37 +00001283 case 'a': // eax.
1284 case 'b': // ebx.
1285 case 'c': // ecx.
1286 case 'd': // edx.
1287 case 'S': // esi.
1288 case 'D': // edi.
1289 case 'A': // edx:eax.
Dale Johanneseneba819a2010-08-24 22:33:12 +00001290 case 'f': // any x87 floating point stack register.
Eli Friedman872996c2008-08-20 02:34:37 +00001291 case 't': // top of floating point stack.
1292 case 'u': // second from top of floating point stack.
1293 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson2285e622008-10-06 00:41:45 +00001294 case 'y': // Any MMX register.
Anders Carlssond2459f92008-10-06 19:17:39 +00001295 case 'x': // Any SSE register.
Eli Friedman872996c2008-08-20 02:34:37 +00001296 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johanneseneba819a2010-08-24 22:33:12 +00001297 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
1298 case 'l': // "Index" registers: any general register that can be used as an
1299 // index in a base+index memory access.
1300 Info.setAllowsRegister();
1301 return true;
1302 case 'C': // SSE floating point constant.
1303 case 'G': // x87 floating point constant.
Anton Korobeynikove7772382009-05-03 13:42:53 +00001304 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +00001305 // x86_64 instructions.
Anton Korobeynikove7772382009-05-03 13:42:53 +00001306 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +00001307 // x86_64 instructions.
Eli Friedman872996c2008-08-20 02:34:37 +00001308 return true;
1309 }
Dale Johanneseneba819a2010-08-24 22:33:12 +00001310 return false;
Eli Friedman872996c2008-08-20 02:34:37 +00001311}
1312
Dale Johannesen3a161e52010-10-29 23:12:32 +00001313const llvm::Type*
1314X86TargetInfo::adjustInlineAsmType(std::string& Constraint,
1315 const llvm::Type* Ty,
1316 llvm::LLVMContext &Context) const {
1317 if (Constraint=="y" && Ty->isVectorTy())
1318 return llvm::Type::getX86_MMXTy(Context);
1319 return Ty;
1320}
1321
1322
Eli Friedman872996c2008-08-20 02:34:37 +00001323std::string
1324X86TargetInfo::convertConstraint(const char Constraint) const {
1325 switch (Constraint) {
1326 case 'a': return std::string("{ax}");
1327 case 'b': return std::string("{bx}");
1328 case 'c': return std::string("{cx}");
1329 case 'd': return std::string("{dx}");
1330 case 'S': return std::string("{si}");
1331 case 'D': return std::string("{di}");
Dale Johannesena49254e2010-10-22 21:07:10 +00001332 case 'p': // address
1333 return std::string("im");
Eli Friedman872996c2008-08-20 02:34:37 +00001334 case 't': // top of floating point stack.
1335 return std::string("{st}");
1336 case 'u': // second from top of floating point stack.
1337 return std::string("{st(1)}"); // second from top of floating point stack.
1338 default:
1339 return std::string(1, Constraint);
1340 }
1341}
Eli Friedman872996c2008-08-20 02:34:37 +00001342} // end anonymous namespace
Chris Lattner4b009652007-07-25 00:24:17 +00001343
1344namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001345// X86-32 generic target
1346class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +00001347public:
Eli Friedman872996c2008-08-20 02:34:37 +00001348 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1349 DoubleAlign = LongLongAlign = 32;
1350 LongDoubleWidth = 96;
1351 LongDoubleAlign = 32;
Eli Friedman2b161652008-08-21 00:13:15 +00001352 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1353 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001354 "a0:0:64-f80:32:32-n8:16:32";
Eli Friedman04ede302009-03-29 20:31:09 +00001355 SizeType = UnsignedInt;
1356 PtrDiffType = SignedInt;
1357 IntPtrType = SignedInt;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +00001358 RegParmMax = 3;
Daniel Dunbar6f94dbb2010-07-14 23:39:36 +00001359
1360 // Use fpret for all types.
1361 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
1362 (1 << TargetInfo::Double) |
1363 (1 << TargetInfo::LongDouble));
Eli Friedman872996c2008-08-20 02:34:37 +00001364 }
1365 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001366 return "typedef char* __builtin_va_list;";
Eli Friedman872996c2008-08-20 02:34:37 +00001367 }
Michael J. Spencerd5513a32010-10-21 03:16:25 +00001368
Chris Lattneraa339182009-09-23 06:06:36 +00001369 int getEHDataRegisterNumber(unsigned RegNo) const {
1370 if (RegNo == 0) return 0;
1371 if (RegNo == 1) return 2;
1372 return -1;
1373 }
Eli Friedman872996c2008-08-20 02:34:37 +00001374};
1375} // end anonymous namespace
1376
1377namespace {
Eli Friedman1c79f4b2009-07-05 18:47:56 +00001378class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
1379public:
1380 OpenBSDI386TargetInfo(const std::string& triple) :
1381 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
1382 SizeType = UnsignedLong;
1383 IntPtrType = SignedLong;
Eli Friedman96ada022009-07-05 22:31:18 +00001384 PtrDiffType = SignedLong;
Eli Friedman1c79f4b2009-07-05 18:47:56 +00001385 }
1386};
1387} // end anonymous namespace
1388
1389namespace {
Edwin Török36565e52009-06-30 17:10:35 +00001390class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman872996c2008-08-20 02:34:37 +00001391public:
Edwin Török36565e52009-06-30 17:10:35 +00001392 DarwinI386TargetInfo(const std::string& triple) :
1393 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman872996c2008-08-20 02:34:37 +00001394 LongDoubleWidth = 128;
1395 LongDoubleAlign = 128;
Eli Friedman04ede302009-03-29 20:31:09 +00001396 SizeType = UnsignedLong;
1397 IntPtrType = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +00001398 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1399 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001400 "a0:0:64-f80:128:128-n8:16:32";
Daniel Dunbar9451c542010-05-27 00:35:16 +00001401 HasAlignMac68kSupport = true;
Edwin Török2d98f9f2009-06-30 17:00:25 +00001402 }
1403
Eli Friedman872996c2008-08-20 02:34:37 +00001404};
Daniel Dunbar64c77a12009-06-29 20:52:51 +00001405} // end anonymous namespace
1406
1407namespace {
Eli Friedman23cb7912008-08-21 01:40:19 +00001408// x86-32 Windows target
Michael J. Spencer01e70082010-10-21 05:21:48 +00001409class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman23cb7912008-08-21 01:40:19 +00001410public:
1411 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencer01e70082010-10-21 05:21:48 +00001412 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +00001413 TLSSupported = false;
Chris Lattnera8a69e12009-06-24 17:12:15 +00001414 WCharType = UnsignedShort;
Eli Friedmanb28055e2009-06-08 21:16:17 +00001415 DoubleAlign = LongLongAlign = 64;
1416 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 +00001417 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
1418 "v128:128:128-a0:0:64-f80:32:32-n8:16:32";
Eli Friedman23cb7912008-08-21 01:40:19 +00001419 }
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00001420 virtual void getTargetDefines(const LangOptions &Opts,
1421 MacroBuilder &Builder) const {
1422 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
1423 }
1424};
1425} // end anonymous namespace
1426
1427namespace {
1428
1429// x86-32 Windows Visual Studio target
1430class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
1431public:
1432 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
1433 : WindowsX86_32TargetInfo(triple) {
1434 LongDoubleWidth = 64;
1435 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
1436 }
1437 virtual void getTargetDefines(const LangOptions &Opts,
1438 MacroBuilder &Builder) const {
1439 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
1440 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
1441 // The value of the following reflects processor type.
1442 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
1443 // We lost the original triple, so we use the default.
1444 Builder.defineMacro("_M_IX86", "600");
1445 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001446};
1447} // end anonymous namespace
1448
1449namespace {
1450// x86-32 MinGW target
1451class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
1452public:
1453 MinGWX86_32TargetInfo(const std::string& triple)
1454 : WindowsX86_32TargetInfo(triple) {
1455 }
1456 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001457 MacroBuilder &Builder) const {
1458 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00001459 DefineStd(Builder, "WIN32", Opts);
1460 DefineStd(Builder, "WINNT", Opts);
1461 Builder.defineMacro("_X86_");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001462 Builder.defineMacro("__MSVCRT__");
1463 Builder.defineMacro("__MINGW32__");
1464 Builder.defineMacro("__declspec", "__declspec");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001465 }
1466};
1467} // end anonymous namespace
1468
1469namespace {
1470// x86-32 Cygwin target
1471class CygwinX86_32TargetInfo : public X86_32TargetInfo {
1472public:
1473 CygwinX86_32TargetInfo(const std::string& triple)
1474 : X86_32TargetInfo(triple) {
1475 TLSSupported = false;
1476 WCharType = UnsignedShort;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001477 DoubleAlign = LongLongAlign = 64;
1478 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1479 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001480 "a0:0:64-f80:32:32-n8:16:32";
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001481 }
1482 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001483 MacroBuilder &Builder) const {
1484 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1485 Builder.defineMacro("__CYGWIN__");
1486 Builder.defineMacro("__CYGWIN32__");
1487 DefineStd(Builder, "unix", Opts);
Douglas Gregor9b22a172010-04-21 05:52:38 +00001488 if (Opts.CPlusPlus)
1489 Builder.defineMacro("_GNU_SOURCE");
Eli Friedman6b6ca942009-06-08 06:11:14 +00001490 }
Eli Friedman23cb7912008-08-21 01:40:19 +00001491};
1492} // end anonymous namespace
1493
1494namespace {
Chris Lattnerf853e732010-04-11 19:29:39 +00001495// x86-32 Haiku target
1496class HaikuX86_32TargetInfo : public X86_32TargetInfo {
1497public:
1498 HaikuX86_32TargetInfo(const std::string& triple)
1499 : X86_32TargetInfo(triple) {
1500 SizeType = UnsignedLong;
Chris Lattner5b8b18a2010-04-22 17:48:00 +00001501 IntPtrType = SignedLong;
1502 PtrDiffType = SignedLong;
Eli Friedman08f845b2010-08-22 01:00:03 +00001503 }
Chris Lattnerf853e732010-04-11 19:29:39 +00001504 virtual void getTargetDefines(const LangOptions &Opts,
1505 MacroBuilder &Builder) const {
1506 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1507 Builder.defineMacro("__INTEL__");
1508 Builder.defineMacro("__HAIKU__");
1509 }
1510};
1511} // end anonymous namespace
1512
1513namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001514// x86-64 generic target
1515class X86_64TargetInfo : public X86TargetInfo {
1516public:
Chris Lattner79682402009-03-20 15:52:06 +00001517 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +00001518 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001519 LongDoubleWidth = 128;
1520 LongDoubleAlign = 128;
Rafael Espindolabfa7c002010-06-04 23:15:27 +00001521 LargeArrayMinWidth = 128;
1522 LargeArrayAlign = 128;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00001523 IntMaxType = SignedLong;
1524 UIntMaxType = UnsignedLong;
Eli Friedman38e31802009-07-01 03:36:11 +00001525 Int64Type = SignedLong;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +00001526 RegParmMax = 6;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00001527
Eli Friedman2b161652008-08-21 00:13:15 +00001528 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1529 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001530 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64";
Daniel Dunbar6f94dbb2010-07-14 23:39:36 +00001531
1532 // Use fpret only for long double.
1533 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Chris Lattner4b009652007-07-25 00:24:17 +00001534 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +00001535 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001536 return "typedef struct __va_list_tag {"
1537 " unsigned gp_offset;"
1538 " unsigned fp_offset;"
1539 " void* overflow_arg_area;"
1540 " void* reg_save_area;"
John McCall33bf24b2010-05-28 18:25:28 +00001541 "} __va_list_tag;"
Eli Friedman3c79eee2009-07-03 00:45:06 +00001542 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson7dd1c952007-11-24 23:38:12 +00001543 }
Michael J. Spencer3d796932010-10-18 07:10:59 +00001544
Chris Lattneraa339182009-09-23 06:06:36 +00001545 int getEHDataRegisterNumber(unsigned RegNo) const {
1546 if (RegNo == 0) return 0;
1547 if (RegNo == 1) return 1;
1548 return -1;
1549 }
Eli Friedman872996c2008-08-20 02:34:37 +00001550};
1551} // end anonymous namespace
1552
1553namespace {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001554// x86-64 Windows target
Michael J. Spencer01e70082010-10-21 05:21:48 +00001555class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001556public:
1557 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencer01e70082010-10-21 05:21:48 +00001558 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001559 TLSSupported = false;
1560 WCharType = UnsignedShort;
Mike Stump4da7a162009-10-08 23:00:00 +00001561 LongWidth = LongAlign = 32;
Michael J. Spencer3d796932010-10-18 07:10:59 +00001562 DoubleAlign = LongLongAlign = 64;
Nate Begeman472bd992010-07-21 02:02:56 +00001563 IntMaxType = SignedLongLong;
1564 UIntMaxType = UnsignedLongLong;
1565 Int64Type = SignedLongLong;
Cameron Esfahani32083822010-09-15 00:28:12 +00001566 SizeType = UnsignedLongLong;
1567 PtrDiffType = SignedLongLong;
1568 IntPtrType = SignedLongLong;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001569 }
1570 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001571 MacroBuilder &Builder) const {
Michael J. Spencer01e70082010-10-21 05:21:48 +00001572 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencer01e70082010-10-21 05:21:48 +00001573 Builder.defineMacro("_WIN64");
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00001574 }
1575};
1576} // end anonymous namespace
1577
1578namespace {
1579// x86-64 Windows Visual Studio target
1580class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
1581public:
1582 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
1583 : WindowsX86_64TargetInfo(triple) {
1584 }
1585 virtual void getTargetDefines(const LangOptions &Opts,
1586 MacroBuilder &Builder) const {
1587 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1588 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001589 Builder.defineMacro("_M_X64");
Michael J. Spencer01e70082010-10-21 05:21:48 +00001590 Builder.defineMacro("_M_AMD64");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001591 }
Chris Lattnerb979e7a2010-08-31 16:44:54 +00001592 virtual const char *getVAListDeclaration() const {
1593 return "typedef char* __builtin_va_list;";
1594 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001595};
1596} // end anonymous namespace
1597
1598namespace {
1599// x86-64 MinGW target
1600class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
1601public:
1602 MinGWX86_64TargetInfo(const std::string& triple)
1603 : WindowsX86_64TargetInfo(triple) {
1604 }
1605 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001606 MacroBuilder &Builder) const {
1607 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00001608 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001609 Builder.defineMacro("__MSVCRT__");
1610 Builder.defineMacro("__MINGW64__");
1611 Builder.defineMacro("__declspec");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001612 }
1613};
1614} // end anonymous namespace
1615
1616namespace {
Eli Friedman38e31802009-07-01 03:36:11 +00001617class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
1618public:
Mike Stump25cf7602009-09-09 15:08:12 +00001619 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman38e31802009-07-01 03:36:11 +00001620 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
1621 Int64Type = SignedLongLong;
1622 }
1623};
1624} // end anonymous namespace
1625
1626namespace {
Eli Friedman96ada022009-07-05 22:31:18 +00001627class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
1628public:
Mike Stump25cf7602009-09-09 15:08:12 +00001629 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman96ada022009-07-05 22:31:18 +00001630 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
1631 IntMaxType = SignedLongLong;
1632 UIntMaxType = UnsignedLongLong;
1633 Int64Type = SignedLongLong;
1634 }
1635};
1636} // end anonymous namespace
1637
1638namespace {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001639class ARMTargetInfo : public TargetInfo {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001640 // Possible FPU choices.
1641 enum FPUMode {
1642 NoFPU,
1643 VFP2FPU,
1644 VFP3FPU,
1645 NeonFPU
1646 };
1647
1648 static bool FPUModeIsVFP(FPUMode Mode) {
1649 return Mode >= VFP2FPU && Mode <= NeonFPU;
1650 }
1651
1652 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1653 static const char * const GCCRegNames[];
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001654
Daniel Dunbar33b40752009-12-18 18:42:37 +00001655 std::string ABI, CPU;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001656
1657 unsigned FPU : 3;
1658
Daniel Dunbar48075d82009-12-19 04:15:38 +00001659 unsigned IsThumb : 1;
1660
1661 // Initialized via features.
1662 unsigned SoftFloat : 1;
1663 unsigned SoftFloatABI : 1;
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001664
Chris Lattnerb4527522010-03-03 19:03:45 +00001665 static const Builtin::Info BuiltinInfo[];
1666
Chris Lattner9fd73612008-04-21 18:56:49 +00001667public:
Daniel Dunbarf0156562009-09-17 16:21:10 +00001668 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbar33b40752009-12-18 18:42:37 +00001669 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001670 {
Daniel Dunbarb9531632009-09-14 00:02:24 +00001671 SizeType = UnsignedInt;
1672 PtrDiffType = SignedInt;
Daniel Dunbarf0156562009-09-17 16:21:10 +00001673
Chris Lattnere20b8122010-04-23 16:29:58 +00001674 // {} in inline assembly are neon specifiers, not assembly variant
1675 // specifiers.
1676 NoAsmVariants = true;
Michael J. Spencerd5513a32010-10-21 03:16:25 +00001677
Daniel Dunbar33b40752009-12-18 18:42:37 +00001678 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0a542ca2009-12-18 19:57:13 +00001679 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001680 if (IsThumb) {
1681 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1682 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001683 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001684 } else {
1685 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1686 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001687 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001688 }
John McCall68086b92010-08-21 22:46:04 +00001689
1690 // ARM targets default to using the ARM C++ ABI.
1691 CXXABI = CXXABI_ARM;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001692 }
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001693 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbarb9531632009-09-14 00:02:24 +00001694 virtual bool setABI(const std::string &Name) {
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001695 ABI = Name;
1696
Daniel Dunbarb9531632009-09-14 00:02:24 +00001697 // The defaults (above) are for AAPCS, check if we need to change them.
1698 //
1699 // FIXME: We need support for -meabi... we could just mangle it into the
1700 // name.
1701 if (Name == "apcs-gnu") {
Daniel Dunbarda94a772010-01-27 20:23:08 +00001702 DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
Daniel Dunbarb9531632009-09-14 00:02:24 +00001703 SizeType = UnsignedLong;
1704
Daniel Dunbar9eb811b2010-04-22 16:14:54 +00001705 // Do not respect the alignment of bit-field types when laying out
1706 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
1707 UseBitFieldTypeAlignment = false;
1708
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001709 if (IsThumb) {
1710 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1711 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001712 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001713 } else {
1714 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1715 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001716 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001717 }
1718
Daniel Dunbarb9531632009-09-14 00:02:24 +00001719 // FIXME: Override "preferred align" for double and long long.
1720 } else if (Name == "aapcs") {
1721 // FIXME: Enumerated types are variable width in straight AAPCS.
1722 } else if (Name == "aapcs-linux") {
1723 ;
1724 } else
1725 return false;
1726
1727 return true;
1728 }
Daniel Dunbar48075d82009-12-19 04:15:38 +00001729
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001730 void getDefaultFeatures(const std::string &CPU,
1731 llvm::StringMap<bool> &Features) const {
1732 // FIXME: This should not be here.
1733 Features["vfp2"] = false;
1734 Features["vfp3"] = false;
1735 Features["neon"] = false;
1736
1737 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
1738 Features["vfp2"] = true;
1739 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
1740 Features["neon"] = true;
1741 }
Michael J. Spencerd5513a32010-10-21 03:16:25 +00001742
Daniel Dunbar48075d82009-12-19 04:15:38 +00001743 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1744 const std::string &Name,
1745 bool Enabled) const {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001746 if (Name == "soft-float" || Name == "soft-float-abi") {
1747 Features[Name] = Enabled;
1748 } else if (Name == "vfp2" || Name == "vfp3" || Name == "neon") {
1749 // These effectively are a single option, reset them when any is enabled.
1750 if (Enabled)
1751 Features["vfp2"] = Features["vfp3"] = Features["neon"] = false;
1752 Features[Name] = Enabled;
1753 } else
Daniel Dunbar48075d82009-12-19 04:15:38 +00001754 return false;
1755
Daniel Dunbar48075d82009-12-19 04:15:38 +00001756 return true;
1757 }
1758
1759 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001760 FPU = NoFPU;
Daniel Dunbar48075d82009-12-19 04:15:38 +00001761 SoftFloat = SoftFloatABI = false;
1762 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
1763 if (Features[i] == "+soft-float")
1764 SoftFloat = true;
1765 else if (Features[i] == "+soft-float-abi")
1766 SoftFloatABI = true;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001767 else if (Features[i] == "+vfp2")
1768 FPU = VFP2FPU;
1769 else if (Features[i] == "+vfp3")
1770 FPU = VFP3FPU;
1771 else if (Features[i] == "+neon")
1772 FPU = NeonFPU;
Daniel Dunbar48075d82009-12-19 04:15:38 +00001773 }
1774
1775 // Remove front-end specific options which the backend handles differently.
1776 std::vector<std::string>::iterator it;
1777 it = std::find(Features.begin(), Features.end(), "+soft-float");
1778 if (it != Features.end())
1779 Features.erase(it);
1780 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
1781 if (it != Features.end())
1782 Features.erase(it);
1783 }
1784
Daniel Dunbar33b40752009-12-18 18:42:37 +00001785 static const char *getCPUDefineSuffix(llvm::StringRef Name) {
1786 return llvm::StringSwitch<const char*>(Name)
1787 .Cases("arm8", "arm810", "4")
1788 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
1789 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
1790 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
1791 .Case("ep9312", "4T")
1792 .Cases("arm10tdmi", "arm1020t", "5T")
1793 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
1794 .Case("arm926ej-s", "5TEJ")
1795 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
1796 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001797 .Case("arm1136j-s", "6J")
Daniel Dunbar33b40752009-12-18 18:42:37 +00001798 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001799 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbar33b40752009-12-18 18:42:37 +00001800 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
1801 .Cases("cortex-a8", "cortex-a9", "7A")
1802 .Default(0);
1803 }
1804 virtual bool setCPU(const std::string &Name) {
1805 if (!getCPUDefineSuffix(Name))
1806 return false;
1807
1808 CPU = Name;
1809 return true;
1810 }
Chris Lattner79682402009-03-20 15:52:06 +00001811 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001812 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00001813 // Target identification.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001814 Builder.defineMacro("__arm");
1815 Builder.defineMacro("__arm__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001816
Chris Lattnerbef1d722009-03-02 22:27:17 +00001817 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001818 Builder.defineMacro("__ARMEL__");
1819 Builder.defineMacro("__LITTLE_ENDIAN__");
1820 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001821
1822 llvm::StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001823 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001824
Mike Stumpf90a29f2009-04-08 02:07:04 +00001825 // Subtarget options.
Daniel Dunbarf0156562009-09-17 16:21:10 +00001826
Daniel Dunbar33b40752009-12-18 18:42:37 +00001827 // FIXME: It's more complicated than this and we don't really support
1828 // interworking.
1829 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001830 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001831
Daniel Dunbar33b40752009-12-18 18:42:37 +00001832 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001833 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001834
Daniel Dunbar48075d82009-12-19 04:15:38 +00001835 if (SoftFloat)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001836 Builder.defineMacro("__SOFTFP__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001837
1838 if (CPU == "xscale")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001839 Builder.defineMacro("__XSCALE__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001840
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001841 bool IsThumb2 = IsThumb && (CPUArch == "6T2" || CPUArch.startswith("7"));
Daniel Dunbarf0156562009-09-17 16:21:10 +00001842 if (IsThumb) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001843 Builder.defineMacro("__THUMBEL__");
1844 Builder.defineMacro("__thumb__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001845 if (IsThumb2)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001846 Builder.defineMacro("__thumb2__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001847 }
1848
1849 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001850 Builder.defineMacro("__APCS_32__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001851
1852 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001853 Builder.defineMacro("__VFP_FP__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001854
1855 // This only gets set when Neon instructions are actually available, unlike
1856 // the VFP define, hence the soft float and arch check. This is subtly
1857 // different from gcc, we follow the intent which was that it should be set
1858 // when Neon instructions are actually available.
1859 if (FPU == NeonFPU && !SoftFloat && IsThumb2)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001860 Builder.defineMacro("__ARM_NEON__");
Chris Lattner9fd73612008-04-21 18:56:49 +00001861 }
1862 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1863 unsigned &NumRecords) const {
Chris Lattnerb4527522010-03-03 19:03:45 +00001864 Records = BuiltinInfo;
1865 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner9fd73612008-04-21 18:56:49 +00001866 }
1867 virtual const char *getVAListDeclaration() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001868 return "typedef char* __builtin_va_list;";
Chris Lattner9fd73612008-04-21 18:56:49 +00001869 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001870 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001871 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001872 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001873 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001874 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001875 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001876 // FIXME: Check if this is complete
Anders Carlsson36834a72009-02-28 17:11:49 +00001877 switch (*Name) {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001878 default:
Nate Begeman222823a2008-04-22 05:03:19 +00001879 case 'l': // r0-r7
1880 case 'h': // r8-r15
1881 case 'w': // VFP Floating point register single precision
1882 case 'P': // VFP Floating point register double precision
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001883 Info.setAllowsRegister();
Nate Begeman222823a2008-04-22 05:03:19 +00001884 return true;
1885 }
Chris Lattner9fd73612008-04-21 18:56:49 +00001886 return false;
1887 }
1888 virtual const char *getClobbers() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001889 // FIXME: Is this really right?
Chris Lattner9fd73612008-04-21 18:56:49 +00001890 return "";
1891 }
1892};
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001893
1894const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbar663e9f82010-08-11 02:17:20 +00001895 // Integer registers
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001896 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbar663e9f82010-08-11 02:17:20 +00001897 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
1898
1899 // Float registers
1900 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
1901 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
1902 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen0bbb50d2010-10-27 23:34:42 +00001903 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbar663e9f82010-08-11 02:17:20 +00001904
Dale Johannesen0bbb50d2010-10-27 23:34:42 +00001905 // Double registers
1906 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
1907 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesen0d79b042010-10-28 01:05:37 +00001908 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
1909 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen0bbb50d2010-10-27 23:34:42 +00001910
1911 // Quad registers
Dale Johannesen0d79b042010-10-28 01:05:37 +00001912 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
1913 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001914};
1915
1916void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar00ea8f02010-08-11 02:17:11 +00001917 unsigned &NumNames) const {
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001918 Names = GCCRegNames;
1919 NumNames = llvm::array_lengthof(GCCRegNames);
1920}
1921
1922const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001923 { { "a1" }, "r0" },
1924 { { "a2" }, "r1" },
1925 { { "a3" }, "r2" },
1926 { { "a4" }, "r3" },
1927 { { "v1" }, "r4" },
1928 { { "v2" }, "r5" },
1929 { { "v3" }, "r6" },
1930 { { "v4" }, "r7" },
1931 { { "v5" }, "r8" },
1932 { { "v6", "rfp" }, "r9" },
1933 { { "sl" }, "r10" },
1934 { { "fp" }, "r11" },
1935 { { "ip" }, "r12" },
Daniel Dunbar00ea8f02010-08-11 02:17:11 +00001936 { { "r13" }, "sp" },
1937 { { "r14" }, "lr" },
1938 { { "r15" }, "pc" },
Dale Johannesen0bbb50d2010-10-27 23:34:42 +00001939 // The S, D and Q registers overlap, but aren't really aliases; we
1940 // don't want to substitute one of these for a different-sized one.
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001941};
1942
1943void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1944 unsigned &NumAliases) const {
1945 Aliases = GCCRegAliases;
1946 NumAliases = llvm::array_lengthof(GCCRegAliases);
1947}
Chris Lattnerb4527522010-03-03 19:03:45 +00001948
1949const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
1950#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
1951#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
1952#include "clang/Basic/BuiltinsARM.def"
1953};
Chris Lattner9fd73612008-04-21 18:56:49 +00001954} // end anonymous namespace.
1955
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001956
1957namespace {
Mike Stump25cf7602009-09-09 15:08:12 +00001958class DarwinARMTargetInfo :
Edwin Török36565e52009-06-30 17:10:35 +00001959 public DarwinTargetInfo<ARMTargetInfo> {
1960protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +00001961 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001962 MacroBuilder &Builder) const {
Daniel Dunbareab96a22010-01-26 01:44:04 +00001963 getDarwinDefines(Builder, Opts, Triple);
Eli Friedman8f575172009-04-19 21:38:35 +00001964 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001965
Edwin Török36565e52009-06-30 17:10:35 +00001966public:
Mike Stump25cf7602009-09-09 15:08:12 +00001967 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar01045582010-05-27 07:00:26 +00001968 : DarwinTargetInfo<ARMTargetInfo>(triple) {
1969 HasAlignMac68kSupport = true;
1970 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001971};
1972} // end anonymous namespace.
1973
Chris Lattner4b009652007-07-25 00:24:17 +00001974namespace {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001975class SparcV8TargetInfo : public TargetInfo {
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001976 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1977 static const char * const GCCRegNames[];
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001978public:
Eli Friedmanff158dd2008-08-20 07:28:14 +00001979 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
1980 // FIXME: Support Sparc quad-precision long double?
Eli Friedman2b161652008-08-21 00:13:15 +00001981 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 +00001982 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedmanff158dd2008-08-20 07:28:14 +00001983 }
Chris Lattner79682402009-03-20 15:52:06 +00001984 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001985 MacroBuilder &Builder) const {
1986 DefineStd(Builder, "sparc", Opts);
1987 Builder.defineMacro("__sparcv8");
1988 Builder.defineMacro("__REGISTER_PREFIX__", "");
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001989 }
1990 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1991 unsigned &NumRecords) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001992 // FIXME: Implement!
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001993 }
1994 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001995 return "typedef void* __builtin_va_list;";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001996 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001997 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001998 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001999 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002000 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00002001 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002002 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002003 // FIXME: Implement!
2004 return false;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002005 }
2006 virtual const char *getClobbers() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002007 // FIXME: Implement!
2008 return "";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002009 }
2010};
2011
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002012const char * const SparcV8TargetInfo::GCCRegNames[] = {
2013 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2014 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2015 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2016 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
2017};
2018
Anton Korobeynikove7772382009-05-03 13:42:53 +00002019void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002020 unsigned &NumNames) const {
2021 Names = GCCRegNames;
2022 NumNames = llvm::array_lengthof(GCCRegNames);
2023}
2024
2025const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikove7772382009-05-03 13:42:53 +00002026 { { "g0" }, "r0" },
2027 { { "g1" }, "r1" },
2028 { { "g2" }, "r2" },
2029 { { "g3" }, "r3" },
2030 { { "g4" }, "r4" },
2031 { { "g5" }, "r5" },
2032 { { "g6" }, "r6" },
2033 { { "g7" }, "r7" },
2034 { { "o0" }, "r8" },
2035 { { "o1" }, "r9" },
2036 { { "o2" }, "r10" },
2037 { { "o3" }, "r11" },
2038 { { "o4" }, "r12" },
2039 { { "o5" }, "r13" },
2040 { { "o6", "sp" }, "r14" },
2041 { { "o7" }, "r15" },
2042 { { "l0" }, "r16" },
2043 { { "l1" }, "r17" },
2044 { { "l2" }, "r18" },
2045 { { "l3" }, "r19" },
2046 { { "l4" }, "r20" },
2047 { { "l5" }, "r21" },
2048 { { "l6" }, "r22" },
2049 { { "l7" }, "r23" },
2050 { { "i0" }, "r24" },
2051 { { "i1" }, "r25" },
2052 { { "i2" }, "r26" },
2053 { { "i3" }, "r27" },
2054 { { "i4" }, "r28" },
2055 { { "i5" }, "r29" },
2056 { { "i6", "fp" }, "r30" },
2057 { { "i7" }, "r31" },
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002058};
2059
Anton Korobeynikove7772382009-05-03 13:42:53 +00002060void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002061 unsigned &NumAliases) const {
2062 Aliases = GCCRegAliases;
2063 NumAliases = llvm::array_lengthof(GCCRegAliases);
2064}
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002065} // end anonymous namespace.
2066
Eli Friedmanff158dd2008-08-20 07:28:14 +00002067namespace {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002068class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
2069public:
2070 AuroraUXSparcV8TargetInfo(const std::string& triple) :
2071 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
2072 SizeType = UnsignedInt;
2073 PtrDiffType = SignedInt;
2074 }
2075};
Edwin Török36565e52009-06-30 17:10:35 +00002076class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002077public:
2078 SolarisSparcV8TargetInfo(const std::string& triple) :
Edwin Török36565e52009-06-30 17:10:35 +00002079 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedman7cca0982008-11-02 02:43:55 +00002080 SizeType = UnsignedInt;
2081 PtrDiffType = SignedInt;
Eli Friedmanff158dd2008-08-20 07:28:14 +00002082 }
2083};
2084} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +00002085
Chris Lattner85970f32008-05-08 05:58:21 +00002086namespace {
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002087 class MSP430TargetInfo : public TargetInfo {
2088 static const char * const GCCRegNames[];
2089 public:
2090 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
2091 TLSSupported = false;
Anton Korobeynikov2a6630a2010-01-30 12:55:11 +00002092 IntWidth = 16; IntAlign = 16;
2093 LongWidth = 32; LongLongWidth = 64;
2094 LongAlign = LongLongAlign = 16;
2095 PointerWidth = 16; PointerAlign = 16;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002096 SizeType = UnsignedInt;
2097 IntMaxType = SignedLong;
2098 UIntMaxType = UnsignedLong;
2099 IntPtrType = SignedShort;
2100 PtrDiffType = SignedInt;
Edward O'Callaghan14a70a32009-11-21 00:49:54 +00002101 SigAtomicType = SignedLong;
Anton Korobeynikov314713f2009-12-19 01:32:37 +00002102 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002103 }
2104 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002105 MacroBuilder &Builder) const {
2106 Builder.defineMacro("MSP430");
2107 Builder.defineMacro("__MSP430__");
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002108 // FIXME: defines for different 'flavours' of MCU
2109 }
2110 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2111 unsigned &NumRecords) const {
2112 // FIXME: Implement.
2113 Records = 0;
2114 NumRecords = 0;
2115 }
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002116 virtual void getGCCRegNames(const char * const *&Names,
2117 unsigned &NumNames) const;
2118 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2119 unsigned &NumAliases) const {
2120 // No aliases.
2121 Aliases = 0;
2122 NumAliases = 0;
2123 }
2124 virtual bool validateAsmConstraint(const char *&Name,
2125 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov174219b2009-10-15 23:17:13 +00002126 // No target constraints for now.
2127 return false;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002128 }
2129 virtual const char *getClobbers() const {
2130 // FIXME: Is this really right?
2131 return "";
2132 }
2133 virtual const char *getVAListDeclaration() const {
2134 // FIXME: implement
Anton Korobeynikovf5955592009-05-08 18:24:57 +00002135 return "typedef char* __builtin_va_list;";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002136 }
2137 };
2138
2139 const char * const MSP430TargetInfo::GCCRegNames[] = {
2140 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2141 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2142 };
2143
2144 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
2145 unsigned &NumNames) const {
2146 Names = GCCRegNames;
2147 NumNames = llvm::array_lengthof(GCCRegNames);
2148 }
2149}
2150
2151
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002152namespace {
2153 class SystemZTargetInfo : public TargetInfo {
2154 static const char * const GCCRegNames[];
2155 public:
2156 SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
2157 TLSSupported = false;
2158 IntWidth = IntAlign = 32;
2159 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
2160 PointerWidth = PointerAlign = 64;
Chris Lattner2e17d912009-11-07 18:59:41 +00002161 DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
2162 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002163 }
2164 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002165 MacroBuilder &Builder) const {
2166 Builder.defineMacro("__s390__");
2167 Builder.defineMacro("__s390x__");
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002168 }
2169 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2170 unsigned &NumRecords) const {
2171 // FIXME: Implement.
2172 Records = 0;
2173 NumRecords = 0;
2174 }
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002175
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002176 virtual void getGCCRegNames(const char * const *&Names,
2177 unsigned &NumNames) const;
2178 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2179 unsigned &NumAliases) const {
2180 // No aliases.
2181 Aliases = 0;
2182 NumAliases = 0;
2183 }
2184 virtual bool validateAsmConstraint(const char *&Name,
2185 TargetInfo::ConstraintInfo &info) const {
2186 // FIXME: implement
2187 return true;
2188 }
2189 virtual const char *getClobbers() const {
2190 // FIXME: Is this really right?
2191 return "";
2192 }
2193 virtual const char *getVAListDeclaration() const {
2194 // FIXME: implement
2195 return "typedef char* __builtin_va_list;";
2196 }
2197 };
2198
2199 const char * const SystemZTargetInfo::GCCRegNames[] = {
2200 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2201 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2202 };
2203
2204 void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
2205 unsigned &NumNames) const {
2206 Names = GCCRegNames;
2207 NumNames = llvm::array_lengthof(GCCRegNames);
2208 }
2209}
2210
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002211namespace {
2212 class BlackfinTargetInfo : public TargetInfo {
2213 static const char * const GCCRegNames[];
2214 public:
2215 BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
2216 TLSSupported = false;
2217 DoubleAlign = 32;
2218 LongLongAlign = 32;
2219 LongDoubleAlign = 32;
Chris Lattner2e17d912009-11-07 18:59:41 +00002220 DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002221 }
2222
2223 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002224 MacroBuilder &Builder) const {
2225 DefineStd(Builder, "bfin", Opts);
2226 DefineStd(Builder, "BFIN", Opts);
2227 Builder.defineMacro("__ADSPBLACKFIN__");
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002228 // FIXME: This one is really dependent on -mcpu
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002229 Builder.defineMacro("__ADSPLPBLACKFIN__");
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002230 // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
2231 }
2232
2233 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2234 unsigned &NumRecords) const {
2235 // FIXME: Implement.
2236 Records = 0;
2237 NumRecords = 0;
2238 }
2239
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002240 virtual void getGCCRegNames(const char * const *&Names,
2241 unsigned &NumNames) const;
2242
2243 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2244 unsigned &NumAliases) const {
2245 // No aliases.
2246 Aliases = 0;
2247 NumAliases = 0;
2248 }
2249
2250 virtual bool validateAsmConstraint(const char *&Name,
2251 TargetInfo::ConstraintInfo &Info) const {
2252 if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
2253 Info.setAllowsRegister();
2254 return true;
2255 }
2256 return false;
2257 }
2258
2259 virtual const char *getClobbers() const {
2260 return "";
2261 }
2262
2263 virtual const char *getVAListDeclaration() const {
2264 return "typedef char* __builtin_va_list;";
2265 }
2266 };
2267
2268 const char * const BlackfinTargetInfo::GCCRegNames[] = {
2269 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2270 "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
2271 "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
2272 "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
2273 "a0", "a1", "cc",
2274 "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
2275 "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
2276 };
2277
2278 void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
2279 unsigned &NumNames) const {
2280 Names = GCCRegNames;
2281 NumNames = llvm::array_lengthof(GCCRegNames);
2282 }
2283}
2284
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002285namespace {
2286
Mike Stump25cf7602009-09-09 15:08:12 +00002287 // LLVM and Clang cannot be used directly to output native binaries for
2288 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002289 // type and alignment information.
Mike Stump25cf7602009-09-09 15:08:12 +00002290 //
2291 // TCE uses the llvm bitcode as input and uses it for generating customized
2292 // target processor and program binary. TCE co-design environment is
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002293 // publicly available in http://tce.cs.tut.fi
2294
2295 class TCETargetInfo : public TargetInfo{
2296 public:
2297 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
2298 TLSSupported = false;
2299 IntWidth = 32;
2300 LongWidth = LongLongWidth = 32;
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002301 PointerWidth = 32;
2302 IntAlign = 32;
2303 LongAlign = LongLongAlign = 32;
2304 PointerAlign = 32;
2305 SizeType = UnsignedInt;
2306 IntMaxType = SignedLong;
2307 UIntMaxType = UnsignedLong;
2308 IntPtrType = SignedInt;
2309 PtrDiffType = SignedInt;
2310 FloatWidth = 32;
2311 FloatAlign = 32;
2312 DoubleWidth = 32;
2313 DoubleAlign = 32;
2314 LongDoubleWidth = 32;
2315 LongDoubleAlign = 32;
2316 FloatFormat = &llvm::APFloat::IEEEsingle;
2317 DoubleFormat = &llvm::APFloat::IEEEsingle;
2318 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner8a1db932010-03-04 21:07:38 +00002319 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
2320 "i16:16:32-i32:32:32-i64:32:32-"
2321 "f32:32:32-f64:64:64-v64:64:64-"
2322 "v128:128:128-a0:0:64-n32";
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002323 }
2324
2325 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002326 MacroBuilder &Builder) const {
2327 DefineStd(Builder, "tce", Opts);
2328 Builder.defineMacro("__TCE__");
2329 Builder.defineMacro("__TCE_V1__");
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002330 }
2331 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2332 unsigned &NumRecords) const {}
Daniel Dunbar2e967de2009-08-24 09:54:37 +00002333 virtual const char *getClobbers() const {
2334 return "";
2335 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002336 virtual const char *getVAListDeclaration() const {
2337 return "typedef void* __builtin_va_list;";
2338 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002339 virtual void getGCCRegNames(const char * const *&Names,
2340 unsigned &NumNames) const {}
2341 virtual bool validateAsmConstraint(const char *&Name,
2342 TargetInfo::ConstraintInfo &info) const {
2343 return true;
2344 }
2345 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2346 unsigned &NumAliases) const {}
2347 };
2348}
2349
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002350namespace {
2351class MipsTargetInfo : public TargetInfo {
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002352 std::string ABI, CPU;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002353 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2354 static const char * const GCCRegNames[];
2355public:
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002356 MipsTargetInfo(const std::string& triple) : TargetInfo(triple), ABI("o32") {
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002357 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2358 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2359 }
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002360 virtual const char *getABI() const { return ABI.c_str(); }
2361 virtual bool setABI(const std::string &Name) {
2362
2363 if ((Name == "o32") || (Name == "eabi")) {
2364 ABI = Name;
2365 return true;
2366 } else
2367 return false;
2368 }
2369 virtual bool setCPU(const std::string &Name) {
2370 CPU = Name;
2371 return true;
2372 }
2373 void getDefaultFeatures(const std::string &CPU,
2374 llvm::StringMap<bool> &Features) const {
2375 Features[ABI] = true;
2376 Features[CPU] = true;
2377 }
2378 virtual void getArchDefines(const LangOptions &Opts,
2379 MacroBuilder &Builder) const {
2380 if (ABI == "o32")
2381 Builder.defineMacro("__mips_o32");
2382 else if (ABI == "eabi")
2383 Builder.defineMacro("__mips_eabi");
2384 }
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002385 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002386 MacroBuilder &Builder) const {
2387 DefineStd(Builder, "mips", Opts);
2388 Builder.defineMacro("_mips");
2389 DefineStd(Builder, "MIPSEB", Opts);
2390 Builder.defineMacro("_MIPSEB");
2391 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002392 getArchDefines(Opts, Builder);
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002393 }
2394 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2395 unsigned &NumRecords) const {
2396 // FIXME: Implement!
2397 }
2398 virtual const char *getVAListDeclaration() const {
2399 return "typedef void* __builtin_va_list;";
2400 }
2401 virtual void getGCCRegNames(const char * const *&Names,
2402 unsigned &NumNames) const;
2403 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2404 unsigned &NumAliases) const;
2405 virtual bool validateAsmConstraint(const char *&Name,
2406 TargetInfo::ConstraintInfo &Info) const {
2407 switch (*Name) {
2408 default:
2409 case 'r': // CPU registers.
2410 case 'd': // Equivalent to "r" unless generating MIPS16 code.
2411 case 'y': // Equivalent to "r", backwards compatibility only.
2412 case 'f': // floating-point registers.
2413 Info.setAllowsRegister();
2414 return true;
2415 }
2416 return false;
2417 }
2418
2419 virtual const char *getClobbers() const {
2420 // FIXME: Implement!
2421 return "";
2422 }
2423};
2424
2425const char * const MipsTargetInfo::GCCRegNames[] = {
Michael J. Spencerd5513a32010-10-21 03:16:25 +00002426 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002427 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
2428 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
2429 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
2430 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
2431 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
2432 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
2433 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
2434 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
2435 "$fcc5","$fcc6","$fcc7"
2436};
2437
2438void MipsTargetInfo::getGCCRegNames(const char * const *&Names,
2439 unsigned &NumNames) const {
2440 Names = GCCRegNames;
2441 NumNames = llvm::array_lengthof(GCCRegNames);
2442}
2443
2444const TargetInfo::GCCRegAlias MipsTargetInfo::GCCRegAliases[] = {
2445 { { "at" }, "$1" },
2446 { { "v0" }, "$2" },
2447 { { "v1" }, "$3" },
2448 { { "a0" }, "$4" },
2449 { { "a1" }, "$5" },
2450 { { "a2" }, "$6" },
2451 { { "a3" }, "$7" },
2452 { { "t0" }, "$8" },
2453 { { "t1" }, "$9" },
2454 { { "t2" }, "$10" },
2455 { { "t3" }, "$11" },
2456 { { "t4" }, "$12" },
2457 { { "t5" }, "$13" },
2458 { { "t6" }, "$14" },
2459 { { "t7" }, "$15" },
2460 { { "s0" }, "$16" },
2461 { { "s1" }, "$17" },
2462 { { "s2" }, "$18" },
2463 { { "s3" }, "$19" },
2464 { { "s4" }, "$20" },
2465 { { "s5" }, "$21" },
2466 { { "s6" }, "$22" },
2467 { { "s7" }, "$23" },
2468 { { "t8" }, "$24" },
2469 { { "t9" }, "$25" },
2470 { { "k0" }, "$26" },
2471 { { "k1" }, "$27" },
2472 { { "gp" }, "$28" },
2473 { { "sp" }, "$29" },
2474 { { "fp" }, "$30" },
2475 { { "ra" }, "$31" }
2476};
2477
2478void MipsTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2479 unsigned &NumAliases) const {
2480 Aliases = GCCRegAliases;
2481 NumAliases = llvm::array_lengthof(GCCRegAliases);
2482}
2483} // end anonymous namespace.
2484
2485namespace {
2486class MipselTargetInfo : public MipsTargetInfo {
2487public:
2488 MipselTargetInfo(const std::string& triple) : MipsTargetInfo(triple) {
2489 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2490 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2491 }
2492
2493 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002494 MacroBuilder &Builder) const;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002495};
2496
2497void MipselTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002498 MacroBuilder &Builder) const {
2499 DefineStd(Builder, "mips", Opts);
2500 Builder.defineMacro("_mips");
2501 DefineStd(Builder, "MIPSEL", Opts);
2502 Builder.defineMacro("_MIPSEL");
2503 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002504 getArchDefines(Opts, Builder);
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002505}
2506} // end anonymous namespace.
2507
Chris Lattner4b009652007-07-25 00:24:17 +00002508//===----------------------------------------------------------------------===//
2509// Driver code
2510//===----------------------------------------------------------------------===//
2511
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002512static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002513 llvm::Triple Triple(T);
2514 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002515
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002516 switch (Triple.getArch()) {
2517 default:
2518 return NULL;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002519
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002520 case llvm::Triple::arm:
Daniel Dunbar3f361b52009-09-11 01:14:50 +00002521 case llvm::Triple::thumb:
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002522 switch (os) {
Rafael Espindolad16a2202010-06-10 00:46:51 +00002523 case llvm::Triple::Linux:
2524 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002525 case llvm::Triple::Darwin:
Eli Friedman2b161652008-08-21 00:13:15 +00002526 return new DarwinARMTargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002527 case llvm::Triple::FreeBSD:
Edwin Török36565e52009-06-30 17:10:35 +00002528 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002529 default:
2530 return new ARMTargetInfo(T);
2531 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002532
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002533 case llvm::Triple::bfin:
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002534 return new BlackfinTargetInfo(T);
2535
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002536 case llvm::Triple::msp430:
2537 return new MSP430TargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002538
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002539 case llvm::Triple::mips:
2540 if (os == llvm::Triple::Psp)
2541 return new PSPTargetInfo<MipsTargetInfo>(T);
2542 if (os == llvm::Triple::Linux)
2543 return new LinuxTargetInfo<MipsTargetInfo>(T);
2544 return new MipsTargetInfo(T);
2545
2546 case llvm::Triple::mipsel:
2547 if (os == llvm::Triple::Psp)
2548 return new PSPTargetInfo<MipselTargetInfo>(T);
2549 if (os == llvm::Triple::Linux)
2550 return new LinuxTargetInfo<MipselTargetInfo>(T);
2551 return new MipselTargetInfo(T);
2552
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002553 case llvm::Triple::ppc:
2554 if (os == llvm::Triple::Darwin)
Daniel Dunbar6501cab2010-05-30 00:07:30 +00002555 return new DarwinPPCTargetInfo(T);
Chris Lattnerf8030412010-02-16 18:14:57 +00002556 else if (os == llvm::Triple::FreeBSD)
2557 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002558 return new PPC32TargetInfo(T);
2559
2560 case llvm::Triple::ppc64:
2561 if (os == llvm::Triple::Darwin)
Daniel Dunbar6501cab2010-05-30 00:07:30 +00002562 return new DarwinPPC64TargetInfo(T);
John Thompsoned7bdbc2009-11-19 17:18:50 +00002563 else if (os == llvm::Triple::Lv2)
2564 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Chris Lattnerf8030412010-02-16 18:14:57 +00002565 else if (os == llvm::Triple::FreeBSD)
2566 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002567 return new PPC64TargetInfo(T);
2568
Chris Lattner2c026472010-03-06 21:21:27 +00002569 case llvm::Triple::mblaze:
2570 return new MBlazeTargetInfo(T);
2571
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002572 case llvm::Triple::sparc:
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002573 if (os == llvm::Triple::AuroraUX)
2574 return new AuroraUXSparcV8TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002575 if (os == llvm::Triple::Solaris)
2576 return new SolarisSparcV8TargetInfo(T);
2577 return new SparcV8TargetInfo(T);
2578
John Thompsoned7bdbc2009-11-19 17:18:50 +00002579 // FIXME: Need a real SPU target.
2580 case llvm::Triple::cellspu:
2581 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
2582
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002583 case llvm::Triple::systemz:
2584 return new SystemZTargetInfo(T);
2585
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002586 case llvm::Triple::tce:
2587 return new TCETargetInfo(T);
2588
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002589 case llvm::Triple::x86:
2590 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002591 case llvm::Triple::AuroraUX:
2592 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002593 case llvm::Triple::Darwin:
2594 return new DarwinI386TargetInfo(T);
2595 case llvm::Triple::Linux:
2596 return new LinuxTargetInfo<X86_32TargetInfo>(T);
2597 case llvm::Triple::DragonFly:
2598 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
2599 case llvm::Triple::NetBSD:
2600 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
2601 case llvm::Triple::OpenBSD:
2602 return new OpenBSDI386TargetInfo(T);
2603 case llvm::Triple::FreeBSD:
2604 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner6f4bed52010-07-07 16:01:42 +00002605 case llvm::Triple::Minix:
2606 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002607 case llvm::Triple::Solaris:
2608 return new SolarisTargetInfo<X86_32TargetInfo>(T);
2609 case llvm::Triple::Cygwin:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002610 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002611 case llvm::Triple::MinGW32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002612 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002613 case llvm::Triple::Win32:
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00002614 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattnerf853e732010-04-11 19:29:39 +00002615 case llvm::Triple::Haiku:
2616 return new HaikuX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002617 default:
2618 return new X86_32TargetInfo(T);
2619 }
2620
2621 case llvm::Triple::x86_64:
2622 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002623 case llvm::Triple::AuroraUX:
2624 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002625 case llvm::Triple::Darwin:
2626 return new DarwinX86_64TargetInfo(T);
2627 case llvm::Triple::Linux:
2628 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner1eac0812010-01-09 05:41:14 +00002629 case llvm::Triple::DragonFly:
2630 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002631 case llvm::Triple::NetBSD:
2632 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
2633 case llvm::Triple::OpenBSD:
2634 return new OpenBSDX86_64TargetInfo(T);
2635 case llvm::Triple::FreeBSD:
2636 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
2637 case llvm::Triple::Solaris:
2638 return new SolarisTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002639 case llvm::Triple::MinGW64:
2640 return new MinGWX86_64TargetInfo(T);
2641 case llvm::Triple::Win32: // This is what Triple.h supports now.
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00002642 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002643 default:
2644 return new X86_64TargetInfo(T);
2645 }
2646 }
Chris Lattner4b009652007-07-25 00:24:17 +00002647}
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002648
2649/// CreateTargetInfo - Return the target info object for the specified target
2650/// triple.
2651TargetInfo *TargetInfo::CreateTargetInfo(Diagnostic &Diags,
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002652 TargetOptions &Opts) {
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002653 llvm::Triple Triple(Opts.Triple);
2654
2655 // Construct the target
2656 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
2657 if (!Target) {
2658 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
2659 return 0;
2660 }
2661
Daniel Dunbar33b40752009-12-18 18:42:37 +00002662 // Set the target CPU if specified.
2663 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
2664 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
2665 return 0;
2666 }
2667
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002668 // Set the target ABI if specified.
2669 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
2670 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
2671 return 0;
2672 }
2673
Charles Davisfed3a2b2010-06-11 01:06:47 +00002674 // Set the target C++ ABI.
John McCall68086b92010-08-21 22:46:04 +00002675 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davisfed3a2b2010-06-11 01:06:47 +00002676 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
2677 return 0;
2678 }
2679
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002680 // Compute the default target features, we need the target to handle this
2681 // because features may have dependencies on one another.
2682 llvm::StringMap<bool> Features;
2683 Target->getDefaultFeatures(Opts.CPU, Features);
2684
2685 // Apply the user specified deltas.
2686 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
2687 ie = Opts.Features.end(); it != ie; ++it) {
2688 const char *Name = it->c_str();
2689
2690 // Apply the feature via the target.
2691 if ((Name[0] != '-' && Name[0] != '+') ||
2692 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
2693 Diags.Report(diag::err_target_invalid_feature) << Name;
2694 return 0;
2695 }
2696 }
2697
2698 // Add the features to the compile options.
2699 //
2700 // FIXME: If we are completely confident that we have the right set, we only
2701 // need to pass the minuses.
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002702 Opts.Features.clear();
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002703 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
2704 ie = Features.end(); it != ie; ++it)
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002705 Opts.Features.push_back(std::string(it->second ? "+" : "-") + it->first());
2706 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002707
2708 return Target.take();
2709}