1//===--- TargetInfo.h - Expose information about the target -----*- C++ -*-===//
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 defines the TargetInfo interface.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_BASIC_TARGETINFO_H
15#define LLVM_CLANG_BASIC_TARGETINFO_H
16
17#include "clang/Basic/LLVM.h"
18#include "llvm/ADT/IntrusiveRefCntPtr.h"
19#include "llvm/ADT/StringMap.h"
20#include "llvm/ADT/StringRef.h"
21#include "llvm/ADT/StringSwitch.h"
22#include "llvm/ADT/Triple.h"
23#include "llvm/Support/DataTypes.h"
24#include "clang/Basic/AddressSpaces.h"
25#include "clang/Basic/VersionTuple.h"
26#include <cassert>
27#include <vector>
28#include <string>
29
30namespace llvm {
31struct fltSemantics;
32}
33
34namespace clang {
35class DiagnosticsEngine;
36class LangOptions;
37class MacroBuilder;
38class SourceLocation;
39class SourceManager;
40class TargetOptions;
41
42namespace Builtin { struct Info; }
43
44/// TargetCXXABI - The types of C++ ABIs for which we can generate code.
45enum TargetCXXABI {
46  /// The generic ("Itanium") C++ ABI, documented at:
47  ///   http://www.codesourcery.com/public/cxx-abi/
48  CXXABI_Itanium,
49
50  /// The ARM C++ ABI, based largely on the Itanium ABI but with
51  /// significant differences.
52  ///    http://infocenter.arm.com
53  ///                    /help/topic/com.arm.doc.ihi0041c/IHI0041C_cppabi.pdf
54  CXXABI_ARM,
55
56  /// The Visual Studio ABI.  Only scattered official documentation exists.
57  CXXABI_Microsoft
58};
59
60/// TargetInfo - This class exposes information about the current target.
61///
62class TargetInfo : public llvm::RefCountedBase<TargetInfo> {
63  llvm::Triple Triple;
64protected:
65  // Target values set by the ctor of the actual target implementation.  Default
66  // values are specified by the TargetInfo constructor.
67  bool TLSSupported;
68  bool NoAsmVariants;  // True if {|} are normal characters.
69  unsigned char PointerWidth, PointerAlign;
70  unsigned char BoolWidth, BoolAlign;
71  unsigned char IntWidth, IntAlign;
72  unsigned char HalfWidth, HalfAlign;
73  unsigned char FloatWidth, FloatAlign;
74  unsigned char DoubleWidth, DoubleAlign;
75  unsigned char LongDoubleWidth, LongDoubleAlign;
76  unsigned char LargeArrayMinWidth, LargeArrayAlign;
77  unsigned char LongWidth, LongAlign;
78  unsigned char LongLongWidth, LongLongAlign;
79  unsigned char MaxAtomicPromoteWidth, MaxAtomicInlineWidth;
80  const char *DescriptionString;
81  const char *UserLabelPrefix;
82  const char *MCountName;
83  const llvm::fltSemantics *HalfFormat, *FloatFormat, *DoubleFormat,
84    *LongDoubleFormat;
85  unsigned char RegParmMax, SSERegParmMax;
86  TargetCXXABI CXXABI;
87  const LangAS::Map *AddrSpaceMap;
88
89  mutable StringRef PlatformName;
90  mutable VersionTuple PlatformMinVersion;
91
92  unsigned HasAlignMac68kSupport : 1;
93  unsigned RealTypeUsesObjCFPRet : 3;
94
95  // TargetInfo Constructor.  Default initializes all fields.
96  TargetInfo(const std::string &T);
97
98public:
99  /// CreateTargetInfo - Construct a target for the given options.
100  ///
101  /// \param Opts - The options to use to initialize the target. The target may
102  /// modify the options to canonicalize the target feature information to match
103  /// what the backend expects.
104  static TargetInfo* CreateTargetInfo(DiagnosticsEngine &Diags,
105                                      TargetOptions &Opts);
106
107  virtual ~TargetInfo();
108
109  ///===---- Target Data Type Query Methods -------------------------------===//
110  enum IntType {
111    NoInt = 0,
112    SignedShort,
113    UnsignedShort,
114    SignedInt,
115    UnsignedInt,
116    SignedLong,
117    UnsignedLong,
118    SignedLongLong,
119    UnsignedLongLong
120  };
121
122  enum RealType {
123    Float = 0,
124    Double,
125    LongDouble
126  };
127
128protected:
129  IntType SizeType, IntMaxType, UIntMaxType, PtrDiffType, IntPtrType, WCharType,
130          WIntType, Char16Type, Char32Type, Int64Type, SigAtomicType;
131
132  /// Control whether the alignment of bit-field types is respected when laying
133  /// out structures. If true, then the alignment of the bit-field type will be
134  /// used to (a) impact the alignment of the containing structure, and (b)
135  /// ensure that the individual bit-field will not straddle an alignment
136  /// boundary.
137  unsigned UseBitFieldTypeAlignment : 1;
138
139  /// Control whether zero length bitfields (e.g., int : 0;) force alignment of
140  /// the next bitfield.  If the alignment of the zero length bitfield is
141  /// greater than the member that follows it, `bar', `bar' will be aligned as
142  /// the type of the zero-length bitfield.
143  unsigned UseZeroLengthBitfieldAlignment : 1;
144
145  /// If non-zero, specifies a fixed alignment value for bitfields that follow
146  /// zero length bitfield, regardless of the zero length bitfield type.
147  unsigned ZeroLengthBitfieldBoundary;
148
149public:
150  IntType getSizeType() const { return SizeType; }
151  IntType getIntMaxType() const { return IntMaxType; }
152  IntType getUIntMaxType() const { return UIntMaxType; }
153  IntType getPtrDiffType(unsigned AddrSpace) const {
154    return AddrSpace == 0 ? PtrDiffType : getPtrDiffTypeV(AddrSpace);
155  }
156  IntType getIntPtrType() const { return IntPtrType; }
157  IntType getWCharType() const { return WCharType; }
158  IntType getWIntType() const { return WIntType; }
159  IntType getChar16Type() const { return Char16Type; }
160  IntType getChar32Type() const { return Char32Type; }
161  IntType getInt64Type() const { return Int64Type; }
162  IntType getSigAtomicType() const { return SigAtomicType; }
163
164
165  /// getTypeWidth - Return the width (in bits) of the specified integer type
166  /// enum. For example, SignedInt -> getIntWidth().
167  unsigned getTypeWidth(IntType T) const;
168
169  /// getTypeAlign - Return the alignment (in bits) of the specified integer
170  /// type enum. For example, SignedInt -> getIntAlign().
171  unsigned getTypeAlign(IntType T) const;
172
173  /// isTypeSigned - Return whether an integer types is signed. Returns true if
174  /// the type is signed; false otherwise.
175  static bool isTypeSigned(IntType T);
176
177  /// getPointerWidth - Return the width of pointers on this target, for the
178  /// specified address space.
179  uint64_t getPointerWidth(unsigned AddrSpace) const {
180    return AddrSpace == 0 ? PointerWidth : getPointerWidthV(AddrSpace);
181  }
182  uint64_t getPointerAlign(unsigned AddrSpace) const {
183    return AddrSpace == 0 ? PointerAlign : getPointerAlignV(AddrSpace);
184  }
185
186  /// getBoolWidth/Align - Return the size of '_Bool' and C++ 'bool' for this
187  /// target, in bits.
188  unsigned getBoolWidth() const { return BoolWidth; }
189  unsigned getBoolAlign() const { return BoolAlign; }
190
191  unsigned getCharWidth() const { return 8; } // FIXME
192  unsigned getCharAlign() const { return 8; } // FIXME
193
194  /// getShortWidth/Align - Return the size of 'signed short' and
195  /// 'unsigned short' for this target, in bits.
196  unsigned getShortWidth() const { return 16; } // FIXME
197  unsigned getShortAlign() const { return 16; } // FIXME
198
199  /// getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for
200  /// this target, in bits.
201  unsigned getIntWidth() const { return IntWidth; }
202  unsigned getIntAlign() const { return IntAlign; }
203
204  /// getLongWidth/Align - Return the size of 'signed long' and 'unsigned long'
205  /// for this target, in bits.
206  unsigned getLongWidth() const { return LongWidth; }
207  unsigned getLongAlign() const { return LongAlign; }
208
209  /// getLongLongWidth/Align - Return the size of 'signed long long' and
210  /// 'unsigned long long' for this target, in bits.
211  unsigned getLongLongWidth() const { return LongLongWidth; }
212  unsigned getLongLongAlign() const { return LongLongAlign; }
213
214  /// getWCharWidth/Align - Return the size of 'wchar_t' for this target, in
215  /// bits.
216  unsigned getWCharWidth() const { return getTypeWidth(WCharType); }
217  unsigned getWCharAlign() const { return getTypeAlign(WCharType); }
218
219  /// getChar16Width/Align - Return the size of 'char16_t' for this target, in
220  /// bits.
221  unsigned getChar16Width() const { return getTypeWidth(Char16Type); }
222  unsigned getChar16Align() const { return getTypeAlign(Char16Type); }
223
224  /// getChar32Width/Align - Return the size of 'char32_t' for this target, in
225  /// bits.
226  unsigned getChar32Width() const { return getTypeWidth(Char32Type); }
227  unsigned getChar32Align() const { return getTypeAlign(Char32Type); }
228
229  /// getHalfWidth/Align/Format - Return the size/align/format of 'half'.
230  unsigned getHalfWidth() const { return HalfWidth; }
231  unsigned getHalfAlign() const { return HalfAlign; }
232  const llvm::fltSemantics &getHalfFormat() const { return *HalfFormat; }
233
234  /// getFloatWidth/Align/Format - Return the size/align/format of 'float'.
235  unsigned getFloatWidth() const { return FloatWidth; }
236  unsigned getFloatAlign() const { return FloatAlign; }
237  const llvm::fltSemantics &getFloatFormat() const { return *FloatFormat; }
238
239  /// getDoubleWidth/Align/Format - Return the size/align/format of 'double'.
240  unsigned getDoubleWidth() const { return DoubleWidth; }
241  unsigned getDoubleAlign() const { return DoubleAlign; }
242  const llvm::fltSemantics &getDoubleFormat() const { return *DoubleFormat; }
243
244  /// getLongDoubleWidth/Align/Format - Return the size/align/format of 'long
245  /// double'.
246  unsigned getLongDoubleWidth() const { return LongDoubleWidth; }
247  unsigned getLongDoubleAlign() const { return LongDoubleAlign; }
248  const llvm::fltSemantics &getLongDoubleFormat() const {
249    return *LongDoubleFormat;
250  }
251
252  // getLargeArrayMinWidth/Align - Return the minimum array size that is
253  // 'large' and its alignment.
254  unsigned getLargeArrayMinWidth() const { return LargeArrayMinWidth; }
255  unsigned getLargeArrayAlign() const { return LargeArrayAlign; }
256
257  /// getMaxAtomicPromoteWidth - Return the maximum width lock-free atomic
258  /// operation which will ever be supported for the given target
259  unsigned getMaxAtomicPromoteWidth() const { return MaxAtomicPromoteWidth; }
260  /// getMaxAtomicInlineWidth - Return the maximum width lock-free atomic
261  /// operation which can be inlined given the supported features of the
262  /// given target.
263  unsigned getMaxAtomicInlineWidth() const { return MaxAtomicInlineWidth; }
264
265  /// getIntMaxTWidth - Return the size of intmax_t and uintmax_t for this
266  /// target, in bits.
267  unsigned getIntMaxTWidth() const {
268    return getTypeWidth(IntMaxType);
269  }
270
271  /// getRegisterWidth - Return the "preferred" register width on this target.
272  uint64_t getRegisterWidth() const {
273    // Currently we assume the register width on the target matches the pointer
274    // width, we can introduce a new variable for this if/when some target wants
275    // it.
276    return LongWidth;
277  }
278
279  /// getUserLabelPrefix - This returns the default value of the
280  /// __USER_LABEL_PREFIX__ macro, which is the prefix given to user symbols by
281  /// default.  On most platforms this is "_", but it is "" on some, and "." on
282  /// others.
283  const char *getUserLabelPrefix() const {
284    return UserLabelPrefix;
285  }
286
287  /// MCountName - This returns name of the mcount instrumentation function.
288  const char *getMCountName() const {
289    return MCountName;
290  }
291
292  /// useBitFieldTypeAlignment() - Check whether the alignment of bit-field
293  /// types is respected when laying out structures.
294  bool useBitFieldTypeAlignment() const {
295    return UseBitFieldTypeAlignment;
296  }
297
298  /// useZeroLengthBitfieldAlignment() - Check whether zero length bitfields
299  /// should force alignment of the next member.
300  bool useZeroLengthBitfieldAlignment() const {
301    return UseZeroLengthBitfieldAlignment;
302  }
303
304  /// getZeroLengthBitfieldBoundary() - Get the fixed alignment value in bits
305  /// for a member that follows a zero length bitfield.
306  unsigned getZeroLengthBitfieldBoundary() const {
307    return ZeroLengthBitfieldBoundary;
308  }
309
310  /// hasAlignMac68kSupport - Check whether this target support '#pragma options
311  /// align=mac68k'.
312  bool hasAlignMac68kSupport() const {
313    return HasAlignMac68kSupport;
314  }
315
316  /// getTypeName - Return the user string for the specified integer type enum.
317  /// For example, SignedShort -> "short".
318  static const char *getTypeName(IntType T);
319
320  /// getTypeConstantSuffix - Return the constant suffix for the specified
321  /// integer type enum. For example, SignedLong -> "L".
322  static const char *getTypeConstantSuffix(IntType T);
323
324  /// \brief Check whether the given real type should use the "fpret" flavor of
325  /// Obj-C message passing on this target.
326  bool useObjCFPRetForRealType(RealType T) const {
327    return RealTypeUsesObjCFPRet & (1 << T);
328  }
329
330  ///===---- Other target property query methods --------------------------===//
331
332  /// getTargetDefines - Appends the target-specific #define values for this
333  /// target set to the specified buffer.
334  virtual void getTargetDefines(const LangOptions &Opts,
335                                MacroBuilder &Builder) const = 0;
336
337
338  /// getTargetBuiltins - Return information about target-specific builtins for
339  /// the current primary target, and info about which builtins are non-portable
340  /// across the current set of primary and secondary targets.
341  virtual void getTargetBuiltins(const Builtin::Info *&Records,
342                                 unsigned &NumRecords) const = 0;
343
344  /// getVAListDeclaration - Return the declaration to use for
345  /// __builtin_va_list, which is target-specific.
346  virtual const char *getVAListDeclaration() const = 0;
347
348  /// isValidClobber - Returns whether the passed in string is
349  /// a valid clobber in an inline asm statement. This is used by
350  /// Sema.
351  bool isValidClobber(StringRef Name) const;
352
353  /// isValidGCCRegisterName - Returns whether the passed in string
354  /// is a valid register name according to GCC. This is used by Sema for
355  /// inline asm statements.
356  bool isValidGCCRegisterName(StringRef Name) const;
357
358  // getNormalizedGCCRegisterName - Returns the "normalized" GCC register name.
359  // For example, on x86 it will return "ax" when "eax" is passed in.
360  StringRef getNormalizedGCCRegisterName(StringRef Name) const;
361
362  struct ConstraintInfo {
363    enum {
364      CI_None = 0x00,
365      CI_AllowsMemory = 0x01,
366      CI_AllowsRegister = 0x02,
367      CI_ReadWrite = 0x04,       // "+r" output constraint (read and write).
368      CI_HasMatchingInput = 0x08 // This output operand has a matching input.
369    };
370    unsigned Flags;
371    int TiedOperand;
372
373    std::string ConstraintStr;  // constraint: "=rm"
374    std::string Name;           // Operand name: [foo] with no []'s.
375  public:
376    ConstraintInfo(StringRef ConstraintStr, StringRef Name)
377      : Flags(0), TiedOperand(-1), ConstraintStr(ConstraintStr.str()),
378      Name(Name.str()) {}
379
380    const std::string &getConstraintStr() const { return ConstraintStr; }
381    const std::string &getName() const { return Name; }
382    bool isReadWrite() const { return (Flags & CI_ReadWrite) != 0; }
383    bool allowsRegister() const { return (Flags & CI_AllowsRegister) != 0; }
384    bool allowsMemory() const { return (Flags & CI_AllowsMemory) != 0; }
385
386    /// hasMatchingInput - Return true if this output operand has a matching
387    /// (tied) input operand.
388    bool hasMatchingInput() const { return (Flags & CI_HasMatchingInput) != 0; }
389
390    /// hasTiedOperand() - Return true if this input operand is a matching
391    /// constraint that ties it to an output operand.  If this returns true,
392    /// then getTiedOperand will indicate which output operand this is tied to.
393    bool hasTiedOperand() const { return TiedOperand != -1; }
394    unsigned getTiedOperand() const {
395      assert(hasTiedOperand() && "Has no tied operand!");
396      return (unsigned)TiedOperand;
397    }
398
399    void setIsReadWrite() { Flags |= CI_ReadWrite; }
400    void setAllowsMemory() { Flags |= CI_AllowsMemory; }
401    void setAllowsRegister() { Flags |= CI_AllowsRegister; }
402    void setHasMatchingInput() { Flags |= CI_HasMatchingInput; }
403
404    /// setTiedOperand - Indicate that this is an input operand that is tied to
405    /// the specified output operand.  Copy over the various constraint
406    /// information from the output.
407    void setTiedOperand(unsigned N, ConstraintInfo &Output) {
408      Output.setHasMatchingInput();
409      Flags = Output.Flags;
410      TiedOperand = N;
411      // Don't copy Name or constraint string.
412    }
413  };
414
415  // validateOutputConstraint, validateInputConstraint - Checks that
416  // a constraint is valid and provides information about it.
417  // FIXME: These should return a real error instead of just true/false.
418  bool validateOutputConstraint(ConstraintInfo &Info) const;
419  bool validateInputConstraint(ConstraintInfo *OutputConstraints,
420                               unsigned NumOutputs,
421                               ConstraintInfo &info) const;
422  bool resolveSymbolicName(const char *&Name,
423                           ConstraintInfo *OutputConstraints,
424                           unsigned NumOutputs, unsigned &Index) const;
425
426  // Constraint parm will be left pointing at the last character of
427  // the constraint.  In practice, it won't be changed unless the
428  // constraint is longer than one character.
429  virtual std::string convertConstraint(const char *&Constraint) const {
430    // 'p' defaults to 'r', but can be overridden by targets.
431    if (*Constraint == 'p')
432      return std::string("r");
433    return std::string(1, *Constraint);
434  }
435
436  // Returns a string of target-specific clobbers, in LLVM format.
437  virtual const char *getClobbers() const = 0;
438
439
440  /// getTriple - Return the target triple of the primary target.
441  const llvm::Triple &getTriple() const {
442    return Triple;
443  }
444
445  const char *getTargetDescription() const {
446    return DescriptionString;
447  }
448
449  struct GCCRegAlias {
450    const char * const Aliases[5];
451    const char * const Register;
452  };
453
454  struct AddlRegName {
455    const char * const Names[5];
456    const unsigned RegNum;
457  };
458
459  virtual bool useGlobalsForAutomaticVariables() const { return false; }
460
461  /// getCFStringSection - Return the section to use for CFString
462  /// literals, or 0 if no special section is used.
463  virtual const char *getCFStringSection() const {
464    return "__DATA,__cfstring";
465  }
466
467  /// getNSStringSection - Return the section to use for NSString
468  /// literals, or 0 if no special section is used.
469  virtual const char *getNSStringSection() const {
470    return "__OBJC,__cstring_object,regular,no_dead_strip";
471  }
472
473  /// getNSStringNonFragileABISection - Return the section to use for
474  /// NSString literals, or 0 if no special section is used (NonFragile ABI).
475  virtual const char *getNSStringNonFragileABISection() const {
476    return "__DATA, __objc_stringobj, regular, no_dead_strip";
477  }
478
479  /// isValidSectionSpecifier - This is an optional hook that targets can
480  /// implement to perform semantic checking on attribute((section("foo")))
481  /// specifiers.  In this case, "foo" is passed in to be checked.  If the
482  /// section specifier is invalid, the backend should return a non-empty string
483  /// that indicates the problem.
484  ///
485  /// This hook is a simple quality of implementation feature to catch errors
486  /// and give good diagnostics in cases when the assembler or code generator
487  /// would otherwise reject the section specifier.
488  ///
489  virtual std::string isValidSectionSpecifier(StringRef SR) const {
490    return "";
491  }
492
493  /// setForcedLangOptions - Set forced language options.
494  /// Apply changes to the target information with respect to certain
495  /// language options which change the target configuration.
496  virtual void setForcedLangOptions(LangOptions &Opts);
497
498  /// getDefaultFeatures - Get the default set of target features for the CPU;
499  /// this should include all legal feature strings on the target.
500  virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
501  }
502
503  /// getABI - Get the ABI in use.
504  virtual const char *getABI() const {
505    return "";
506  }
507
508  /// getCXXABI - Get the C++ ABI in use.
509  virtual TargetCXXABI getCXXABI() const {
510    return CXXABI;
511  }
512
513  /// setCPU - Target the specific CPU.
514  ///
515  /// \return - False on error (invalid CPU name).
516  virtual bool setCPU(const std::string &Name) {
517    return false;
518  }
519
520  /// setABI - Use the specific ABI.
521  ///
522  /// \return - False on error (invalid ABI name).
523  virtual bool setABI(const std::string &Name) {
524    return false;
525  }
526
527  /// setCXXABI - Use this specific C++ ABI.
528  ///
529  /// \return - False on error (invalid C++ ABI name).
530  bool setCXXABI(const std::string &Name) {
531    static const TargetCXXABI Unknown = static_cast<TargetCXXABI>(-1);
532    TargetCXXABI ABI = llvm::StringSwitch<TargetCXXABI>(Name)
533      .Case("arm", CXXABI_ARM)
534      .Case("itanium", CXXABI_Itanium)
535      .Case("microsoft", CXXABI_Microsoft)
536      .Default(Unknown);
537    if (ABI == Unknown) return false;
538    return setCXXABI(ABI);
539  }
540
541  /// setCXXABI - Set the C++ ABI to be used by this implementation.
542  ///
543  /// \return - False on error (ABI not valid on this target)
544  virtual bool setCXXABI(TargetCXXABI ABI) {
545    CXXABI = ABI;
546    return true;
547  }
548
549  /// setFeatureEnabled - Enable or disable a specific target feature,
550  /// the feature name must be valid.
551  ///
552  /// \return - False on error (invalid feature name).
553  virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
554                                 const std::string &Name,
555                                 bool Enabled) const {
556    return false;
557  }
558
559  /// HandleTargetOptions - Perform initialization based on the user configured
560  /// set of features (e.g., +sse4). The list is guaranteed to have at most one
561  /// entry per feature.
562  ///
563  /// The target may modify the features list, to change which options are
564  /// passed onwards to the backend.
565  virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
566  }
567
568  // getRegParmMax - Returns maximal number of args passed in registers.
569  unsigned getRegParmMax() const {
570    assert(RegParmMax < 7 && "RegParmMax value is larger than AST can handle");
571    return RegParmMax;
572  }
573
574  /// isTLSSupported - Whether the target supports thread-local storage.
575  bool isTLSSupported() const {
576    return TLSSupported;
577  }
578
579  /// hasNoAsmVariants - Return true if {|} are normal characters in the
580  /// asm string.  If this returns false (the default), then {abc|xyz} is syntax
581  /// that says that when compiling for asm variant #0, "abc" should be
582  /// generated, but when compiling for asm variant #1, "xyz" should be
583  /// generated.
584  bool hasNoAsmVariants() const {
585    return NoAsmVariants;
586  }
587
588  /// getEHDataRegisterNumber - Return the register number that
589  /// __builtin_eh_return_regno would return with the specified argument.
590  virtual int getEHDataRegisterNumber(unsigned RegNo) const {
591    return -1;
592  }
593
594  /// getStaticInitSectionSpecifier - Return the section to use for C++ static
595  /// initialization functions.
596  virtual const char *getStaticInitSectionSpecifier() const {
597    return 0;
598  }
599
600  const LangAS::Map &getAddressSpaceMap() const {
601    return *AddrSpaceMap;
602  }
603
604  /// \brief Retrieve the name of the platform as it is used in the
605  /// availability attribute.
606  StringRef getPlatformName() const { return PlatformName; }
607
608  /// \brief Retrieve the minimum desired version of the platform, to
609  /// which the program should be compiled.
610  VersionTuple getPlatformMinVersion() const { return PlatformMinVersion; }
611
612protected:
613  virtual uint64_t getPointerWidthV(unsigned AddrSpace) const {
614    return PointerWidth;
615  }
616  virtual uint64_t getPointerAlignV(unsigned AddrSpace) const {
617    return PointerAlign;
618  }
619  virtual enum IntType getPtrDiffTypeV(unsigned AddrSpace) const {
620    return PtrDiffType;
621  }
622  virtual void getGCCRegNames(const char * const *&Names,
623                              unsigned &NumNames) const = 0;
624  virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
625                                unsigned &NumAliases) const = 0;
626  virtual void getGCCAddlRegNames(const AddlRegName *&Addl,
627				  unsigned &NumAddl) const {
628    Addl = 0;
629    NumAddl = 0;
630  }
631  virtual bool validateAsmConstraint(const char *&Name,
632                                     TargetInfo::ConstraintInfo &info) const= 0;
633};
634
635}  // end namespace clang
636
637#endif
638