Home | History | Annotate | Download | only in Sema 
      1 //===--- AttributeList.cpp --------------------------------------*- 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 implementation
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "clang/Sema/AttributeList.h"
     15 #include "clang/AST/ASTContext.h"
     16 #include "clang/AST/Expr.h"
     17 #include "clang/Basic/IdentifierTable.h"
     18 #include "llvm/ADT/SmallString.h"
     19 #include "llvm/ADT/StringSwitch.h"
     20 using namespace clang;
     21 
     22 size_t AttributeList::allocated_size() const {
     23   if (IsAvailability) return AttributeFactory::AvailabilityAllocSize;
     24   else if (IsTypeTagForDatatype)
     25     return AttributeFactory::TypeTagForDatatypeAllocSize;
     26   return (sizeof(AttributeList) + NumArgs * sizeof(Expr*));
     27 }
     28 
     29 AttributeFactory::AttributeFactory() {
     30   // Go ahead and configure all the inline capacity.  This is just a memset.
     31   FreeLists.resize(InlineFreeListsCapacity);
     32 }
     33 AttributeFactory::~AttributeFactory() {}
     34 
     35 static size_t getFreeListIndexForSize(size_t size) {
     36   assert(size >= sizeof(AttributeList));
     37   assert((size % sizeof(void*)) == 0);
     38   return ((size - sizeof(AttributeList)) / sizeof(void*));
     39 }
     40 
     41 void *AttributeFactory::allocate(size_t size) {
     42   // Check for a previously reclaimed attribute.
     43   size_t index = getFreeListIndexForSize(size);
     44   if (index < FreeLists.size()) {
     45     if (AttributeList *attr = FreeLists[index]) {
     46       FreeLists[index] = attr->NextInPool;
     47       return attr;
     48     }
     49   }
     50 
     51   // Otherwise, allocate something new.
     52   return Alloc.Allocate(size, llvm::AlignOf<AttributeFactory>::Alignment);
     53 }
     54 
     55 void AttributeFactory::reclaimPool(AttributeList *cur) {
     56   assert(cur && "reclaiming empty pool!");
     57   do {
     58     // Read this here, because we're going to overwrite NextInPool
     59     // when we toss 'cur' into the appropriate queue.
     60     AttributeList *next = cur->NextInPool;
     61 
     62     size_t size = cur->allocated_size();
     63     size_t freeListIndex = getFreeListIndexForSize(size);
     64 
     65     // Expand FreeLists to the appropriate size, if required.
     66     if (freeListIndex >= FreeLists.size())
     67       FreeLists.resize(freeListIndex+1);
     68 
     69     // Add 'cur' to the appropriate free-list.
     70     cur->NextInPool = FreeLists[freeListIndex];
     71     FreeLists[freeListIndex] = cur;
     72 
     73     cur = next;
     74   } while (cur);
     75 }
     76 
     77 void AttributePool::takePool(AttributeList *pool) {
     78   assert(pool);
     79 
     80   // Fast path:  this pool is empty.
     81   if (!Head) {
     82     Head = pool;
     83     return;
     84   }
     85 
     86   // Reverse the pool onto the current head.  This optimizes for the
     87   // pattern of pulling a lot of pools into a single pool.
     88   do {
     89     AttributeList *next = pool->NextInPool;
     90     pool->NextInPool = Head;
     91     Head = pool;
     92     pool = next;
     93   } while (pool);
     94 }
     95 
     96 AttributeList *
     97 AttributePool::createIntegerAttribute(ASTContext &C, IdentifierInfo *Name,
     98                                       SourceLocation TokLoc, int Arg) {
     99   Expr *IArg = IntegerLiteral::Create(C, llvm::APInt(32, (uint64_t) Arg),
    100                                       C.IntTy, TokLoc);
    101   return create(Name, TokLoc, 0, TokLoc, 0, TokLoc, &IArg, 1,
    102                 AttributeList::AS_GNU);
    103 }
    104 
    105 #include "clang/Sema/AttrParsedAttrKinds.inc"
    106 
    107 AttributeList::Kind AttributeList::getKind(const IdentifierInfo *Name,
    108                                            const IdentifierInfo *ScopeName,
    109                                            Syntax SyntaxUsed) {
    110   StringRef AttrName = Name->getName();
    111 
    112   // Normalize the attribute name, __foo__ becomes foo.
    113   if (AttrName.startswith("__") && AttrName.endswith("__") &&
    114       AttrName.size() >= 4)
    115     AttrName = AttrName.substr(2, AttrName.size() - 4);
    116 
    117   SmallString<64> Buf;
    118   if (ScopeName)
    119     Buf += ScopeName->getName();
    120   // Ensure that in the case of C++11 attributes, we look for '::foo' if it is
    121   // unscoped.
    122   if (ScopeName || SyntaxUsed == AS_CXX11)
    123     Buf += "::";
    124   Buf += AttrName;
    125 
    126   return ::getAttrKind(Buf);
    127 }
    128 
    129 unsigned AttributeList::getAttributeSpellingListIndex() const {
    130   // Both variables will be used in tablegen generated
    131   // attribute spell list index matching code.
    132   StringRef Name = AttrName->getName();
    133   StringRef Scope = ScopeName ? ScopeName->getName() : "";
    134 
    135 #include "clang/Sema/AttrSpellingListIndex.inc"
    136 
    137 }
    138 
    139