contrib/llvm/tools/clang/include/clang/Basic/TargetInfo.h

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