blob: 07c2bb960bcf01362a779897fd361144b9f2566d [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"
Daniel Dunbarca3e9912009-11-15 06:48:46 +000019#include "clang/Basic/TargetBuiltins.h"
20#include "clang/Basic/TargetOptions.h"
Eli Friedmand4011892008-05-20 14:27:34 +000021#include "llvm/ADT/APFloat.h"
Daniel Dunbarca3e9912009-11-15 06:48:46 +000022#include "llvm/ADT/OwningPtr.h"
Daniel Dunbar8dd8f262009-11-11 09:38:56 +000023#include "llvm/ADT/STLExtras.h"
Chris Lattnerc345a802009-03-20 16:06:38 +000024#include "llvm/ADT/SmallString.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"
Chris Lattner4b009652007-07-25 00:24:17 +000029using namespace clang;
30
Chris Lattner4b009652007-07-25 00:24:17 +000031//===----------------------------------------------------------------------===//
32// Common code shared among targets.
33//===----------------------------------------------------------------------===//
34
Daniel Dunbar0433a022009-08-19 20:04:03 +000035static void Define(std::vector<char> &Buf, const llvm::StringRef &Macro,
36 const llvm::StringRef &Val = "1") {
Chris Lattner0db667a2007-10-06 06:57:34 +000037 const char *Def = "#define ";
38 Buf.insert(Buf.end(), Def, Def+strlen(Def));
Daniel Dunbar0433a022009-08-19 20:04:03 +000039 Buf.insert(Buf.end(), Macro.begin(), Macro.end());
Chris Lattner0db667a2007-10-06 06:57:34 +000040 Buf.push_back(' ');
Daniel Dunbar0433a022009-08-19 20:04:03 +000041 Buf.insert(Buf.end(), Val.begin(), Val.end());
Chris Lattner0db667a2007-10-06 06:57:34 +000042 Buf.push_back('\n');
43}
44
Chris Lattnerc345a802009-03-20 16:06:38 +000045/// DefineStd - Define a macro name and standard variants. For example if
46/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
47/// when in GNU mode.
Anton Korobeynikove7772382009-05-03 13:42:53 +000048static void DefineStd(std::vector<char> &Buf, const char *MacroName,
Chris Lattnerc345a802009-03-20 16:06:38 +000049 const LangOptions &Opts) {
50 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikove7772382009-05-03 13:42:53 +000051
Chris Lattnerc345a802009-03-20 16:06:38 +000052 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
53 // in the user's namespace.
54 if (Opts.GNUMode)
55 Define(Buf, MacroName);
Anton Korobeynikove7772382009-05-03 13:42:53 +000056
Chris Lattnerc345a802009-03-20 16:06:38 +000057 // Define __unix.
58 llvm::SmallString<20> TmpStr;
59 TmpStr = "__";
60 TmpStr += MacroName;
Daniel Dunbar0433a022009-08-19 20:04:03 +000061 Define(Buf, TmpStr.str());
Anton Korobeynikove7772382009-05-03 13:42:53 +000062
Chris Lattnerc345a802009-03-20 16:06:38 +000063 // Define __unix__.
64 TmpStr += "__";
Daniel Dunbar0433a022009-08-19 20:04:03 +000065 Define(Buf, TmpStr.str());
Chris Lattnerc345a802009-03-20 16:06:38 +000066}
67
Chris Lattnerbd00eb82008-10-05 21:50:58 +000068//===----------------------------------------------------------------------===//
69// Defines specific to certain operating systems.
70//===----------------------------------------------------------------------===//
Chris Lattner43954312009-08-10 19:03:04 +000071
Edwin Török36565e52009-06-30 17:10:35 +000072namespace {
Douglas Gregor937331f2009-07-01 15:12:53 +000073template<typename TgtInfo>
74class OSTargetInfo : public TgtInfo {
Edwin Török36565e52009-06-30 17:10:35 +000075protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +000076 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Edwin Török36565e52009-06-30 17:10:35 +000077 std::vector<char> &Defines) const=0;
78public:
Douglas Gregor937331f2009-07-01 15:12:53 +000079 OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
Edwin Török36565e52009-06-30 17:10:35 +000080 virtual void getTargetDefines(const LangOptions &Opts,
81 std::vector<char> &Defines) const {
Douglas Gregor937331f2009-07-01 15:12:53 +000082 TgtInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar608b3882009-08-24 09:10:05 +000083 getOSDefines(Opts, TgtInfo::getTriple(), Defines);
Edwin Török2d98f9f2009-06-30 17:00:25 +000084 }
Edwin Török36565e52009-06-30 17:10:35 +000085
86};
Chris Lattnerf54f2212009-08-12 06:24:27 +000087} // end anonymous namespace
Edwin Török2d98f9f2009-06-30 17:00:25 +000088
Chris Lattner43954312009-08-10 19:03:04 +000089
Daniel Dunbar93f64532009-04-10 19:52:24 +000090static void getDarwinDefines(std::vector<char> &Defs, const LangOptions &Opts) {
Chris Lattner59122202009-06-23 00:43:21 +000091 Define(Defs, "__APPLE_CC__", "5621");
Eli Friedman872996c2008-08-20 02:34:37 +000092 Define(Defs, "__APPLE__");
93 Define(Defs, "__MACH__");
Chris Lattner8405e092009-02-05 07:19:24 +000094 Define(Defs, "OBJC_NEW_PROPERTIES");
Anton Korobeynikove7772382009-05-03 13:42:53 +000095
Chris Lattner8181e622009-04-07 16:50:40 +000096 // __weak is always defined, for use in blocks and with objc pointers.
97 Define(Defs, "__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikove7772382009-05-03 13:42:53 +000098
Chris Lattner8181e622009-04-07 16:50:40 +000099 // Darwin defines __strong even in C mode (just to nothing).
100 if (!Opts.ObjC1 || Opts.getGCMode() == LangOptions::NonGC)
Chris Lattner33854aa2009-04-07 04:48:21 +0000101 Define(Defs, "__strong", "");
Chris Lattner8181e622009-04-07 16:50:40 +0000102 else
Chris Lattner33854aa2009-04-07 04:48:21 +0000103 Define(Defs, "__strong", "__attribute__((objc_gc(strong)))");
Eli Friedmaneff0a422009-06-04 23:00:29 +0000104
105 if (Opts.Static)
106 Define(Defs, "__STATIC__");
107 else
108 Define(Defs, "__DYNAMIC__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000109
110 if (Opts.POSIXThreads)
111 Define(Defs, "_REENTRANT", "1");
Daniel Dunbar93f64532009-04-10 19:52:24 +0000112}
113
Daniel Dunbar608b3882009-08-24 09:10:05 +0000114static void getDarwinOSXDefines(std::vector<char> &Defs,
115 const llvm::Triple &Triple) {
116 if (Triple.getOS() != llvm::Triple::Darwin)
Chris Lattnerf54f2212009-08-12 06:24:27 +0000117 return;
Mike Stump25cf7602009-09-09 15:08:12 +0000118
Chris Lattnerc5dc8eb2008-09-30 01:00:25 +0000119 // Figure out which "darwin number" the target triple is. "darwin9" -> 10.5.
Daniel Dunbar93f64532009-04-10 19:52:24 +0000120 unsigned Maj, Min, Rev;
Daniel Dunbar608b3882009-08-24 09:10:05 +0000121 Triple.getDarwinNumber(Maj, Min, Rev);
Mike Stump25cf7602009-09-09 15:08:12 +0000122
Chris Lattnerf54f2212009-08-12 06:24:27 +0000123 char MacOSXStr[] = "1000";
124 if (Maj >= 4 && Maj <= 13) { // 10.0-10.9
125 // darwin7 -> 1030, darwin8 -> 1040, darwin9 -> 1050, etc.
126 MacOSXStr[2] = '0' + Maj-4;
Daniel Dunbar93f64532009-04-10 19:52:24 +0000127 }
Chris Lattnerf54f2212009-08-12 06:24:27 +0000128
129 // Handle minor version: 10.4.9 -> darwin8.9 -> "1049"
130 // Cap 10.4.11 -> darwin8.11 -> "1049"
131 MacOSXStr[3] = std::min(Min, 9U)+'0';
132 Define(Defs, "__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", MacOSXStr);
Daniel Dunbar93f64532009-04-10 19:52:24 +0000133}
134
Anton Korobeynikove7772382009-05-03 13:42:53 +0000135static void getDarwinIPhoneOSDefines(std::vector<char> &Defs,
Daniel Dunbar608b3882009-08-24 09:10:05 +0000136 const llvm::Triple &Triple) {
137 if (Triple.getOS() != llvm::Triple::Darwin)
Chris Lattnerf54f2212009-08-12 06:24:27 +0000138 return;
Mike Stump25cf7602009-09-09 15:08:12 +0000139
Daniel Dunbar93f64532009-04-10 19:52:24 +0000140 // Figure out which "darwin number" the target triple is. "darwin9" -> 10.5.
141 unsigned Maj, Min, Rev;
Daniel Dunbar608b3882009-08-24 09:10:05 +0000142 Triple.getDarwinNumber(Maj, Min, Rev);
Mike Stump25cf7602009-09-09 15:08:12 +0000143
Chris Lattnerf54f2212009-08-12 06:24:27 +0000144 // When targetting iPhone OS, interpret the minor version and
145 // revision as the iPhone OS version
146 char iPhoneOSStr[] = "10000";
147 if (Min >= 2 && Min <= 9) { // iPhone OS 2.0-9.0
148 // darwin9.2.0 -> 20000, darwin9.3.0 -> 30000, etc.
149 iPhoneOSStr[0] = '0' + Min;
Chris Lattnerc5dc8eb2008-09-30 01:00:25 +0000150 }
Chris Lattnerf54f2212009-08-12 06:24:27 +0000151
152 // Handle minor version: 2.2 -> darwin9.2.2 -> 20200
153 iPhoneOSStr[2] = std::min(Rev, 9U)+'0';
154 Define(Defs, "__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__",
155 iPhoneOSStr);
Eli Friedman872996c2008-08-20 02:34:37 +0000156}
Chris Lattner4b009652007-07-25 00:24:17 +0000157
Chris Lattner43954312009-08-10 19:03:04 +0000158namespace {
Edwin Török36565e52009-06-30 17:10:35 +0000159template<typename Target>
160class DarwinTargetInfo : public OSTargetInfo<Target> {
161protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000162 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Edwin Török36565e52009-06-30 17:10:35 +0000163 std::vector<char> &Defines) const {
164 getDarwinDefines(Defines, Opts);
165 getDarwinOSXDefines(Defines, Triple);
166 }
Mike Stump25cf7602009-09-09 15:08:12 +0000167
Edwin Török36565e52009-06-30 17:10:35 +0000168public:
169 DarwinTargetInfo(const std::string& triple) :
170 OSTargetInfo<Target>(triple) {
171 this->TLSSupported = false;
172 }
173
Edwin Török36565e52009-06-30 17:10:35 +0000174 virtual const char *getUnicodeStringSection() const {
175 return "__TEXT,__ustring";
176 }
Mike Stump25cf7602009-09-09 15:08:12 +0000177
Chris Lattner43954312009-08-10 19:03:04 +0000178 virtual std::string isValidSectionSpecifier(const llvm::StringRef &SR) const {
179 // Let MCSectionMachO validate this.
180 llvm::StringRef Segment, Section;
181 unsigned TAA, StubSize;
182 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
183 TAA, StubSize);
184 }
Edwin Török36565e52009-06-30 17:10:35 +0000185};
186
Chris Lattner43954312009-08-10 19:03:04 +0000187
Edwin Török36565e52009-06-30 17:10:35 +0000188// DragonFlyBSD Target
189template<typename Target>
190class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
191protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000192 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Edwin Török36565e52009-06-30 17:10:35 +0000193 std::vector<char> &Defs) const {
194 // DragonFly defines; list based off of gcc output
195 Define(Defs, "__DragonFly__");
196 Define(Defs, "__DragonFly_cc_version", "100001");
197 Define(Defs, "__ELF__");
198 Define(Defs, "__KPRINTF_ATTRIBUTE__");
199 Define(Defs, "__tune_i386__");
200 DefineStd(Defs, "unix", Opts);
201 }
202public:
Mike Stump25cf7602009-09-09 15:08:12 +0000203 DragonFlyBSDTargetInfo(const std::string &triple)
Edwin Török36565e52009-06-30 17:10:35 +0000204 : OSTargetInfo<Target>(triple) {}
205};
206
207// FreeBSD Target
208template<typename Target>
209class FreeBSDTargetInfo : public OSTargetInfo<Target> {
210protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000211 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Edwin Török36565e52009-06-30 17:10:35 +0000212 std::vector<char> &Defs) const {
213 // FreeBSD defines; list based off of gcc output
214
Daniel Dunbar608b3882009-08-24 09:10:05 +0000215 // FIXME: Move version number handling to llvm::Triple.
216 const char *FreeBSD = strstr(Triple.getTriple().c_str(),
217 "-freebsd");
Edwin Török36565e52009-06-30 17:10:35 +0000218 FreeBSD += strlen("-freebsd");
219 char release[] = "X";
220 release[0] = FreeBSD[0];
221 char version[] = "X00001";
222 version[0] = FreeBSD[0];
223
224 Define(Defs, "__FreeBSD__", release);
225 Define(Defs, "__FreeBSD_cc_version", version);
226 Define(Defs, "__KPRINTF_ATTRIBUTE__");
227 DefineStd(Defs, "unix", Opts);
228 Define(Defs, "__ELF__", "1");
229 }
230public:
Mike Stump25cf7602009-09-09 15:08:12 +0000231 FreeBSDTargetInfo(const std::string &triple)
Duncan Sandscd2cb662009-07-08 13:55:08 +0000232 : OSTargetInfo<Target>(triple) {
233 this->UserLabelPrefix = "";
234 }
Edwin Török36565e52009-06-30 17:10:35 +0000235};
236
237// Linux target
238template<typename Target>
239class LinuxTargetInfo : public OSTargetInfo<Target> {
240protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000241 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Edwin Török36565e52009-06-30 17:10:35 +0000242 std::vector<char> &Defs) const {
243 // Linux defines; list based off of gcc output
244 DefineStd(Defs, "unix", Opts);
245 DefineStd(Defs, "linux", Opts);
246 Define(Defs, "__gnu_linux__");
247 Define(Defs, "__ELF__", "1");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000248 if (Opts.POSIXThreads)
249 Define(Defs, "_REENTRANT", "1");
Edwin Török36565e52009-06-30 17:10:35 +0000250 }
251public:
Mike Stump25cf7602009-09-09 15:08:12 +0000252 LinuxTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +0000253 : OSTargetInfo<Target>(triple) {
254 this->UserLabelPrefix = "";
255 }
256};
257
Chris Lattner25fff082009-07-13 20:29:08 +0000258// NetBSD Target
259template<typename Target>
260class NetBSDTargetInfo : public OSTargetInfo<Target> {
261protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000262 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Chris Lattner25fff082009-07-13 20:29:08 +0000263 std::vector<char> &Defs) const {
264 // NetBSD defines; list based off of gcc output
265 Define(Defs, "__NetBSD__", "1");
266 Define(Defs, "__unix__", "1");
267 Define(Defs, "__ELF__", "1");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000268 if (Opts.POSIXThreads)
269 Define(Defs, "_POSIX_THREADS", "1");
Chris Lattner25fff082009-07-13 20:29:08 +0000270 }
271public:
Mike Stump25cf7602009-09-09 15:08:12 +0000272 NetBSDTargetInfo(const std::string &triple)
Chris Lattner25fff082009-07-13 20:29:08 +0000273 : OSTargetInfo<Target>(triple) {
274 this->UserLabelPrefix = "";
275 }
276};
277
Edwin Török36565e52009-06-30 17:10:35 +0000278// OpenBSD Target
279template<typename Target>
280class OpenBSDTargetInfo : public OSTargetInfo<Target> {
281protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000282 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Edwin Török36565e52009-06-30 17:10:35 +0000283 std::vector<char> &Defs) const {
284 // OpenBSD defines; list based off of gcc output
285
286 Define(Defs, "__OpenBSD__", "1");
287 DefineStd(Defs, "unix", Opts);
288 Define(Defs, "__ELF__", "1");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000289 if (Opts.POSIXThreads)
290 Define(Defs, "_POSIX_THREADS", "1");
Edwin Török36565e52009-06-30 17:10:35 +0000291 }
292public:
Mike Stump25cf7602009-09-09 15:08:12 +0000293 OpenBSDTargetInfo(const std::string &triple)
Edwin Török36565e52009-06-30 17:10:35 +0000294 : OSTargetInfo<Target>(triple) {}
295};
296
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000297// PSP Target
298template<typename Target>
299class PSPTargetInfo : public OSTargetInfo<Target> {
300protected:
301 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
302 std::vector<char> &Defs) const {
303 // PSP defines; list based on the output of the pspdev gcc toolchain.
304 Define(Defs, "PSP", "1");
305 Define(Defs, "_PSP", "1");
306 Define(Defs, "__psp__", "1");
307 Define(Defs, "__ELF__", "1");
308 }
309public:
310 PSPTargetInfo(const std::string& triple)
311 : OSTargetInfo<Target>(triple) {
312 this->UserLabelPrefix = "";
313 }
314};
315
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +0000316// AuroraUX target
317template<typename Target>
318class AuroraUXTargetInfo : public OSTargetInfo<Target> {
319protected:
320 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
321 std::vector<char> &Defs) const {
322 DefineStd(Defs, "sun", Opts);
323 DefineStd(Defs, "unix", Opts);
324 Define(Defs, "__ELF__");
325 Define(Defs, "__svr4__");
326 Define(Defs, "__SVR4");
327 }
328public:
329 AuroraUXTargetInfo(const std::string& triple)
330 : OSTargetInfo<Target>(triple) {
331 this->UserLabelPrefix = "";
332 this->WCharType = this->SignedLong;
333 // FIXME: WIntType should be SignedLong
334 }
335};
336
Edwin Török36565e52009-06-30 17:10:35 +0000337// Solaris target
338template<typename Target>
339class SolarisTargetInfo : public OSTargetInfo<Target> {
340protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000341 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Edwin Török36565e52009-06-30 17:10:35 +0000342 std::vector<char> &Defs) const {
343 DefineStd(Defs, "sun", Opts);
344 DefineStd(Defs, "unix", Opts);
345 Define(Defs, "__ELF__");
346 Define(Defs, "__svr4__");
347 Define(Defs, "__SVR4");
348 }
349public:
Mike Stump25cf7602009-09-09 15:08:12 +0000350 SolarisTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +0000351 : OSTargetInfo<Target>(triple) {
352 this->UserLabelPrefix = "";
353 this->WCharType = this->SignedLong;
354 // FIXME: WIntType should be SignedLong
355 }
356};
Mike Stump25cf7602009-09-09 15:08:12 +0000357} // end anonymous namespace.
Edwin Török36565e52009-06-30 17:10:35 +0000358
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000359//===----------------------------------------------------------------------===//
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000360// Specific target implementations.
361//===----------------------------------------------------------------------===//
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000362
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000363namespace {
364// PPC abstract base class
365class PPCTargetInfo : public TargetInfo {
366 static const Builtin::Info BuiltinInfo[];
367 static const char * const GCCRegNames[];
368 static const TargetInfo::GCCRegAlias GCCRegAliases[];
369
370public:
Eli Friedmand9389be2009-06-05 07:05:05 +0000371 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
372
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000373 virtual void getTargetBuiltins(const Builtin::Info *&Records,
374 unsigned &NumRecords) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000375 Records = BuiltinInfo;
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000376 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000377 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000378
Chris Lattner79682402009-03-20 15:52:06 +0000379 virtual void getTargetDefines(const LangOptions &Opts,
380 std::vector<char> &Defines) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000381
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000382 virtual const char *getVAListDeclaration() const {
Chris Lattnera07708f2008-10-27 01:11:29 +0000383 return "typedef char* __builtin_va_list;";
384 // This is the right definition for ABI/V4: System V.4/eabi.
385 /*return "typedef struct __va_list_tag {"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000386 " unsigned char gpr;"
387 " unsigned char fpr;"
388 " unsigned short reserved;"
389 " void* overflow_arg_area;"
390 " void* reg_save_area;"
Chris Lattnera07708f2008-10-27 01:11:29 +0000391 "} __builtin_va_list[1];";*/
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000392 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000393 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000394 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000395 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000396 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +0000397 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000398 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +0000399 switch (*Name) {
Anders Carlsson4ce42302007-11-27 04:11:28 +0000400 default: return false;
401 case 'O': // Zero
402 return true;
403 case 'b': // Base register
404 case 'f': // Floating point register
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000405 Info.setAllowsRegister();
Anders Carlsson4ce42302007-11-27 04:11:28 +0000406 return true;
407 }
408 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000409 virtual const char *getClobbers() const {
410 return "";
Anders Carlsson4ce42302007-11-27 04:11:28 +0000411 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000412};
Anders Carlsson4ce42302007-11-27 04:11:28 +0000413
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000414const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000415#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
416#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000417#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000418};
Anton Korobeynikove7772382009-05-03 13:42:53 +0000419
420
Chris Lattnerbef1d722009-03-02 22:27:17 +0000421/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
422/// #defines that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +0000423void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
424 std::vector<char> &Defs) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +0000425 // Target identification.
426 Define(Defs, "__ppc__");
427 Define(Defs, "_ARCH_PPC");
428 Define(Defs, "__POWERPC__");
429 if (PointerWidth == 64) {
430 Define(Defs, "_ARCH_PPC64");
431 Define(Defs, "_LP64");
432 Define(Defs, "__LP64__");
433 Define(Defs, "__ppc64__");
434 } else {
435 Define(Defs, "__ppc__");
436 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000437
Chris Lattnerbef1d722009-03-02 22:27:17 +0000438 // Target properties.
439 Define(Defs, "_BIG_ENDIAN");
440 Define(Defs, "__BIG_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000441
Chris Lattnerbef1d722009-03-02 22:27:17 +0000442 // Subtarget options.
443 Define(Defs, "__NATURAL_ALIGNMENT__");
444 Define(Defs, "__REGISTER_PREFIX__", "");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000445
Chris Lattnerbef1d722009-03-02 22:27:17 +0000446 // FIXME: Should be controlled by command line option.
447 Define(Defs, "__LONG_DOUBLE_128__");
448}
449
Chris Lattner9fd73612008-04-21 18:56:49 +0000450
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000451const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattner14d2bb72009-09-16 05:05:27 +0000452 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
453 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
454 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
455 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
456 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
457 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
458 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
459 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000460 "mq", "lr", "ctr", "ap",
Chris Lattner14d2bb72009-09-16 05:05:27 +0000461 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000462 "xer",
Chris Lattner14d2bb72009-09-16 05:05:27 +0000463 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
464 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
465 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
466 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000467 "vrsave", "vscr",
468 "spe_acc", "spefscr",
469 "sfp"
470};
Chris Lattner4b009652007-07-25 00:24:17 +0000471
Anton Korobeynikove7772382009-05-03 13:42:53 +0000472void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000473 unsigned &NumNames) const {
474 Names = GCCRegNames;
475 NumNames = llvm::array_lengthof(GCCRegNames);
476}
Chris Lattner4b009652007-07-25 00:24:17 +0000477
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000478const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
479 // While some of these aliases do map to different registers
480 // they still share the same register name.
Daniel Dunbar40b774e2009-09-17 07:03:19 +0000481 { { "0" }, "r0" },
482 { { "1"}, "r1" },
483 { { "2" }, "r2" },
484 { { "3" }, "r3" },
485 { { "4" }, "r4" },
486 { { "5" }, "r5" },
487 { { "6" }, "r6" },
488 { { "7" }, "r7" },
489 { { "8" }, "r8" },
490 { { "9" }, "r9" },
491 { { "10" }, "r10" },
492 { { "11" }, "r11" },
493 { { "12" }, "r12" },
494 { { "13" }, "r13" },
495 { { "14" }, "r14" },
496 { { "15" }, "r15" },
497 { { "16" }, "r16" },
498 { { "17" }, "r17" },
499 { { "18" }, "r18" },
500 { { "19" }, "r19" },
501 { { "20" }, "r20" },
502 { { "21" }, "r21" },
503 { { "22" }, "r22" },
504 { { "23" }, "r23" },
505 { { "24" }, "r24" },
506 { { "25" }, "r25" },
507 { { "26" }, "r26" },
508 { { "27" }, "r27" },
509 { { "28" }, "r28" },
510 { { "29" }, "r29" },
511 { { "30" }, "r30" },
512 { { "31" }, "r31" },
513 { { "fr0" }, "f0" },
514 { { "fr1" }, "f1" },
515 { { "fr2" }, "f2" },
516 { { "fr3" }, "f3" },
517 { { "fr4" }, "f4" },
518 { { "fr5" }, "f5" },
519 { { "fr6" }, "f6" },
520 { { "fr7" }, "f7" },
521 { { "fr8" }, "f8" },
522 { { "fr9" }, "f9" },
Mike Stump369c21c2009-09-17 21:15:00 +0000523 { { "fr10" }, "f10" },
Daniel Dunbar40b774e2009-09-17 07:03:19 +0000524 { { "fr11" }, "f11" },
525 { { "fr12" }, "f12" },
526 { { "fr13" }, "f13" },
527 { { "fr14" }, "f14" },
528 { { "fr15" }, "f15" },
529 { { "fr16" }, "f16" },
530 { { "fr17" }, "f17" },
531 { { "fr18" }, "f18" },
532 { { "fr19" }, "f19" },
533 { { "fr20" }, "f20" },
534 { { "fr21" }, "f21" },
535 { { "fr22" }, "f22" },
536 { { "fr23" }, "f23" },
537 { { "fr24" }, "f24" },
538 { { "fr25" }, "f25" },
539 { { "fr26" }, "f26" },
540 { { "fr27" }, "f27" },
541 { { "fr28" }, "f28" },
542 { { "fr29" }, "f29" },
543 { { "fr30" }, "f30" },
544 { { "fr31" }, "f31" },
545 { { "cc" }, "cr0" },
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000546};
547
Anton Korobeynikove7772382009-05-03 13:42:53 +0000548void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000549 unsigned &NumAliases) const {
550 Aliases = GCCRegAliases;
551 NumAliases = llvm::array_lengthof(GCCRegAliases);
552}
553} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +0000554
555namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000556class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000557public:
Eli Friedman2b161652008-08-21 00:13:15 +0000558 PPC32TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
559 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 +0000560 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Eli Friedman2b161652008-08-21 00:13:15 +0000561 }
Chris Lattner4b009652007-07-25 00:24:17 +0000562};
563} // end anonymous namespace.
564
565namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000566class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000567public:
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000568 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +0000569 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman38e31802009-07-01 03:36:11 +0000570 IntMaxType = SignedLong;
571 UIntMaxType = UnsignedLong;
572 Int64Type = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +0000573 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 +0000574 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnere5fde952008-05-09 06:17:04 +0000575 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000576};
577} // end anonymous namespace.
578
Chris Lattner4b009652007-07-25 00:24:17 +0000579namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000580// Namespace for x86 abstract base class
581const Builtin::Info BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000582#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
583#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000584#include "clang/Basic/BuiltinsX86.def"
Eli Friedman872996c2008-08-20 02:34:37 +0000585};
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000586
Eli Friedman872996c2008-08-20 02:34:37 +0000587const char *GCCRegNames[] = {
588 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
589 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
590 "argp", "flags", "fspr", "dirflag", "frame",
591 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
592 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
593 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
594 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
595};
596
597const TargetInfo::GCCRegAlias GCCRegAliases[] = {
598 { { "al", "ah", "eax", "rax" }, "ax" },
599 { { "bl", "bh", "ebx", "rbx" }, "bx" },
600 { { "cl", "ch", "ecx", "rcx" }, "cx" },
601 { { "dl", "dh", "edx", "rdx" }, "dx" },
602 { { "esi", "rsi" }, "si" },
603 { { "edi", "rdi" }, "di" },
604 { { "esp", "rsp" }, "sp" },
605 { { "ebp", "rbp" }, "bp" },
606};
607
608// X86 target abstract base class; x86-32 and x86-64 are very close, so
609// most of the implementation can be shared.
610class X86TargetInfo : public TargetInfo {
Chris Lattner715fe4c2009-03-02 22:40:39 +0000611 enum X86SSEEnum {
612 NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
613 } SSELevel;
Eli Friedman872996c2008-08-20 02:34:37 +0000614public:
Anton Korobeynikove7772382009-05-03 13:42:53 +0000615 X86TargetInfo(const std::string& triple)
Daniel Dunbar07181d72009-05-06 03:16:41 +0000616 : TargetInfo(triple), SSELevel(NoMMXSSE) {
Eli Friedman872996c2008-08-20 02:34:37 +0000617 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner4b009652007-07-25 00:24:17 +0000618 }
619 virtual void getTargetBuiltins(const Builtin::Info *&Records,
620 unsigned &NumRecords) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000621 Records = BuiltinInfo;
622 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000623 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000624 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman872996c2008-08-20 02:34:37 +0000625 unsigned &NumNames) const {
626 Names = GCCRegNames;
627 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000628 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000629 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000630 unsigned &NumAliases) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000631 Aliases = GCCRegAliases;
632 NumAliases = llvm::array_lengthof(GCCRegAliases);
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000633 }
Anders Carlsson36834a72009-02-28 17:11:49 +0000634 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman872996c2008-08-20 02:34:37 +0000635 TargetInfo::ConstraintInfo &info) const;
636 virtual std::string convertConstraint(const char Constraint) const;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000637 virtual const char *getClobbers() const {
Eli Friedman872996c2008-08-20 02:34:37 +0000638 return "~{dirflag},~{fpsr},~{flags}";
639 }
Chris Lattner79682402009-03-20 15:52:06 +0000640 virtual void getTargetDefines(const LangOptions &Opts,
641 std::vector<char> &Defines) const;
Daniel Dunbar0838f962009-05-06 21:07:50 +0000642 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
643 const std::string &Name,
644 bool Enabled) const;
Mike Stump25cf7602009-09-09 15:08:12 +0000645 virtual void getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000646 llvm::StringMap<bool> &Features) const;
Daniel Dunbar8dd8f262009-11-11 09:38:56 +0000647 virtual void HandleTargetFeatures(const std::vector<std::string> &Features);
Chris Lattner4b009652007-07-25 00:24:17 +0000648};
Chris Lattner7d6220c2009-03-02 22:20:04 +0000649
Mike Stump25cf7602009-09-09 15:08:12 +0000650void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000651 llvm::StringMap<bool> &Features) const {
Daniel Dunbar07181d72009-05-06 03:16:41 +0000652 // FIXME: This should not be here.
653 Features["3dnow"] = false;
654 Features["3dnowa"] = false;
655 Features["mmx"] = false;
656 Features["sse"] = false;
657 Features["sse2"] = false;
658 Features["sse3"] = false;
659 Features["ssse3"] = false;
660 Features["sse41"] = false;
661 Features["sse42"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000662
Daniel Dunbar07181d72009-05-06 03:16:41 +0000663 // LLVM does not currently recognize this.
664 // Features["sse4a"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000665
Daniel Dunbar07181d72009-05-06 03:16:41 +0000666 // FIXME: This *really* should not be here.
667
668 // X86_64 always has SSE2.
669 if (PointerWidth == 64)
670 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
671
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000672 if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
673 CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
674 ;
675 else if (CPU == "pentium-mmx" || CPU == "pentium2")
676 setFeatureEnabled(Features, "mmx", true);
677 else if (CPU == "pentium3")
678 setFeatureEnabled(Features, "sse", true);
679 else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64")
680 setFeatureEnabled(Features, "sse2", true);
681 else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona")
682 setFeatureEnabled(Features, "sse3", true);
683 else if (CPU == "core2")
684 setFeatureEnabled(Features, "ssse3", true);
685 else if (CPU == "penryn") {
686 setFeatureEnabled(Features, "sse4", true);
687 Features["sse42"] = false;
688 } else if (CPU == "atom")
689 setFeatureEnabled(Features, "sse3", true);
690 else if (CPU == "corei7")
691 setFeatureEnabled(Features, "sse4", true);
692 else if (CPU == "k6" || CPU == "winchip-c6")
693 setFeatureEnabled(Features, "mmx", true);
Mike Stump25cf7602009-09-09 15:08:12 +0000694 else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000695 CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
696 setFeatureEnabled(Features, "mmx", true);
697 setFeatureEnabled(Features, "3dnow", true);
698 } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
699 setFeatureEnabled(Features, "sse", true);
700 setFeatureEnabled(Features, "3dnowa", true);
701 } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
702 CPU == "athlon-fx") {
Mike Stump25cf7602009-09-09 15:08:12 +0000703 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000704 setFeatureEnabled(Features, "3dnowa", true);
705 } else if (CPU == "c3-2")
706 setFeatureEnabled(Features, "sse", true);
Daniel Dunbar07181d72009-05-06 03:16:41 +0000707}
708
Daniel Dunbar0838f962009-05-06 21:07:50 +0000709bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump25cf7602009-09-09 15:08:12 +0000710 const std::string &Name,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000711 bool Enabled) const {
712 // FIXME: This *really* should not be here.
713 if (!Features.count(Name) && Name != "sse4")
714 return false;
715
716 if (Enabled) {
717 if (Name == "mmx")
718 Features["mmx"] = true;
719 else if (Name == "sse")
720 Features["mmx"] = Features["sse"] = true;
721 else if (Name == "sse2")
722 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
723 else if (Name == "sse3")
Mike Stump25cf7602009-09-09 15:08:12 +0000724 Features["mmx"] = Features["sse"] = Features["sse2"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000725 Features["sse3"] = true;
726 else if (Name == "ssse3")
Mike Stump25cf7602009-09-09 15:08:12 +0000727 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000728 Features["ssse3"] = true;
729 else if (Name == "sse4")
Mike Stump25cf7602009-09-09 15:08:12 +0000730 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000731 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
732 else if (Name == "3dnow")
733 Features["3dnowa"] = true;
734 else if (Name == "3dnowa")
735 Features["3dnow"] = Features["3dnowa"] = true;
736 } else {
737 if (Name == "mmx")
Mike Stump25cf7602009-09-09 15:08:12 +0000738 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000739 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
740 else if (Name == "sse")
Mike Stump25cf7602009-09-09 15:08:12 +0000741 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000742 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
743 else if (Name == "sse2")
Mike Stump25cf7602009-09-09 15:08:12 +0000744 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000745 Features["sse41"] = Features["sse42"] = false;
746 else if (Name == "sse3")
Mike Stump25cf7602009-09-09 15:08:12 +0000747 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +0000748 Features["sse42"] = false;
749 else if (Name == "ssse3")
750 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
751 else if (Name == "sse4")
752 Features["sse41"] = Features["sse42"] = false;
753 else if (Name == "3dnow")
754 Features["3dnow"] = Features["3dnowa"] = false;
755 else if (Name == "3dnowa")
756 Features["3dnowa"] = false;
757 }
758
759 return true;
760}
761
Daniel Dunbar07181d72009-05-06 03:16:41 +0000762/// HandleTargetOptions - Perform initialization based on the user
763/// configured set of features.
Daniel Dunbar8dd8f262009-11-11 09:38:56 +0000764void
765X86TargetInfo::HandleTargetFeatures(const std::vector<std::string> &Features) {
766 // Remember the maximum enabled sselevel.
767 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
768 // Ignore disabled features.
769 if (Features[i][0] == '-')
770 continue;
771
772 assert(Features[i][0] == '+' && "Invalid target feature!");
773 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
774 .Case("sse42", SSE42)
775 .Case("sse41", SSE41)
776 .Case("ssse3", SSSE3)
777 .Case("sse2", SSE2)
778 .Case("sse", SSE1)
779 .Case("mmx", MMX)
780 .Default(NoMMXSSE);
781 SSELevel = std::max(SSELevel, Level);
782 }
Chris Lattner7d6220c2009-03-02 22:20:04 +0000783}
Chris Lattnerbef1d722009-03-02 22:27:17 +0000784
785/// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
786/// that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +0000787void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
788 std::vector<char> &Defs) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +0000789 // Target identification.
790 if (PointerWidth == 64) {
791 Define(Defs, "_LP64");
792 Define(Defs, "__LP64__");
793 Define(Defs, "__amd64__");
794 Define(Defs, "__amd64");
795 Define(Defs, "__x86_64");
796 Define(Defs, "__x86_64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000797 } else {
Chris Lattnerc345a802009-03-20 16:06:38 +0000798 DefineStd(Defs, "i386", Opts);
Chris Lattnerbef1d722009-03-02 22:27:17 +0000799 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000800
Chris Lattnerbef1d722009-03-02 22:27:17 +0000801 // Target properties.
802 Define(Defs, "__LITTLE_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000803
Chris Lattnerbef1d722009-03-02 22:27:17 +0000804 // Subtarget options.
805 Define(Defs, "__nocona");
806 Define(Defs, "__nocona__");
807 Define(Defs, "__tune_nocona__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000808 Define(Defs, "__REGISTER_PREFIX__", "");
Chris Lattner715fe4c2009-03-02 22:40:39 +0000809
Chris Lattner25ac1c12009-04-19 17:32:33 +0000810 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
811 // functions in glibc header files that use FP Stack inline asm which the
812 // backend can't deal with (PR879).
813 Define(Defs, "__NO_MATH_INLINES");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000814
Chris Lattner715fe4c2009-03-02 22:40:39 +0000815 // Each case falls through to the previous one here.
816 switch (SSELevel) {
817 case SSE42:
818 Define(Defs, "__SSE4_2__");
819 case SSE41:
820 Define(Defs, "__SSE4_1__");
821 case SSSE3:
822 Define(Defs, "__SSSE3__");
823 case SSE3:
824 Define(Defs, "__SSE3__");
825 case SSE2:
826 Define(Defs, "__SSE2__");
827 Define(Defs, "__SSE2_MATH__"); // -mfp-math=sse always implied.
828 case SSE1:
829 Define(Defs, "__SSE__");
830 Define(Defs, "__SSE_MATH__"); // -mfp-math=sse always implied.
831 case MMX:
832 Define(Defs, "__MMX__");
833 case NoMMXSSE:
834 break;
835 }
Chris Lattnerbef1d722009-03-02 22:27:17 +0000836}
Anton Korobeynikove7772382009-05-03 13:42:53 +0000837
838
Eli Friedman872996c2008-08-20 02:34:37 +0000839bool
Anders Carlsson36834a72009-02-28 17:11:49 +0000840X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000841 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +0000842 switch (*Name) {
Eli Friedman872996c2008-08-20 02:34:37 +0000843 default: return false;
844 case 'a': // eax.
845 case 'b': // ebx.
846 case 'c': // ecx.
847 case 'd': // edx.
848 case 'S': // esi.
849 case 'D': // edi.
850 case 'A': // edx:eax.
851 case 't': // top of floating point stack.
852 case 'u': // second from top of floating point stack.
853 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson2285e622008-10-06 00:41:45 +0000854 case 'y': // Any MMX register.
Anders Carlssond2459f92008-10-06 19:17:39 +0000855 case 'x': // Any SSE register.
Eli Friedman872996c2008-08-20 02:34:37 +0000856 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Anton Korobeynikove7772382009-05-03 13:42:53 +0000857 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +0000858 // x86_64 instructions.
Anton Korobeynikove7772382009-05-03 13:42:53 +0000859 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +0000860 // x86_64 instructions.
Eli Friedman872996c2008-08-20 02:34:37 +0000861 case 'N': // unsigned 8-bit integer constant for use with in and out
862 // instructions.
Eli Friedman7e17aed2009-06-08 20:45:44 +0000863 case 'R': // "legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000864 Info.setAllowsRegister();
Eli Friedman872996c2008-08-20 02:34:37 +0000865 return true;
866 }
867}
868
869std::string
870X86TargetInfo::convertConstraint(const char Constraint) const {
871 switch (Constraint) {
872 case 'a': return std::string("{ax}");
873 case 'b': return std::string("{bx}");
874 case 'c': return std::string("{cx}");
875 case 'd': return std::string("{dx}");
876 case 'S': return std::string("{si}");
877 case 'D': return std::string("{di}");
878 case 't': // top of floating point stack.
879 return std::string("{st}");
880 case 'u': // second from top of floating point stack.
881 return std::string("{st(1)}"); // second from top of floating point stack.
882 default:
883 return std::string(1, Constraint);
884 }
885}
Eli Friedman872996c2008-08-20 02:34:37 +0000886} // end anonymous namespace
Chris Lattner4b009652007-07-25 00:24:17 +0000887
888namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000889// X86-32 generic target
890class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000891public:
Eli Friedman872996c2008-08-20 02:34:37 +0000892 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
893 DoubleAlign = LongLongAlign = 32;
894 LongDoubleWidth = 96;
895 LongDoubleAlign = 32;
Eli Friedman2b161652008-08-21 00:13:15 +0000896 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
897 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +0000898 "a0:0:64-f80:32:32-n8:16:32";
Eli Friedman04ede302009-03-29 20:31:09 +0000899 SizeType = UnsignedInt;
900 PtrDiffType = SignedInt;
901 IntPtrType = SignedInt;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +0000902 RegParmMax = 3;
Eli Friedman872996c2008-08-20 02:34:37 +0000903 }
904 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000905 return "typedef char* __builtin_va_list;";
Eli Friedman872996c2008-08-20 02:34:37 +0000906 }
Chris Lattneraa339182009-09-23 06:06:36 +0000907
908 int getEHDataRegisterNumber(unsigned RegNo) const {
909 if (RegNo == 0) return 0;
910 if (RegNo == 1) return 2;
911 return -1;
912 }
Eli Friedman872996c2008-08-20 02:34:37 +0000913};
914} // end anonymous namespace
915
916namespace {
Eli Friedman1c79f4b2009-07-05 18:47:56 +0000917class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
918public:
919 OpenBSDI386TargetInfo(const std::string& triple) :
920 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
921 SizeType = UnsignedLong;
922 IntPtrType = SignedLong;
Eli Friedman96ada022009-07-05 22:31:18 +0000923 PtrDiffType = SignedLong;
Eli Friedman1c79f4b2009-07-05 18:47:56 +0000924 }
925};
926} // end anonymous namespace
927
928namespace {
Edwin Török36565e52009-06-30 17:10:35 +0000929class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman872996c2008-08-20 02:34:37 +0000930public:
Edwin Török36565e52009-06-30 17:10:35 +0000931 DarwinI386TargetInfo(const std::string& triple) :
932 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman872996c2008-08-20 02:34:37 +0000933 LongDoubleWidth = 128;
934 LongDoubleAlign = 128;
Eli Friedman04ede302009-03-29 20:31:09 +0000935 SizeType = UnsignedLong;
936 IntPtrType = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +0000937 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
938 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +0000939 "a0:0:64-f80:128:128-n8:16:32";
Edwin Török2d98f9f2009-06-30 17:00:25 +0000940 }
941
Eli Friedman872996c2008-08-20 02:34:37 +0000942};
Daniel Dunbar64c77a12009-06-29 20:52:51 +0000943} // end anonymous namespace
944
945namespace {
Eli Friedman23cb7912008-08-21 01:40:19 +0000946// x86-32 Windows target
947class WindowsX86_32TargetInfo : public X86_32TargetInfo {
948public:
949 WindowsX86_32TargetInfo(const std::string& triple)
950 : X86_32TargetInfo(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +0000951 TLSSupported = false;
Chris Lattnera8a69e12009-06-24 17:12:15 +0000952 WCharType = UnsignedShort;
Eli Friedmanb28055e2009-06-08 21:16:17 +0000953 DoubleAlign = LongLongAlign = 64;
954 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
955 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +0000956 "a0:0:64-f80:32:32-n8:16:32";
Eli Friedman23cb7912008-08-21 01:40:19 +0000957 }
Chris Lattner79682402009-03-20 15:52:06 +0000958 virtual void getTargetDefines(const LangOptions &Opts,
959 std::vector<char> &Defines) const {
960 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Eli Friedman23cb7912008-08-21 01:40:19 +0000961 // This list is based off of the the list of things MingW defines
Eli Friedman23cb7912008-08-21 01:40:19 +0000962 Define(Defines, "_WIN32");
Chris Lattnerc345a802009-03-20 16:06:38 +0000963 DefineStd(Defines, "WIN32", Opts);
964 DefineStd(Defines, "WINNT", Opts);
Eli Friedman23cb7912008-08-21 01:40:19 +0000965 Define(Defines, "_X86_");
Eli Friedman23cb7912008-08-21 01:40:19 +0000966 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +0000967};
968} // end anonymous namespace
Eli Friedman6b6ca942009-06-08 06:11:14 +0000969
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +0000970namespace {
971
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +0000972// x86-32 Windows Visual Studio target
973class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
974public:
975 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
976 : WindowsX86_32TargetInfo(triple) {
977 }
978 virtual void getTargetDefines(const LangOptions &Opts,
979 std::vector<char> &Defines) const {
980 WindowsX86_32TargetInfo::getTargetDefines(Opts, Defines);
981 // The value of the following reflects processor type.
982 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
983 // We lost the original triple, so we use the default.
984 Define(Defines, "_M_IX86", "600");
985 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +0000986};
987} // end anonymous namespace
988
989namespace {
990// x86-32 MinGW target
991class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
992public:
993 MinGWX86_32TargetInfo(const std::string& triple)
994 : WindowsX86_32TargetInfo(triple) {
995 }
996 virtual void getTargetDefines(const LangOptions &Opts,
997 std::vector<char> &Defines) const {
998 WindowsX86_32TargetInfo::getTargetDefines(Opts, Defines);
999 Define(Defines, "__MSVCRT__");
1000 Define(Defines, "__MINGW32__");
Cédric Venet2c16e4e2009-09-27 10:09:11 +00001001 Define(Defines, "__declspec", "__declspec");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001002 }
1003};
1004} // end anonymous namespace
1005
1006namespace {
1007// x86-32 Cygwin target
1008class CygwinX86_32TargetInfo : public X86_32TargetInfo {
1009public:
1010 CygwinX86_32TargetInfo(const std::string& triple)
1011 : X86_32TargetInfo(triple) {
1012 TLSSupported = false;
1013 WCharType = UnsignedShort;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001014 DoubleAlign = LongLongAlign = 64;
1015 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1016 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001017 "a0:0:64-f80:32:32-n8:16:32";
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001018 }
1019 virtual void getTargetDefines(const LangOptions &Opts,
1020 std::vector<char> &Defines) const {
1021 X86_32TargetInfo::getTargetDefines(Opts, Defines);
1022 Define(Defines, "__CYGWIN__");
1023 Define(Defines, "__CYGWIN32__");
1024 DefineStd(Defines, "unix", Opts);
Eli Friedman6b6ca942009-06-08 06:11:14 +00001025 }
Eli Friedman23cb7912008-08-21 01:40:19 +00001026};
1027} // end anonymous namespace
1028
1029namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001030// x86-64 generic target
1031class X86_64TargetInfo : public X86TargetInfo {
1032public:
Chris Lattner79682402009-03-20 15:52:06 +00001033 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +00001034 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001035 LongDoubleWidth = 128;
1036 LongDoubleAlign = 128;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00001037 IntMaxType = SignedLong;
1038 UIntMaxType = UnsignedLong;
Eli Friedman38e31802009-07-01 03:36:11 +00001039 Int64Type = SignedLong;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +00001040 RegParmMax = 6;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00001041
Eli Friedman2b161652008-08-21 00:13:15 +00001042 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1043 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001044 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64";
Chris Lattner4b009652007-07-25 00:24:17 +00001045 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +00001046 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001047 return "typedef struct __va_list_tag {"
1048 " unsigned gp_offset;"
1049 " unsigned fp_offset;"
1050 " void* overflow_arg_area;"
1051 " void* reg_save_area;"
Eli Friedman3c79eee2009-07-03 00:45:06 +00001052 "} __va_list_tag;"
1053 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson7dd1c952007-11-24 23:38:12 +00001054 }
Chris Lattneraa339182009-09-23 06:06:36 +00001055
1056 int getEHDataRegisterNumber(unsigned RegNo) const {
1057 if (RegNo == 0) return 0;
1058 if (RegNo == 1) return 1;
1059 return -1;
1060 }
Eli Friedman872996c2008-08-20 02:34:37 +00001061};
1062} // end anonymous namespace
1063
1064namespace {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001065// x86-64 Windows target
1066class WindowsX86_64TargetInfo : public X86_64TargetInfo {
1067public:
1068 WindowsX86_64TargetInfo(const std::string& triple)
1069 : X86_64TargetInfo(triple) {
1070 TLSSupported = false;
1071 WCharType = UnsignedShort;
Mike Stump4da7a162009-10-08 23:00:00 +00001072 LongWidth = LongAlign = 32;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001073 DoubleAlign = LongLongAlign = 64;
1074 }
1075 virtual void getTargetDefines(const LangOptions &Opts,
1076 std::vector<char> &Defines) const {
1077 X86_64TargetInfo::getTargetDefines(Opts, Defines);
1078 Define(Defines, "_WIN64");
1079 DefineStd(Defines, "WIN64", Opts);
1080 }
1081};
1082} // end anonymous namespace
1083
1084namespace {
1085// x86-64 Windows Visual Studio target
1086class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
1087public:
1088 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
1089 : WindowsX86_64TargetInfo(triple) {
1090 }
1091 virtual void getTargetDefines(const LangOptions &Opts,
1092 std::vector<char> &Defines) const {
1093 WindowsX86_64TargetInfo::getTargetDefines(Opts, Defines);
1094 Define(Defines, "_M_X64");
1095 }
1096 virtual const char *getVAListDeclaration() const {
1097 return "typedef char* va_list;";
1098 }
1099};
1100} // end anonymous namespace
1101
1102namespace {
1103// x86-64 MinGW target
1104class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
1105public:
1106 MinGWX86_64TargetInfo(const std::string& triple)
1107 : WindowsX86_64TargetInfo(triple) {
1108 }
1109 virtual void getTargetDefines(const LangOptions &Opts,
1110 std::vector<char> &Defines) const {
1111 WindowsX86_64TargetInfo::getTargetDefines(Opts, Defines);
1112 Define(Defines, "__MSVCRT__");
1113 Define(Defines, "__MINGW64__");
1114 Define(Defines, "__declspec");
1115 }
1116};
1117} // end anonymous namespace
1118
1119namespace {
Eli Friedman38e31802009-07-01 03:36:11 +00001120class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
1121public:
Mike Stump25cf7602009-09-09 15:08:12 +00001122 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman38e31802009-07-01 03:36:11 +00001123 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
1124 Int64Type = SignedLongLong;
1125 }
1126};
1127} // end anonymous namespace
1128
1129namespace {
Eli Friedman96ada022009-07-05 22:31:18 +00001130class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
1131public:
Mike Stump25cf7602009-09-09 15:08:12 +00001132 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman96ada022009-07-05 22:31:18 +00001133 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
1134 IntMaxType = SignedLongLong;
1135 UIntMaxType = UnsignedLongLong;
1136 Int64Type = SignedLongLong;
1137 }
1138};
1139} // end anonymous namespace
1140
1141namespace {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001142class ARMTargetInfo : public TargetInfo {
Mike Stumpf90a29f2009-04-08 02:07:04 +00001143 enum {
1144 Armv4t,
1145 Armv5,
1146 Armv6,
Mike Stump4e21ba42009-08-04 19:48:52 +00001147 Armv7a,
Mike Stumpf90a29f2009-04-08 02:07:04 +00001148 XScale
1149 } ArmArch;
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001150
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001151 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1152 static const char * const GCCRegNames[];
1153
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001154 std::string ABI;
Daniel Dunbarf0156562009-09-17 16:21:10 +00001155 bool IsThumb;
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001156
Chris Lattner9fd73612008-04-21 18:56:49 +00001157public:
Daniel Dunbarf0156562009-09-17 16:21:10 +00001158 ARMTargetInfo(const std::string &TripleStr)
1159 : TargetInfo(TripleStr), ABI("aapcs-linux"), IsThumb(false)
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001160 {
Daniel Dunbarf0156562009-09-17 16:21:10 +00001161 llvm::Triple Triple(TripleStr);
1162
Daniel Dunbarb9531632009-09-14 00:02:24 +00001163 SizeType = UnsignedInt;
1164 PtrDiffType = SignedInt;
Daniel Dunbarf0156562009-09-17 16:21:10 +00001165
1166 // FIXME: This shouldn't be done this way, we should use features to
1167 // indicate the arch. See lib/Driver/Tools.cpp.
1168 llvm::StringRef Version(""), Arch = Triple.getArchName();
1169 if (Arch.startswith("arm"))
1170 Version = Arch.substr(3);
1171 else if (Arch.startswith("thumb"))
1172 Version = Arch.substr(5);
1173 if (Version == "v7")
Mike Stump4e21ba42009-08-04 19:48:52 +00001174 ArmArch = Armv7a;
Daniel Dunbarf0156562009-09-17 16:21:10 +00001175 else if (Version.empty() || Version == "v6" || Version == "v6t2")
Mike Stumpf90a29f2009-04-08 02:07:04 +00001176 ArmArch = Armv6;
Daniel Dunbarf0156562009-09-17 16:21:10 +00001177 else if (Version == "v5")
Mike Stumpf90a29f2009-04-08 02:07:04 +00001178 ArmArch = Armv5;
Daniel Dunbarf0156562009-09-17 16:21:10 +00001179 else if (Version == "v4t")
Mike Stumpf90a29f2009-04-08 02:07:04 +00001180 ArmArch = Armv4t;
Daniel Dunbarf0156562009-09-17 16:21:10 +00001181 else if (Arch == "xscale" || Arch == "thumbv5e")
Mike Stumpf90a29f2009-04-08 02:07:04 +00001182 ArmArch = XScale;
Daniel Dunbarf0156562009-09-17 16:21:10 +00001183 else
Chris Lattner433d9722009-04-23 04:22:04 +00001184 ArmArch = Armv6;
Daniel Dunbarf0156562009-09-17 16:21:10 +00001185
1186 if (Arch.startswith("thumb"))
1187 IsThumb = true;
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001188
1189 if (IsThumb) {
1190 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1191 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001192 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001193 } else {
1194 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1195 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001196 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001197 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001198 }
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001199 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbarb9531632009-09-14 00:02:24 +00001200 virtual bool setABI(const std::string &Name) {
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001201 ABI = Name;
1202
Daniel Dunbarb9531632009-09-14 00:02:24 +00001203 // The defaults (above) are for AAPCS, check if we need to change them.
1204 //
1205 // FIXME: We need support for -meabi... we could just mangle it into the
1206 // name.
1207 if (Name == "apcs-gnu") {
1208 DoubleAlign = LongLongAlign = 32;
1209 SizeType = UnsignedLong;
1210
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001211 if (IsThumb) {
1212 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1213 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001214 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001215 } else {
1216 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1217 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001218 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001219 }
1220
Daniel Dunbarb9531632009-09-14 00:02:24 +00001221 // FIXME: Override "preferred align" for double and long long.
1222 } else if (Name == "aapcs") {
1223 // FIXME: Enumerated types are variable width in straight AAPCS.
1224 } else if (Name == "aapcs-linux") {
1225 ;
1226 } else
1227 return false;
1228
1229 return true;
1230 }
Chris Lattner79682402009-03-20 15:52:06 +00001231 virtual void getTargetDefines(const LangOptions &Opts,
1232 std::vector<char> &Defs) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00001233 // Target identification.
1234 Define(Defs, "__arm");
1235 Define(Defs, "__arm__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001236
Chris Lattnerbef1d722009-03-02 22:27:17 +00001237 // Target properties.
1238 Define(Defs, "__LITTLE_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001239
Mike Stumpf90a29f2009-04-08 02:07:04 +00001240 // Subtarget options.
Daniel Dunbarf0156562009-09-17 16:21:10 +00001241 //
1242 // FIXME: Neither THUMB_INTERWORK nor SOFTFP is not being set correctly
1243 // here.
Mike Stump4e21ba42009-08-04 19:48:52 +00001244 if (ArmArch == Armv7a) {
1245 Define(Defs, "__ARM_ARCH_7A__");
1246 Define(Defs, "__THUMB_INTERWORK__");
1247 } else if (ArmArch == Armv6) {
Mike Stumpf90a29f2009-04-08 02:07:04 +00001248 Define(Defs, "__ARM_ARCH_6K__");
1249 Define(Defs, "__THUMB_INTERWORK__");
1250 } else if (ArmArch == Armv5) {
1251 Define(Defs, "__ARM_ARCH_5TEJ__");
1252 Define(Defs, "__THUMB_INTERWORK__");
1253 Define(Defs, "__SOFTFP__");
1254 } else if (ArmArch == Armv4t) {
1255 Define(Defs, "__ARM_ARCH_4T__");
1256 Define(Defs, "__SOFTFP__");
1257 } else if (ArmArch == XScale) {
1258 Define(Defs, "__ARM_ARCH_5TE__");
1259 Define(Defs, "__XSCALE__");
1260 Define(Defs, "__SOFTFP__");
1261 }
Daniel Dunbarf0156562009-09-17 16:21:10 +00001262
Chris Lattnerbef1d722009-03-02 22:27:17 +00001263 Define(Defs, "__ARMEL__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001264
1265 if (IsThumb) {
1266 Define(Defs, "__THUMBEL__");
1267 Define(Defs, "__thumb__");
1268 if (ArmArch == Armv7a)
1269 Define(Defs, "__thumb2__");
1270 }
1271
1272 // Note, this is always on in gcc, even though it doesn't make sense.
Eli Friedman468ca6d2009-05-29 19:00:15 +00001273 Define(Defs, "__APCS_32__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001274 // FIXME: This should be conditional on VFP instruction support.
Eli Friedman468ca6d2009-05-29 19:00:15 +00001275 Define(Defs, "__VFP_FP__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001276
1277 Define(Defs, "__USING_SJLJ_EXCEPTIONS__");
Chris Lattner9fd73612008-04-21 18:56:49 +00001278 }
1279 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1280 unsigned &NumRecords) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001281 // FIXME: Implement.
1282 Records = 0;
Chris Lattner9fd73612008-04-21 18:56:49 +00001283 NumRecords = 0;
1284 }
1285 virtual const char *getVAListDeclaration() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001286 return "typedef char* __builtin_va_list;";
Chris Lattner9fd73612008-04-21 18:56:49 +00001287 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001288 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001289 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001290 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001291 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001292 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001293 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001294 // FIXME: Check if this is complete
Anders Carlsson36834a72009-02-28 17:11:49 +00001295 switch (*Name) {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001296 default:
Nate Begeman222823a2008-04-22 05:03:19 +00001297 case 'l': // r0-r7
1298 case 'h': // r8-r15
1299 case 'w': // VFP Floating point register single precision
1300 case 'P': // VFP Floating point register double precision
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001301 Info.setAllowsRegister();
Nate Begeman222823a2008-04-22 05:03:19 +00001302 return true;
1303 }
Chris Lattner9fd73612008-04-21 18:56:49 +00001304 return false;
1305 }
1306 virtual const char *getClobbers() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001307 // FIXME: Is this really right?
Chris Lattner9fd73612008-04-21 18:56:49 +00001308 return "";
1309 }
1310};
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001311
1312const char * const ARMTargetInfo::GCCRegNames[] = {
1313 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1314 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1315};
1316
1317void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
1318 unsigned &NumNames) const {
1319 Names = GCCRegNames;
1320 NumNames = llvm::array_lengthof(GCCRegNames);
1321}
1322
1323const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
1324
1325 { { "a1" }, "r0" },
1326 { { "a2" }, "r1" },
1327 { { "a3" }, "r2" },
1328 { { "a4" }, "r3" },
1329 { { "v1" }, "r4" },
1330 { { "v2" }, "r5" },
1331 { { "v3" }, "r6" },
1332 { { "v4" }, "r7" },
1333 { { "v5" }, "r8" },
1334 { { "v6", "rfp" }, "r9" },
1335 { { "sl" }, "r10" },
1336 { { "fp" }, "r11" },
1337 { { "ip" }, "r12" },
1338 { { "sp" }, "r13" },
1339 { { "lr" }, "r14" },
1340 { { "pc" }, "r15" },
1341};
1342
1343void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1344 unsigned &NumAliases) const {
1345 Aliases = GCCRegAliases;
1346 NumAliases = llvm::array_lengthof(GCCRegAliases);
1347}
Chris Lattner9fd73612008-04-21 18:56:49 +00001348} // end anonymous namespace.
1349
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001350
1351namespace {
Mike Stump25cf7602009-09-09 15:08:12 +00001352class DarwinARMTargetInfo :
Edwin Török36565e52009-06-30 17:10:35 +00001353 public DarwinTargetInfo<ARMTargetInfo> {
1354protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +00001355 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Edwin Török36565e52009-06-30 17:10:35 +00001356 std::vector<char> &Defines) const {
1357 getDarwinDefines(Defines, Opts);
1358 getDarwinIPhoneOSDefines(Defines, Triple);
Eli Friedman8f575172009-04-19 21:38:35 +00001359 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001360
Edwin Török36565e52009-06-30 17:10:35 +00001361public:
Mike Stump25cf7602009-09-09 15:08:12 +00001362 DarwinARMTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +00001363 : DarwinTargetInfo<ARMTargetInfo>(triple) {}
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001364};
1365} // end anonymous namespace.
1366
Chris Lattner4b009652007-07-25 00:24:17 +00001367namespace {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001368class SparcV8TargetInfo : public TargetInfo {
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001369 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1370 static const char * const GCCRegNames[];
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001371public:
Eli Friedmanff158dd2008-08-20 07:28:14 +00001372 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
1373 // FIXME: Support Sparc quad-precision long double?
Eli Friedman2b161652008-08-21 00:13:15 +00001374 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 +00001375 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedmanff158dd2008-08-20 07:28:14 +00001376 }
Chris Lattner79682402009-03-20 15:52:06 +00001377 virtual void getTargetDefines(const LangOptions &Opts,
1378 std::vector<char> &Defines) const {
Eli Friedmana456b7f2009-05-22 01:12:57 +00001379 DefineStd(Defines, "sparc", Opts);
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001380 Define(Defines, "__sparcv8");
Eli Friedmana456b7f2009-05-22 01:12:57 +00001381 Define(Defines, "__REGISTER_PREFIX__", "");
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001382 }
1383 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1384 unsigned &NumRecords) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001385 // FIXME: Implement!
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001386 }
1387 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001388 return "typedef void* __builtin_va_list;";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001389 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001390 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001391 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001392 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001393 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001394 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001395 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001396 // FIXME: Implement!
1397 return false;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001398 }
1399 virtual const char *getClobbers() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001400 // FIXME: Implement!
1401 return "";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001402 }
1403};
1404
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001405const char * const SparcV8TargetInfo::GCCRegNames[] = {
1406 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1407 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1408 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1409 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
1410};
1411
Anton Korobeynikove7772382009-05-03 13:42:53 +00001412void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001413 unsigned &NumNames) const {
1414 Names = GCCRegNames;
1415 NumNames = llvm::array_lengthof(GCCRegNames);
1416}
1417
1418const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikove7772382009-05-03 13:42:53 +00001419 { { "g0" }, "r0" },
1420 { { "g1" }, "r1" },
1421 { { "g2" }, "r2" },
1422 { { "g3" }, "r3" },
1423 { { "g4" }, "r4" },
1424 { { "g5" }, "r5" },
1425 { { "g6" }, "r6" },
1426 { { "g7" }, "r7" },
1427 { { "o0" }, "r8" },
1428 { { "o1" }, "r9" },
1429 { { "o2" }, "r10" },
1430 { { "o3" }, "r11" },
1431 { { "o4" }, "r12" },
1432 { { "o5" }, "r13" },
1433 { { "o6", "sp" }, "r14" },
1434 { { "o7" }, "r15" },
1435 { { "l0" }, "r16" },
1436 { { "l1" }, "r17" },
1437 { { "l2" }, "r18" },
1438 { { "l3" }, "r19" },
1439 { { "l4" }, "r20" },
1440 { { "l5" }, "r21" },
1441 { { "l6" }, "r22" },
1442 { { "l7" }, "r23" },
1443 { { "i0" }, "r24" },
1444 { { "i1" }, "r25" },
1445 { { "i2" }, "r26" },
1446 { { "i3" }, "r27" },
1447 { { "i4" }, "r28" },
1448 { { "i5" }, "r29" },
1449 { { "i6", "fp" }, "r30" },
1450 { { "i7" }, "r31" },
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001451};
1452
Anton Korobeynikove7772382009-05-03 13:42:53 +00001453void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001454 unsigned &NumAliases) const {
1455 Aliases = GCCRegAliases;
1456 NumAliases = llvm::array_lengthof(GCCRegAliases);
1457}
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001458} // end anonymous namespace.
1459
Eli Friedmanff158dd2008-08-20 07:28:14 +00001460namespace {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00001461class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
1462public:
1463 AuroraUXSparcV8TargetInfo(const std::string& triple) :
1464 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
1465 SizeType = UnsignedInt;
1466 PtrDiffType = SignedInt;
1467 }
1468};
Edwin Török36565e52009-06-30 17:10:35 +00001469class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001470public:
1471 SolarisSparcV8TargetInfo(const std::string& triple) :
Edwin Török36565e52009-06-30 17:10:35 +00001472 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedman7cca0982008-11-02 02:43:55 +00001473 SizeType = UnsignedInt;
1474 PtrDiffType = SignedInt;
Eli Friedmanff158dd2008-08-20 07:28:14 +00001475 }
1476};
1477} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +00001478
Chris Lattner85970f32008-05-08 05:58:21 +00001479namespace {
1480 class PIC16TargetInfo : public TargetInfo{
1481 public:
1482 PIC16TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +00001483 TLSSupported = false;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001484 IntWidth = 16;
1485 LongWidth = LongLongWidth = 32;
1486 PointerWidth = 16;
1487 IntAlign = 8;
1488 LongAlign = LongLongAlign = 8;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001489 PointerAlign = 8;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001490 SizeType = UnsignedInt;
1491 IntMaxType = SignedLong;
1492 UIntMaxType = UnsignedLong;
Chris Lattnerd9ef7242009-02-13 22:28:55 +00001493 IntPtrType = SignedShort;
Eli Friedman7cca0982008-11-02 02:43:55 +00001494 PtrDiffType = SignedInt;
Sanjiv Guptaae8f1e82009-06-02 04:43:46 +00001495 FloatWidth = 32;
1496 FloatAlign = 32;
1497 DoubleWidth = 32;
1498 DoubleAlign = 32;
1499 LongDoubleWidth = 32;
1500 LongDoubleAlign = 32;
1501 FloatFormat = &llvm::APFloat::IEEEsingle;
1502 DoubleFormat = &llvm::APFloat::IEEEsingle;
1503 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner2e17d912009-11-07 18:59:41 +00001504 DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8-f32:32:32-n8";
Sanjiv Guptaae8f1e82009-06-02 04:43:46 +00001505
Chris Lattner85970f32008-05-08 05:58:21 +00001506 }
Chris Lattner727b3c42008-05-09 06:08:39 +00001507 virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }
1508 virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }
Chris Lattner79682402009-03-20 15:52:06 +00001509 virtual void getTargetDefines(const LangOptions &Opts,
1510 std::vector<char> &Defines) const {
Chris Lattner85970f32008-05-08 05:58:21 +00001511 Define(Defines, "__pic16");
Sanjiv Guptad75fd0b2009-07-07 04:42:23 +00001512 Define(Defines, "rom", "__attribute__((address_space(1)))");
1513 Define(Defines, "ram", "__attribute__((address_space(0)))");
Mike Stump25cf7602009-09-09 15:08:12 +00001514 Define(Defines, "_section(SectName)",
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00001515 "__attribute__((section(SectName)))");
Sanjiv Gupta09e95f02009-10-24 18:08:20 +00001516 Define(Defines, "near",
1517 "__attribute__((section(\"Address=NEAR\")))");
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00001518 Define(Defines, "_address(Addr)",
1519 "__attribute__((section(\"Address=\"#Addr)))");
Sanjiv Guptad75fd0b2009-07-07 04:42:23 +00001520 Define(Defines, "_CONFIG(conf)", "asm(\"CONFIG \"#conf)");
Sanjiv Gupta9e2b9e02009-08-20 17:48:52 +00001521 Define(Defines, "_interrupt",
1522 "__attribute__((section(\"interrupt=0x4\"))) \
1523 __attribute__((used))");
Chris Lattner85970f32008-05-08 05:58:21 +00001524 }
1525 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1526 unsigned &NumRecords) const {}
Mike Stump25cf7602009-09-09 15:08:12 +00001527 virtual const char *getVAListDeclaration() const {
Daniel Dunbar2e967de2009-08-24 09:54:37 +00001528 return "";
1529 }
1530 virtual const char *getClobbers() const {
1531 return "";
1532 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001533 virtual void getGCCRegNames(const char * const *&Names,
1534 unsigned &NumNames) const {}
1535 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner85970f32008-05-08 05:58:21 +00001536 TargetInfo::ConstraintInfo &info) const {
1537 return true;
1538 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001539 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner85970f32008-05-08 05:58:21 +00001540 unsigned &NumAliases) const {}
1541 virtual bool useGlobalsForAutomaticVariables() const {return true;}
1542 };
1543}
1544
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001545namespace {
1546 class MSP430TargetInfo : public TargetInfo {
1547 static const char * const GCCRegNames[];
1548 public:
1549 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
1550 TLSSupported = false;
1551 IntWidth = 16;
1552 LongWidth = LongLongWidth = 32;
1553 PointerWidth = 16;
1554 IntAlign = 8;
1555 LongAlign = LongLongAlign = 8;
1556 PointerAlign = 8;
1557 SizeType = UnsignedInt;
1558 IntMaxType = SignedLong;
1559 UIntMaxType = UnsignedLong;
1560 IntPtrType = SignedShort;
1561 PtrDiffType = SignedInt;
Chris Lattner2e17d912009-11-07 18:59:41 +00001562 DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8-n8:16";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001563 }
1564 virtual void getTargetDefines(const LangOptions &Opts,
1565 std::vector<char> &Defines) const {
1566 Define(Defines, "MSP430");
1567 Define(Defines, "__MSP430__");
1568 // FIXME: defines for different 'flavours' of MCU
1569 }
1570 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1571 unsigned &NumRecords) const {
1572 // FIXME: Implement.
1573 Records = 0;
1574 NumRecords = 0;
1575 }
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001576 virtual void getGCCRegNames(const char * const *&Names,
1577 unsigned &NumNames) const;
1578 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1579 unsigned &NumAliases) const {
1580 // No aliases.
1581 Aliases = 0;
1582 NumAliases = 0;
1583 }
1584 virtual bool validateAsmConstraint(const char *&Name,
1585 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov174219b2009-10-15 23:17:13 +00001586 // No target constraints for now.
1587 return false;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001588 }
1589 virtual const char *getClobbers() const {
1590 // FIXME: Is this really right?
1591 return "";
1592 }
1593 virtual const char *getVAListDeclaration() const {
1594 // FIXME: implement
Anton Korobeynikovf5955592009-05-08 18:24:57 +00001595 return "typedef char* __builtin_va_list;";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001596 }
1597 };
1598
1599 const char * const MSP430TargetInfo::GCCRegNames[] = {
1600 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1601 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1602 };
1603
1604 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
1605 unsigned &NumNames) const {
1606 Names = GCCRegNames;
1607 NumNames = llvm::array_lengthof(GCCRegNames);
1608 }
1609}
1610
1611
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001612namespace {
1613 class SystemZTargetInfo : public TargetInfo {
1614 static const char * const GCCRegNames[];
1615 public:
1616 SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
1617 TLSSupported = false;
1618 IntWidth = IntAlign = 32;
1619 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
1620 PointerWidth = PointerAlign = 64;
Chris Lattner2e17d912009-11-07 18:59:41 +00001621 DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
1622 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001623 }
1624 virtual void getTargetDefines(const LangOptions &Opts,
1625 std::vector<char> &Defines) const {
1626 Define(Defines, "__s390__");
1627 Define(Defines, "__s390x__");
1628 }
1629 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1630 unsigned &NumRecords) const {
1631 // FIXME: Implement.
1632 Records = 0;
1633 NumRecords = 0;
1634 }
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001635
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00001636 virtual void getGCCRegNames(const char * const *&Names,
1637 unsigned &NumNames) const;
1638 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1639 unsigned &NumAliases) const {
1640 // No aliases.
1641 Aliases = 0;
1642 NumAliases = 0;
1643 }
1644 virtual bool validateAsmConstraint(const char *&Name,
1645 TargetInfo::ConstraintInfo &info) const {
1646 // FIXME: implement
1647 return true;
1648 }
1649 virtual const char *getClobbers() const {
1650 // FIXME: Is this really right?
1651 return "";
1652 }
1653 virtual const char *getVAListDeclaration() const {
1654 // FIXME: implement
1655 return "typedef char* __builtin_va_list;";
1656 }
1657 };
1658
1659 const char * const SystemZTargetInfo::GCCRegNames[] = {
1660 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1661 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1662 };
1663
1664 void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
1665 unsigned &NumNames) const {
1666 Names = GCCRegNames;
1667 NumNames = llvm::array_lengthof(GCCRegNames);
1668 }
1669}
1670
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001671namespace {
1672 class BlackfinTargetInfo : public TargetInfo {
1673 static const char * const GCCRegNames[];
1674 public:
1675 BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
1676 TLSSupported = false;
1677 DoubleAlign = 32;
1678 LongLongAlign = 32;
1679 LongDoubleAlign = 32;
Chris Lattner2e17d912009-11-07 18:59:41 +00001680 DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001681 }
1682
1683 virtual void getTargetDefines(const LangOptions &Opts,
1684 std::vector<char> &Defines) const {
1685 DefineStd(Defines, "bfin", Opts);
1686 DefineStd(Defines, "BFIN", Opts);
1687 Define(Defines, "__ADSPBLACKFIN__");
1688 // FIXME: This one is really dependent on -mcpu
1689 Define(Defines, "__ADSPLPBLACKFIN__");
1690 // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
1691 }
1692
1693 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1694 unsigned &NumRecords) const {
1695 // FIXME: Implement.
1696 Records = 0;
1697 NumRecords = 0;
1698 }
1699
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001700 virtual void getGCCRegNames(const char * const *&Names,
1701 unsigned &NumNames) const;
1702
1703 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1704 unsigned &NumAliases) const {
1705 // No aliases.
1706 Aliases = 0;
1707 NumAliases = 0;
1708 }
1709
1710 virtual bool validateAsmConstraint(const char *&Name,
1711 TargetInfo::ConstraintInfo &Info) const {
1712 if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
1713 Info.setAllowsRegister();
1714 return true;
1715 }
1716 return false;
1717 }
1718
1719 virtual const char *getClobbers() const {
1720 return "";
1721 }
1722
1723 virtual const char *getVAListDeclaration() const {
1724 return "typedef char* __builtin_va_list;";
1725 }
1726 };
1727
1728 const char * const BlackfinTargetInfo::GCCRegNames[] = {
1729 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1730 "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
1731 "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
1732 "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
1733 "a0", "a1", "cc",
1734 "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
1735 "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
1736 };
1737
1738 void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
1739 unsigned &NumNames) const {
1740 Names = GCCRegNames;
1741 NumNames = llvm::array_lengthof(GCCRegNames);
1742 }
1743}
1744
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00001745namespace {
1746
Mike Stump25cf7602009-09-09 15:08:12 +00001747 // LLVM and Clang cannot be used directly to output native binaries for
1748 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00001749 // type and alignment information.
Mike Stump25cf7602009-09-09 15:08:12 +00001750 //
1751 // TCE uses the llvm bitcode as input and uses it for generating customized
1752 // target processor and program binary. TCE co-design environment is
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00001753 // publicly available in http://tce.cs.tut.fi
1754
1755 class TCETargetInfo : public TargetInfo{
1756 public:
1757 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
1758 TLSSupported = false;
1759 IntWidth = 32;
1760 LongWidth = LongLongWidth = 32;
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00001761 PointerWidth = 32;
1762 IntAlign = 32;
1763 LongAlign = LongLongAlign = 32;
1764 PointerAlign = 32;
1765 SizeType = UnsignedInt;
1766 IntMaxType = SignedLong;
1767 UIntMaxType = UnsignedLong;
1768 IntPtrType = SignedInt;
1769 PtrDiffType = SignedInt;
1770 FloatWidth = 32;
1771 FloatAlign = 32;
1772 DoubleWidth = 32;
1773 DoubleAlign = 32;
1774 LongDoubleWidth = 32;
1775 LongDoubleAlign = 32;
1776 FloatFormat = &llvm::APFloat::IEEEsingle;
1777 DoubleFormat = &llvm::APFloat::IEEEsingle;
1778 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
1779 DescriptionString = "E-p:32:32:32-a0:32:32"
1780 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64"
Chris Lattner2e17d912009-11-07 18:59:41 +00001781 "-f32:32:32-f64:32:64-n32";
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00001782 }
1783
1784 virtual void getTargetDefines(const LangOptions &Opts,
1785 std::vector<char> &Defines) const {
1786 DefineStd(Defines, "tce", Opts);
1787 Define(Defines, "__TCE__");
1788 Define(Defines, "__TCE_V1__");
1789 }
1790 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1791 unsigned &NumRecords) const {}
Daniel Dunbar2e967de2009-08-24 09:54:37 +00001792 virtual const char *getClobbers() const {
1793 return "";
1794 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00001795 virtual const char *getVAListDeclaration() const {
1796 return "typedef void* __builtin_va_list;";
1797 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00001798 virtual void getGCCRegNames(const char * const *&Names,
1799 unsigned &NumNames) const {}
1800 virtual bool validateAsmConstraint(const char *&Name,
1801 TargetInfo::ConstraintInfo &info) const {
1802 return true;
1803 }
1804 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1805 unsigned &NumAliases) const {}
1806 };
1807}
1808
Edward O'Callaghan097309f2009-11-15 10:22:07 +00001809namespace {
1810class MipsTargetInfo : public TargetInfo {
1811 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1812 static const char * const GCCRegNames[];
1813public:
1814 MipsTargetInfo(const std::string& triple) : TargetInfo(triple) {
1815 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
1816 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
1817 }
1818 virtual void getTargetDefines(const LangOptions &Opts,
1819 std::vector<char> &Defines) const {
1820 DefineStd(Defines, "mips", Opts);
1821 Define(Defines, "_mips");
1822 DefineStd(Defines, "MIPSEB", Opts);
1823 Define(Defines, "_MIPSEB");
1824 Define(Defines, "__REGISTER_PREFIX__", "");
1825 }
1826 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1827 unsigned &NumRecords) const {
1828 // FIXME: Implement!
1829 }
1830 virtual const char *getVAListDeclaration() const {
1831 return "typedef void* __builtin_va_list;";
1832 }
1833 virtual void getGCCRegNames(const char * const *&Names,
1834 unsigned &NumNames) const;
1835 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1836 unsigned &NumAliases) const;
1837 virtual bool validateAsmConstraint(const char *&Name,
1838 TargetInfo::ConstraintInfo &Info) const {
1839 switch (*Name) {
1840 default:
1841 case 'r': // CPU registers.
1842 case 'd': // Equivalent to "r" unless generating MIPS16 code.
1843 case 'y': // Equivalent to "r", backwards compatibility only.
1844 case 'f': // floating-point registers.
1845 Info.setAllowsRegister();
1846 return true;
1847 }
1848 return false;
1849 }
1850
1851 virtual const char *getClobbers() const {
1852 // FIXME: Implement!
1853 return "";
1854 }
1855};
1856
1857const char * const MipsTargetInfo::GCCRegNames[] = {
1858 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
1859 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
1860 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
1861 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
1862 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1863 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1864 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1865 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1866 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
1867 "$fcc5","$fcc6","$fcc7"
1868};
1869
1870void MipsTargetInfo::getGCCRegNames(const char * const *&Names,
1871 unsigned &NumNames) const {
1872 Names = GCCRegNames;
1873 NumNames = llvm::array_lengthof(GCCRegNames);
1874}
1875
1876const TargetInfo::GCCRegAlias MipsTargetInfo::GCCRegAliases[] = {
1877 { { "at" }, "$1" },
1878 { { "v0" }, "$2" },
1879 { { "v1" }, "$3" },
1880 { { "a0" }, "$4" },
1881 { { "a1" }, "$5" },
1882 { { "a2" }, "$6" },
1883 { { "a3" }, "$7" },
1884 { { "t0" }, "$8" },
1885 { { "t1" }, "$9" },
1886 { { "t2" }, "$10" },
1887 { { "t3" }, "$11" },
1888 { { "t4" }, "$12" },
1889 { { "t5" }, "$13" },
1890 { { "t6" }, "$14" },
1891 { { "t7" }, "$15" },
1892 { { "s0" }, "$16" },
1893 { { "s1" }, "$17" },
1894 { { "s2" }, "$18" },
1895 { { "s3" }, "$19" },
1896 { { "s4" }, "$20" },
1897 { { "s5" }, "$21" },
1898 { { "s6" }, "$22" },
1899 { { "s7" }, "$23" },
1900 { { "t8" }, "$24" },
1901 { { "t9" }, "$25" },
1902 { { "k0" }, "$26" },
1903 { { "k1" }, "$27" },
1904 { { "gp" }, "$28" },
1905 { { "sp" }, "$29" },
1906 { { "fp" }, "$30" },
1907 { { "ra" }, "$31" }
1908};
1909
1910void MipsTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1911 unsigned &NumAliases) const {
1912 Aliases = GCCRegAliases;
1913 NumAliases = llvm::array_lengthof(GCCRegAliases);
1914}
1915} // end anonymous namespace.
1916
1917namespace {
1918class MipselTargetInfo : public MipsTargetInfo {
1919public:
1920 MipselTargetInfo(const std::string& triple) : MipsTargetInfo(triple) {
1921 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
1922 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
1923 }
1924
1925 virtual void getTargetDefines(const LangOptions &Opts,
1926 std::vector<char> &Defines) const;
1927};
1928
1929void MipselTargetInfo::getTargetDefines(const LangOptions &Opts,
1930 std::vector<char> &Defines) const {
1931 DefineStd(Defines, "mips", Opts);
1932 Define(Defines, "_mips");
1933 DefineStd(Defines, "MIPSEL", Opts);
1934 Define(Defines, "_MIPSEL");
1935 Define(Defines, "__REGISTER_PREFIX__", "");
1936}
1937} // end anonymous namespace.
1938
Chris Lattner4b009652007-07-25 00:24:17 +00001939//===----------------------------------------------------------------------===//
1940// Driver code
1941//===----------------------------------------------------------------------===//
1942
Daniel Dunbarca3e9912009-11-15 06:48:46 +00001943static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00001944 llvm::Triple Triple(T);
1945 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001946
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00001947 switch (Triple.getArch()) {
1948 default:
1949 return NULL;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001950
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00001951 case llvm::Triple::arm:
Daniel Dunbar3f361b52009-09-11 01:14:50 +00001952 case llvm::Triple::thumb:
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00001953 switch (os) {
1954 case llvm::Triple::Darwin:
Eli Friedman2b161652008-08-21 00:13:15 +00001955 return new DarwinARMTargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00001956 case llvm::Triple::FreeBSD:
Edwin Török36565e52009-06-30 17:10:35 +00001957 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00001958 default:
1959 return new ARMTargetInfo(T);
1960 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001961
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00001962 case llvm::Triple::bfin:
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00001963 return new BlackfinTargetInfo(T);
1964
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00001965 case llvm::Triple::msp430:
1966 return new MSP430TargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001967
Edward O'Callaghan097309f2009-11-15 10:22:07 +00001968 case llvm::Triple::mips:
1969 if (os == llvm::Triple::Psp)
1970 return new PSPTargetInfo<MipsTargetInfo>(T);
1971 if (os == llvm::Triple::Linux)
1972 return new LinuxTargetInfo<MipsTargetInfo>(T);
1973 return new MipsTargetInfo(T);
1974
1975 case llvm::Triple::mipsel:
1976 if (os == llvm::Triple::Psp)
1977 return new PSPTargetInfo<MipselTargetInfo>(T);
1978 if (os == llvm::Triple::Linux)
1979 return new LinuxTargetInfo<MipselTargetInfo>(T);
1980 return new MipselTargetInfo(T);
1981
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00001982 case llvm::Triple::pic16:
1983 return new PIC16TargetInfo(T);
1984
1985 case llvm::Triple::ppc:
1986 if (os == llvm::Triple::Darwin)
1987 return new DarwinTargetInfo<PPCTargetInfo>(T);
1988 return new PPC32TargetInfo(T);
1989
1990 case llvm::Triple::ppc64:
1991 if (os == llvm::Triple::Darwin)
1992 return new DarwinTargetInfo<PPC64TargetInfo>(T);
1993 return new PPC64TargetInfo(T);
1994
1995 case llvm::Triple::sparc:
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00001996 if (os == llvm::Triple::AuroraUX)
1997 return new AuroraUXSparcV8TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00001998 if (os == llvm::Triple::Solaris)
1999 return new SolarisSparcV8TargetInfo(T);
2000 return new SparcV8TargetInfo(T);
2001
2002 case llvm::Triple::systemz:
2003 return new SystemZTargetInfo(T);
2004
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002005 case llvm::Triple::tce:
2006 return new TCETargetInfo(T);
2007
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002008 case llvm::Triple::x86:
2009 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002010 case llvm::Triple::AuroraUX:
2011 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002012 case llvm::Triple::Darwin:
2013 return new DarwinI386TargetInfo(T);
2014 case llvm::Triple::Linux:
2015 return new LinuxTargetInfo<X86_32TargetInfo>(T);
2016 case llvm::Triple::DragonFly:
2017 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
2018 case llvm::Triple::NetBSD:
2019 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
2020 case llvm::Triple::OpenBSD:
2021 return new OpenBSDI386TargetInfo(T);
2022 case llvm::Triple::FreeBSD:
2023 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
2024 case llvm::Triple::Solaris:
2025 return new SolarisTargetInfo<X86_32TargetInfo>(T);
2026 case llvm::Triple::Cygwin:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002027 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002028 case llvm::Triple::MinGW32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002029 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002030 case llvm::Triple::Win32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002031 return new VisualStudioWindowsX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002032 default:
2033 return new X86_32TargetInfo(T);
2034 }
2035
2036 case llvm::Triple::x86_64:
2037 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002038 case llvm::Triple::AuroraUX:
2039 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002040 case llvm::Triple::Darwin:
2041 return new DarwinX86_64TargetInfo(T);
2042 case llvm::Triple::Linux:
2043 return new LinuxTargetInfo<X86_64TargetInfo>(T);
2044 case llvm::Triple::NetBSD:
2045 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
2046 case llvm::Triple::OpenBSD:
2047 return new OpenBSDX86_64TargetInfo(T);
2048 case llvm::Triple::FreeBSD:
2049 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
2050 case llvm::Triple::Solaris:
2051 return new SolarisTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002052 case llvm::Triple::MinGW64:
2053 return new MinGWX86_64TargetInfo(T);
2054 case llvm::Triple::Win32: // This is what Triple.h supports now.
2055 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002056 default:
2057 return new X86_64TargetInfo(T);
2058 }
2059 }
Chris Lattner4b009652007-07-25 00:24:17 +00002060}
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002061
2062/// CreateTargetInfo - Return the target info object for the specified target
2063/// triple.
2064TargetInfo *TargetInfo::CreateTargetInfo(Diagnostic &Diags,
2065 const TargetOptions &Opts) {
2066 llvm::Triple Triple(Opts.Triple);
2067
2068 // Construct the target
2069 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
2070 if (!Target) {
2071 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
2072 return 0;
2073 }
2074
2075 // Set the target ABI if specified.
2076 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
2077 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
2078 return 0;
2079 }
2080
2081 // Compute the default target features, we need the target to handle this
2082 // because features may have dependencies on one another.
2083 llvm::StringMap<bool> Features;
2084 Target->getDefaultFeatures(Opts.CPU, Features);
2085
2086 // Apply the user specified deltas.
2087 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
2088 ie = Opts.Features.end(); it != ie; ++it) {
2089 const char *Name = it->c_str();
2090
2091 // Apply the feature via the target.
2092 if ((Name[0] != '-' && Name[0] != '+') ||
2093 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
2094 Diags.Report(diag::err_target_invalid_feature) << Name;
2095 return 0;
2096 }
2097 }
2098
2099 // Add the features to the compile options.
2100 //
2101 // FIXME: If we are completely confident that we have the right set, we only
2102 // need to pass the minuses.
2103 std::vector<std::string> StrFeatures;
2104 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
2105 ie = Features.end(); it != ie; ++it)
2106 StrFeatures.push_back(std::string(it->second ? "+" : "-") + it->first());
2107 Target->HandleTargetFeatures(StrFeatures);
2108
2109 return Target.take();
2110}