Targets.cpp revision db57a4cdb0a6abf3239f3a794a900ce312c5887b 
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/TargetInfo.h"
16#include "clang/Basic/Builtins.h"
17#include "clang/Basic/Diagnostic.h"
18#include "clang/Basic/LangOptions.h"
19#include "clang/Basic/MacroBuilder.h"
20#include "clang/Basic/TargetBuiltins.h"
21#include "clang/Basic/TargetOptions.h"
22#include "llvm/ADT/APFloat.h"
23#include "llvm/ADT/OwningPtr.h"
24#include "llvm/ADT/STLExtras.h"
25#include "llvm/ADT/StringRef.h"
26#include "llvm/ADT/StringSwitch.h"
27#include "llvm/ADT/Triple.h"
28#include "llvm/MC/MCSectionMachO.h"
29#include "llvm/Type.h"
30#include <algorithm>
31using namespace clang;
32
33//===----------------------------------------------------------------------===//
34//  Common code shared among targets.
35//===----------------------------------------------------------------------===//
36
37/// DefineStd - Define a macro name and standard variants.  For example if
38/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
39/// when in GNU mode.
40static void DefineStd(MacroBuilder &Builder, llvm::StringRef MacroName,
41                      const LangOptions &Opts) {
42  assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
43
44  // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
45  // in the user's namespace.
46  if (Opts.GNUMode)
47    Builder.defineMacro(MacroName);
48
49  // Define __unix.
50  Builder.defineMacro("__" + MacroName);
51
52  // Define __unix__.
53  Builder.defineMacro("__" + MacroName + "__");
54}
55
56//===----------------------------------------------------------------------===//
57// Defines specific to certain operating systems.
58//===----------------------------------------------------------------------===//
59
60namespace {
61template<typename TgtInfo>
62class OSTargetInfo : public TgtInfo {
63protected:
64  virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
65                            MacroBuilder &Builder) const=0;
66public:
67  OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
68  virtual void getTargetDefines(const LangOptions &Opts,
69                                MacroBuilder &Builder) const {
70    TgtInfo::getTargetDefines(Opts, Builder);
71    getOSDefines(Opts, TgtInfo::getTriple(), Builder);
72  }
73
74};
75} // end anonymous namespace
76
77
78static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
79                             const llvm::Triple &Triple,
80                             llvm::StringRef &PlatformName,
81                             VersionTuple &PlatformMinVersion) {
82  Builder.defineMacro("__APPLE_CC__", "5621");
83  Builder.defineMacro("__APPLE__");
84  Builder.defineMacro("__MACH__");
85  Builder.defineMacro("OBJC_NEW_PROPERTIES");
86
87  // __weak is always defined, for use in blocks and with objc pointers.
88  Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
89
90  // Darwin defines __strong even in C mode (just to nothing).
91  if (!Opts.ObjC1 || Opts.getGCMode() == LangOptions::NonGC)
92    Builder.defineMacro("__strong", "");
93  else
94    Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
95
96  if (Opts.Static)
97    Builder.defineMacro("__STATIC__");
98  else
99    Builder.defineMacro("__DYNAMIC__");
100
101  if (Opts.POSIXThreads)
102    Builder.defineMacro("_REENTRANT");
103
104  // Get the platform type and version number from the triple.
105  unsigned Maj, Min, Rev;
106
107  // If no version was given, default to to 10.4.0, for simplifying tests.
108  if (Triple.getOSName() == "darwin" || Triple.getOSName() == "osx") {
109    PlatformName = "macosx";
110    Min = Rev = 0;
111    Maj = 8;
112  } else {
113    // Otherwise, honor all three triple forms ("-darwinNNN[-iphoneos]",
114    // "-osxNNN", and "-iosNNN").
115
116    if (Triple.getOS() == llvm::Triple::Darwin) {
117      // For historical reasons that make little sense, the version passed here
118      // is the "darwin" version, which drops the 10 and offsets by 4.
119      Triple.getOSVersion(Maj, Min, Rev);
120
121      if (Triple.getEnvironmentName() == "iphoneos") {
122        PlatformName = "ios";
123      } else {
124        assert(Rev == 0 && "invalid triple, unexpected micro version!");
125        PlatformName = "macosx";
126        Rev = Min;
127        Min = Maj - 4;
128        Maj = 10;
129      }
130    } else if (Triple.getOS() == llvm::Triple::OSX) {
131      Triple.getOSVersion(Maj, Min, Rev);
132      PlatformName = "macosx";
133    } else {
134      assert(Triple.getOS() == llvm::Triple::IOS && "unexpected triple!");
135      Triple.getOSVersion(Maj, Min, Rev);
136      PlatformName = "ios";
137    }
138  }
139
140  // Set the appropriate OS version define.
141  if (PlatformName == "ios") {
142    assert(Maj < 10 && Min < 99 && Rev < 99 && "Invalid version!");
143    char Str[6];
144    Str[0] = '0' + Maj;
145    Str[1] = '0' + (Min / 10);
146    Str[2] = '0' + (Min % 10);
147    Str[3] = '0' + (Rev / 10);
148    Str[4] = '0' + (Rev % 10);
149    Str[5] = '\0';
150    Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
151  } else {
152    assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
153    assert(Maj < 99 && Min < 10 && Rev < 10 && "Invalid version!");
154    char Str[5];
155    Str[0] = '0' + (Maj / 10);
156    Str[1] = '0' + (Maj % 10);
157    Str[2] = '0' + Min;
158    Str[3] = '0' + Rev;
159    Str[4] = '\0';
160    Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
161  }
162
163  PlatformMinVersion = VersionTuple(Maj, Min, Rev);
164}
165
166namespace {
167template<typename Target>
168class DarwinTargetInfo : public OSTargetInfo<Target> {
169protected:
170  virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
171                            MacroBuilder &Builder) const {
172    getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
173                     this->PlatformMinVersion);
174  }
175
176public:
177  DarwinTargetInfo(const std::string& triple) :
178    OSTargetInfo<Target>(triple) {
179      this->TLSSupported = llvm::Triple(triple).getDarwinMajorNumber() > 10;
180      this->MCountName = "\01mcount";
181    }
182
183  virtual std::string isValidSectionSpecifier(llvm::StringRef SR) const {
184    // Let MCSectionMachO validate this.
185    llvm::StringRef Segment, Section;
186    unsigned TAA, StubSize;
187    bool HasTAA;
188    return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
189                                                       TAA, HasTAA, StubSize);
190  }
191
192  virtual const char *getStaticInitSectionSpecifier() const {
193    // FIXME: We should return 0 when building kexts.
194    return "__TEXT,__StaticInit,regular,pure_instructions";
195  }
196
197};
198
199
200// DragonFlyBSD Target
201template<typename Target>
202class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
203protected:
204  virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
205                            MacroBuilder &Builder) const {
206    // DragonFly defines; list based off of gcc output
207    Builder.defineMacro("__DragonFly__");
208    Builder.defineMacro("__DragonFly_cc_version", "100001");
209    Builder.defineMacro("__ELF__");
210    Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
211    Builder.defineMacro("__tune_i386__");
212    DefineStd(Builder, "unix", Opts);
213  }
214public:
215  DragonFlyBSDTargetInfo(const std::string &triple)
216    : OSTargetInfo<Target>(triple) {}
217};
218
219// FreeBSD Target
220template<typename Target>
221class FreeBSDTargetInfo : public OSTargetInfo<Target> {
222protected:
223  virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
224                            MacroBuilder &Builder) const {
225    // FreeBSD defines; list based off of gcc output
226
227    // FIXME: Move version number handling to llvm::Triple.
228    llvm::StringRef Release = Triple.getOSName().substr(strlen("freebsd"), 1);
229
230    Builder.defineMacro("__FreeBSD__", Release);
231    Builder.defineMacro("__FreeBSD_cc_version", Release + "00001");
232    Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
233    DefineStd(Builder, "unix", Opts);
234    Builder.defineMacro("__ELF__");
235  }
236public:
237  FreeBSDTargetInfo(const std::string &triple)
238    : OSTargetInfo<Target>(triple) {
239      this->UserLabelPrefix = "";
240
241      llvm::Triple Triple(triple);
242      switch (Triple.getArch()) {
243        default:
244        case llvm::Triple::x86:
245        case llvm::Triple::x86_64:
246          this->MCountName = ".mcount";
247          break;
248        case llvm::Triple::mips:
249        case llvm::Triple::mipsel:
250        case llvm::Triple::ppc:
251        case llvm::Triple::ppc64:
252          this->MCountName = "_mcount";
253          break;
254        case llvm::Triple::arm:
255          this->MCountName = "__mcount";
256          break;
257      }
258
259    }
260};
261
262// Minix Target
263template<typename Target>
264class MinixTargetInfo : public OSTargetInfo<Target> {
265protected:
266  virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
267                            MacroBuilder &Builder) const {
268    // Minix defines
269
270    Builder.defineMacro("__minix", "3");
271    Builder.defineMacro("_EM_WSIZE", "4");
272    Builder.defineMacro("_EM_PSIZE", "4");
273    Builder.defineMacro("_EM_SSIZE", "2");
274    Builder.defineMacro("_EM_LSIZE", "4");
275    Builder.defineMacro("_EM_FSIZE", "4");
276    Builder.defineMacro("_EM_DSIZE", "8");
277    DefineStd(Builder, "unix", Opts);
278  }
279public:
280  MinixTargetInfo(const std::string &triple)
281    : OSTargetInfo<Target>(triple) {
282      this->UserLabelPrefix = "";
283    }
284};
285
286// Linux target
287template<typename Target>
288class LinuxTargetInfo : public OSTargetInfo<Target> {
289protected:
290  virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
291                            MacroBuilder &Builder) const {
292    // Linux defines; list based off of gcc output
293    DefineStd(Builder, "unix", Opts);
294    DefineStd(Builder, "linux", Opts);
295    Builder.defineMacro("__gnu_linux__");
296    Builder.defineMacro("__ELF__");
297    if (Opts.POSIXThreads)
298      Builder.defineMacro("_REENTRANT");
299    if (Opts.CPlusPlus)
300      Builder.defineMacro("_GNU_SOURCE");
301  }
302public:
303  LinuxTargetInfo(const std::string& triple)
304    : OSTargetInfo<Target>(triple) {
305    this->UserLabelPrefix = "";
306    this->WIntType = TargetInfo::UnsignedInt;
307  }
308};
309
310// NetBSD Target
311template<typename Target>
312class NetBSDTargetInfo : public OSTargetInfo<Target> {
313protected:
314  virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
315                            MacroBuilder &Builder) const {
316    // NetBSD defines; list based off of gcc output
317    Builder.defineMacro("__NetBSD__");
318    Builder.defineMacro("__unix__");
319    Builder.defineMacro("__ELF__");
320    if (Opts.POSIXThreads)
321      Builder.defineMacro("_POSIX_THREADS");
322  }
323public:
324  NetBSDTargetInfo(const std::string &triple)
325    : OSTargetInfo<Target>(triple) {
326      this->UserLabelPrefix = "";
327    }
328};
329
330// OpenBSD Target
331template<typename Target>
332class OpenBSDTargetInfo : public OSTargetInfo<Target> {
333protected:
334  virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
335                            MacroBuilder &Builder) const {
336    // OpenBSD defines; list based off of gcc output
337
338    Builder.defineMacro("__OpenBSD__");
339    DefineStd(Builder, "unix", Opts);
340    Builder.defineMacro("__ELF__");
341    if (Opts.POSIXThreads)
342      Builder.defineMacro("_POSIX_THREADS");
343  }
344public:
345  OpenBSDTargetInfo(const std::string &triple)
346    : OSTargetInfo<Target>(triple) {}
347};
348
349// PSP Target
350template<typename Target>
351class PSPTargetInfo : public OSTargetInfo<Target> {
352protected:
353  virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
354                            MacroBuilder &Builder) const {
355    // PSP defines; list based on the output of the pspdev gcc toolchain.
356    Builder.defineMacro("PSP");
357    Builder.defineMacro("_PSP");
358    Builder.defineMacro("__psp__");
359    Builder.defineMacro("__ELF__");
360  }
361public:
362  PSPTargetInfo(const std::string& triple)
363    : OSTargetInfo<Target>(triple) {
364    this->UserLabelPrefix = "";
365  }
366};
367
368// PS3 PPU Target
369template<typename Target>
370class PS3PPUTargetInfo : public OSTargetInfo<Target> {
371protected:
372  virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
373                            MacroBuilder &Builder) const {
374    // PS3 PPU defines.
375    Builder.defineMacro("__PPC__");
376    Builder.defineMacro("__PPU__");
377    Builder.defineMacro("__CELLOS_LV2__");
378    Builder.defineMacro("__ELF__");
379    Builder.defineMacro("__LP32__");
380    Builder.defineMacro("_ARCH_PPC64");
381    Builder.defineMacro("__powerpc64__");
382  }
383public:
384  PS3PPUTargetInfo(const std::string& triple)
385    : OSTargetInfo<Target>(triple) {
386    this->UserLabelPrefix = "";
387    this->LongWidth = this->LongAlign = this->PointerWidth = this->PointerAlign = 32;
388    this->IntMaxType = TargetInfo::SignedLongLong;
389    this->UIntMaxType = TargetInfo::UnsignedLongLong;
390    this->Int64Type = TargetInfo::SignedLongLong;
391    this->SizeType = TargetInfo::UnsignedInt;
392    this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
393                        "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
394  }
395};
396
397// FIXME: Need a real SPU target.
398// PS3 SPU Target
399template<typename Target>
400class PS3SPUTargetInfo : public OSTargetInfo<Target> {
401protected:
402  virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
403                            MacroBuilder &Builder) const {
404    // PS3 PPU defines.
405    Builder.defineMacro("__SPU__");
406    Builder.defineMacro("__ELF__");
407  }
408public:
409  PS3SPUTargetInfo(const std::string& triple)
410    : OSTargetInfo<Target>(triple) {
411    this->UserLabelPrefix = "";
412  }
413};
414
415// AuroraUX target
416template<typename Target>
417class AuroraUXTargetInfo : public OSTargetInfo<Target> {
418protected:
419  virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
420                            MacroBuilder &Builder) const {
421    DefineStd(Builder, "sun", Opts);
422    DefineStd(Builder, "unix", Opts);
423    Builder.defineMacro("__ELF__");
424    Builder.defineMacro("__svr4__");
425    Builder.defineMacro("__SVR4");
426  }
427public:
428  AuroraUXTargetInfo(const std::string& triple)
429    : OSTargetInfo<Target>(triple) {
430    this->UserLabelPrefix = "";
431    this->WCharType = this->SignedLong;
432    // FIXME: WIntType should be SignedLong
433  }
434};
435
436// Solaris target
437template<typename Target>
438class SolarisTargetInfo : public OSTargetInfo<Target> {
439protected:
440  virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
441                            MacroBuilder &Builder) const {
442    DefineStd(Builder, "sun", Opts);
443    DefineStd(Builder, "unix", Opts);
444    Builder.defineMacro("__ELF__");
445    Builder.defineMacro("__svr4__");
446    Builder.defineMacro("__SVR4");
447  }
448public:
449  SolarisTargetInfo(const std::string& triple)
450    : OSTargetInfo<Target>(triple) {
451    this->UserLabelPrefix = "";
452    this->WCharType = this->SignedLong;
453    // FIXME: WIntType should be SignedLong
454  }
455};
456
457// Windows target
458template<typename Target>
459class WindowsTargetInfo : public OSTargetInfo<Target> {
460protected:
461  virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
462                            MacroBuilder &Builder) const {
463    Builder.defineMacro("_WIN32");
464  }
465  void getVisualStudioDefines(const LangOptions &Opts,
466                              MacroBuilder &Builder) const {
467    if (Opts.CPlusPlus) {
468      if (Opts.RTTI)
469        Builder.defineMacro("_CPPRTTI");
470
471      if (Opts.Exceptions)
472        Builder.defineMacro("_CPPUNWIND");
473    }
474
475    if (!Opts.CharIsSigned)
476      Builder.defineMacro("_CHAR_UNSIGNED");
477
478    // FIXME: POSIXThreads isn't exactly the option this should be defined for,
479    //        but it works for now.
480    if (Opts.POSIXThreads)
481      Builder.defineMacro("_MT");
482
483    if (Opts.MSCVersion != 0)
484      Builder.defineMacro("_MSC_VER", llvm::Twine(Opts.MSCVersion));
485
486    if (Opts.Microsoft) {
487      Builder.defineMacro("_MSC_EXTENSIONS");
488
489      if (Opts.CPlusPlus0x) {
490        Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
491        Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
492        Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
493      }
494    }
495
496    Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
497  }
498
499public:
500  WindowsTargetInfo(const std::string &triple)
501    : OSTargetInfo<Target>(triple) {}
502};
503
504} // end anonymous namespace.
505
506//===----------------------------------------------------------------------===//
507// Specific target implementations.
508//===----------------------------------------------------------------------===//
509
510namespace {
511// PPC abstract base class
512class PPCTargetInfo : public TargetInfo {
513  static const Builtin::Info BuiltinInfo[];
514  static const char * const GCCRegNames[];
515  static const TargetInfo::GCCRegAlias GCCRegAliases[];
516
517public:
518  PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
519
520  virtual void getTargetBuiltins(const Builtin::Info *&Records,
521                                 unsigned &NumRecords) const {
522    Records = BuiltinInfo;
523    NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
524  }
525
526  virtual void getTargetDefines(const LangOptions &Opts,
527                                MacroBuilder &Builder) const;
528
529  virtual void getGCCRegNames(const char * const *&Names,
530                              unsigned &NumNames) const;
531  virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
532                                unsigned &NumAliases) const;
533  virtual bool validateAsmConstraint(const char *&Name,
534                                     TargetInfo::ConstraintInfo &Info) const {
535    switch (*Name) {
536    default: return false;
537    case 'O': // Zero
538      break;
539    case 'b': // Base register
540    case 'f': // Floating point register
541      Info.setAllowsRegister();
542      break;
543    // FIXME: The following are added to allow parsing.
544    // I just took a guess at what the actions should be.
545    // Also, is more specific checking needed?  I.e. specific registers?
546    case 'd': // Floating point register (containing 64-bit value)
547    case 'v': // Altivec vector register
548      Info.setAllowsRegister();
549      break;
550    case 'w':
551      switch (Name[1]) {
552        case 'd':// VSX vector register to hold vector double data
553        case 'f':// VSX vector register to hold vector float data
554        case 's':// VSX vector register to hold scalar float data
555        case 'a':// Any VSX register
556          break;
557        default:
558          return false;
559      }
560      Info.setAllowsRegister();
561      Name++; // Skip over 'w'.
562      break;
563    case 'h': // `MQ', `CTR', or `LINK' register
564    case 'q': // `MQ' register
565    case 'c': // `CTR' register
566    case 'l': // `LINK' register
567    case 'x': // `CR' register (condition register) number 0
568    case 'y': // `CR' register (condition register)
569    case 'z': // `XER[CA]' carry bit (part of the XER register)
570      Info.setAllowsRegister();
571      break;
572    case 'I': // Signed 16-bit constant
573    case 'J': // Unsigned 16-bit constant shifted left 16 bits
574              //  (use `L' instead for SImode constants)
575    case 'K': // Unsigned 16-bit constant
576    case 'L': // Signed 16-bit constant shifted left 16 bits
577    case 'M': // Constant larger than 31
578    case 'N': // Exact power of 2
579    case 'P': // Constant whose negation is a signed 16-bit constant
580    case 'G': // Floating point constant that can be loaded into a
581              // register with one instruction per word
582    case 'H': // Integer/Floating point constant that can be loaded
583              // into a register using three instructions
584      break;
585    case 'm': // Memory operand. Note that on PowerPC targets, m can
586              // include addresses that update the base register. It
587              // is therefore only safe to use `m' in an asm statement
588              // if that asm statement accesses the operand exactly once.
589              // The asm statement must also use `%U<opno>' as a
590              // placeholder for the "update" flag in the corresponding
591              // load or store instruction. For example:
592              // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
593              // is correct but:
594              // asm ("st %1,%0" : "=m" (mem) : "r" (val));
595              // is not. Use es rather than m if you don't want the base
596              // register to be updated.
597    case 'e':
598      if (Name[1] != 's')
599          return false;
600              // es: A "stable" memory operand; that is, one which does not
601              // include any automodification of the base register. Unlike
602              // `m', this constraint can be used in asm statements that
603              // might access the operand several times, or that might not
604              // access it at all.
605      Info.setAllowsMemory();
606      Name++; // Skip over 'e'.
607      break;
608    case 'Q': // Memory operand that is an offset from a register (it is
609              // usually better to use `m' or `es' in asm statements)
610    case 'Z': // Memory operand that is an indexed or indirect from a
611              // register (it is usually better to use `m' or `es' in
612              // asm statements)
613      Info.setAllowsMemory();
614      Info.setAllowsRegister();
615      break;
616    case 'R': // AIX TOC entry
617    case 'a': // Address operand that is an indexed or indirect from a
618              // register (`p' is preferable for asm statements)
619    case 'S': // Constant suitable as a 64-bit mask operand
620    case 'T': // Constant suitable as a 32-bit mask operand
621    case 'U': // System V Release 4 small data area reference
622    case 't': // AND masks that can be performed by two rldic{l, r}
623              // instructions
624    case 'W': // Vector constant that does not require memory
625    case 'j': // Vector constant that is all zeros.
626      break;
627    // End FIXME.
628    }
629    return true;
630  }
631  virtual const char *getClobbers() const {
632    return "";
633  }
634};
635
636const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
637#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES, false },
638#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
639                                              ALL_LANGUAGES, false },
640#include "clang/Basic/BuiltinsPPC.def"
641};
642
643
644/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
645/// #defines that are not tied to a specific subtarget.
646void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
647                                     MacroBuilder &Builder) const {
648  // Target identification.
649  Builder.defineMacro("__ppc__");
650  Builder.defineMacro("_ARCH_PPC");
651  Builder.defineMacro("__powerpc__");
652  Builder.defineMacro("__POWERPC__");
653  if (PointerWidth == 64) {
654    Builder.defineMacro("_ARCH_PPC64");
655    Builder.defineMacro("_LP64");
656    Builder.defineMacro("__LP64__");
657    Builder.defineMacro("__powerpc64__");
658    Builder.defineMacro("__ppc64__");
659  } else {
660    Builder.defineMacro("__ppc__");
661  }
662
663  // Target properties.
664  Builder.defineMacro("_BIG_ENDIAN");
665  Builder.defineMacro("__BIG_ENDIAN__");
666
667  // Subtarget options.
668  Builder.defineMacro("__NATURAL_ALIGNMENT__");
669  Builder.defineMacro("__REGISTER_PREFIX__", "");
670
671  // FIXME: Should be controlled by command line option.
672  Builder.defineMacro("__LONG_DOUBLE_128__");
673
674  if (Opts.AltiVec) {
675    Builder.defineMacro("__VEC__", "10206");
676    Builder.defineMacro("__ALTIVEC__");
677  }
678}
679
680
681const char * const PPCTargetInfo::GCCRegNames[] = {
682  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
683  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
684  "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
685  "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
686  "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
687  "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
688  "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
689  "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
690  "mq", "lr", "ctr", "ap",
691  "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
692  "xer",
693  "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
694  "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
695  "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
696  "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
697  "vrsave", "vscr",
698  "spe_acc", "spefscr",
699  "sfp"
700};
701
702void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
703                                   unsigned &NumNames) const {
704  Names = GCCRegNames;
705  NumNames = llvm::array_lengthof(GCCRegNames);
706}
707
708const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
709  // While some of these aliases do map to different registers
710  // they still share the same register name.
711  { { "0" }, "r0" },
712  { { "1"}, "r1" },
713  { { "2" }, "r2" },
714  { { "3" }, "r3" },
715  { { "4" }, "r4" },
716  { { "5" }, "r5" },
717  { { "6" }, "r6" },
718  { { "7" }, "r7" },
719  { { "8" }, "r8" },
720  { { "9" }, "r9" },
721  { { "10" }, "r10" },
722  { { "11" }, "r11" },
723  { { "12" }, "r12" },
724  { { "13" }, "r13" },
725  { { "14" }, "r14" },
726  { { "15" }, "r15" },
727  { { "16" }, "r16" },
728  { { "17" }, "r17" },
729  { { "18" }, "r18" },
730  { { "19" }, "r19" },
731  { { "20" }, "r20" },
732  { { "21" }, "r21" },
733  { { "22" }, "r22" },
734  { { "23" }, "r23" },
735  { { "24" }, "r24" },
736  { { "25" }, "r25" },
737  { { "26" }, "r26" },
738  { { "27" }, "r27" },
739  { { "28" }, "r28" },
740  { { "29" }, "r29" },
741  { { "30" }, "r30" },
742  { { "31" }, "r31" },
743  { { "fr0" }, "f0" },
744  { { "fr1" }, "f1" },
745  { { "fr2" }, "f2" },
746  { { "fr3" }, "f3" },
747  { { "fr4" }, "f4" },
748  { { "fr5" }, "f5" },
749  { { "fr6" }, "f6" },
750  { { "fr7" }, "f7" },
751  { { "fr8" }, "f8" },
752  { { "fr9" }, "f9" },
753  { { "fr10" }, "f10" },
754  { { "fr11" }, "f11" },
755  { { "fr12" }, "f12" },
756  { { "fr13" }, "f13" },
757  { { "fr14" }, "f14" },
758  { { "fr15" }, "f15" },
759  { { "fr16" }, "f16" },
760  { { "fr17" }, "f17" },
761  { { "fr18" }, "f18" },
762  { { "fr19" }, "f19" },
763  { { "fr20" }, "f20" },
764  { { "fr21" }, "f21" },
765  { { "fr22" }, "f22" },
766  { { "fr23" }, "f23" },
767  { { "fr24" }, "f24" },
768  { { "fr25" }, "f25" },
769  { { "fr26" }, "f26" },
770  { { "fr27" }, "f27" },
771  { { "fr28" }, "f28" },
772  { { "fr29" }, "f29" },
773  { { "fr30" }, "f30" },
774  { { "fr31" }, "f31" },
775  { { "cc" }, "cr0" },
776};
777
778void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
779                                     unsigned &NumAliases) const {
780  Aliases = GCCRegAliases;
781  NumAliases = llvm::array_lengthof(GCCRegAliases);
782}
783} // end anonymous namespace.
784
785namespace {
786class PPC32TargetInfo : public PPCTargetInfo {
787public:
788  PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
789    DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
790                        "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
791
792    if (getTriple().getOS() == llvm::Triple::FreeBSD)
793        SizeType = UnsignedInt;
794  }
795
796  virtual const char *getVAListDeclaration() const {
797    // This is the ELF definition, and is overridden by the Darwin sub-target
798    return "typedef struct __va_list_tag {"
799           "  unsigned char gpr;"
800           "  unsigned char fpr;"
801           "  unsigned short reserved;"
802           "  void* overflow_arg_area;"
803           "  void* reg_save_area;"
804           "} __builtin_va_list[1];";
805  }
806};
807} // end anonymous namespace.
808
809namespace {
810class PPC64TargetInfo : public PPCTargetInfo {
811public:
812  PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
813    LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
814    IntMaxType = SignedLong;
815    UIntMaxType = UnsignedLong;
816    Int64Type = SignedLong;
817    DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
818                        "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
819  }
820  virtual const char *getVAListDeclaration() const {
821    return "typedef char* __builtin_va_list;";
822  }
823};
824} // end anonymous namespace.
825
826
827namespace {
828class DarwinPPC32TargetInfo :
829  public DarwinTargetInfo<PPC32TargetInfo> {
830public:
831  DarwinPPC32TargetInfo(const std::string& triple)
832    : DarwinTargetInfo<PPC32TargetInfo>(triple) {
833    HasAlignMac68kSupport = true;
834    BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
835  }
836  virtual const char *getVAListDeclaration() const {
837    return "typedef char* __builtin_va_list;";
838  }
839};
840
841class DarwinPPC64TargetInfo :
842  public DarwinTargetInfo<PPC64TargetInfo> {
843public:
844  DarwinPPC64TargetInfo(const std::string& triple)
845    : DarwinTargetInfo<PPC64TargetInfo>(triple) {
846    HasAlignMac68kSupport = true;
847  }
848};
849} // end anonymous namespace.
850
851namespace {
852// MBlaze abstract base class
853class MBlazeTargetInfo : public TargetInfo {
854  static const char * const GCCRegNames[];
855  static const TargetInfo::GCCRegAlias GCCRegAliases[];
856
857public:
858  MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
859    DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
860  }
861
862  virtual void getTargetBuiltins(const Builtin::Info *&Records,
863                                 unsigned &NumRecords) const {
864    // FIXME: Implement.
865    Records = 0;
866    NumRecords = 0;
867  }
868
869  virtual void getTargetDefines(const LangOptions &Opts,
870                                MacroBuilder &Builder) const;
871
872  virtual const char *getVAListDeclaration() const {
873    return "typedef char* __builtin_va_list;";
874  }
875  virtual const char *getTargetPrefix() const {
876    return "mblaze";
877  }
878  virtual void getGCCRegNames(const char * const *&Names,
879                              unsigned &NumNames) const;
880  virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
881                                unsigned &NumAliases) const;
882  virtual bool validateAsmConstraint(const char *&Name,
883                                     TargetInfo::ConstraintInfo &Info) const {
884    switch (*Name) {
885    default: return false;
886    case 'O': // Zero
887      return true;
888    case 'b': // Base register
889    case 'f': // Floating point register
890      Info.setAllowsRegister();
891      return true;
892    }
893  }
894  virtual const char *getClobbers() const {
895    return "";
896  }
897};
898
899/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
900/// #defines that are not tied to a specific subtarget.
901void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
902                                     MacroBuilder &Builder) const {
903  // Target identification.
904  Builder.defineMacro("__microblaze__");
905  Builder.defineMacro("_ARCH_MICROBLAZE");
906  Builder.defineMacro("__MICROBLAZE__");
907
908  // Target properties.
909  Builder.defineMacro("_BIG_ENDIAN");
910  Builder.defineMacro("__BIG_ENDIAN__");
911
912  // Subtarget options.
913  Builder.defineMacro("__REGISTER_PREFIX__", "");
914}
915
916
917const char * const MBlazeTargetInfo::GCCRegNames[] = {
918  "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
919  "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
920  "r16",  "r17",  "r18",  "r19",  "r20",  "r21",  "r22",  "r23",
921  "r24",  "r25",  "r26",  "r27",  "r28",  "r29",  "r30",  "r31",
922  "$f0",  "$f1",  "$f2",  "$f3",  "$f4",  "$f5",  "$f6",  "$f7",
923  "$f8",  "$f9",  "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
924  "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
925  "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
926  "hi",   "lo",   "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
927  "$fcc5","$fcc6","$fcc7","$ap",  "$rap", "$frp"
928};
929
930void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
931                                   unsigned &NumNames) const {
932  Names = GCCRegNames;
933  NumNames = llvm::array_lengthof(GCCRegNames);
934}
935
936const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
937  { {"f0"},  "r0" },
938  { {"f1"},  "r1" },
939  { {"f2"},  "r2" },
940  { {"f3"},  "r3" },
941  { {"f4"},  "r4" },
942  { {"f5"},  "r5" },
943  { {"f6"},  "r6" },
944  { {"f7"},  "r7" },
945  { {"f8"},  "r8" },
946  { {"f9"},  "r9" },
947  { {"f10"}, "r10" },
948  { {"f11"}, "r11" },
949  { {"f12"}, "r12" },
950  { {"f13"}, "r13" },
951  { {"f14"}, "r14" },
952  { {"f15"}, "r15" },
953  { {"f16"}, "r16" },
954  { {"f17"}, "r17" },
955  { {"f18"}, "r18" },
956  { {"f19"}, "r19" },
957  { {"f20"}, "r20" },
958  { {"f21"}, "r21" },
959  { {"f22"}, "r22" },
960  { {"f23"}, "r23" },
961  { {"f24"}, "r24" },
962  { {"f25"}, "r25" },
963  { {"f26"}, "r26" },
964  { {"f27"}, "r27" },
965  { {"f28"}, "r28" },
966  { {"f29"}, "r29" },
967  { {"f30"}, "r30" },
968  { {"f31"}, "r31" },
969};
970
971void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
972                                     unsigned &NumAliases) const {
973  Aliases = GCCRegAliases;
974  NumAliases = llvm::array_lengthof(GCCRegAliases);
975}
976} // end anonymous namespace.
977
978namespace {
979// Namespace for x86 abstract base class
980const Builtin::Info BuiltinInfo[] = {
981#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES, false },
982#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
983                                              ALL_LANGUAGES, false },
984#include "clang/Basic/BuiltinsX86.def"
985};
986
987static const char* const GCCRegNames[] = {
988  "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
989  "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
990  "argp", "flags", "fspr", "dirflag", "frame",
991  "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
992  "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
993  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
994  "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
995};
996
997const TargetInfo::GCCRegAlias GCCRegAliases[] = {
998  { { "al", "ah", "eax", "rax" }, "ax" },
999  { { "bl", "bh", "ebx", "rbx" }, "bx" },
1000  { { "cl", "ch", "ecx", "rcx" }, "cx" },
1001  { { "dl", "dh", "edx", "rdx" }, "dx" },
1002  { { "esi", "rsi" }, "si" },
1003  { { "edi", "rdi" }, "di" },
1004  { { "esp", "rsp" }, "sp" },
1005  { { "ebp", "rbp" }, "bp" },
1006};
1007
1008// X86 target abstract base class; x86-32 and x86-64 are very close, so
1009// most of the implementation can be shared.
1010class X86TargetInfo : public TargetInfo {
1011  enum X86SSEEnum {
1012    NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
1013  } SSELevel;
1014  enum AMD3DNowEnum {
1015    NoAMD3DNow, AMD3DNow, AMD3DNowAthlon
1016  } AMD3DNowLevel;
1017
1018  bool HasAES;
1019  bool HasAVX;
1020
1021public:
1022  X86TargetInfo(const std::string& triple)
1023    : TargetInfo(triple), SSELevel(NoMMXSSE), AMD3DNowLevel(NoAMD3DNow),
1024      HasAES(false), HasAVX(false) {
1025    LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
1026  }
1027  virtual void getTargetBuiltins(const Builtin::Info *&Records,
1028                                 unsigned &NumRecords) const {
1029    Records = BuiltinInfo;
1030    NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
1031  }
1032  virtual void getGCCRegNames(const char * const *&Names,
1033                              unsigned &NumNames) const {
1034    Names = GCCRegNames;
1035    NumNames = llvm::array_lengthof(GCCRegNames);
1036  }
1037  virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1038                                unsigned &NumAliases) const {
1039    Aliases = GCCRegAliases;
1040    NumAliases = llvm::array_lengthof(GCCRegAliases);
1041  }
1042  virtual bool validateAsmConstraint(const char *&Name,
1043                                     TargetInfo::ConstraintInfo &info) const;
1044  virtual std::string convertConstraint(const char Constraint) const;
1045  virtual const char *getClobbers() const {
1046    return "~{dirflag},~{fpsr},~{flags}";
1047  }
1048  virtual void getTargetDefines(const LangOptions &Opts,
1049                                MacroBuilder &Builder) const;
1050  virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1051                                 const std::string &Name,
1052                                 bool Enabled) const;
1053  virtual void getDefaultFeatures(const std::string &CPU,
1054                                  llvm::StringMap<bool> &Features) const;
1055  virtual void HandleTargetFeatures(std::vector<std::string> &Features);
1056};
1057
1058void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
1059                                       llvm::StringMap<bool> &Features) const {
1060  // FIXME: This should not be here.
1061  Features["3dnow"] = false;
1062  Features["3dnowa"] = false;
1063  Features["mmx"] = false;
1064  Features["sse"] = false;
1065  Features["sse2"] = false;
1066  Features["sse3"] = false;
1067  Features["ssse3"] = false;
1068  Features["sse41"] = false;
1069  Features["sse42"] = false;
1070  Features["aes"] = false;
1071  Features["avx"] = false;
1072
1073  // LLVM does not currently recognize this.
1074  // Features["sse4a"] = false;
1075
1076  // FIXME: This *really* should not be here.
1077
1078  // X86_64 always has SSE2.
1079  if (PointerWidth == 64)
1080    Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1081
1082  if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
1083      CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
1084    ;
1085  else if (CPU == "pentium-mmx" || CPU == "pentium2")
1086    setFeatureEnabled(Features, "mmx", true);
1087  else if (CPU == "pentium3")
1088    setFeatureEnabled(Features, "sse", true);
1089  else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64")
1090    setFeatureEnabled(Features, "sse2", true);
1091  else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona")
1092    setFeatureEnabled(Features, "sse3", true);
1093  else if (CPU == "core2")
1094    setFeatureEnabled(Features, "ssse3", true);
1095  else if (CPU == "penryn") {
1096    setFeatureEnabled(Features, "sse4", true);
1097    Features["sse42"] = false;
1098  } else if (CPU == "atom")
1099    setFeatureEnabled(Features, "sse3", true);
1100  else if (CPU == "corei7") {
1101    setFeatureEnabled(Features, "sse4", true);
1102    setFeatureEnabled(Features, "aes", true);
1103  } else if (CPU == "sandybridge") {
1104    setFeatureEnabled(Features, "sse4", true);
1105    setFeatureEnabled(Features, "aes", true);
1106//    setFeatureEnabled(Features, "avx", true);
1107  } else if (CPU == "k6" || CPU == "winchip-c6")
1108    setFeatureEnabled(Features, "mmx", true);
1109  else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
1110           CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
1111    setFeatureEnabled(Features, "mmx", true);
1112    setFeatureEnabled(Features, "3dnow", true);
1113  } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
1114    setFeatureEnabled(Features, "sse", true);
1115    setFeatureEnabled(Features, "3dnowa", true);
1116  } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
1117           CPU == "athlon-fx") {
1118    setFeatureEnabled(Features, "sse2", true);
1119    setFeatureEnabled(Features, "3dnowa", true);
1120  } else if (CPU == "k8-sse3") {
1121    setFeatureEnabled(Features, "sse3", true);
1122    setFeatureEnabled(Features, "3dnowa", true);
1123  } else if (CPU == "c3-2")
1124    setFeatureEnabled(Features, "sse", true);
1125}
1126
1127bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1128                                      const std::string &Name,
1129                                      bool Enabled) const {
1130  // FIXME: This *really* should not be here.  We need some way of translating
1131  // options into llvm subtarget features.
1132  if (!Features.count(Name) &&
1133      (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
1134    return false;
1135
1136  if (Enabled) {
1137    if (Name == "mmx")
1138      Features["mmx"] = true;
1139    else if (Name == "sse")
1140      Features["mmx"] = Features["sse"] = true;
1141    else if (Name == "sse2")
1142      Features["mmx"] = Features["sse"] = Features["sse2"] = true;
1143    else if (Name == "sse3")
1144      Features["mmx"] = Features["sse"] = Features["sse2"] =
1145        Features["sse3"] = true;
1146    else if (Name == "ssse3")
1147      Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1148        Features["ssse3"] = true;
1149    else if (Name == "sse4" || Name == "sse4.2")
1150      Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1151        Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
1152    else if (Name == "sse4.1")
1153      Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1154        Features["ssse3"] = Features["sse41"] = true;
1155    else if (Name == "3dnow")
1156      Features["3dnowa"] = true;
1157    else if (Name == "3dnowa")
1158      Features["3dnow"] = Features["3dnowa"] = true;
1159    else if (Name == "aes")
1160      Features["aes"] = true;
1161    else if (Name == "avx")
1162      Features["avx"] = true;
1163  } else {
1164    if (Name == "mmx")
1165      Features["mmx"] = Features["3dnow"] = Features["3dnowa"] =
1166        Features["sse"] = Features["sse2"] = Features["sse3"] =
1167        Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1168    else if (Name == "sse")
1169      Features["sse"] = Features["sse2"] = Features["sse3"] =
1170        Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1171    else if (Name == "sse2")
1172      Features["sse2"] = Features["sse3"] = Features["ssse3"] =
1173        Features["sse41"] = Features["sse42"] = false;
1174    else if (Name == "sse3")
1175      Features["sse3"] = Features["ssse3"] = Features["sse41"] =
1176        Features["sse42"] = false;
1177    else if (Name == "ssse3")
1178      Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1179    else if (Name == "sse4" || Name == "sse4.1")
1180      Features["sse41"] = Features["sse42"] = false;
1181    else if (Name == "sse4.2")
1182      Features["sse42"] = false;
1183    else if (Name == "3dnow")
1184      Features["3dnow"] = Features["3dnowa"] = false;
1185    else if (Name == "3dnowa")
1186      Features["3dnowa"] = false;
1187    else if (Name == "aes")
1188      Features["aes"] = false;
1189    else if (Name == "avx")
1190      Features["avx"] = false;
1191  }
1192
1193  return true;
1194}
1195
1196/// HandleTargetOptions - Perform initialization based on the user
1197/// configured set of features.
1198void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
1199  // Remember the maximum enabled sselevel.
1200  for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1201    // Ignore disabled features.
1202    if (Features[i][0] == '-')
1203      continue;
1204
1205    if (Features[i].substr(1) == "aes") {
1206      HasAES = true;
1207      continue;
1208    }
1209
1210    // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1211    // For now let it be enabled together with other SSE levels.
1212    if (Features[i].substr(1) == "avx") {
1213      HasAVX = true;
1214      continue;
1215    }
1216
1217    assert(Features[i][0] == '+' && "Invalid target feature!");
1218    X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1219      .Case("sse42", SSE42)
1220      .Case("sse41", SSE41)
1221      .Case("ssse3", SSSE3)
1222      .Case("sse3", SSE3)
1223      .Case("sse2", SSE2)
1224      .Case("sse", SSE1)
1225      .Case("mmx", MMX)
1226      .Default(NoMMXSSE);
1227    SSELevel = std::max(SSELevel, Level);
1228
1229    AMD3DNowEnum ThreeDNowLevel =
1230      llvm::StringSwitch<AMD3DNowEnum>(Features[i].substr(1))
1231        .Case("3dnowa", AMD3DNowAthlon)
1232        .Case("3dnow", AMD3DNow)
1233        .Default(NoAMD3DNow);
1234
1235    AMD3DNowLevel = std::max(AMD3DNowLevel, ThreeDNowLevel);
1236  }
1237}
1238
1239/// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
1240/// that are not tied to a specific subtarget.
1241void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
1242                                     MacroBuilder &Builder) const {
1243  // Target identification.
1244  if (PointerWidth == 64) {
1245    Builder.defineMacro("_LP64");
1246    Builder.defineMacro("__LP64__");
1247    Builder.defineMacro("__amd64__");
1248    Builder.defineMacro("__amd64");
1249    Builder.defineMacro("__x86_64");
1250    Builder.defineMacro("__x86_64__");
1251  } else {
1252    DefineStd(Builder, "i386", Opts);
1253  }
1254
1255  if (HasAES)
1256    Builder.defineMacro("__AES__");
1257
1258  if (HasAVX)
1259    Builder.defineMacro("__AVX__");
1260
1261  // Target properties.
1262  Builder.defineMacro("__LITTLE_ENDIAN__");
1263
1264  // Subtarget options.
1265  Builder.defineMacro("__nocona");
1266  Builder.defineMacro("__nocona__");
1267  Builder.defineMacro("__tune_nocona__");
1268  Builder.defineMacro("__REGISTER_PREFIX__", "");
1269
1270  // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1271  // functions in glibc header files that use FP Stack inline asm which the
1272  // backend can't deal with (PR879).
1273  Builder.defineMacro("__NO_MATH_INLINES");
1274
1275  // Each case falls through to the previous one here.
1276  switch (SSELevel) {
1277  case SSE42:
1278    Builder.defineMacro("__SSE4_2__");
1279  case SSE41:
1280    Builder.defineMacro("__SSE4_1__");
1281  case SSSE3:
1282    Builder.defineMacro("__SSSE3__");
1283  case SSE3:
1284    Builder.defineMacro("__SSE3__");
1285  case SSE2:
1286    Builder.defineMacro("__SSE2__");
1287    Builder.defineMacro("__SSE2_MATH__");  // -mfp-math=sse always implied.
1288  case SSE1:
1289    Builder.defineMacro("__SSE__");
1290    Builder.defineMacro("__SSE_MATH__");   // -mfp-math=sse always implied.
1291  case MMX:
1292    Builder.defineMacro("__MMX__");
1293  case NoMMXSSE:
1294    break;
1295  }
1296
1297  if (Opts.Microsoft && PointerWidth == 32) {
1298    switch (SSELevel) {
1299    case SSE42:
1300    case SSE41:
1301    case SSSE3:
1302    case SSE3:
1303    case SSE2:
1304      Builder.defineMacro("_M_IX86_FP", llvm::Twine(2));
1305      break;
1306    case SSE1:
1307      Builder.defineMacro("_M_IX86_FP", llvm::Twine(1));
1308      break;
1309    default:
1310      Builder.defineMacro("_M_IX86_FP", llvm::Twine(0));
1311    }
1312  }
1313
1314  // Each case falls through to the previous one here.
1315  switch (AMD3DNowLevel) {
1316  case AMD3DNowAthlon:
1317    Builder.defineMacro("__3dNOW_A__");
1318  case AMD3DNow:
1319    Builder.defineMacro("__3dNOW__");
1320  case NoAMD3DNow:
1321    break;
1322  }
1323}
1324
1325
1326bool
1327X86TargetInfo::validateAsmConstraint(const char *&Name,
1328                                     TargetInfo::ConstraintInfo &Info) const {
1329  switch (*Name) {
1330  default: return false;
1331  case 'Y': // first letter of a pair:
1332    switch (*(Name+1)) {
1333    default: return false;
1334    case '0':  // First SSE register.
1335    case 't':  // Any SSE register, when SSE2 is enabled.
1336    case 'i':  // Any SSE register, when SSE2 and inter-unit moves enabled.
1337    case 'm':  // any MMX register, when inter-unit moves enabled.
1338      break;   // falls through to setAllowsRegister.
1339  }
1340  case 'a': // eax.
1341  case 'b': // ebx.
1342  case 'c': // ecx.
1343  case 'd': // edx.
1344  case 'S': // esi.
1345  case 'D': // edi.
1346  case 'A': // edx:eax.
1347  case 'f': // any x87 floating point stack register.
1348  case 't': // top of floating point stack.
1349  case 'u': // second from top of floating point stack.
1350  case 'q': // Any register accessible as [r]l: a, b, c, and d.
1351  case 'y': // Any MMX register.
1352  case 'x': // Any SSE register.
1353  case 'Q': // Any register accessible as [r]h: a, b, c, and d.
1354  case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
1355  case 'l': // "Index" registers: any general register that can be used as an
1356            // index in a base+index memory access.
1357    Info.setAllowsRegister();
1358    return true;
1359  case 'C': // SSE floating point constant.
1360  case 'G': // x87 floating point constant.
1361  case 'e': // 32-bit signed integer constant for use with zero-extending
1362            // x86_64 instructions.
1363  case 'Z': // 32-bit unsigned integer constant for use with zero-extending
1364            // x86_64 instructions.
1365    return true;
1366  }
1367  return false;
1368}
1369
1370
1371std::string
1372X86TargetInfo::convertConstraint(const char Constraint) const {
1373  switch (Constraint) {
1374  case 'a': return std::string("{ax}");
1375  case 'b': return std::string("{bx}");
1376  case 'c': return std::string("{cx}");
1377  case 'd': return std::string("{dx}");
1378  case 'S': return std::string("{si}");
1379  case 'D': return std::string("{di}");
1380  case 'p': // address
1381    return std::string("im");
1382  case 't': // top of floating point stack.
1383    return std::string("{st}");
1384  case 'u': // second from top of floating point stack.
1385    return std::string("{st(1)}"); // second from top of floating point stack.
1386  default:
1387    return std::string(1, Constraint);
1388  }
1389}
1390} // end anonymous namespace
1391
1392namespace {
1393// X86-32 generic target
1394class X86_32TargetInfo : public X86TargetInfo {
1395public:
1396  X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1397    DoubleAlign = LongLongAlign = 32;
1398    LongDoubleWidth = 96;
1399    LongDoubleAlign = 32;
1400    DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1401                        "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
1402                        "a0:0:64-f80:32:32-n8:16:32";
1403    SizeType = UnsignedInt;
1404    PtrDiffType = SignedInt;
1405    IntPtrType = SignedInt;
1406    RegParmMax = 3;
1407
1408    // Use fpret for all types.
1409    RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
1410                             (1 << TargetInfo::Double) |
1411                             (1 << TargetInfo::LongDouble));
1412  }
1413  virtual const char *getVAListDeclaration() const {
1414    return "typedef char* __builtin_va_list;";
1415  }
1416
1417  int getEHDataRegisterNumber(unsigned RegNo) const {
1418    if (RegNo == 0) return 0;
1419    if (RegNo == 1) return 2;
1420    return -1;
1421  }
1422};
1423} // end anonymous namespace
1424
1425namespace {
1426class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
1427public:
1428  OpenBSDI386TargetInfo(const std::string& triple) :
1429    OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
1430    SizeType = UnsignedLong;
1431    IntPtrType = SignedLong;
1432    PtrDiffType = SignedLong;
1433  }
1434};
1435} // end anonymous namespace
1436
1437namespace {
1438class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
1439public:
1440  DarwinI386TargetInfo(const std::string& triple) :
1441    DarwinTargetInfo<X86_32TargetInfo>(triple) {
1442    LongDoubleWidth = 128;
1443    LongDoubleAlign = 128;
1444    SizeType = UnsignedLong;
1445    IntPtrType = SignedLong;
1446    DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1447                        "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
1448                        "a0:0:64-f80:128:128-n8:16:32";
1449    HasAlignMac68kSupport = true;
1450  }
1451
1452};
1453} // end anonymous namespace
1454
1455namespace {
1456// x86-32 Windows target
1457class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
1458public:
1459  WindowsX86_32TargetInfo(const std::string& triple)
1460    : WindowsTargetInfo<X86_32TargetInfo>(triple) {
1461    TLSSupported = false;
1462    WCharType = UnsignedShort;
1463    DoubleAlign = LongLongAlign = 64;
1464    DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1465                        "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
1466                        "v128:128:128-a0:0:64-f80:32:32-n8:16:32";
1467  }
1468  virtual void getTargetDefines(const LangOptions &Opts,
1469                                MacroBuilder &Builder) const {
1470    WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
1471  }
1472};
1473} // end anonymous namespace
1474
1475namespace {
1476
1477// x86-32 Windows Visual Studio target
1478class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
1479public:
1480  VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
1481    : WindowsX86_32TargetInfo(triple) {
1482    LongDoubleWidth = LongDoubleAlign = 64;
1483    LongDoubleFormat = &llvm::APFloat::IEEEdouble;
1484  }
1485  virtual void getTargetDefines(const LangOptions &Opts,
1486                                MacroBuilder &Builder) const {
1487    WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
1488    WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
1489    // The value of the following reflects processor type.
1490    // 300=386, 400=486, 500=Pentium, 600=Blend (default)
1491    // We lost the original triple, so we use the default.
1492    Builder.defineMacro("_M_IX86", "600");
1493  }
1494};
1495} // end anonymous namespace
1496
1497namespace {
1498// x86-32 MinGW target
1499class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
1500public:
1501  MinGWX86_32TargetInfo(const std::string& triple)
1502    : WindowsX86_32TargetInfo(triple) {
1503  }
1504  virtual void getTargetDefines(const LangOptions &Opts,
1505                                MacroBuilder &Builder) const {
1506    WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
1507    DefineStd(Builder, "WIN32", Opts);
1508    DefineStd(Builder, "WINNT", Opts);
1509    Builder.defineMacro("_X86_");
1510    Builder.defineMacro("__MSVCRT__");
1511    Builder.defineMacro("__MINGW32__");
1512
1513    // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
1514    // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
1515    if (Opts.Microsoft)
1516      // Provide "as-is" __declspec.
1517      Builder.defineMacro("__declspec", "__declspec");
1518    else
1519      // Provide alias of __attribute__ like mingw32-gcc.
1520      Builder.defineMacro("__declspec(a)", "__attribute__((a))");
1521  }
1522};
1523} // end anonymous namespace
1524
1525namespace {
1526// x86-32 Cygwin target
1527class CygwinX86_32TargetInfo : public X86_32TargetInfo {
1528public:
1529  CygwinX86_32TargetInfo(const std::string& triple)
1530    : X86_32TargetInfo(triple) {
1531    TLSSupported = false;
1532    WCharType = UnsignedShort;
1533    DoubleAlign = LongLongAlign = 64;
1534    DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1535                        "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
1536                        "a0:0:64-f80:32:32-n8:16:32";
1537  }
1538  virtual void getTargetDefines(const LangOptions &Opts,
1539                                MacroBuilder &Builder) const {
1540    X86_32TargetInfo::getTargetDefines(Opts, Builder);
1541    Builder.defineMacro("__CYGWIN__");
1542    Builder.defineMacro("__CYGWIN32__");
1543    DefineStd(Builder, "unix", Opts);
1544    if (Opts.CPlusPlus)
1545      Builder.defineMacro("_GNU_SOURCE");
1546  }
1547};
1548} // end anonymous namespace
1549
1550namespace {
1551// x86-32 Haiku target
1552class HaikuX86_32TargetInfo : public X86_32TargetInfo {
1553public:
1554  HaikuX86_32TargetInfo(const std::string& triple)
1555    : X86_32TargetInfo(triple) {
1556    SizeType = UnsignedLong;
1557    IntPtrType = SignedLong;
1558    PtrDiffType = SignedLong;
1559    this->UserLabelPrefix = "";
1560  }
1561  virtual void getTargetDefines(const LangOptions &Opts,
1562                                MacroBuilder &Builder) const {
1563    X86_32TargetInfo::getTargetDefines(Opts, Builder);
1564    Builder.defineMacro("__INTEL__");
1565    Builder.defineMacro("__HAIKU__");
1566  }
1567};
1568} // end anonymous namespace
1569
1570namespace {
1571// x86-64 generic target
1572class X86_64TargetInfo : public X86TargetInfo {
1573public:
1574  X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
1575    LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
1576    LongDoubleWidth = 128;
1577    LongDoubleAlign = 128;
1578    LargeArrayMinWidth = 128;
1579    LargeArrayAlign = 128;
1580    IntMaxType = SignedLong;
1581    UIntMaxType = UnsignedLong;
1582    Int64Type = SignedLong;
1583    RegParmMax = 6;
1584
1585    DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1586                        "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
1587                        "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64";
1588
1589    // Use fpret only for long double.
1590    RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
1591  }
1592  virtual const char *getVAListDeclaration() const {
1593    return "typedef struct __va_list_tag {"
1594           "  unsigned gp_offset;"
1595           "  unsigned fp_offset;"
1596           "  void* overflow_arg_area;"
1597           "  void* reg_save_area;"
1598           "} __va_list_tag;"
1599           "typedef __va_list_tag __builtin_va_list[1];";
1600  }
1601
1602  int getEHDataRegisterNumber(unsigned RegNo) const {
1603    if (RegNo == 0) return 0;
1604    if (RegNo == 1) return 1;
1605    return -1;
1606  }
1607};
1608} // end anonymous namespace
1609
1610namespace {
1611// x86-64 Windows target
1612class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
1613public:
1614  WindowsX86_64TargetInfo(const std::string& triple)
1615    : WindowsTargetInfo<X86_64TargetInfo>(triple) {
1616    TLSSupported = false;
1617    WCharType = UnsignedShort;
1618    LongWidth = LongAlign = 32;
1619    DoubleAlign = LongLongAlign = 64;
1620    IntMaxType = SignedLongLong;
1621    UIntMaxType = UnsignedLongLong;
1622    Int64Type = SignedLongLong;
1623    SizeType = UnsignedLongLong;
1624    PtrDiffType = SignedLongLong;
1625    IntPtrType = SignedLongLong;
1626    this->UserLabelPrefix = "";
1627  }
1628  virtual void getTargetDefines(const LangOptions &Opts,
1629                                MacroBuilder &Builder) const {
1630    WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
1631    Builder.defineMacro("_WIN64");
1632  }
1633  virtual const char *getVAListDeclaration() const {
1634    return "typedef char* __builtin_va_list;";
1635  }
1636};
1637} // end anonymous namespace
1638
1639namespace {
1640// x86-64 Windows Visual Studio target
1641class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
1642public:
1643  VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
1644    : WindowsX86_64TargetInfo(triple) {
1645    LongDoubleWidth = LongDoubleAlign = 64;
1646    LongDoubleFormat = &llvm::APFloat::IEEEdouble;
1647  }
1648  virtual void getTargetDefines(const LangOptions &Opts,
1649                                MacroBuilder &Builder) const {
1650    WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1651    WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
1652    Builder.defineMacro("_M_X64");
1653    Builder.defineMacro("_M_AMD64");
1654  }
1655};
1656} // end anonymous namespace
1657
1658namespace {
1659// x86-64 MinGW target
1660class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
1661public:
1662  MinGWX86_64TargetInfo(const std::string& triple)
1663    : WindowsX86_64TargetInfo(triple) {
1664  }
1665  virtual void getTargetDefines(const LangOptions &Opts,
1666                                MacroBuilder &Builder) const {
1667    WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1668    DefineStd(Builder, "WIN64", Opts);
1669    Builder.defineMacro("__MSVCRT__");
1670    Builder.defineMacro("__MINGW32__");
1671    Builder.defineMacro("__MINGW64__");
1672
1673    // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
1674    // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
1675    if (Opts.Microsoft)
1676      // Provide "as-is" __declspec.
1677      Builder.defineMacro("__declspec", "__declspec");
1678    else
1679      // Provide alias of __attribute__ like mingw32-gcc.
1680      Builder.defineMacro("__declspec(a)", "__attribute__((a))");
1681  }
1682};
1683} // end anonymous namespace
1684
1685namespace {
1686class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
1687public:
1688  DarwinX86_64TargetInfo(const std::string& triple)
1689      : DarwinTargetInfo<X86_64TargetInfo>(triple) {
1690    Int64Type = SignedLongLong;
1691  }
1692};
1693} // end anonymous namespace
1694
1695namespace {
1696class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
1697public:
1698  OpenBSDX86_64TargetInfo(const std::string& triple)
1699      : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
1700    IntMaxType = SignedLongLong;
1701    UIntMaxType = UnsignedLongLong;
1702    Int64Type = SignedLongLong;
1703  }
1704};
1705} // end anonymous namespace
1706
1707namespace {
1708class ARMTargetInfo : public TargetInfo {
1709  // Possible FPU choices.
1710  enum FPUMode {
1711    NoFPU,
1712    VFP2FPU,
1713    VFP3FPU,
1714    NeonFPU
1715  };
1716
1717  static bool FPUModeIsVFP(FPUMode Mode) {
1718    return Mode >= VFP2FPU && Mode <= NeonFPU;
1719  }
1720
1721  static const TargetInfo::GCCRegAlias GCCRegAliases[];
1722  static const char * const GCCRegNames[];
1723
1724  std::string ABI, CPU;
1725
1726  unsigned FPU : 3;
1727
1728  unsigned IsThumb : 1;
1729
1730  // Initialized via features.
1731  unsigned SoftFloat : 1;
1732  unsigned SoftFloatABI : 1;
1733
1734  static const Builtin::Info BuiltinInfo[];
1735
1736public:
1737  ARMTargetInfo(const std::string &TripleStr)
1738    : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
1739  {
1740    SizeType = UnsignedInt;
1741    PtrDiffType = SignedInt;
1742
1743    // {} in inline assembly are neon specifiers, not assembly variant
1744    // specifiers.
1745    NoAsmVariants = true;
1746
1747    // FIXME: Should we just treat this as a feature?
1748    IsThumb = getTriple().getArchName().startswith("thumb");
1749    if (IsThumb) {
1750      // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
1751      // so set preferred for small types to 32.
1752      DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1753                           "i64:64:64-f32:32:32-f64:64:64-"
1754                           "v64:64:64-v128:64:128-a0:0:32-n32");
1755    } else {
1756      DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1757                           "i64:64:64-f32:32:32-f64:64:64-"
1758                           "v64:64:64-v128:64:128-a0:0:64-n32");
1759    }
1760
1761    // ARM targets default to using the ARM C++ ABI.
1762    CXXABI = CXXABI_ARM;
1763  }
1764  virtual const char *getABI() const { return ABI.c_str(); }
1765  virtual bool setABI(const std::string &Name) {
1766    ABI = Name;
1767
1768    // The defaults (above) are for AAPCS, check if we need to change them.
1769    //
1770    // FIXME: We need support for -meabi... we could just mangle it into the
1771    // name.
1772    if (Name == "apcs-gnu") {
1773      DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
1774      SizeType = UnsignedLong;
1775
1776      // Do not respect the alignment of bit-field types when laying out
1777      // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
1778      UseBitFieldTypeAlignment = false;
1779
1780      if (IsThumb) {
1781        // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
1782        // so set preferred for small types to 32.
1783        DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1784                             "i64:32:32-f32:32:32-f64:32:32-"
1785                             "v64:32:64-v128:32:128-a0:0:32-n32");
1786      } else {
1787        DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1788                             "i64:32:64-f32:32:32-f64:32:64-"
1789                             "v64:32:64-v128:32:128-a0:0:32-n32");
1790      }
1791
1792      // FIXME: Override "preferred align" for double and long long.
1793    } else if (Name == "aapcs") {
1794      // FIXME: Enumerated types are variable width in straight AAPCS.
1795    } else if (Name == "aapcs-linux") {
1796      ;
1797    } else
1798      return false;
1799
1800    return true;
1801  }
1802
1803  void getDefaultFeatures(const std::string &CPU,
1804                          llvm::StringMap<bool> &Features) const {
1805    // FIXME: This should not be here.
1806    Features["vfp2"] = false;
1807    Features["vfp3"] = false;
1808    Features["neon"] = false;
1809
1810    if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
1811      Features["vfp2"] = true;
1812    else if (CPU == "cortex-a8" || CPU == "cortex-a9")
1813      Features["neon"] = true;
1814  }
1815
1816  virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1817                                 const std::string &Name,
1818                                 bool Enabled) const {
1819    if (Name == "soft-float" || Name == "soft-float-abi") {
1820      Features[Name] = Enabled;
1821    } else if (Name == "vfp2" || Name == "vfp3" || Name == "neon") {
1822      // These effectively are a single option, reset them when any is enabled.
1823      if (Enabled)
1824        Features["vfp2"] = Features["vfp3"] = Features["neon"] = false;
1825      Features[Name] = Enabled;
1826    } else
1827      return false;
1828
1829    return true;
1830  }
1831
1832  virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
1833    FPU = NoFPU;
1834    SoftFloat = SoftFloatABI = false;
1835    for (unsigned i = 0, e = Features.size(); i != e; ++i) {
1836      if (Features[i] == "+soft-float")
1837        SoftFloat = true;
1838      else if (Features[i] == "+soft-float-abi")
1839        SoftFloatABI = true;
1840      else if (Features[i] == "+vfp2")
1841        FPU = VFP2FPU;
1842      else if (Features[i] == "+vfp3")
1843        FPU = VFP3FPU;
1844      else if (Features[i] == "+neon")
1845        FPU = NeonFPU;
1846    }
1847
1848    // Remove front-end specific options which the backend handles differently.
1849    std::vector<std::string>::iterator it;
1850    it = std::find(Features.begin(), Features.end(), "+soft-float");
1851    if (it != Features.end())
1852      Features.erase(it);
1853    it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
1854    if (it != Features.end())
1855      Features.erase(it);
1856  }
1857
1858  static const char *getCPUDefineSuffix(llvm::StringRef Name) {
1859    return llvm::StringSwitch<const char*>(Name)
1860      .Cases("arm8", "arm810", "4")
1861      .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
1862      .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
1863      .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
1864      .Case("ep9312", "4T")
1865      .Cases("arm10tdmi", "arm1020t", "5T")
1866      .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
1867      .Case("arm926ej-s", "5TEJ")
1868      .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
1869      .Cases("xscale", "iwmmxt", "5TE")
1870      .Case("arm1136j-s", "6J")
1871      .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
1872      .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
1873      .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
1874      .Cases("cortex-a8", "cortex-a9", "7A")
1875      .Case("cortex-m3", "7M")
1876      .Case("cortex-m0", "6M")
1877      .Default(0);
1878  }
1879  virtual bool setCPU(const std::string &Name) {
1880    if (!getCPUDefineSuffix(Name))
1881      return false;
1882
1883    CPU = Name;
1884    return true;
1885  }
1886  virtual void getTargetDefines(const LangOptions &Opts,
1887                                MacroBuilder &Builder) const {
1888    // Target identification.
1889    Builder.defineMacro("__arm");
1890    Builder.defineMacro("__arm__");
1891
1892    // Target properties.
1893    Builder.defineMacro("__ARMEL__");
1894    Builder.defineMacro("__LITTLE_ENDIAN__");
1895    Builder.defineMacro("__REGISTER_PREFIX__", "");
1896
1897    llvm::StringRef CPUArch = getCPUDefineSuffix(CPU);
1898    Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
1899
1900    // Subtarget options.
1901
1902    // FIXME: It's more complicated than this and we don't really support
1903    // interworking.
1904    if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
1905      Builder.defineMacro("__THUMB_INTERWORK__");
1906
1907    if (ABI == "aapcs" || ABI == "aapcs-linux")
1908      Builder.defineMacro("__ARM_EABI__");
1909
1910    if (SoftFloat)
1911      Builder.defineMacro("__SOFTFP__");
1912
1913    if (CPU == "xscale")
1914      Builder.defineMacro("__XSCALE__");
1915
1916    bool IsThumb2 = IsThumb && (CPUArch == "6T2" || CPUArch.startswith("7"));
1917    if (IsThumb) {
1918      Builder.defineMacro("__THUMBEL__");
1919      Builder.defineMacro("__thumb__");
1920      if (IsThumb2)
1921        Builder.defineMacro("__thumb2__");
1922    }
1923
1924    // Note, this is always on in gcc, even though it doesn't make sense.
1925    Builder.defineMacro("__APCS_32__");
1926
1927    if (FPUModeIsVFP((FPUMode) FPU))
1928      Builder.defineMacro("__VFP_FP__");
1929
1930    // This only gets set when Neon instructions are actually available, unlike
1931    // the VFP define, hence the soft float and arch check. This is subtly
1932    // different from gcc, we follow the intent which was that it should be set
1933    // when Neon instructions are actually available.
1934    if (FPU == NeonFPU && !SoftFloat && IsThumb2)
1935      Builder.defineMacro("__ARM_NEON__");
1936  }
1937  virtual void getTargetBuiltins(const Builtin::Info *&Records,
1938                                 unsigned &NumRecords) const {
1939    Records = BuiltinInfo;
1940    NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
1941  }
1942  virtual const char *getVAListDeclaration() const {
1943    return "typedef char* __builtin_va_list;";
1944  }
1945  virtual void getGCCRegNames(const char * const *&Names,
1946                              unsigned &NumNames) const;
1947  virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1948                                unsigned &NumAliases) const;
1949  virtual bool validateAsmConstraint(const char *&Name,
1950                                     TargetInfo::ConstraintInfo &Info) const {
1951    // FIXME: Check if this is complete
1952    switch (*Name) {
1953    default:
1954    case 'l': // r0-r7
1955    case 'h': // r8-r15
1956    case 'w': // VFP Floating point register single precision
1957    case 'P': // VFP Floating point register double precision
1958      Info.setAllowsRegister();
1959      return true;
1960    }
1961    return false;
1962  }
1963  virtual const char *getClobbers() const {
1964    // FIXME: Is this really right?
1965    return "";
1966  }
1967};
1968
1969const char * const ARMTargetInfo::GCCRegNames[] = {
1970  // Integer registers
1971  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1972  "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
1973
1974  // Float registers
1975  "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
1976  "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
1977  "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
1978  "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
1979
1980  // Double registers
1981  "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
1982  "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
1983  "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
1984  "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
1985
1986  // Quad registers
1987  "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
1988  "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
1989};
1990
1991void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
1992                                   unsigned &NumNames) const {
1993  Names = GCCRegNames;
1994  NumNames = llvm::array_lengthof(GCCRegNames);
1995}
1996
1997const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
1998  { { "a1" }, "r0" },
1999  { { "a2" }, "r1" },
2000  { { "a3" }, "r2" },
2001  { { "a4" }, "r3" },
2002  { { "v1" }, "r4" },
2003  { { "v2" }, "r5" },
2004  { { "v3" }, "r6" },
2005  { { "v4" }, "r7" },
2006  { { "v5" }, "r8" },
2007  { { "v6", "rfp" }, "r9" },
2008  { { "sl" }, "r10" },
2009  { { "fp" }, "r11" },
2010  { { "ip" }, "r12" },
2011  { { "r13" }, "sp" },
2012  { { "r14" }, "lr" },
2013  { { "r15" }, "pc" },
2014  // The S, D and Q registers overlap, but aren't really aliases; we
2015  // don't want to substitute one of these for a different-sized one.
2016};
2017
2018void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2019                                       unsigned &NumAliases) const {
2020  Aliases = GCCRegAliases;
2021  NumAliases = llvm::array_lengthof(GCCRegAliases);
2022}
2023
2024const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
2025#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES, false },
2026#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
2027                                              ALL_LANGUAGES, false },
2028#include "clang/Basic/BuiltinsARM.def"
2029};
2030} // end anonymous namespace.
2031
2032
2033namespace {
2034class DarwinARMTargetInfo :
2035  public DarwinTargetInfo<ARMTargetInfo> {
2036protected:
2037  virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2038                            MacroBuilder &Builder) const {
2039    getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
2040  }
2041
2042public:
2043  DarwinARMTargetInfo(const std::string& triple)
2044    : DarwinTargetInfo<ARMTargetInfo>(triple) {
2045    HasAlignMac68kSupport = true;
2046  }
2047};
2048} // end anonymous namespace.
2049
2050namespace {
2051class SparcV8TargetInfo : public TargetInfo {
2052  static const TargetInfo::GCCRegAlias GCCRegAliases[];
2053  static const char * const GCCRegNames[];
2054  bool SoftFloat;
2055public:
2056  SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
2057    // FIXME: Support Sparc quad-precision long double?
2058    DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2059                        "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
2060  }
2061  virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2062                                 const std::string &Name,
2063                                 bool Enabled) const {
2064    if (Name == "soft-float")
2065      Features[Name] = Enabled;
2066    else
2067      return false;
2068
2069    return true;
2070  }
2071  virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
2072    SoftFloat = false;
2073    for (unsigned i = 0, e = Features.size(); i != e; ++i)
2074      if (Features[i] == "+soft-float")
2075        SoftFloat = true;
2076  }
2077  virtual void getTargetDefines(const LangOptions &Opts,
2078                                MacroBuilder &Builder) const {
2079    DefineStd(Builder, "sparc", Opts);
2080    Builder.defineMacro("__sparcv8");
2081    Builder.defineMacro("__REGISTER_PREFIX__", "");
2082
2083    if (SoftFloat)
2084      Builder.defineMacro("SOFT_FLOAT", "1");
2085  }
2086  virtual void getTargetBuiltins(const Builtin::Info *&Records,
2087                                 unsigned &NumRecords) const {
2088    // FIXME: Implement!
2089  }
2090  virtual const char *getVAListDeclaration() const {
2091    return "typedef void* __builtin_va_list;";
2092  }
2093  virtual void getGCCRegNames(const char * const *&Names,
2094                              unsigned &NumNames) const;
2095  virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2096                                unsigned &NumAliases) const;
2097  virtual bool validateAsmConstraint(const char *&Name,
2098                                     TargetInfo::ConstraintInfo &info) const {
2099    // FIXME: Implement!
2100    return false;
2101  }
2102  virtual const char *getClobbers() const {
2103    // FIXME: Implement!
2104    return "";
2105  }
2106};
2107
2108const char * const SparcV8TargetInfo::GCCRegNames[] = {
2109  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2110  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2111  "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2112  "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
2113};
2114
2115void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
2116                                       unsigned &NumNames) const {
2117  Names = GCCRegNames;
2118  NumNames = llvm::array_lengthof(GCCRegNames);
2119}
2120
2121const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
2122  { { "g0" }, "r0" },
2123  { { "g1" }, "r1" },
2124  { { "g2" }, "r2" },
2125  { { "g3" }, "r3" },
2126  { { "g4" }, "r4" },
2127  { { "g5" }, "r5" },
2128  { { "g6" }, "r6" },
2129  { { "g7" }, "r7" },
2130  { { "o0" }, "r8" },
2131  { { "o1" }, "r9" },
2132  { { "o2" }, "r10" },
2133  { { "o3" }, "r11" },
2134  { { "o4" }, "r12" },
2135  { { "o5" }, "r13" },
2136  { { "o6", "sp" }, "r14" },
2137  { { "o7" }, "r15" },
2138  { { "l0" }, "r16" },
2139  { { "l1" }, "r17" },
2140  { { "l2" }, "r18" },
2141  { { "l3" }, "r19" },
2142  { { "l4" }, "r20" },
2143  { { "l5" }, "r21" },
2144  { { "l6" }, "r22" },
2145  { { "l7" }, "r23" },
2146  { { "i0" }, "r24" },
2147  { { "i1" }, "r25" },
2148  { { "i2" }, "r26" },
2149  { { "i3" }, "r27" },
2150  { { "i4" }, "r28" },
2151  { { "i5" }, "r29" },
2152  { { "i6", "fp" }, "r30" },
2153  { { "i7" }, "r31" },
2154};
2155
2156void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2157                                         unsigned &NumAliases) const {
2158  Aliases = GCCRegAliases;
2159  NumAliases = llvm::array_lengthof(GCCRegAliases);
2160}
2161} // end anonymous namespace.
2162
2163namespace {
2164class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
2165public:
2166  AuroraUXSparcV8TargetInfo(const std::string& triple) :
2167      AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
2168    SizeType = UnsignedInt;
2169    PtrDiffType = SignedInt;
2170  }
2171};
2172class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
2173public:
2174  SolarisSparcV8TargetInfo(const std::string& triple) :
2175      SolarisTargetInfo<SparcV8TargetInfo>(triple) {
2176    SizeType = UnsignedInt;
2177    PtrDiffType = SignedInt;
2178  }
2179};
2180} // end anonymous namespace.
2181
2182namespace {
2183  class MSP430TargetInfo : public TargetInfo {
2184    static const char * const GCCRegNames[];
2185  public:
2186    MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
2187      TLSSupported = false;
2188      IntWidth = 16; IntAlign = 16;
2189      LongWidth = 32; LongLongWidth = 64;
2190      LongAlign = LongLongAlign = 16;
2191      PointerWidth = 16; PointerAlign = 16;
2192      SizeType = UnsignedInt;
2193      IntMaxType = SignedLong;
2194      UIntMaxType = UnsignedLong;
2195      IntPtrType = SignedShort;
2196      PtrDiffType = SignedInt;
2197      SigAtomicType = SignedLong;
2198      DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
2199   }
2200    virtual void getTargetDefines(const LangOptions &Opts,
2201                                  MacroBuilder &Builder) const {
2202      Builder.defineMacro("MSP430");
2203      Builder.defineMacro("__MSP430__");
2204      // FIXME: defines for different 'flavours' of MCU
2205    }
2206    virtual void getTargetBuiltins(const Builtin::Info *&Records,
2207                                   unsigned &NumRecords) const {
2208     // FIXME: Implement.
2209      Records = 0;
2210      NumRecords = 0;
2211    }
2212    virtual void getGCCRegNames(const char * const *&Names,
2213                                unsigned &NumNames) const;
2214    virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2215                                  unsigned &NumAliases) const {
2216      // No aliases.
2217      Aliases = 0;
2218      NumAliases = 0;
2219    }
2220    virtual bool validateAsmConstraint(const char *&Name,
2221                                       TargetInfo::ConstraintInfo &info) const {
2222      // No target constraints for now.
2223      return false;
2224    }
2225    virtual const char *getClobbers() const {
2226      // FIXME: Is this really right?
2227      return "";
2228    }
2229    virtual const char *getVAListDeclaration() const {
2230      // FIXME: implement
2231      return "typedef char* __builtin_va_list;";
2232   }
2233  };
2234
2235  const char * const MSP430TargetInfo::GCCRegNames[] = {
2236    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2237    "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2238  };
2239
2240  void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
2241                                        unsigned &NumNames) const {
2242    Names = GCCRegNames;
2243    NumNames = llvm::array_lengthof(GCCRegNames);
2244  }
2245}
2246
2247
2248namespace {
2249  class SystemZTargetInfo : public TargetInfo {
2250    static const char * const GCCRegNames[];
2251  public:
2252    SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
2253      TLSSupported = false;
2254      IntWidth = IntAlign = 32;
2255      LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
2256      PointerWidth = PointerAlign = 64;
2257      DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
2258      "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
2259   }
2260    virtual void getTargetDefines(const LangOptions &Opts,
2261                                  MacroBuilder &Builder) const {
2262      Builder.defineMacro("__s390__");
2263      Builder.defineMacro("__s390x__");
2264    }
2265    virtual void getTargetBuiltins(const Builtin::Info *&Records,
2266                                   unsigned &NumRecords) const {
2267      // FIXME: Implement.
2268      Records = 0;
2269      NumRecords = 0;
2270    }
2271
2272    virtual void getGCCRegNames(const char * const *&Names,
2273                                unsigned &NumNames) const;
2274    virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2275                                  unsigned &NumAliases) const {
2276      // No aliases.
2277      Aliases = 0;
2278      NumAliases = 0;
2279    }
2280    virtual bool validateAsmConstraint(const char *&Name,
2281                                       TargetInfo::ConstraintInfo &info) const {
2282      // FIXME: implement
2283      return true;
2284    }
2285    virtual const char *getClobbers() const {
2286      // FIXME: Is this really right?
2287      return "";
2288    }
2289    virtual const char *getVAListDeclaration() const {
2290      // FIXME: implement
2291      return "typedef char* __builtin_va_list;";
2292   }
2293  };
2294
2295  const char * const SystemZTargetInfo::GCCRegNames[] = {
2296    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2297    "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2298  };
2299
2300  void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
2301                                         unsigned &NumNames) const {
2302    Names = GCCRegNames;
2303    NumNames = llvm::array_lengthof(GCCRegNames);
2304  }
2305}
2306
2307namespace {
2308  class BlackfinTargetInfo : public TargetInfo {
2309    static const char * const GCCRegNames[];
2310  public:
2311    BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
2312      TLSSupported = false;
2313      DoubleAlign = 32;
2314      LongLongAlign = 32;
2315      LongDoubleAlign = 32;
2316      DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
2317    }
2318
2319    virtual void getTargetDefines(const LangOptions &Opts,
2320                                  MacroBuilder &Builder) const {
2321      DefineStd(Builder, "bfin", Opts);
2322      DefineStd(Builder, "BFIN", Opts);
2323      Builder.defineMacro("__ADSPBLACKFIN__");
2324      // FIXME: This one is really dependent on -mcpu
2325      Builder.defineMacro("__ADSPLPBLACKFIN__");
2326      // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
2327    }
2328
2329    virtual void getTargetBuiltins(const Builtin::Info *&Records,
2330                                   unsigned &NumRecords) const {
2331      // FIXME: Implement.
2332      Records = 0;
2333      NumRecords = 0;
2334    }
2335
2336    virtual void getGCCRegNames(const char * const *&Names,
2337                                unsigned &NumNames) const;
2338
2339    virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2340                                  unsigned &NumAliases) const {
2341      // No aliases.
2342      Aliases = 0;
2343      NumAliases = 0;
2344    }
2345
2346    virtual bool validateAsmConstraint(const char *&Name,
2347                                       TargetInfo::ConstraintInfo &Info) const {
2348      if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
2349        Info.setAllowsRegister();
2350        return true;
2351      }
2352      return false;
2353    }
2354
2355    virtual const char *getClobbers() const {
2356      return "";
2357    }
2358
2359    virtual const char *getVAListDeclaration() const {
2360      return "typedef char* __builtin_va_list;";
2361    }
2362  };
2363
2364  const char * const BlackfinTargetInfo::GCCRegNames[] = {
2365    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2366    "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
2367    "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
2368    "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
2369    "a0", "a1", "cc",
2370    "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
2371    "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
2372  };
2373
2374  void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
2375                                          unsigned &NumNames) const {
2376    Names = GCCRegNames;
2377    NumNames = llvm::array_lengthof(GCCRegNames);
2378  }
2379}
2380
2381namespace {
2382
2383  // LLVM and Clang cannot be used directly to output native binaries for
2384  // target, but is used to compile C code to llvm bitcode with correct
2385  // type and alignment information.
2386  //
2387  // TCE uses the llvm bitcode as input and uses it for generating customized
2388  // target processor and program binary. TCE co-design environment is
2389  // publicly available in http://tce.cs.tut.fi
2390
2391  class TCETargetInfo : public TargetInfo{
2392  public:
2393    TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
2394      TLSSupported = false;
2395      IntWidth = 32;
2396      LongWidth = LongLongWidth = 32;
2397      PointerWidth = 32;
2398      IntAlign = 32;
2399      LongAlign = LongLongAlign = 32;
2400      PointerAlign = 32;
2401      SizeType = UnsignedInt;
2402      IntMaxType = SignedLong;
2403      UIntMaxType = UnsignedLong;
2404      IntPtrType = SignedInt;
2405      PtrDiffType = SignedInt;
2406      FloatWidth = 32;
2407      FloatAlign = 32;
2408      DoubleWidth = 32;
2409      DoubleAlign = 32;
2410      LongDoubleWidth = 32;
2411      LongDoubleAlign = 32;
2412      FloatFormat = &llvm::APFloat::IEEEsingle;
2413      DoubleFormat = &llvm::APFloat::IEEEsingle;
2414      LongDoubleFormat = &llvm::APFloat::IEEEsingle;
2415      DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
2416                          "i16:16:32-i32:32:32-i64:32:32-"
2417                          "f32:32:32-f64:32:32-v64:32:32-"
2418                          "v128:32:32-a0:0:32-n32";
2419    }
2420
2421    virtual void getTargetDefines(const LangOptions &Opts,
2422                                  MacroBuilder &Builder) const {
2423      DefineStd(Builder, "tce", Opts);
2424      Builder.defineMacro("__TCE__");
2425      Builder.defineMacro("__TCE_V1__");
2426    }
2427    virtual void getTargetBuiltins(const Builtin::Info *&Records,
2428                                   unsigned &NumRecords) const {}
2429    virtual const char *getClobbers() const {
2430      return "";
2431    }
2432    virtual const char *getVAListDeclaration() const {
2433      return "typedef void* __builtin_va_list;";
2434    }
2435    virtual void getGCCRegNames(const char * const *&Names,
2436                                unsigned &NumNames) const {}
2437    virtual bool validateAsmConstraint(const char *&Name,
2438                                       TargetInfo::ConstraintInfo &info) const {
2439      return true;
2440    }
2441    virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2442                                  unsigned &NumAliases) const {}
2443  };
2444}
2445
2446namespace {
2447class MipsTargetInfo : public TargetInfo {
2448  std::string ABI, CPU;
2449  static const TargetInfo::GCCRegAlias GCCRegAliases[];
2450  static const char * const GCCRegNames[];
2451public:
2452  MipsTargetInfo(const std::string& triple) : TargetInfo(triple), ABI("o32") {
2453    DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2454                        "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2455  }
2456  virtual const char *getABI() const { return ABI.c_str(); }
2457  virtual bool setABI(const std::string &Name) {
2458
2459    if ((Name == "o32") || (Name == "eabi")) {
2460      ABI = Name;
2461      return true;
2462    } else
2463      return false;
2464  }
2465  virtual bool setCPU(const std::string &Name) {
2466    CPU = Name;
2467    return true;
2468  }
2469  void getDefaultFeatures(const std::string &CPU,
2470                          llvm::StringMap<bool> &Features) const {
2471    Features[ABI] = true;
2472    Features[CPU] = true;
2473  }
2474  virtual void getArchDefines(const LangOptions &Opts,
2475                                MacroBuilder &Builder) const {
2476    if (ABI == "o32")
2477      Builder.defineMacro("__mips_o32");
2478    else if (ABI == "eabi")
2479      Builder.defineMacro("__mips_eabi");
2480  }
2481  virtual void getTargetDefines(const LangOptions &Opts,
2482                                MacroBuilder &Builder) const {
2483    DefineStd(Builder, "mips", Opts);
2484    Builder.defineMacro("_mips");
2485    DefineStd(Builder, "MIPSEB", Opts);
2486    Builder.defineMacro("_MIPSEB");
2487    Builder.defineMacro("__REGISTER_PREFIX__", "");
2488    getArchDefines(Opts, Builder);
2489  }
2490  virtual void getTargetBuiltins(const Builtin::Info *&Records,
2491                                 unsigned &NumRecords) const {
2492    // FIXME: Implement!
2493  }
2494  virtual const char *getVAListDeclaration() const {
2495    return "typedef void* __builtin_va_list;";
2496  }
2497  virtual void getGCCRegNames(const char * const *&Names,
2498                              unsigned &NumNames) const;
2499  virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2500                                unsigned &NumAliases) const;
2501  virtual bool validateAsmConstraint(const char *&Name,
2502                                     TargetInfo::ConstraintInfo &Info) const {
2503    switch (*Name) {
2504    default:
2505    case 'r': // CPU registers.
2506    case 'd': // Equivalent to "r" unless generating MIPS16 code.
2507    case 'y': // Equivalent to "r", backwards compatibility only.
2508    case 'f': // floating-point registers.
2509      Info.setAllowsRegister();
2510      return true;
2511    }
2512    return false;
2513  }
2514
2515  virtual const char *getClobbers() const {
2516    // FIXME: Implement!
2517    return "";
2518  }
2519};
2520
2521const char * const MipsTargetInfo::GCCRegNames[] = {
2522  "$0",   "$1",   "$2",   "$3",   "$4",   "$5",   "$6",   "$7",
2523  "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
2524  "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
2525  "$24",  "$25",  "$26",  "$27",  "$28",  "$sp",  "$fp",  "$31",
2526  "$f0",  "$f1",  "$f2",  "$f3",  "$f4",  "$f5",  "$f6",  "$f7",
2527  "$f8",  "$f9",  "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
2528  "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
2529  "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
2530  "hi",   "lo",   "",     "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
2531  "$fcc5","$fcc6","$fcc7"
2532};
2533
2534void MipsTargetInfo::getGCCRegNames(const char * const *&Names,
2535                                       unsigned &NumNames) const {
2536  Names = GCCRegNames;
2537  NumNames = llvm::array_lengthof(GCCRegNames);
2538}
2539
2540const TargetInfo::GCCRegAlias MipsTargetInfo::GCCRegAliases[] = {
2541  { { "at" },  "$1" },
2542  { { "v0" },  "$2" },
2543  { { "v1" },  "$3" },
2544  { { "a0" },  "$4" },
2545  { { "a1" },  "$5" },
2546  { { "a2" },  "$6" },
2547  { { "a3" },  "$7" },
2548  { { "t0" },  "$8" },
2549  { { "t1" },  "$9" },
2550  { { "t2" }, "$10" },
2551  { { "t3" }, "$11" },
2552  { { "t4" }, "$12" },
2553  { { "t5" }, "$13" },
2554  { { "t6" }, "$14" },
2555  { { "t7" }, "$15" },
2556  { { "s0" }, "$16" },
2557  { { "s1" }, "$17" },
2558  { { "s2" }, "$18" },
2559  { { "s3" }, "$19" },
2560  { { "s4" }, "$20" },
2561  { { "s5" }, "$21" },
2562  { { "s6" }, "$22" },
2563  { { "s7" }, "$23" },
2564  { { "t8" }, "$24" },
2565  { { "t9" }, "$25" },
2566  { { "k0" }, "$26" },
2567  { { "k1" }, "$27" },
2568  { { "gp" }, "$28" },
2569  { { "sp" }, "$29" },
2570  { { "fp" }, "$30" },
2571  { { "ra" }, "$31" }
2572};
2573
2574void MipsTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2575                                         unsigned &NumAliases) const {
2576  Aliases = GCCRegAliases;
2577  NumAliases = llvm::array_lengthof(GCCRegAliases);
2578}
2579} // end anonymous namespace.
2580
2581namespace {
2582class MipselTargetInfo : public MipsTargetInfo {
2583public:
2584  MipselTargetInfo(const std::string& triple) : MipsTargetInfo(triple) {
2585    DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2586                        "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2587  }
2588
2589  virtual void getTargetDefines(const LangOptions &Opts,
2590                                MacroBuilder &Builder) const;
2591};
2592
2593void MipselTargetInfo::getTargetDefines(const LangOptions &Opts,
2594                                        MacroBuilder &Builder) const {
2595  DefineStd(Builder, "mips", Opts);
2596  Builder.defineMacro("_mips");
2597  DefineStd(Builder, "MIPSEL", Opts);
2598  Builder.defineMacro("_MIPSEL");
2599  Builder.defineMacro("__REGISTER_PREFIX__", "");
2600  getArchDefines(Opts, Builder);
2601}
2602} // end anonymous namespace.
2603
2604//===----------------------------------------------------------------------===//
2605// Driver code
2606//===----------------------------------------------------------------------===//
2607
2608static TargetInfo *AllocateTarget(const std::string &T) {
2609  llvm::Triple Triple(T);
2610  llvm::Triple::OSType os = Triple.getOS();
2611
2612  switch (Triple.getArch()) {
2613  default:
2614    return NULL;
2615
2616  case llvm::Triple::arm:
2617  case llvm::Triple::thumb:
2618    if (Triple.isOSDarwin())
2619      return new DarwinARMTargetInfo(T);
2620
2621    switch (os) {
2622    case llvm::Triple::Linux:
2623      return new LinuxTargetInfo<ARMTargetInfo>(T);
2624    case llvm::Triple::FreeBSD:
2625      return new FreeBSDTargetInfo<ARMTargetInfo>(T);
2626    default:
2627      return new ARMTargetInfo(T);
2628    }
2629
2630  case llvm::Triple::bfin:
2631    return new BlackfinTargetInfo(T);
2632
2633  case llvm::Triple::msp430:
2634    return new MSP430TargetInfo(T);
2635
2636  case llvm::Triple::mips:
2637    if (os == llvm::Triple::Psp)
2638      return new PSPTargetInfo<MipsTargetInfo>(T);
2639    if (os == llvm::Triple::Linux)
2640      return new LinuxTargetInfo<MipsTargetInfo>(T);
2641    return new MipsTargetInfo(T);
2642
2643  case llvm::Triple::mipsel:
2644    if (os == llvm::Triple::Psp)
2645      return new PSPTargetInfo<MipselTargetInfo>(T);
2646    if (os == llvm::Triple::Linux)
2647      return new LinuxTargetInfo<MipselTargetInfo>(T);
2648    return new MipselTargetInfo(T);
2649
2650  case llvm::Triple::ppc:
2651    if (Triple.isOSDarwin())
2652      return new DarwinPPC32TargetInfo(T);
2653    else if (os == llvm::Triple::FreeBSD)
2654      return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
2655    return new PPC32TargetInfo(T);
2656
2657  case llvm::Triple::ppc64:
2658    if (Triple.isOSDarwin())
2659      return new DarwinPPC64TargetInfo(T);
2660    else if (os == llvm::Triple::Lv2)
2661      return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
2662    else if (os == llvm::Triple::FreeBSD)
2663      return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
2664    return new PPC64TargetInfo(T);
2665
2666  case llvm::Triple::mblaze:
2667    return new MBlazeTargetInfo(T);
2668
2669  case llvm::Triple::sparc:
2670    if (os == llvm::Triple::AuroraUX)
2671      return new AuroraUXSparcV8TargetInfo(T);
2672    if (os == llvm::Triple::Solaris)
2673      return new SolarisSparcV8TargetInfo(T);
2674    return new SparcV8TargetInfo(T);
2675
2676  // FIXME: Need a real SPU target.
2677  case llvm::Triple::cellspu:
2678    return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
2679
2680  case llvm::Triple::systemz:
2681    return new SystemZTargetInfo(T);
2682
2683  case llvm::Triple::tce:
2684    return new TCETargetInfo(T);
2685
2686  case llvm::Triple::x86:
2687    if (Triple.isOSDarwin())
2688      return new DarwinI386TargetInfo(T);
2689
2690    switch (os) {
2691    case llvm::Triple::AuroraUX:
2692      return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
2693    case llvm::Triple::Linux:
2694      return new LinuxTargetInfo<X86_32TargetInfo>(T);
2695    case llvm::Triple::DragonFly:
2696      return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
2697    case llvm::Triple::NetBSD:
2698      return new NetBSDTargetInfo<X86_32TargetInfo>(T);
2699    case llvm::Triple::OpenBSD:
2700      return new OpenBSDI386TargetInfo(T);
2701    case llvm::Triple::FreeBSD:
2702      return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
2703    case llvm::Triple::Minix:
2704      return new MinixTargetInfo<X86_32TargetInfo>(T);
2705    case llvm::Triple::Solaris:
2706      return new SolarisTargetInfo<X86_32TargetInfo>(T);
2707    case llvm::Triple::Cygwin:
2708      return new CygwinX86_32TargetInfo(T);
2709    case llvm::Triple::MinGW32:
2710      return new MinGWX86_32TargetInfo(T);
2711    case llvm::Triple::Win32:
2712      return new VisualStudioWindowsX86_32TargetInfo(T);
2713    case llvm::Triple::Haiku:
2714      return new HaikuX86_32TargetInfo(T);
2715    default:
2716      return new X86_32TargetInfo(T);
2717    }
2718
2719  case llvm::Triple::x86_64:
2720    if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
2721      return new DarwinX86_64TargetInfo(T);
2722
2723    switch (os) {
2724    case llvm::Triple::AuroraUX:
2725      return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
2726    case llvm::Triple::Linux:
2727      return new LinuxTargetInfo<X86_64TargetInfo>(T);
2728    case llvm::Triple::DragonFly:
2729      return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
2730    case llvm::Triple::NetBSD:
2731      return new NetBSDTargetInfo<X86_64TargetInfo>(T);
2732    case llvm::Triple::OpenBSD:
2733      return new OpenBSDX86_64TargetInfo(T);
2734    case llvm::Triple::FreeBSD:
2735      return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
2736    case llvm::Triple::Solaris:
2737      return new SolarisTargetInfo<X86_64TargetInfo>(T);
2738    case llvm::Triple::MinGW32:
2739      return new MinGWX86_64TargetInfo(T);
2740    case llvm::Triple::Win32:   // This is what Triple.h supports now.
2741      return new VisualStudioWindowsX86_64TargetInfo(T);
2742    default:
2743      return new X86_64TargetInfo(T);
2744    }
2745  }
2746}
2747
2748/// CreateTargetInfo - Return the target info object for the specified target
2749/// triple.
2750TargetInfo *TargetInfo::CreateTargetInfo(Diagnostic &Diags,
2751                                         TargetOptions &Opts) {
2752  llvm::Triple Triple(Opts.Triple);
2753
2754  // Construct the target
2755  llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
2756  if (!Target) {
2757    Diags.Report(diag::err_target_unknown_triple) << Triple.str();
2758    return 0;
2759  }
2760
2761  // Set the target CPU if specified.
2762  if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
2763    Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
2764    return 0;
2765  }
2766
2767  // Set the target ABI if specified.
2768  if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
2769    Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
2770    return 0;
2771  }
2772
2773  // Set the target C++ ABI.
2774  if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
2775    Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
2776    return 0;
2777  }
2778
2779  // Compute the default target features, we need the target to handle this
2780  // because features may have dependencies on one another.
2781  llvm::StringMap<bool> Features;
2782  Target->getDefaultFeatures(Opts.CPU, Features);
2783
2784  // Apply the user specified deltas.
2785  for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
2786         ie = Opts.Features.end(); it != ie; ++it) {
2787    const char *Name = it->c_str();
2788
2789    // Apply the feature via the target.
2790    if ((Name[0] != '-' && Name[0] != '+') ||
2791        !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
2792      Diags.Report(diag::err_target_invalid_feature) << Name;
2793      return 0;
2794    }
2795  }
2796
2797  // Add the features to the compile options.
2798  //
2799  // FIXME: If we are completely confident that we have the right set, we only
2800  // need to pass the minuses.
2801  Opts.Features.clear();
2802  for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
2803         ie = Features.end(); it != ie; ++it)
2804    Opts.Features.push_back(std::string(it->second ? "+" : "-") + it->first());
2805  Target->HandleTargetFeatures(Opts.Features);
2806
2807  return Target.take();
2808}
2809