AttributeList.cpp revision 0d5a069f66df09b3308ccfdce84a88170034c657 
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/StringSwitch.h"
19#include "llvm/ADT/SmallString.h"
20using namespace clang;
21
22size_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
29AttributeFactory::AttributeFactory() {
30  // Go ahead and configure all the inline capacity.  This is just a memset.
31  FreeLists.resize(InlineFreeListsCapacity);
32}
33AttributeFactory::~AttributeFactory() {}
34
35static 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
41void *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
55void 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
77void 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
96AttributeList *
97AttributePool::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
107AttributeList::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