Targets.cpp revision b63decfa6e1b165693f1fbfe52d5faec832968f7 
1//===--- Targets.cpp - Implement -arch option and targets -----------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements construction of a TargetInfo object from a
11// target triple.
12//
13//===----------------------------------------------------------------------===//
14
15#include "clang/Basic/Builtins.h"
16#include "clang/Basic/TargetBuiltins.h"
17#include "clang/Basic/TargetInfo.h"
18#include "clang/Basic/LangOptions.h"
19#include "llvm/ADT/APFloat.h"
20#include "llvm/ADT/SmallString.h"
21#include "llvm/ADT/StringRef.h"
22#include "llvm/ADT/STLExtras.h"
23#include "llvm/ADT/Triple.h"
24#include "llvm/MC/MCSectionMachO.h"
25using namespace clang;
26
27//===----------------------------------------------------------------------===//
28//  Common code shared among targets.
29//===----------------------------------------------------------------------===//
30
31static void Define(std::vector<char> &Buf, const llvm::StringRef &Macro,
32                   const llvm::StringRef &Val = "1") {
33  const char *Def = "#define ";
34  Buf.insert(Buf.end(), Def, Def+strlen(Def));
35  Buf.insert(Buf.end(), Macro.begin(), Macro.end());
36  Buf.push_back(' ');
37  Buf.insert(Buf.end(), Val.begin(), Val.end());
38  Buf.push_back('\n');
39}
40
41/// DefineStd - Define a macro name and standard variants.  For example if
42/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
43/// when in GNU mode.
44static void DefineStd(std::vector<char> &Buf, const char *MacroName,
45                      const LangOptions &Opts) {
46  assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
47
48  // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
49  // in the user's namespace.
50  if (Opts.GNUMode)
51    Define(Buf, MacroName);
52
53  // Define __unix.
54  llvm::SmallString<20> TmpStr;
55  TmpStr = "__";
56  TmpStr += MacroName;
57  Define(Buf, TmpStr.str());
58
59  // Define __unix__.
60  TmpStr += "__";
61  Define(Buf, TmpStr.str());
62}
63
64//===----------------------------------------------------------------------===//
65// Defines specific to certain operating systems.
66//===----------------------------------------------------------------------===//
67
68namespace {
69template<typename TgtInfo>
70class OSTargetInfo : public TgtInfo {
71protected:
72  virtual void getOSDefines(const LangOptions &Opts, const char *Triple,
73                            std::vector<char> &Defines) const=0;
74public:
75  OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
76  virtual void getTargetDefines(const LangOptions &Opts,
77                                std::vector<char> &Defines) const {
78    TgtInfo::getTargetDefines(Opts, Defines);
79    getOSDefines(Opts, TgtInfo::getTargetTriple(), Defines);
80  }
81
82};
83} // end anonymous namespace
84
85
86static void getDarwinDefines(std::vector<char> &Defs, const LangOptions &Opts) {
87  Define(Defs, "__APPLE_CC__", "5621");
88  Define(Defs, "__APPLE__");
89  Define(Defs, "__MACH__");
90  Define(Defs, "OBJC_NEW_PROPERTIES");
91
92  // __weak is always defined, for use in blocks and with objc pointers.
93  Define(Defs, "__weak", "__attribute__((objc_gc(weak)))");
94
95  // Darwin defines __strong even in C mode (just to nothing).
96  if (!Opts.ObjC1 || Opts.getGCMode() == LangOptions::NonGC)
97    Define(Defs, "__strong", "");
98  else
99    Define(Defs, "__strong", "__attribute__((objc_gc(strong)))");
100
101  if (Opts.Static)
102    Define(Defs, "__STATIC__");
103  else
104    Define(Defs, "__DYNAMIC__");
105}
106
107static void getDarwinOSXDefines(std::vector<char> &Defs, const char *TripleStr){
108  llvm::Triple TheTriple(TripleStr);
109  if (TheTriple.getOS() != llvm::Triple::Darwin)
110    return;
111
112  // Figure out which "darwin number" the target triple is.  "darwin9" -> 10.5.
113  unsigned Maj, Min, Rev;
114  TheTriple.getDarwinNumber(Maj, Min, Rev);
115
116  char MacOSXStr[] = "1000";
117  if (Maj >= 4 && Maj <= 13) { // 10.0-10.9
118    // darwin7 -> 1030, darwin8 -> 1040, darwin9 -> 1050, etc.
119    MacOSXStr[2] = '0' + Maj-4;
120  }
121
122  // Handle minor version: 10.4.9 -> darwin8.9 -> "1049"
123  // Cap 10.4.11 -> darwin8.11 -> "1049"
124  MacOSXStr[3] = std::min(Min, 9U)+'0';
125  Define(Defs, "__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", MacOSXStr);
126}
127
128static void getDarwinIPhoneOSDefines(std::vector<char> &Defs,
129                                     const char *TripleStr) {
130  llvm::Triple TheTriple(TripleStr);
131  if (TheTriple.getOS() != llvm::Triple::Darwin)
132    return;
133
134  // Figure out which "darwin number" the target triple is.  "darwin9" -> 10.5.
135  unsigned Maj, Min, Rev;
136  TheTriple.getDarwinNumber(Maj, Min, Rev);
137
138  // When targetting iPhone OS, interpret the minor version and
139  // revision as the iPhone OS version
140  char iPhoneOSStr[] = "10000";
141  if (Min >= 2 && Min <= 9) { // iPhone OS 2.0-9.0
142    // darwin9.2.0 -> 20000, darwin9.3.0 -> 30000, etc.
143    iPhoneOSStr[0] = '0' + Min;
144  }
145
146  // Handle minor version: 2.2 -> darwin9.2.2 -> 20200
147  iPhoneOSStr[2] = std::min(Rev, 9U)+'0';
148  Define(Defs, "__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__",
149         iPhoneOSStr);
150}
151
152/// GetDarwinLanguageOptions - Set the default language options for darwin.
153static void GetDarwinLanguageOptions(LangOptions &Opts,
154                                     const char *TripleStr) {
155  Opts.NeXTRuntime = true;
156
157  llvm::Triple TheTriple(TripleStr);
158  if (TheTriple.getOS() != llvm::Triple::Darwin)
159    return;
160
161  unsigned MajorVersion = TheTriple.getDarwinMajorNumber();
162
163  // Blocks and stack protectors default to on for 10.6 (darwin10) and beyond.
164  if (MajorVersion > 9) {
165    Opts.Blocks = 1;
166    Opts.setStackProtectorMode(LangOptions::SSPOn);
167  }
168
169  // Non-fragile ABI (in 64-bit mode) default to on for 10.5 (darwin9) and
170  // beyond.
171  if (MajorVersion >= 9 && Opts.ObjC1 &&
172      TheTriple.getArch() == llvm::Triple::x86_64)
173    Opts.ObjCNonFragileABI = 1;
174}
175
176namespace {
177template<typename Target>
178class DarwinTargetInfo : public OSTargetInfo<Target> {
179protected:
180  virtual void getOSDefines(const LangOptions &Opts, const char *Triple,
181                    std::vector<char> &Defines) const {
182    getDarwinDefines(Defines, Opts);
183    getDarwinOSXDefines(Defines, Triple);
184  }
185
186  /// getDefaultLangOptions - Allow the target to specify default settings for
187  /// various language options.  These may be overridden by command line
188  /// options.
189  virtual void getDefaultLangOptions(LangOptions &Opts) {
190    TargetInfo::getDefaultLangOptions(Opts);
191    GetDarwinLanguageOptions(Opts, TargetInfo::getTargetTriple());
192  }
193public:
194  DarwinTargetInfo(const std::string& triple) :
195    OSTargetInfo<Target>(triple) {
196      this->TLSSupported = false;
197    }
198
199  virtual const char *getUnicodeStringSymbolPrefix() const {
200    return "__utf16_string_";
201  }
202
203  virtual const char *getUnicodeStringSection() const {
204    return "__TEXT,__ustring";
205  }
206
207  virtual std::string isValidSectionSpecifier(const llvm::StringRef &SR) const {
208    // Let MCSectionMachO validate this.
209    llvm::StringRef Segment, Section;
210    unsigned TAA, StubSize;
211    return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
212                                                       TAA, StubSize);
213  }
214};
215
216
217// DragonFlyBSD Target
218template<typename Target>
219class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
220protected:
221  virtual void getOSDefines(const LangOptions &Opts, const char *Triple,
222                    std::vector<char> &Defs) const {
223    // DragonFly defines; list based off of gcc output
224    Define(Defs, "__DragonFly__");
225    Define(Defs, "__DragonFly_cc_version", "100001");
226    Define(Defs, "__ELF__");
227    Define(Defs, "__KPRINTF_ATTRIBUTE__");
228    Define(Defs, "__tune_i386__");
229    DefineStd(Defs, "unix", Opts);
230  }
231public:
232  DragonFlyBSDTargetInfo(const std::string &triple)
233    : OSTargetInfo<Target>(triple) {}
234};
235
236// FreeBSD Target
237template<typename Target>
238class FreeBSDTargetInfo : public OSTargetInfo<Target> {
239protected:
240  virtual void getOSDefines(const LangOptions &Opts, const char *Triple,
241                    std::vector<char> &Defs) const {
242    // FreeBSD defines; list based off of gcc output
243
244    const char *FreeBSD = strstr(Triple, "-freebsd");
245    FreeBSD += strlen("-freebsd");
246    char release[] = "X";
247    release[0] = FreeBSD[0];
248    char version[] = "X00001";
249    version[0] = FreeBSD[0];
250
251    Define(Defs, "__FreeBSD__", release);
252    Define(Defs, "__FreeBSD_cc_version", version);
253    Define(Defs, "__KPRINTF_ATTRIBUTE__");
254    DefineStd(Defs, "unix", Opts);
255    Define(Defs, "__ELF__", "1");
256  }
257public:
258  FreeBSDTargetInfo(const std::string &triple)
259    : OSTargetInfo<Target>(triple) {
260      this->UserLabelPrefix = "";
261    }
262};
263
264// Linux target
265template<typename Target>
266class LinuxTargetInfo : public OSTargetInfo<Target> {
267protected:
268  virtual void getOSDefines(const LangOptions &Opts, const char *Triple,
269                           std::vector<char> &Defs) const {
270    // Linux defines; list based off of gcc output
271    DefineStd(Defs, "unix", Opts);
272    DefineStd(Defs, "linux", Opts);
273    Define(Defs, "__gnu_linux__");
274    Define(Defs, "__ELF__", "1");
275  }
276public:
277  LinuxTargetInfo(const std::string& triple)
278    : OSTargetInfo<Target>(triple) {
279    this->UserLabelPrefix = "";
280  }
281};
282
283// NetBSD Target
284template<typename Target>
285class NetBSDTargetInfo : public OSTargetInfo<Target> {
286protected:
287  virtual void getOSDefines(const LangOptions &Opts, const char *Triple,
288                    std::vector<char> &Defs) const {
289    // NetBSD defines; list based off of gcc output
290    Define(Defs, "__NetBSD__", "1");
291    Define(Defs, "__unix__", "1");
292    Define(Defs, "__ELF__", "1");
293  }
294public:
295  NetBSDTargetInfo(const std::string &triple)
296    : OSTargetInfo<Target>(triple) {
297      this->UserLabelPrefix = "";
298    }
299};
300
301// OpenBSD Target
302template<typename Target>
303class OpenBSDTargetInfo : public OSTargetInfo<Target> {
304protected:
305  virtual void getOSDefines(const LangOptions &Opts, const char *Triple,
306                    std::vector<char> &Defs) const {
307    // OpenBSD defines; list based off of gcc output
308
309    Define(Defs, "__OpenBSD__", "1");
310    DefineStd(Defs, "unix", Opts);
311    Define(Defs, "__ELF__", "1");
312  }
313public:
314  OpenBSDTargetInfo(const std::string &triple)
315    : OSTargetInfo<Target>(triple) {}
316};
317
318// Solaris target
319template<typename Target>
320class SolarisTargetInfo : public OSTargetInfo<Target> {
321protected:
322  virtual void getOSDefines(const LangOptions &Opts, const char *Triple,
323                                std::vector<char> &Defs) const {
324    DefineStd(Defs, "sun", Opts);
325    DefineStd(Defs, "unix", Opts);
326    Define(Defs, "__ELF__");
327    Define(Defs, "__svr4__");
328    Define(Defs, "__SVR4");
329  }
330public:
331  SolarisTargetInfo(const std::string& triple)
332    : OSTargetInfo<Target>(triple) {
333    this->UserLabelPrefix = "";
334    this->WCharType = this->SignedLong;
335    // FIXME: WIntType should be SignedLong
336  }
337};
338} // end anonymous namespace.
339
340/// GetWindowsLanguageOptions - Set the default language options for Windows.
341static void GetWindowsLanguageOptions(LangOptions &Opts,
342                                     const char *Triple) {
343  Opts.Microsoft = true;
344}
345
346//===----------------------------------------------------------------------===//
347// Specific target implementations.
348//===----------------------------------------------------------------------===//
349
350namespace {
351// PPC abstract base class
352class PPCTargetInfo : public TargetInfo {
353  static const Builtin::Info BuiltinInfo[];
354  static const char * const GCCRegNames[];
355  static const TargetInfo::GCCRegAlias GCCRegAliases[];
356
357public:
358  PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
359
360  virtual void getTargetBuiltins(const Builtin::Info *&Records,
361                                 unsigned &NumRecords) const {
362    Records = BuiltinInfo;
363    NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
364  }
365
366  virtual void getTargetDefines(const LangOptions &Opts,
367                                std::vector<char> &Defines) const;
368
369  virtual const char *getVAListDeclaration() const {
370    return "typedef char* __builtin_va_list;";
371    // This is the right definition for ABI/V4: System V.4/eabi.
372    /*return "typedef struct __va_list_tag {"
373           "  unsigned char gpr;"
374           "  unsigned char fpr;"
375           "  unsigned short reserved;"
376           "  void* overflow_arg_area;"
377           "  void* reg_save_area;"
378           "} __builtin_va_list[1];";*/
379  }
380  virtual const char *getTargetPrefix() const {
381    return "ppc";
382  }
383  virtual void getGCCRegNames(const char * const *&Names,
384                              unsigned &NumNames) const;
385  virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
386                                unsigned &NumAliases) const;
387  virtual bool validateAsmConstraint(const char *&Name,
388                                     TargetInfo::ConstraintInfo &Info) const {
389    switch (*Name) {
390    default: return false;
391    case 'O': // Zero
392      return true;
393    case 'b': // Base register
394    case 'f': // Floating point register
395      Info.setAllowsRegister();
396      return true;
397    }
398  }
399  virtual void getDefaultLangOptions(LangOptions &Opts) {
400    TargetInfo::getDefaultLangOptions(Opts);
401    Opts.CharIsSigned = false;
402  }
403  virtual const char *getClobbers() const {
404    return "";
405  }
406};
407
408const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
409#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
410#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
411#include "clang/Basic/BuiltinsPPC.def"
412};
413
414
415/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
416/// #defines that are not tied to a specific subtarget.
417void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
418                                     std::vector<char> &Defs) const {
419  // Target identification.
420  Define(Defs, "__ppc__");
421  Define(Defs, "_ARCH_PPC");
422  Define(Defs, "__POWERPC__");
423  if (PointerWidth == 64) {
424    Define(Defs, "_ARCH_PPC64");
425    Define(Defs, "_LP64");
426    Define(Defs, "__LP64__");
427    Define(Defs, "__ppc64__");
428  } else {
429    Define(Defs, "__ppc__");
430  }
431
432  // Target properties.
433  Define(Defs, "_BIG_ENDIAN");
434  Define(Defs, "__BIG_ENDIAN__");
435
436  // Subtarget options.
437  Define(Defs, "__NATURAL_ALIGNMENT__");
438  Define(Defs, "__REGISTER_PREFIX__", "");
439
440  // FIXME: Should be controlled by command line option.
441  Define(Defs, "__LONG_DOUBLE_128__");
442}
443
444
445const char * const PPCTargetInfo::GCCRegNames[] = {
446  "0", "1", "2", "3", "4", "5", "6", "7",
447  "8", "9", "10", "11", "12", "13", "14", "15",
448  "16", "17", "18", "19", "20", "21", "22", "23",
449  "24", "25", "26", "27", "28", "29", "30", "31",
450  "0", "1", "2", "3", "4", "5", "6", "7",
451  "8", "9", "10", "11", "12", "13", "14", "15",
452  "16", "17", "18", "19", "20", "21", "22", "23",
453  "24", "25", "26", "27", "28", "29", "30", "31",
454  "mq", "lr", "ctr", "ap",
455  "0", "1", "2", "3", "4", "5", "6", "7",
456  "xer",
457  "0", "1", "2", "3", "4", "5", "6", "7",
458  "8", "9", "10", "11", "12", "13", "14", "15",
459  "16", "17", "18", "19", "20", "21", "22", "23",
460  "24", "25", "26", "27", "28", "29", "30", "31",
461  "vrsave", "vscr",
462  "spe_acc", "spefscr",
463  "sfp"
464};
465
466void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
467                                   unsigned &NumNames) const {
468  Names = GCCRegNames;
469  NumNames = llvm::array_lengthof(GCCRegNames);
470}
471
472const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
473  // While some of these aliases do map to different registers
474  // they still share the same register name.
475  { { "cc", "cr0", "fr0", "r0", "v0"}, "0" },
476  { { "cr1", "fr1", "r1", "sp", "v1"}, "1" },
477  { { "cr2", "fr2", "r2", "toc", "v2"}, "2" },
478  { { "cr3", "fr3", "r3", "v3"}, "3" },
479  { { "cr4", "fr4", "r4", "v4"}, "4" },
480  { { "cr5", "fr5", "r5", "v5"}, "5" },
481  { { "cr6", "fr6", "r6", "v6"}, "6" },
482  { { "cr7", "fr7", "r7", "v7"}, "7" },
483  { { "fr8", "r8", "v8"}, "8" },
484  { { "fr9", "r9", "v9"}, "9" },
485  { { "fr10", "r10", "v10"}, "10" },
486  { { "fr11", "r11", "v11"}, "11" },
487  { { "fr12", "r12", "v12"}, "12" },
488  { { "fr13", "r13", "v13"}, "13" },
489  { { "fr14", "r14", "v14"}, "14" },
490  { { "fr15", "r15", "v15"}, "15" },
491  { { "fr16", "r16", "v16"}, "16" },
492  { { "fr17", "r17", "v17"}, "17" },
493  { { "fr18", "r18", "v18"}, "18" },
494  { { "fr19", "r19", "v19"}, "19" },
495  { { "fr20", "r20", "v20"}, "20" },
496  { { "fr21", "r21", "v21"}, "21" },
497  { { "fr22", "r22", "v22"}, "22" },
498  { { "fr23", "r23", "v23"}, "23" },
499  { { "fr24", "r24", "v24"}, "24" },
500  { { "fr25", "r25", "v25"}, "25" },
501  { { "fr26", "r26", "v26"}, "26" },
502  { { "fr27", "r27", "v27"}, "27" },
503  { { "fr28", "r28", "v28"}, "28" },
504  { { "fr29", "r29", "v29"}, "29" },
505  { { "fr30", "r30", "v30"}, "30" },
506  { { "fr31", "r31", "v31"}, "31" },
507};
508
509void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
510                                     unsigned &NumAliases) const {
511  Aliases = GCCRegAliases;
512  NumAliases = llvm::array_lengthof(GCCRegAliases);
513}
514} // end anonymous namespace.
515
516namespace {
517class PPC32TargetInfo : public PPCTargetInfo {
518public:
519  PPC32TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
520    DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
521                        "i64:64:64-f32:32:32-f64:64:64-v128:128:128";
522  }
523};
524} // end anonymous namespace.
525
526namespace {
527class PPC64TargetInfo : public PPCTargetInfo {
528public:
529  PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
530    LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
531    IntMaxType = SignedLong;
532    UIntMaxType = UnsignedLong;
533    Int64Type = SignedLong;
534    DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
535                        "i64:64:64-f32:32:32-f64:64:64-v128:128:128";
536  }
537};
538} // end anonymous namespace.
539
540namespace {
541// Namespace for x86 abstract base class
542const Builtin::Info BuiltinInfo[] = {
543#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
544#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
545#include "clang/Basic/BuiltinsX86.def"
546};
547
548const char *GCCRegNames[] = {
549  "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
550  "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
551  "argp", "flags", "fspr", "dirflag", "frame",
552  "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
553  "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
554  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
555  "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
556};
557
558const TargetInfo::GCCRegAlias GCCRegAliases[] = {
559  { { "al", "ah", "eax", "rax" }, "ax" },
560  { { "bl", "bh", "ebx", "rbx" }, "bx" },
561  { { "cl", "ch", "ecx", "rcx" }, "cx" },
562  { { "dl", "dh", "edx", "rdx" }, "dx" },
563  { { "esi", "rsi" }, "si" },
564  { { "edi", "rdi" }, "di" },
565  { { "esp", "rsp" }, "sp" },
566  { { "ebp", "rbp" }, "bp" },
567};
568
569// X86 target abstract base class; x86-32 and x86-64 are very close, so
570// most of the implementation can be shared.
571class X86TargetInfo : public TargetInfo {
572  enum X86SSEEnum {
573    NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
574  } SSELevel;
575public:
576  X86TargetInfo(const std::string& triple)
577    : TargetInfo(triple), SSELevel(NoMMXSSE) {
578    LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
579  }
580  virtual void getTargetBuiltins(const Builtin::Info *&Records,
581                                 unsigned &NumRecords) const {
582    Records = BuiltinInfo;
583    NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
584  }
585  virtual const char *getTargetPrefix() const {
586    return "x86";
587  }
588  virtual void getGCCRegNames(const char * const *&Names,
589                              unsigned &NumNames) const {
590    Names = GCCRegNames;
591    NumNames = llvm::array_lengthof(GCCRegNames);
592  }
593  virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
594                                unsigned &NumAliases) const {
595    Aliases = GCCRegAliases;
596    NumAliases = llvm::array_lengthof(GCCRegAliases);
597  }
598  virtual bool validateAsmConstraint(const char *&Name,
599                                     TargetInfo::ConstraintInfo &info) const;
600  virtual std::string convertConstraint(const char Constraint) const;
601  virtual const char *getClobbers() const {
602    return "~{dirflag},~{fpsr},~{flags}";
603  }
604  virtual void getTargetDefines(const LangOptions &Opts,
605                                std::vector<char> &Defines) const;
606  virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
607                                 const std::string &Name,
608                                 bool Enabled) const;
609  virtual void getDefaultFeatures(const std::string &CPU,
610                                  llvm::StringMap<bool> &Features) const;
611  virtual void HandleTargetFeatures(const llvm::StringMap<bool> &Features);
612};
613
614void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
615                                       llvm::StringMap<bool> &Features) const {
616  // FIXME: This should not be here.
617  Features["3dnow"] = false;
618  Features["3dnowa"] = false;
619  Features["mmx"] = false;
620  Features["sse"] = false;
621  Features["sse2"] = false;
622  Features["sse3"] = false;
623  Features["ssse3"] = false;
624  Features["sse41"] = false;
625  Features["sse42"] = false;
626
627  // LLVM does not currently recognize this.
628  // Features["sse4a"] = false;
629
630  // FIXME: This *really* should not be here.
631
632  // X86_64 always has SSE2.
633  if (PointerWidth == 64)
634    Features["sse2"] = Features["sse"] = Features["mmx"] = true;
635
636  if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
637      CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
638    ;
639  else if (CPU == "pentium-mmx" || CPU == "pentium2")
640    setFeatureEnabled(Features, "mmx", true);
641  else if (CPU == "pentium3")
642    setFeatureEnabled(Features, "sse", true);
643  else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64")
644    setFeatureEnabled(Features, "sse2", true);
645  else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona")
646    setFeatureEnabled(Features, "sse3", true);
647  else if (CPU == "core2")
648    setFeatureEnabled(Features, "ssse3", true);
649  else if (CPU == "penryn") {
650    setFeatureEnabled(Features, "sse4", true);
651    Features["sse42"] = false;
652  } else if (CPU == "atom")
653    setFeatureEnabled(Features, "sse3", true);
654  else if (CPU == "corei7")
655    setFeatureEnabled(Features, "sse4", true);
656  else if (CPU == "k6" || CPU == "winchip-c6")
657    setFeatureEnabled(Features, "mmx", true);
658  else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
659           CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
660    setFeatureEnabled(Features, "mmx", true);
661    setFeatureEnabled(Features, "3dnow", true);
662  } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
663    setFeatureEnabled(Features, "sse", true);
664    setFeatureEnabled(Features, "3dnowa", true);
665  } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
666           CPU == "athlon-fx") {
667    setFeatureEnabled(Features, "sse2", true);
668    setFeatureEnabled(Features, "3dnowa", true);
669  } else if (CPU == "c3-2")
670    setFeatureEnabled(Features, "sse", true);
671}
672
673bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
674                                      const std::string &Name,
675                                      bool Enabled) const {
676  // FIXME: This *really* should not be here.
677  if (!Features.count(Name) && Name != "sse4")
678    return false;
679
680  if (Enabled) {
681    if (Name == "mmx")
682      Features["mmx"] = true;
683    else if (Name == "sse")
684      Features["mmx"] = Features["sse"] = true;
685    else if (Name == "sse2")
686      Features["mmx"] = Features["sse"] = Features["sse2"] = true;
687    else if (Name == "sse3")
688      Features["mmx"] = Features["sse"] = Features["sse2"] =
689        Features["sse3"] = true;
690    else if (Name == "ssse3")
691      Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
692        Features["ssse3"] = true;
693    else if (Name == "sse4")
694      Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
695        Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
696    else if (Name == "3dnow")
697      Features["3dnowa"] = true;
698    else if (Name == "3dnowa")
699      Features["3dnow"] = Features["3dnowa"] = true;
700  } else {
701    if (Name == "mmx")
702      Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
703        Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
704    else if (Name == "sse")
705      Features["sse"] = Features["sse2"] = Features["sse3"] =
706        Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
707    else if (Name == "sse2")
708      Features["sse2"] = Features["sse3"] = Features["ssse3"] =
709        Features["sse41"] = Features["sse42"] = false;
710    else if (Name == "sse3")
711      Features["sse3"] = Features["ssse3"] = Features["sse41"] =
712        Features["sse42"] = false;
713    else if (Name == "ssse3")
714      Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
715    else if (Name == "sse4")
716      Features["sse41"] = Features["sse42"] = false;
717    else if (Name == "3dnow")
718      Features["3dnow"] = Features["3dnowa"] = false;
719    else if (Name == "3dnowa")
720      Features["3dnowa"] = false;
721  }
722
723  return true;
724}
725
726/// HandleTargetOptions - Perform initialization based on the user
727/// configured set of features.
728void X86TargetInfo::HandleTargetFeatures(const llvm::StringMap<bool>&Features) {
729  if (Features.lookup("sse42"))
730    SSELevel = SSE42;
731  else if (Features.lookup("sse41"))
732    SSELevel = SSE41;
733  else if (Features.lookup("ssse3"))
734    SSELevel = SSSE3;
735  else if (Features.lookup("sse3"))
736    SSELevel = SSE3;
737  else if (Features.lookup("sse2"))
738    SSELevel = SSE2;
739  else if (Features.lookup("sse"))
740    SSELevel = SSE1;
741  else if (Features.lookup("mmx"))
742    SSELevel = MMX;
743}
744
745/// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
746/// that are not tied to a specific subtarget.
747void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
748                                     std::vector<char> &Defs) const {
749  // Target identification.
750  if (PointerWidth == 64) {
751    Define(Defs, "_LP64");
752    Define(Defs, "__LP64__");
753    Define(Defs, "__amd64__");
754    Define(Defs, "__amd64");
755    Define(Defs, "__x86_64");
756    Define(Defs, "__x86_64__");
757  } else {
758    DefineStd(Defs, "i386", Opts);
759  }
760
761  // Target properties.
762  Define(Defs, "__LITTLE_ENDIAN__");
763
764  // Subtarget options.
765  Define(Defs, "__nocona");
766  Define(Defs, "__nocona__");
767  Define(Defs, "__tune_nocona__");
768  Define(Defs, "__REGISTER_PREFIX__", "");
769
770  // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
771  // functions in glibc header files that use FP Stack inline asm which the
772  // backend can't deal with (PR879).
773  Define(Defs, "__NO_MATH_INLINES");
774
775  // Each case falls through to the previous one here.
776  switch (SSELevel) {
777  case SSE42:
778    Define(Defs, "__SSE4_2__");
779  case SSE41:
780    Define(Defs, "__SSE4_1__");
781  case SSSE3:
782    Define(Defs, "__SSSE3__");
783  case SSE3:
784    Define(Defs, "__SSE3__");
785  case SSE2:
786    Define(Defs, "__SSE2__");
787    Define(Defs, "__SSE2_MATH__");  // -mfp-math=sse always implied.
788  case SSE1:
789    Define(Defs, "__SSE__");
790    Define(Defs, "__SSE_MATH__");   // -mfp-math=sse always implied.
791  case MMX:
792    Define(Defs, "__MMX__");
793  case NoMMXSSE:
794    break;
795  }
796}
797
798
799bool
800X86TargetInfo::validateAsmConstraint(const char *&Name,
801                                     TargetInfo::ConstraintInfo &Info) const {
802  switch (*Name) {
803  default: return false;
804  case 'a': // eax.
805  case 'b': // ebx.
806  case 'c': // ecx.
807  case 'd': // edx.
808  case 'S': // esi.
809  case 'D': // edi.
810  case 'A': // edx:eax.
811  case 't': // top of floating point stack.
812  case 'u': // second from top of floating point stack.
813  case 'q': // Any register accessible as [r]l: a, b, c, and d.
814  case 'y': // Any MMX register.
815  case 'x': // Any SSE register.
816  case 'Q': // Any register accessible as [r]h: a, b, c, and d.
817  case 'e': // 32-bit signed integer constant for use with zero-extending
818            // x86_64 instructions.
819  case 'Z': // 32-bit unsigned integer constant for use with zero-extending
820            // x86_64 instructions.
821  case 'N': // unsigned 8-bit integer constant for use with in and out
822            // instructions.
823  case 'R': // "legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
824    Info.setAllowsRegister();
825    return true;
826  }
827}
828
829std::string
830X86TargetInfo::convertConstraint(const char Constraint) const {
831  switch (Constraint) {
832  case 'a': return std::string("{ax}");
833  case 'b': return std::string("{bx}");
834  case 'c': return std::string("{cx}");
835  case 'd': return std::string("{dx}");
836  case 'S': return std::string("{si}");
837  case 'D': return std::string("{di}");
838  case 't': // top of floating point stack.
839    return std::string("{st}");
840  case 'u': // second from top of floating point stack.
841    return std::string("{st(1)}"); // second from top of floating point stack.
842  default:
843    return std::string(1, Constraint);
844  }
845}
846} // end anonymous namespace
847
848namespace {
849// X86-32 generic target
850class X86_32TargetInfo : public X86TargetInfo {
851public:
852  X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
853    DoubleAlign = LongLongAlign = 32;
854    LongDoubleWidth = 96;
855    LongDoubleAlign = 32;
856    DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
857                        "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
858                        "a0:0:64-f80:32:32";
859    SizeType = UnsignedInt;
860    PtrDiffType = SignedInt;
861    IntPtrType = SignedInt;
862    RegParmMax = 3;
863  }
864  virtual const char *getVAListDeclaration() const {
865    return "typedef char* __builtin_va_list;";
866  }
867};
868} // end anonymous namespace
869
870namespace {
871class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
872public:
873  OpenBSDI386TargetInfo(const std::string& triple) :
874    OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
875    SizeType = UnsignedLong;
876    IntPtrType = SignedLong;
877    PtrDiffType = SignedLong;
878  }
879};
880} // end anonymous namespace
881
882namespace {
883class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
884public:
885  DarwinI386TargetInfo(const std::string& triple) :
886    DarwinTargetInfo<X86_32TargetInfo>(triple) {
887    LongDoubleWidth = 128;
888    LongDoubleAlign = 128;
889    SizeType = UnsignedLong;
890    IntPtrType = SignedLong;
891    DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
892                        "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
893                        "a0:0:64-f80:128:128";
894  }
895
896};
897} // end anonymous namespace
898
899namespace {
900// x86-32 Windows target
901class WindowsX86_32TargetInfo : public X86_32TargetInfo {
902public:
903  WindowsX86_32TargetInfo(const std::string& triple)
904    : X86_32TargetInfo(triple) {
905    TLSSupported = false;
906    WCharType = UnsignedShort;
907    WCharWidth = WCharAlign = 16;
908    DoubleAlign = LongLongAlign = 64;
909    DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
910                        "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
911                        "a0:0:64-f80:32:32";
912  }
913  virtual void getTargetDefines(const LangOptions &Opts,
914                                std::vector<char> &Defines) const {
915    X86_32TargetInfo::getTargetDefines(Opts, Defines);
916    // This list is based off of the the list of things MingW defines
917    Define(Defines, "_WIN32");
918    DefineStd(Defines, "WIN32", Opts);
919    DefineStd(Defines, "WINNT", Opts);
920    Define(Defines, "_X86_");
921    Define(Defines, "__MSVCRT__");
922  }
923
924  virtual void getDefaultLangOptions(LangOptions &Opts) {
925    X86_32TargetInfo::getDefaultLangOptions(Opts);
926    GetWindowsLanguageOptions(Opts, getTargetTriple());
927  }
928};
929} // end anonymous namespace
930
931namespace {
932// x86-64 generic target
933class X86_64TargetInfo : public X86TargetInfo {
934public:
935  X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
936    LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
937    LongDoubleWidth = 128;
938    LongDoubleAlign = 128;
939    IntMaxType = SignedLong;
940    UIntMaxType = UnsignedLong;
941    Int64Type = SignedLong;
942    RegParmMax = 6;
943
944    DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
945                        "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
946                        "a0:0:64-s0:64:64-f80:128:128";
947  }
948  virtual const char *getVAListDeclaration() const {
949    return "typedef struct __va_list_tag {"
950           "  unsigned gp_offset;"
951           "  unsigned fp_offset;"
952           "  void* overflow_arg_area;"
953           "  void* reg_save_area;"
954           "} __va_list_tag;"
955           "typedef __va_list_tag __builtin_va_list[1];";
956  }
957};
958} // end anonymous namespace
959
960namespace {
961class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
962public:
963  DarwinX86_64TargetInfo(const std::string& triple)
964      : DarwinTargetInfo<X86_64TargetInfo>(triple) {
965    Int64Type = SignedLongLong;
966  }
967};
968} // end anonymous namespace
969
970namespace {
971class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
972public:
973  OpenBSDX86_64TargetInfo(const std::string& triple)
974      : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
975    IntMaxType = SignedLongLong;
976    UIntMaxType = UnsignedLongLong;
977    Int64Type = SignedLongLong;
978  }
979};
980} // end anonymous namespace
981
982namespace {
983class ARMTargetInfo : public TargetInfo {
984  enum {
985    Armv4t,
986    Armv5,
987    Armv6,
988    Armv7a,
989    XScale
990  } ArmArch;
991public:
992  ARMTargetInfo(const std::string& triple) : TargetInfo(triple) {
993    // FIXME: Are the defaults correct for ARM?
994    DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
995                        "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:64";
996    if (triple.find("armv7-") == 0)
997      ArmArch = Armv7a;
998    else if (triple.find("arm-") == 0 || triple.find("armv6-") == 0)
999      ArmArch = Armv6;
1000    else if (triple.find("armv5-") == 0)
1001      ArmArch = Armv5;
1002    else if (triple.find("armv4t-") == 0)
1003      ArmArch = Armv4t;
1004    else if (triple.find("xscale-") == 0)
1005      ArmArch = XScale;
1006    else if (triple.find("armv") == 0) {
1007      // FIXME: fuzzy match for other random weird arm triples.  This is useful
1008      // for the static analyzer and other clients, but probably should be
1009      // re-evaluated when codegen is brought up.
1010      ArmArch = Armv6;
1011    }
1012  }
1013  virtual void getTargetDefines(const LangOptions &Opts,
1014                                std::vector<char> &Defs) const {
1015    // Target identification.
1016    Define(Defs, "__arm");
1017    Define(Defs, "__arm__");
1018
1019    // Target properties.
1020    Define(Defs, "__LITTLE_ENDIAN__");
1021
1022    // Subtarget options.
1023    if (ArmArch == Armv7a) {
1024      Define(Defs, "__ARM_ARCH_7A__");
1025      Define(Defs, "__THUMB_INTERWORK__");
1026    } else if (ArmArch == Armv6) {
1027      Define(Defs, "__ARM_ARCH_6K__");
1028      Define(Defs, "__THUMB_INTERWORK__");
1029    } else if (ArmArch == Armv5) {
1030      Define(Defs, "__ARM_ARCH_5TEJ__");
1031      Define(Defs, "__THUMB_INTERWORK__");
1032      Define(Defs, "__SOFTFP__");
1033    } else if (ArmArch == Armv4t) {
1034      Define(Defs, "__ARM_ARCH_4T__");
1035      Define(Defs, "__SOFTFP__");
1036    } else if (ArmArch == XScale) {
1037      Define(Defs, "__ARM_ARCH_5TE__");
1038      Define(Defs, "__XSCALE__");
1039      Define(Defs, "__SOFTFP__");
1040    }
1041    Define(Defs, "__ARMEL__");
1042    Define(Defs, "__APCS_32__");
1043    Define(Defs, "__VFP_FP__");
1044  }
1045  virtual void getTargetBuiltins(const Builtin::Info *&Records,
1046                                 unsigned &NumRecords) const {
1047    // FIXME: Implement.
1048    Records = 0;
1049    NumRecords = 0;
1050  }
1051  virtual const char *getVAListDeclaration() const {
1052    return "typedef char* __builtin_va_list;";
1053  }
1054  virtual const char *getTargetPrefix() const {
1055    return "arm";
1056  }
1057  virtual void getGCCRegNames(const char * const *&Names,
1058                              unsigned &NumNames) const {
1059    // FIXME: Implement.
1060    Names = 0;
1061    NumNames = 0;
1062  }
1063  virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1064                                unsigned &NumAliases) const {
1065    // FIXME: Implement.
1066    Aliases = 0;
1067    NumAliases = 0;
1068  }
1069  virtual bool validateAsmConstraint(const char *&Name,
1070                                     TargetInfo::ConstraintInfo &Info) const {
1071    // FIXME: Check if this is complete
1072    switch (*Name) {
1073    default:
1074    case 'l': // r0-r7
1075    case 'h': // r8-r15
1076    case 'w': // VFP Floating point register single precision
1077    case 'P': // VFP Floating point register double precision
1078      Info.setAllowsRegister();
1079      return true;
1080    }
1081    return false;
1082  }
1083  virtual const char *getClobbers() const {
1084    // FIXME: Is this really right?
1085    return "";
1086  }
1087};
1088} // end anonymous namespace.
1089
1090
1091namespace {
1092class DarwinARMTargetInfo :
1093  public DarwinTargetInfo<ARMTargetInfo> {
1094protected:
1095  virtual void getOSDefines(const LangOptions &Opts, const char *Triple,
1096                    std::vector<char> &Defines) const {
1097    getDarwinDefines(Defines, Opts);
1098    getDarwinIPhoneOSDefines(Defines, Triple);
1099  }
1100
1101public:
1102  DarwinARMTargetInfo(const std::string& triple)
1103    : DarwinTargetInfo<ARMTargetInfo>(triple) {}
1104};
1105} // end anonymous namespace.
1106
1107namespace {
1108class SparcV8TargetInfo : public TargetInfo {
1109  static const TargetInfo::GCCRegAlias GCCRegAliases[];
1110  static const char * const GCCRegNames[];
1111public:
1112  SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
1113    // FIXME: Support Sparc quad-precision long double?
1114    DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1115                        "i64:64:64-f32:32:32-f64:64:64-v64:64:64";
1116  }
1117  virtual void getTargetDefines(const LangOptions &Opts,
1118                                std::vector<char> &Defines) const {
1119    DefineStd(Defines, "sparc", Opts);
1120    Define(Defines, "__sparcv8");
1121    Define(Defines, "__REGISTER_PREFIX__", "");
1122  }
1123  virtual void getTargetBuiltins(const Builtin::Info *&Records,
1124                                 unsigned &NumRecords) const {
1125    // FIXME: Implement!
1126  }
1127  virtual const char *getVAListDeclaration() const {
1128    return "typedef void* __builtin_va_list;";
1129  }
1130  virtual const char *getTargetPrefix() const {
1131    return "sparc";
1132  }
1133  virtual void getGCCRegNames(const char * const *&Names,
1134                              unsigned &NumNames) const;
1135  virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1136                                unsigned &NumAliases) const;
1137  virtual bool validateAsmConstraint(const char *&Name,
1138                                     TargetInfo::ConstraintInfo &info) const {
1139    // FIXME: Implement!
1140    return false;
1141  }
1142  virtual const char *getClobbers() const {
1143    // FIXME: Implement!
1144    return "";
1145  }
1146};
1147
1148const char * const SparcV8TargetInfo::GCCRegNames[] = {
1149  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1150  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1151  "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1152  "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
1153};
1154
1155void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
1156                                       unsigned &NumNames) const {
1157  Names = GCCRegNames;
1158  NumNames = llvm::array_lengthof(GCCRegNames);
1159}
1160
1161const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
1162  { { "g0" }, "r0" },
1163  { { "g1" }, "r1" },
1164  { { "g2" }, "r2" },
1165  { { "g3" }, "r3" },
1166  { { "g4" }, "r4" },
1167  { { "g5" }, "r5" },
1168  { { "g6" }, "r6" },
1169  { { "g7" }, "r7" },
1170  { { "o0" }, "r8" },
1171  { { "o1" }, "r9" },
1172  { { "o2" }, "r10" },
1173  { { "o3" }, "r11" },
1174  { { "o4" }, "r12" },
1175  { { "o5" }, "r13" },
1176  { { "o6", "sp" }, "r14" },
1177  { { "o7" }, "r15" },
1178  { { "l0" }, "r16" },
1179  { { "l1" }, "r17" },
1180  { { "l2" }, "r18" },
1181  { { "l3" }, "r19" },
1182  { { "l4" }, "r20" },
1183  { { "l5" }, "r21" },
1184  { { "l6" }, "r22" },
1185  { { "l7" }, "r23" },
1186  { { "i0" }, "r24" },
1187  { { "i1" }, "r25" },
1188  { { "i2" }, "r26" },
1189  { { "i3" }, "r27" },
1190  { { "i4" }, "r28" },
1191  { { "i5" }, "r29" },
1192  { { "i6", "fp" }, "r30" },
1193  { { "i7" }, "r31" },
1194};
1195
1196void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1197                                         unsigned &NumAliases) const {
1198  Aliases = GCCRegAliases;
1199  NumAliases = llvm::array_lengthof(GCCRegAliases);
1200}
1201} // end anonymous namespace.
1202
1203namespace {
1204class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
1205public:
1206  SolarisSparcV8TargetInfo(const std::string& triple) :
1207      SolarisTargetInfo<SparcV8TargetInfo>(triple) {
1208    SizeType = UnsignedInt;
1209    PtrDiffType = SignedInt;
1210  }
1211};
1212} // end anonymous namespace.
1213
1214namespace {
1215  class PIC16TargetInfo : public TargetInfo{
1216  public:
1217    PIC16TargetInfo(const std::string& triple) : TargetInfo(triple) {
1218      TLSSupported = false;
1219      IntWidth = 16;
1220      LongWidth = LongLongWidth = 32;
1221      IntMaxTWidth = 32;
1222      PointerWidth = 16;
1223      IntAlign = 8;
1224      LongAlign = LongLongAlign = 8;
1225      PointerAlign = 8;
1226      SizeType = UnsignedInt;
1227      IntMaxType = SignedLong;
1228      UIntMaxType = UnsignedLong;
1229      IntPtrType = SignedShort;
1230      PtrDiffType = SignedInt;
1231      FloatWidth = 32;
1232      FloatAlign = 32;
1233      DoubleWidth = 32;
1234      DoubleAlign = 32;
1235      LongDoubleWidth = 32;
1236      LongDoubleAlign = 32;
1237      FloatFormat = &llvm::APFloat::IEEEsingle;
1238      DoubleFormat = &llvm::APFloat::IEEEsingle;
1239      LongDoubleFormat = &llvm::APFloat::IEEEsingle;
1240      DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8-f32:32:32";
1241
1242    }
1243    virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }
1244    virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }
1245    virtual void getTargetDefines(const LangOptions &Opts,
1246                                  std::vector<char> &Defines) const {
1247      Define(Defines, "__pic16");
1248      Define(Defines, "rom", "__attribute__((address_space(1)))");
1249      Define(Defines, "ram", "__attribute__((address_space(0)))");
1250      Define(Defines, "_section(SectName)", "__attribute__((section(SectName)))");
1251      Define(Defines, "_address(Addr)","__attribute__((section(\"Address=\"#Addr)))");
1252      Define(Defines, "_CONFIG(conf)", "asm(\"CONFIG \"#conf)");
1253    }
1254    virtual void getTargetBuiltins(const Builtin::Info *&Records,
1255                                   unsigned &NumRecords) const {}
1256    virtual const char *getVAListDeclaration() const { return "";}
1257    virtual const char *getClobbers() const {return "";}
1258    virtual const char *getTargetPrefix() const {return "pic16";}
1259    virtual void getGCCRegNames(const char * const *&Names,
1260                                unsigned &NumNames) const {}
1261    virtual bool validateAsmConstraint(const char *&Name,
1262                                       TargetInfo::ConstraintInfo &info) const {
1263      return true;
1264    }
1265    virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1266                                  unsigned &NumAliases) const {}
1267    virtual bool useGlobalsForAutomaticVariables() const {return true;}
1268  };
1269}
1270
1271namespace {
1272  class MSP430TargetInfo : public TargetInfo {
1273    static const char * const GCCRegNames[];
1274  public:
1275    MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
1276      TLSSupported = false;
1277      IntWidth = 16;
1278      LongWidth = LongLongWidth = 32;
1279      IntMaxTWidth = 32;
1280      PointerWidth = 16;
1281      IntAlign = 8;
1282      LongAlign = LongLongAlign = 8;
1283      PointerAlign = 8;
1284      SizeType = UnsignedInt;
1285      IntMaxType = SignedLong;
1286      UIntMaxType = UnsignedLong;
1287      IntPtrType = SignedShort;
1288      PtrDiffType = SignedInt;
1289      DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8";
1290   }
1291    virtual void getTargetDefines(const LangOptions &Opts,
1292                                 std::vector<char> &Defines) const {
1293      Define(Defines, "MSP430");
1294      Define(Defines, "__MSP430__");
1295      // FIXME: defines for different 'flavours' of MCU
1296    }
1297    virtual void getTargetBuiltins(const Builtin::Info *&Records,
1298                                   unsigned &NumRecords) const {
1299     // FIXME: Implement.
1300      Records = 0;
1301      NumRecords = 0;
1302    }
1303    virtual const char *getTargetPrefix() const {
1304      return "msp430";
1305    }
1306    virtual void getGCCRegNames(const char * const *&Names,
1307                                unsigned &NumNames) const;
1308    virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1309                                  unsigned &NumAliases) const {
1310      // No aliases.
1311      Aliases = 0;
1312      NumAliases = 0;
1313    }
1314    virtual bool validateAsmConstraint(const char *&Name,
1315                                       TargetInfo::ConstraintInfo &info) const {
1316      // FIXME: implement
1317      return true;
1318    }
1319    virtual const char *getClobbers() const {
1320      // FIXME: Is this really right?
1321      return "";
1322    }
1323    virtual const char *getVAListDeclaration() const {
1324      // FIXME: implement
1325      return "typedef char* __builtin_va_list;";
1326   }
1327  };
1328
1329  const char * const MSP430TargetInfo::GCCRegNames[] = {
1330    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1331    "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1332  };
1333
1334  void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
1335                                        unsigned &NumNames) const {
1336    Names = GCCRegNames;
1337    NumNames = llvm::array_lengthof(GCCRegNames);
1338  }
1339}
1340
1341
1342namespace {
1343  class SystemZTargetInfo : public TargetInfo {
1344    static const char * const GCCRegNames[];
1345  public:
1346    SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
1347      TLSSupported = false;
1348      IntWidth = IntAlign = 32;
1349      LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
1350      PointerWidth = PointerAlign = 64;
1351      DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16";
1352   }
1353    virtual void getTargetDefines(const LangOptions &Opts,
1354                                 std::vector<char> &Defines) const {
1355      Define(Defines, "__s390__");
1356      Define(Defines, "__s390x__");
1357    }
1358    virtual void getTargetBuiltins(const Builtin::Info *&Records,
1359                                   unsigned &NumRecords) const {
1360      // FIXME: Implement.
1361      Records = 0;
1362      NumRecords = 0;
1363    }
1364    virtual const char *getTargetPrefix() const {
1365      return "s390x";
1366    }
1367
1368    virtual void getDefaultLangOptions(LangOptions &Opts) {
1369      TargetInfo::getDefaultLangOptions(Opts);
1370      Opts.CharIsSigned = false;
1371    }
1372
1373    virtual void getGCCRegNames(const char * const *&Names,
1374                                unsigned &NumNames) const;
1375    virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1376                                  unsigned &NumAliases) const {
1377      // No aliases.
1378      Aliases = 0;
1379      NumAliases = 0;
1380    }
1381    virtual bool validateAsmConstraint(const char *&Name,
1382                                       TargetInfo::ConstraintInfo &info) const {
1383      // FIXME: implement
1384      return true;
1385    }
1386    virtual const char *getClobbers() const {
1387      // FIXME: Is this really right?
1388      return "";
1389    }
1390    virtual const char *getVAListDeclaration() const {
1391      // FIXME: implement
1392      return "typedef char* __builtin_va_list;";
1393   }
1394  };
1395
1396  const char * const SystemZTargetInfo::GCCRegNames[] = {
1397    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1398    "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1399  };
1400
1401  void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
1402                                         unsigned &NumNames) const {
1403    Names = GCCRegNames;
1404    NumNames = llvm::array_lengthof(GCCRegNames);
1405  }
1406}
1407
1408namespace {
1409  class BlackfinTargetInfo : public TargetInfo {
1410    static const char * const GCCRegNames[];
1411  public:
1412    BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
1413      TLSSupported = false;
1414      DoubleAlign = 32;
1415      LongLongAlign = 32;
1416      LongDoubleAlign = 32;
1417      DescriptionString = "e-p:32:32-i64:32-f64:32";
1418    }
1419
1420    virtual void getTargetDefines(const LangOptions &Opts,
1421                                  std::vector<char> &Defines) const {
1422      DefineStd(Defines, "bfin", Opts);
1423      DefineStd(Defines, "BFIN", Opts);
1424      Define(Defines, "__ADSPBLACKFIN__");
1425      // FIXME: This one is really dependent on -mcpu
1426      Define(Defines, "__ADSPLPBLACKFIN__");
1427      // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
1428    }
1429
1430    virtual void getTargetBuiltins(const Builtin::Info *&Records,
1431                                   unsigned &NumRecords) const {
1432      // FIXME: Implement.
1433      Records = 0;
1434      NumRecords = 0;
1435    }
1436
1437    virtual const char *getTargetPrefix() const {
1438      return "bfin";
1439    }
1440
1441    virtual void getGCCRegNames(const char * const *&Names,
1442                                unsigned &NumNames) const;
1443
1444    virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1445                                  unsigned &NumAliases) const {
1446      // No aliases.
1447      Aliases = 0;
1448      NumAliases = 0;
1449    }
1450
1451    virtual bool validateAsmConstraint(const char *&Name,
1452                                       TargetInfo::ConstraintInfo &Info) const {
1453      if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
1454        Info.setAllowsRegister();
1455        return true;
1456      }
1457      return false;
1458    }
1459
1460    virtual const char *getClobbers() const {
1461      return "";
1462    }
1463
1464    virtual const char *getVAListDeclaration() const {
1465      return "typedef char* __builtin_va_list;";
1466    }
1467  };
1468
1469  const char * const BlackfinTargetInfo::GCCRegNames[] = {
1470    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1471    "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
1472    "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
1473    "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
1474    "a0", "a1", "cc",
1475    "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
1476    "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
1477  };
1478
1479  void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
1480                                          unsigned &NumNames) const {
1481    Names = GCCRegNames;
1482    NumNames = llvm::array_lengthof(GCCRegNames);
1483  }
1484}
1485
1486namespace {
1487
1488  // LLVM and Clang cannot be used directly to output native binaries for
1489  // target, but is used to compile C code to llvm bitcode with correct
1490  // type and alignment information.
1491  //
1492  // TCE uses the llvm bitcode as input and uses it for generating customized
1493  // target processor and program binary. TCE co-design environment is
1494  // publicly available in http://tce.cs.tut.fi
1495
1496  class TCETargetInfo : public TargetInfo{
1497  public:
1498    TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
1499      TLSSupported = false;
1500      IntWidth = 32;
1501      LongWidth = LongLongWidth = 32;
1502      IntMaxTWidth = 32;
1503      PointerWidth = 32;
1504      IntAlign = 32;
1505      LongAlign = LongLongAlign = 32;
1506      PointerAlign = 32;
1507      SizeType = UnsignedInt;
1508      IntMaxType = SignedLong;
1509      UIntMaxType = UnsignedLong;
1510      IntPtrType = SignedInt;
1511      PtrDiffType = SignedInt;
1512      FloatWidth = 32;
1513      FloatAlign = 32;
1514      DoubleWidth = 32;
1515      DoubleAlign = 32;
1516      LongDoubleWidth = 32;
1517      LongDoubleAlign = 32;
1518      FloatFormat = &llvm::APFloat::IEEEsingle;
1519      DoubleFormat = &llvm::APFloat::IEEEsingle;
1520      LongDoubleFormat = &llvm::APFloat::IEEEsingle;
1521      DescriptionString = "E-p:32:32:32-a0:32:32"
1522                          "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64"
1523                          "-f32:32:32-f64:32:64";
1524    }
1525
1526    virtual void getTargetDefines(const LangOptions &Opts,
1527                                  std::vector<char> &Defines) const {
1528      DefineStd(Defines, "tce", Opts);
1529      Define(Defines, "__TCE__");
1530      Define(Defines, "__TCE_V1__");
1531    }
1532    virtual void getTargetBuiltins(const Builtin::Info *&Records,
1533                                   unsigned &NumRecords) const {}
1534    virtual const char *getClobbers() const {return "";}
1535    virtual const char *getVAListDeclaration() const {
1536      return "typedef void* __builtin_va_list;";
1537    }
1538    virtual const char *getTargetPrefix() const {return "tce";}
1539    virtual void getGCCRegNames(const char * const *&Names,
1540                                unsigned &NumNames) const {}
1541    virtual bool validateAsmConstraint(const char *&Name,
1542                                       TargetInfo::ConstraintInfo &info) const {
1543      return true;
1544    }
1545    virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1546                                  unsigned &NumAliases) const {}
1547  };
1548}
1549
1550//===----------------------------------------------------------------------===//
1551// Driver code
1552//===----------------------------------------------------------------------===//
1553
1554/// CreateTargetInfo - Return the target info object for the specified target
1555/// triple.
1556TargetInfo* TargetInfo::CreateTargetInfo(const std::string &T) {
1557  llvm::Triple Triple(T);
1558  llvm::Triple::OSType os = Triple.getOS();
1559
1560  switch (Triple.getArch()) {
1561  default:
1562    return NULL;
1563
1564  case llvm::Triple::arm:
1565    switch (os) {
1566    case llvm::Triple::Darwin:
1567      return new DarwinARMTargetInfo(T);
1568    case llvm::Triple::FreeBSD:
1569      return new FreeBSDTargetInfo<ARMTargetInfo>(T);
1570    default:
1571      return new ARMTargetInfo(T);
1572    }
1573
1574  case llvm::Triple::bfin:
1575    return new BlackfinTargetInfo(T);
1576
1577  case llvm::Triple::msp430:
1578    return new MSP430TargetInfo(T);
1579
1580  case llvm::Triple::pic16:
1581    return new PIC16TargetInfo(T);
1582
1583  case llvm::Triple::ppc:
1584    if (os == llvm::Triple::Darwin)
1585      return new DarwinTargetInfo<PPCTargetInfo>(T);
1586    return new PPC32TargetInfo(T);
1587
1588  case llvm::Triple::ppc64:
1589    if (os == llvm::Triple::Darwin)
1590      return new DarwinTargetInfo<PPC64TargetInfo>(T);
1591    return new PPC64TargetInfo(T);
1592
1593  case llvm::Triple::sparc:
1594    if (os == llvm::Triple::Solaris)
1595      return new SolarisSparcV8TargetInfo(T);
1596    return new SparcV8TargetInfo(T);
1597
1598  case llvm::Triple::systemz:
1599    return new SystemZTargetInfo(T);
1600
1601  case llvm::Triple::tce:
1602    return new TCETargetInfo(T);
1603
1604  case llvm::Triple::x86:
1605    switch (os) {
1606    case llvm::Triple::Darwin:
1607      return new DarwinI386TargetInfo(T);
1608    case llvm::Triple::Linux:
1609      return new LinuxTargetInfo<X86_32TargetInfo>(T);
1610    case llvm::Triple::DragonFly:
1611      return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
1612    case llvm::Triple::NetBSD:
1613      return new NetBSDTargetInfo<X86_32TargetInfo>(T);
1614    case llvm::Triple::OpenBSD:
1615      return new OpenBSDI386TargetInfo(T);
1616    case llvm::Triple::FreeBSD:
1617      return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
1618    case llvm::Triple::Solaris:
1619      return new SolarisTargetInfo<X86_32TargetInfo>(T);
1620    case llvm::Triple::Cygwin:
1621    case llvm::Triple::MinGW32:
1622    case llvm::Triple::MinGW64:
1623    case llvm::Triple::Win32:
1624      return new WindowsX86_32TargetInfo(T);
1625    default:
1626      return new X86_32TargetInfo(T);
1627    }
1628
1629  case llvm::Triple::x86_64:
1630    switch (os) {
1631    case llvm::Triple::Darwin:
1632      return new DarwinX86_64TargetInfo(T);
1633    case llvm::Triple::Linux:
1634      return new LinuxTargetInfo<X86_64TargetInfo>(T);
1635    case llvm::Triple::NetBSD:
1636      return new NetBSDTargetInfo<X86_64TargetInfo>(T);
1637    case llvm::Triple::OpenBSD:
1638      return new OpenBSDX86_64TargetInfo(T);
1639    case llvm::Triple::FreeBSD:
1640      return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
1641    case llvm::Triple::Solaris:
1642      return new SolarisTargetInfo<X86_64TargetInfo>(T);
1643    default:
1644      return new X86_64TargetInfo(T);
1645    }
1646  }
1647}
1648