contrib/llvm/tools/clang/include/clang/Sema/AttributeList.h

   1 //===--- AttributeList.h - Parsed attribute sets ----------------*- 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 AttributeList class, which is used to collect
  11 // parsed attributes.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_SEMA_ATTRLIST_H
  16 #define LLVM_CLANG_SEMA_ATTRLIST_H
  17
  18 #include "clang/Basic/SourceLocation.h"
  19 #include "clang/Basic/VersionTuple.h"
  20 #include "clang/Sema/Ownership.h"
  21 #include "llvm/ADT/PointerUnion.h"
  22 #include "llvm/ADT/SmallVector.h"
  23 #include "llvm/ADT/Triple.h"
  24 #include "llvm/Support/Allocator.h"
  25 #include <cassert>
  26
  27 namespace clang {
  28   class ASTContext;
  29   class IdentifierInfo;
  30   class Expr;
  31
  32 /// \brief Represents information about a change in availability for
  33 /// an entity, which is part of the encoding of the 'availability'
  34 /// attribute.
  35 struct AvailabilityChange {
  36   /// \brief The location of the keyword indicating the kind of change.
  37   SourceLocation KeywordLoc;
  38
  39   /// \brief The version number at which the change occurred.
  40   VersionTuple Version;
  41
  42   /// \brief The source range covering the version number.
  43   SourceRange VersionRange;
  44
  45   /// \brief Determine whether this availability change is valid.
  46   bool isValid() const { return !Version.empty(); }
  47 };
  48
  49 /// \brief Wraps an identifier and optional source location for the identifier.
  50 struct IdentifierLoc {
  51   SourceLocation Loc;
  52   IdentifierInfo *Ident;
  53
  54   static IdentifierLoc *create(ASTContext &Ctx, SourceLocation Loc,
  55                                IdentifierInfo *Ident);
  56 };
  57
  58 /// \brief A union of the various pointer types that can be passed to an
  59 /// AttributeList as an argument.
  60 typedef llvm::PointerUnion<Expr*, IdentifierLoc*> ArgsUnion;
  61 typedef llvm::SmallVector<ArgsUnion, 12U> ArgsVector;
  62
  63 /// AttributeList - Represents a syntactic attribute.
  64 ///
  65 /// For a GNU attribute, there are four forms of this construct:
  66 ///
  67 /// 1: __attribute__(( const )). ParmName/Args/NumArgs will all be unused.
  68 /// 2: __attribute__(( mode(byte) )). ParmName used, Args/NumArgs unused.
  69 /// 3: __attribute__(( format(printf, 1, 2) )). ParmName/Args/NumArgs all used.
  70 /// 4: __attribute__(( aligned(16) )). ParmName is unused, Args/Num used.
  71 ///
  72 class AttributeList { // TODO: This should really be called ParsedAttribute
  73 public:
  74   /// The style used to specify an attribute.
  75   enum Syntax {
  76     /// __attribute__((...))
  77     AS_GNU,
  78     /// [[...]]
  79     AS_CXX11,
  80     /// __declspec(...)
  81     AS_Declspec,
  82     /// __ptr16, alignas(...), etc.
  83     AS_Keyword,
  84     /// #pragma ...
  85     AS_Pragma
  86   };
  87
  88 private:
  89   IdentifierInfo *AttrName;
  90   IdentifierInfo *ScopeName;
  91   SourceRange AttrRange;
  92   SourceLocation ScopeLoc;
  93   SourceLocation EllipsisLoc;
  94
  95   /// The number of expression arguments this attribute has.
  96   /// The expressions themselves are stored after the object.
  97   unsigned NumArgs : 16;
  98
  99   /// Corresponds to the Syntax enum.
 100   unsigned SyntaxUsed : 2;
 101
 102   /// True if already diagnosed as invalid.
 103   mutable unsigned Invalid : 1;
 104
 105   /// True if this attribute was used as a type attribute.
 106   mutable unsigned UsedAsTypeAttr : 1;
 107
 108   /// True if this has the extra information associated with an
 109   /// availability attribute.
 110   unsigned IsAvailability : 1;
 111
 112   /// True if this has extra information associated with a
 113   /// type_tag_for_datatype attribute.
 114   unsigned IsTypeTagForDatatype : 1;
 115
 116   /// True if this has extra information associated with a
 117   /// Microsoft __delcspec(property) attribute.
 118   unsigned IsProperty : 1;
 119
 120   /// True if this has a ParsedType
 121   unsigned HasParsedType : 1;
 122
 123   unsigned AttrKind : 8;
 124
 125   /// \brief The location of the 'unavailable' keyword in an
 126   /// availability attribute.
 127   SourceLocation UnavailableLoc;
 128
 129   const Expr *MessageExpr;
 130
 131   /// The next attribute in the current position.
 132   AttributeList *NextInPosition;
 133
 134   /// The next attribute allocated in the current Pool.
 135   AttributeList *NextInPool;
 136
 137   /// Arguments, if any, are stored immediately following the object.
 138   ArgsUnion *getArgsBuffer() {
 139     return reinterpret_cast<ArgsUnion*>(this+1);
 140   }
 141   ArgsUnion const *getArgsBuffer() const {
 142     return reinterpret_cast<ArgsUnion const *>(this+1);
 143   }
 144
 145   enum AvailabilitySlot {
 146     IntroducedSlot, DeprecatedSlot, ObsoletedSlot
 147   };
 148
 149   /// Availability information is stored immediately following the arguments,
 150   /// if any, at the end of the object.
 151   AvailabilityChange &getAvailabilitySlot(AvailabilitySlot index) {
 152     return reinterpret_cast<AvailabilityChange*>(getArgsBuffer()
 153                                                  + NumArgs)[index];
 154   }
 155   const AvailabilityChange &getAvailabilitySlot(AvailabilitySlot index) const {
 156     return reinterpret_cast<const AvailabilityChange*>(getArgsBuffer()
 157                                                        + NumArgs)[index];
 158   }
 159
 160 public:
 161   struct TypeTagForDatatypeData {
 162     ParsedType *MatchingCType;
 163     unsigned LayoutCompatible : 1;
 164     unsigned MustBeNull : 1;
 165   };
 166   struct PropertyData {
 167     IdentifierInfo *GetterId, *SetterId;
 168     PropertyData(IdentifierInfo *getterId, IdentifierInfo *setterId)
 169     : GetterId(getterId), SetterId(setterId) {}
 170   };
 171
 172 private:
 173   /// Type tag information is stored immediately following the arguments, if
 174   /// any, at the end of the object.  They are mutually exlusive with
 175   /// availability slots.
 176   TypeTagForDatatypeData &getTypeTagForDatatypeDataSlot() {
 177     return *reinterpret_cast<TypeTagForDatatypeData*>(getArgsBuffer()+NumArgs);
 178   }
 179
 180   const TypeTagForDatatypeData &getTypeTagForDatatypeDataSlot() const {
 181     return *reinterpret_cast<const TypeTagForDatatypeData*>(getArgsBuffer()
 182                                                             + NumArgs);
 183   }
 184
 185   /// The type buffer immediately follows the object and are mutually exclusive
 186   /// with arguments.
 187   ParsedType &getTypeBuffer() {
 188     return *reinterpret_cast<ParsedType *>(this + 1);
 189   }
 190
 191   const ParsedType &getTypeBuffer() const {
 192     return *reinterpret_cast<const ParsedType *>(this + 1);
 193   }
 194
 195   /// The property data immediately follows the object is is mutually exclusive
 196   /// with arguments.
 197   PropertyData &getPropertyDataBuffer() {
 198     assert(IsProperty);
 199     return *reinterpret_cast<PropertyData*>(this + 1);
 200   }
 201
 202   const PropertyData &getPropertyDataBuffer() const {
 203     assert(IsProperty);
 204     return *reinterpret_cast<const PropertyData*>(this + 1);
 205   }
 206
 207   AttributeList(const AttributeList &) LLVM_DELETED_FUNCTION;
 208   void operator=(const AttributeList &) LLVM_DELETED_FUNCTION;
 209   void operator delete(void *) LLVM_DELETED_FUNCTION;
 210   ~AttributeList() LLVM_DELETED_FUNCTION;
 211
 212   size_t allocated_size() const;
 213
 214   /// Constructor for attributes with expression arguments.
 215   AttributeList(IdentifierInfo *attrName, SourceRange attrRange,
 216                 IdentifierInfo *scopeName, SourceLocation scopeLoc,
 217                 ArgsUnion *args, unsigned numArgs,
 218                 Syntax syntaxUsed, SourceLocation ellipsisLoc)
 219     : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
 220       ScopeLoc(scopeLoc), EllipsisLoc(ellipsisLoc), NumArgs(numArgs),
 221       SyntaxUsed(syntaxUsed), Invalid(false), UsedAsTypeAttr(false),
 222       IsAvailability(false), IsTypeTagForDatatype(false), IsProperty(false),
 223       HasParsedType(false), NextInPosition(nullptr), NextInPool(nullptr) {
 224     if (numArgs) memcpy(getArgsBuffer(), args, numArgs * sizeof(ArgsUnion));
 225     AttrKind = getKind(getName(), getScopeName(), syntaxUsed);
 226   }
 227
 228   /// Constructor for availability attributes.
 229   AttributeList(IdentifierInfo *attrName, SourceRange attrRange,
 230                 IdentifierInfo *scopeName, SourceLocation scopeLoc,
 231                 IdentifierLoc *Parm, const AvailabilityChange &introduced,
 232                 const AvailabilityChange &deprecated,
 233                 const AvailabilityChange &obsoleted,
 234                 SourceLocation unavailable,
 235                 const Expr *messageExpr,
 236                 Syntax syntaxUsed)
 237     : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
 238       ScopeLoc(scopeLoc), EllipsisLoc(), NumArgs(1), SyntaxUsed(syntaxUsed),
 239       Invalid(false), UsedAsTypeAttr(false), IsAvailability(true),
 240       IsTypeTagForDatatype(false), IsProperty(false), HasParsedType(false),
 241       UnavailableLoc(unavailable), MessageExpr(messageExpr),
 242       NextInPosition(nullptr), NextInPool(nullptr) {
 243     ArgsUnion PVal(Parm);
 244     memcpy(getArgsBuffer(), &PVal, sizeof(ArgsUnion));
 245     new (&getAvailabilitySlot(IntroducedSlot)) AvailabilityChange(introduced);
 246     new (&getAvailabilitySlot(DeprecatedSlot)) AvailabilityChange(deprecated);
 247     new (&getAvailabilitySlot(ObsoletedSlot)) AvailabilityChange(obsoleted);
 248     AttrKind = getKind(getName(), getScopeName(), syntaxUsed);
 249   }
 250
 251   /// Constructor for objc_bridge_related attributes.
 252   AttributeList(IdentifierInfo *attrName, SourceRange attrRange,
 253                 IdentifierInfo *scopeName, SourceLocation scopeLoc,
 254                 IdentifierLoc *Parm1,
 255                 IdentifierLoc *Parm2,
 256                 IdentifierLoc *Parm3,
 257                 Syntax syntaxUsed)
 258   : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
 259     ScopeLoc(scopeLoc), EllipsisLoc(), NumArgs(3), SyntaxUsed(syntaxUsed),
 260     Invalid(false), UsedAsTypeAttr(false), IsAvailability(false),
 261     IsTypeTagForDatatype(false), IsProperty(false), HasParsedType(false),
 262     NextInPosition(nullptr), NextInPool(nullptr) {
 263     ArgsVector Args;
 264     Args.push_back(Parm1);
 265     Args.push_back(Parm2);
 266     Args.push_back(Parm3);
 267     memcpy(getArgsBuffer(), &Args[0], 3 * sizeof(ArgsUnion));
 268     AttrKind = getKind(getName(), getScopeName(), syntaxUsed);
 269   }
 270
 271   /// Constructor for type_tag_for_datatype attribute.
 272   AttributeList(IdentifierInfo *attrName, SourceRange attrRange,
 273                 IdentifierInfo *scopeName, SourceLocation scopeLoc,
 274                 IdentifierLoc *ArgKind, ParsedType matchingCType,
 275                 bool layoutCompatible, bool mustBeNull, Syntax syntaxUsed)
 276     : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
 277       ScopeLoc(scopeLoc), EllipsisLoc(), NumArgs(1), SyntaxUsed(syntaxUsed),
 278       Invalid(false), UsedAsTypeAttr(false), IsAvailability(false),
 279       IsTypeTagForDatatype(true), IsProperty(false), HasParsedType(false),
 280       NextInPosition(nullptr), NextInPool(nullptr) {
 281     ArgsUnion PVal(ArgKind);
 282     memcpy(getArgsBuffer(), &PVal, sizeof(ArgsUnion));
 283     TypeTagForDatatypeData &ExtraData = getTypeTagForDatatypeDataSlot();
 284     new (&ExtraData.MatchingCType) ParsedType(matchingCType);
 285     ExtraData.LayoutCompatible = layoutCompatible;
 286     ExtraData.MustBeNull = mustBeNull;
 287     AttrKind = getKind(getName(), getScopeName(), syntaxUsed);
 288   }
 289
 290   /// Constructor for attributes with a single type argument.
 291   AttributeList(IdentifierInfo *attrName, SourceRange attrRange,
 292                 IdentifierInfo *scopeName, SourceLocation scopeLoc,
 293                 ParsedType typeArg, Syntax syntaxUsed)
 294       : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
 295         ScopeLoc(scopeLoc), EllipsisLoc(), NumArgs(0), SyntaxUsed(syntaxUsed),
 296         Invalid(false), UsedAsTypeAttr(false), IsAvailability(false),
 297         IsTypeTagForDatatype(false), IsProperty(false), HasParsedType(true),
 298         NextInPosition(nullptr), NextInPool(nullptr) {
 299     new (&getTypeBuffer()) ParsedType(typeArg);
 300     AttrKind = getKind(getName(), getScopeName(), syntaxUsed);
 301   }
 302
 303   /// Constructor for microsoft __declspec(property) attribute.
 304   AttributeList(IdentifierInfo *attrName, SourceRange attrRange,
 305                 IdentifierInfo *scopeName, SourceLocation scopeLoc,
 306                 IdentifierInfo *getterId, IdentifierInfo *setterId,
 307                 Syntax syntaxUsed)
 308     : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
 309       ScopeLoc(scopeLoc), EllipsisLoc(), NumArgs(0), SyntaxUsed(syntaxUsed),
 310       Invalid(false), UsedAsTypeAttr(false), IsAvailability(false),
 311       IsTypeTagForDatatype(false), IsProperty(true), HasParsedType(false),
 312       NextInPosition(nullptr), NextInPool(nullptr) {
 313     new (&getPropertyDataBuffer()) PropertyData(getterId, setterId);
 314     AttrKind = getKind(getName(), getScopeName(), syntaxUsed);
 315   }
 316
 317   friend class AttributePool;
 318   friend class AttributeFactory;
 319
 320 public:
 321   enum Kind {
 322     #define PARSED_ATTR(NAME) AT_##NAME,
 323     #include "clang/Sema/AttrParsedAttrList.inc"
 324     #undef PARSED_ATTR
 325     IgnoredAttribute,
 326     UnknownAttribute
 327   };
 328
 329   IdentifierInfo *getName() const { return AttrName; }
 330   SourceLocation getLoc() const { return AttrRange.getBegin(); }
 331   SourceRange getRange() const { return AttrRange; }
 332
 333   bool hasScope() const { return ScopeName; }
 334   IdentifierInfo *getScopeName() const { return ScopeName; }
 335   SourceLocation getScopeLoc() const { return ScopeLoc; }
 336
 337   bool hasParsedType() const { return HasParsedType; }
 338
 339   /// Is this the Microsoft __declspec(property) attribute?
 340   bool isDeclspecPropertyAttribute() const  {
 341     return IsProperty;
 342   }
 343
 344   bool isAlignasAttribute() const {
 345     // FIXME: Use a better mechanism to determine this.
 346     return getKind() == AT_Aligned && SyntaxUsed == AS_Keyword;
 347   }
 348
 349   bool isDeclspecAttribute() const { return SyntaxUsed == AS_Declspec; }
 350   bool isCXX11Attribute() const {
 351     return SyntaxUsed == AS_CXX11 || isAlignasAttribute();
 352   }
 353   bool isKeywordAttribute() const { return SyntaxUsed == AS_Keyword; }
 354
 355   bool isInvalid() const { return Invalid; }
 356   void setInvalid(bool b = true) const { Invalid = b; }
 357
 358   bool isUsedAsTypeAttr() const { return UsedAsTypeAttr; }
 359   void setUsedAsTypeAttr() { UsedAsTypeAttr = true; }
 360
 361   bool isPackExpansion() const { return EllipsisLoc.isValid(); }
 362   SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
 363
 364   Kind getKind() const { return Kind(AttrKind); }
 365   static Kind getKind(const IdentifierInfo *Name, const IdentifierInfo *Scope,
 366                       Syntax SyntaxUsed);
 367
 368   AttributeList *getNext() const { return NextInPosition; }
 369   void setNext(AttributeList *N) { NextInPosition = N; }
 370
 371   /// getNumArgs - Return the number of actual arguments to this attribute.
 372   unsigned getNumArgs() const { return NumArgs; }
 373
 374   /// getArg - Return the specified argument.
 375   ArgsUnion getArg(unsigned Arg) const {
 376     assert(Arg < NumArgs && "Arg access out of range!");
 377     return getArgsBuffer()[Arg];
 378   }
 379
 380   bool isArgExpr(unsigned Arg) const {
 381     return Arg < NumArgs && getArg(Arg).is<Expr*>();
 382   }
 383   Expr *getArgAsExpr(unsigned Arg) const {
 384     return getArg(Arg).get<Expr*>();
 385   }
 386
 387   bool isArgIdent(unsigned Arg) const {
 388     return Arg < NumArgs && getArg(Arg).is<IdentifierLoc*>();
 389   }
 390   IdentifierLoc *getArgAsIdent(unsigned Arg) const {
 391     return getArg(Arg).get<IdentifierLoc*>();
 392   }
 393
 394   const AvailabilityChange &getAvailabilityIntroduced() const {
 395     assert(getKind() == AT_Availability && "Not an availability attribute");
 396     return getAvailabilitySlot(IntroducedSlot);
 397   }
 398
 399   const AvailabilityChange &getAvailabilityDeprecated() const {
 400     assert(getKind() == AT_Availability && "Not an availability attribute");
 401     return getAvailabilitySlot(DeprecatedSlot);
 402   }
 403
 404   const AvailabilityChange &getAvailabilityObsoleted() const {
 405     assert(getKind() == AT_Availability && "Not an availability attribute");
 406     return getAvailabilitySlot(ObsoletedSlot);
 407   }
 408
 409   SourceLocation getUnavailableLoc() const {
 410     assert(getKind() == AT_Availability && "Not an availability attribute");
 411     return UnavailableLoc;
 412   }
 413
 414   const Expr * getMessageExpr() const {
 415     assert(getKind() == AT_Availability && "Not an availability attribute");
 416     return MessageExpr;
 417   }
 418
 419   const ParsedType &getMatchingCType() const {
 420     assert(getKind() == AT_TypeTagForDatatype &&
 421            "Not a type_tag_for_datatype attribute");
 422     return *getTypeTagForDatatypeDataSlot().MatchingCType;
 423   }
 424
 425   bool getLayoutCompatible() const {
 426     assert(getKind() == AT_TypeTagForDatatype &&
 427            "Not a type_tag_for_datatype attribute");
 428     return getTypeTagForDatatypeDataSlot().LayoutCompatible;
 429   }
 430
 431   bool getMustBeNull() const {
 432     assert(getKind() == AT_TypeTagForDatatype &&
 433            "Not a type_tag_for_datatype attribute");
 434     return getTypeTagForDatatypeDataSlot().MustBeNull;
 435   }
 436
 437   const ParsedType &getTypeArg() const {
 438     assert(HasParsedType && "Not a type attribute");
 439     return getTypeBuffer();
 440   }
 441
 442   const PropertyData &getPropertyData() const {
 443     assert(isDeclspecPropertyAttribute() && "Not a __delcspec(property) attribute");
 444     return getPropertyDataBuffer();
 445   }
 446
 447   /// \brief Get an index into the attribute spelling list
 448   /// defined in Attr.td. This index is used by an attribute
 449   /// to pretty print itself.
 450   unsigned getAttributeSpellingListIndex() const;
 451
 452   bool isTargetSpecificAttr() const;
 453   bool isTypeAttr() const;
 454
 455   bool hasCustomParsing() const;
 456   unsigned getMinArgs() const;
 457   unsigned getMaxArgs() const;
 458   bool diagnoseAppertainsTo(class Sema &S, const Decl *D) const;
 459   bool diagnoseLangOpts(class Sema &S) const;
 460   bool existsInTarget(const llvm::Triple &T) const;
 461   bool isKnownToGCC() const;
 462
 463   /// \brief If the parsed attribute has a semantic equivalent, and it would
 464   /// have a semantic Spelling enumeration (due to having semantically-distinct
 465   /// spelling variations), return the value of that semantic spelling. If the
 466   /// parsed attribute does not have a semantic equivalent, or would not have
 467   /// a Spelling enumeration, the value UINT_MAX is returned.
 468   unsigned getSemanticSpelling() const;
 469 };
 470
 471 /// A factory, from which one makes pools, from which one creates
 472 /// individual attributes which are deallocated with the pool.
 473 ///
 474 /// Note that it's tolerably cheap to create and destroy one of
 475 /// these as long as you don't actually allocate anything in it.
 476 class AttributeFactory {
 477 public:
 478   enum {
 479     /// The required allocation size of an availability attribute,
 480     /// which we want to ensure is a multiple of sizeof(void*).
 481     AvailabilityAllocSize =
 482       sizeof(AttributeList)
 483       + ((3 * sizeof(AvailabilityChange) + sizeof(void*) +
 484          sizeof(ArgsUnion) - 1)
 485          / sizeof(void*) * sizeof(void*)),
 486     TypeTagForDatatypeAllocSize =
 487       sizeof(AttributeList)
 488       + (sizeof(AttributeList::TypeTagForDatatypeData) + sizeof(void *) +
 489          sizeof(ArgsUnion) - 1)
 490         / sizeof(void*) * sizeof(void*),
 491     PropertyAllocSize =
 492       sizeof(AttributeList)
 493       + (sizeof(AttributeList::PropertyData) + sizeof(void *) - 1)
 494         / sizeof(void*) * sizeof(void*)
 495   };
 496
 497 private:
 498   enum {
 499     /// The number of free lists we want to be sure to support
 500     /// inline.  This is just enough that availability attributes
 501     /// don't surpass it.  It's actually very unlikely we'll see an
 502     /// attribute that needs more than that; on x86-64 you'd need 10
 503     /// expression arguments, and on i386 you'd need 19.
 504     InlineFreeListsCapacity =
 505       1 + (AvailabilityAllocSize - sizeof(AttributeList)) / sizeof(void*)
 506   };
 507
 508   llvm::BumpPtrAllocator Alloc;
 509
 510   /// Free lists.  The index is determined by the following formula:
 511   ///   (size - sizeof(AttributeList)) / sizeof(void*)
 512   SmallVector<AttributeList*, InlineFreeListsCapacity> FreeLists;
 513
 514   // The following are the private interface used by AttributePool.
 515   friend class AttributePool;
 516
 517   /// Allocate an attribute of the given size.
 518   void *allocate(size_t size);
 519
 520   /// Reclaim all the attributes in the given pool chain, which is
 521   /// non-empty.  Note that the current implementation is safe
 522   /// against reclaiming things which were not actually allocated
 523   /// with the allocator, although of course it's important to make
 524   /// sure that their allocator lives at least as long as this one.
 525   void reclaimPool(AttributeList *head);
 526
 527 public:
 528   AttributeFactory();
 529   ~AttributeFactory();
 530 };
 531
 532 class AttributePool {
 533   AttributeFactory &Factory;
 534   AttributeList *Head;
 535
 536   void *allocate(size_t size) {
 537     return Factory.allocate(size);
 538   }
 539
 540   AttributeList *add(AttributeList *attr) {
 541     // We don't care about the order of the pool.
 542     attr->NextInPool = Head;
 543     Head = attr;
 544     return attr;
 545   }
 546
 547   void takePool(AttributeList *pool);
 548
 549 public:
 550   /// Create a new pool for a factory.
 551   AttributePool(AttributeFactory &factory) : Factory(factory), Head(nullptr) {}
 552
 553   /// Move the given pool's allocations to this pool.
 554   AttributePool(AttributePool &pool) : Factory(pool.Factory), Head(pool.Head) {
 555     pool.Head = nullptr;
 556   }
 557
 558   AttributeFactory &getFactory() const { return Factory; }
 559
 560   void clear() {
 561     if (Head) {
 562       Factory.reclaimPool(Head);
 563       Head = nullptr;
 564     }
 565   }
 566
 567   /// Take the given pool's allocations and add them to this pool.
 568   void takeAllFrom(AttributePool &pool) {
 569     if (pool.Head) {
 570       takePool(pool.Head);
 571       pool.Head = nullptr;
 572     }
 573   }
 574
 575   ~AttributePool() {
 576     if (Head) Factory.reclaimPool(Head);
 577   }
 578
 579   AttributeList *create(IdentifierInfo *attrName, SourceRange attrRange,
 580                         IdentifierInfo *scopeName, SourceLocation scopeLoc,
 581                         ArgsUnion *args, unsigned numArgs,
 582                         AttributeList::Syntax syntax,
 583                         SourceLocation ellipsisLoc = SourceLocation()) {
 584     void *memory = allocate(sizeof(AttributeList)
 585                             + numArgs * sizeof(ArgsUnion));
 586     return add(new (memory) AttributeList(attrName, attrRange,
 587                                           scopeName, scopeLoc,
 588                                           args, numArgs, syntax,
 589                                           ellipsisLoc));
 590   }
 591
 592   AttributeList *create(IdentifierInfo *attrName, SourceRange attrRange,
 593                         IdentifierInfo *scopeName, SourceLocation scopeLoc,
 594                         IdentifierLoc *Param,
 595                         const AvailabilityChange &introduced,
 596                         const AvailabilityChange &deprecated,
 597                         const AvailabilityChange &obsoleted,
 598                         SourceLocation unavailable,
 599                         const Expr *MessageExpr,
 600                         AttributeList::Syntax syntax) {
 601     void *memory = allocate(AttributeFactory::AvailabilityAllocSize);
 602     return add(new (memory) AttributeList(attrName, attrRange,
 603                                           scopeName, scopeLoc,
 604                                           Param, introduced, deprecated,
 605                                           obsoleted, unavailable, MessageExpr,
 606                                           syntax));
 607   }
 608
 609   AttributeList *create(IdentifierInfo *attrName, SourceRange attrRange,
 610                         IdentifierInfo *scopeName, SourceLocation scopeLoc,
 611                         IdentifierLoc *Param1,
 612                         IdentifierLoc *Param2,
 613                         IdentifierLoc *Param3,
 614                         AttributeList::Syntax syntax) {
 615     size_t size = sizeof(AttributeList) + 3 * sizeof(ArgsUnion);
 616     void *memory = allocate(size);
 617     return add(new (memory) AttributeList(attrName, attrRange,
 618                                           scopeName, scopeLoc,
 619                                           Param1, Param2, Param3,
 620                                           syntax));
 621   }
 622
 623   AttributeList *createTypeTagForDatatype(
 624                     IdentifierInfo *attrName, SourceRange attrRange,
 625                     IdentifierInfo *scopeName, SourceLocation scopeLoc,
 626                     IdentifierLoc *argumentKind, ParsedType matchingCType,
 627                     bool layoutCompatible, bool mustBeNull,
 628                     AttributeList::Syntax syntax) {
 629     void *memory = allocate(AttributeFactory::TypeTagForDatatypeAllocSize);
 630     return add(new (memory) AttributeList(attrName, attrRange,
 631                                           scopeName, scopeLoc,
 632                                           argumentKind, matchingCType,
 633                                           layoutCompatible, mustBeNull,
 634                                           syntax));
 635   }
 636
 637   AttributeList *createTypeAttribute(
 638                     IdentifierInfo *attrName, SourceRange attrRange,
 639                     IdentifierInfo *scopeName, SourceLocation scopeLoc,
 640                     ParsedType typeArg, AttributeList::Syntax syntaxUsed) {
 641     void *memory = allocate(sizeof(AttributeList) + sizeof(void *));
 642     return add(new (memory) AttributeList(attrName, attrRange,
 643                                           scopeName, scopeLoc,
 644                                           typeArg, syntaxUsed));
 645   }
 646
 647   AttributeList *createPropertyAttribute(
 648                     IdentifierInfo *attrName, SourceRange attrRange,
 649                     IdentifierInfo *scopeName, SourceLocation scopeLoc,
 650                     IdentifierInfo *getterId, IdentifierInfo *setterId,
 651                     AttributeList::Syntax syntaxUsed) {
 652     void *memory = allocate(AttributeFactory::PropertyAllocSize);
 653     return add(new (memory) AttributeList(attrName, attrRange,
 654                                           scopeName, scopeLoc,
 655                                           getterId, setterId,
 656                                           syntaxUsed));
 657   }
 658 };
 659
 660 /// ParsedAttributes - A collection of parsed attributes.  Currently
 661 /// we don't differentiate between the various attribute syntaxes,
 662 /// which is basically silly.
 663 ///
 664 /// Right now this is a very lightweight container, but the expectation
 665 /// is that this will become significantly more serious.
 666 class ParsedAttributes {
 667 public:
 668   ParsedAttributes(AttributeFactory &factory)
 669     : pool(factory), list(nullptr) {
 670   }
 671
 672   ParsedAttributes(const ParsedAttributes &) LLVM_DELETED_FUNCTION;
 673
 674   AttributePool &getPool() const { return pool; }
 675
 676   bool empty() const { return list == nullptr; }
 677
 678   void add(AttributeList *newAttr) {
 679     assert(newAttr);
 680     assert(newAttr->getNext() == nullptr);
 681     newAttr->setNext(list);
 682     list = newAttr;
 683   }
 684
 685   void addAll(AttributeList *newList) {
 686     if (!newList) return;
 687
 688     AttributeList *lastInNewList = newList;
 689     while (AttributeList *next = lastInNewList->getNext())
 690       lastInNewList = next;
 691
 692     lastInNewList->setNext(list);
 693     list = newList;
 694   }
 695
 696   void set(AttributeList *newList) {
 697     list = newList;
 698   }
 699
 700   void takeAllFrom(ParsedAttributes &attrs) {
 701     addAll(attrs.list);
 702     attrs.list = nullptr;
 703     pool.takeAllFrom(attrs.pool);
 704   }
 705
 706   void clear() { list = nullptr; pool.clear(); }
 707   AttributeList *getList() const { return list; }
 708
 709   /// Returns a reference to the attribute list.  Try not to introduce
 710   /// dependencies on this method, it may not be long-lived.
 711   AttributeList *&getListRef() { return list; }
 712
 713   /// Add attribute with expression arguments.
 714   AttributeList *addNew(IdentifierInfo *attrName, SourceRange attrRange,
 715                         IdentifierInfo *scopeName, SourceLocation scopeLoc,
 716                         ArgsUnion *args, unsigned numArgs,
 717                         AttributeList::Syntax syntax,
 718                         SourceLocation ellipsisLoc = SourceLocation()) {
 719     AttributeList *attr =
 720       pool.create(attrName, attrRange, scopeName, scopeLoc, args, numArgs,
 721                   syntax, ellipsisLoc);
 722     add(attr);
 723     return attr;
 724   }
 725
 726   /// Add availability attribute.
 727   AttributeList *addNew(IdentifierInfo *attrName, SourceRange attrRange,
 728                         IdentifierInfo *scopeName, SourceLocation scopeLoc,
 729                         IdentifierLoc *Param,
 730                         const AvailabilityChange &introduced,
 731                         const AvailabilityChange &deprecated,
 732                         const AvailabilityChange &obsoleted,
 733                         SourceLocation unavailable,
 734                         const Expr *MessageExpr,
 735                         AttributeList::Syntax syntax) {
 736     AttributeList *attr =
 737       pool.create(attrName, attrRange, scopeName, scopeLoc, Param, introduced,
 738                   deprecated, obsoleted, unavailable, MessageExpr, syntax);
 739     add(attr);
 740     return attr;
 741   }
 742
 743   /// Add objc_bridge_related attribute.
 744   AttributeList *addNew(IdentifierInfo *attrName, SourceRange attrRange,
 745                         IdentifierInfo *scopeName, SourceLocation scopeLoc,
 746                         IdentifierLoc *Param1,
 747                         IdentifierLoc *Param2,
 748                         IdentifierLoc *Param3,
 749                         AttributeList::Syntax syntax) {
 750     AttributeList *attr =
 751       pool.create(attrName, attrRange, scopeName, scopeLoc,
 752                   Param1, Param2, Param3, syntax);
 753     add(attr);
 754     return attr;
 755   }
 756
 757   /// Add type_tag_for_datatype attribute.
 758   AttributeList *addNewTypeTagForDatatype(
 759                         IdentifierInfo *attrName, SourceRange attrRange,
 760                         IdentifierInfo *scopeName, SourceLocation scopeLoc,
 761                         IdentifierLoc *argumentKind, ParsedType matchingCType,
 762                         bool layoutCompatible, bool mustBeNull,
 763                         AttributeList::Syntax syntax) {
 764     AttributeList *attr =
 765       pool.createTypeTagForDatatype(attrName, attrRange,
 766                                     scopeName, scopeLoc,
 767                                     argumentKind, matchingCType,
 768                                     layoutCompatible, mustBeNull, syntax);
 769     add(attr);
 770     return attr;
 771   }
 772
 773   /// Add an attribute with a single type argument.
 774   AttributeList *
 775   addNewTypeAttr(IdentifierInfo *attrName, SourceRange attrRange,
 776                  IdentifierInfo *scopeName, SourceLocation scopeLoc,
 777                  ParsedType typeArg, AttributeList::Syntax syntaxUsed) {
 778     AttributeList *attr =
 779         pool.createTypeAttribute(attrName, attrRange, scopeName, scopeLoc,
 780                                  typeArg, syntaxUsed);
 781     add(attr);
 782     return attr;
 783   }
 784
 785   /// Add microsoft __delspec(property) attribute.
 786   AttributeList *
 787   addNewPropertyAttr(IdentifierInfo *attrName, SourceRange attrRange,
 788                  IdentifierInfo *scopeName, SourceLocation scopeLoc,
 789                  IdentifierInfo *getterId, IdentifierInfo *setterId,
 790                  AttributeList::Syntax syntaxUsed) {
 791     AttributeList *attr =
 792         pool.createPropertyAttribute(attrName, attrRange, scopeName, scopeLoc,
 793                                      getterId, setterId, syntaxUsed);
 794     add(attr);
 795     return attr;
 796   }
 797
 798 private:
 799   mutable AttributePool pool;
 800   AttributeList *list;
 801 };
 802
 803 /// These constants match the enumerated choices of
 804 /// err_attribute_argument_n_type and err_attribute_argument_type.
 805 enum AttributeArgumentNType {
 806   AANT_ArgumentIntOrBool,
 807   AANT_ArgumentIntegerConstant,
 808   AANT_ArgumentString,
 809   AANT_ArgumentIdentifier
 810 };
 811
 812 /// These constants match the enumerated choices of
 813 /// warn_attribute_wrong_decl_type and err_attribute_wrong_decl_type.
 814 enum AttributeDeclKind {
 815   ExpectedFunction,
 816   ExpectedUnion,
 817   ExpectedVariableOrFunction,
 818   ExpectedFunctionOrMethod,
 819   ExpectedParameter,
 820   ExpectedFunctionMethodOrBlock,
 821   ExpectedFunctionMethodOrClass,
 822   ExpectedFunctionMethodOrParameter,
 823   ExpectedClass,
 824   ExpectedVariable,
 825   ExpectedMethod,
 826   ExpectedVariableFunctionOrLabel,
 827   ExpectedFieldOrGlobalVar,
 828   ExpectedStruct,
 829   ExpectedVariableFunctionOrTag,
 830   ExpectedTLSVar,
 831   ExpectedVariableOrField,
 832   ExpectedVariableFieldOrTag,
 833   ExpectedTypeOrNamespace,
 834   ExpectedObjectiveCInterface,
 835   ExpectedMethodOrProperty,
 836   ExpectedStructOrUnion,
 837   ExpectedStructOrUnionOrClass,
 838   ExpectedType,
 839   ExpectedObjCInstanceMethod,
 840   ExpectedObjCInterfaceDeclInitMethod,
 841   ExpectedFunctionVariableOrClass,
 842   ExpectedObjectiveCProtocol,
 843   ExpectedFunctionGlobalVarMethodOrProperty,
 844   ExpectedStructOrTypedef,
 845   ExpectedObjectiveCInterfaceOrProtocol
 846 };
 847
 848 }  // end namespace clang
 849
 850 #endif