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