contrib/llvm/tools/clang/lib/Sema/AttributeList.cpp

   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/Expr.h"
  16 #include "clang/Basic/IdentifierTable.h"
  17 #include "llvm/ADT/StringSwitch.h"
  18 using namespace clang;
  19
  20 size_t AttributeList::allocated_size() const {
  21   if (IsAvailability) return AttributeFactory::AvailabilityAllocSize;
  22   return (sizeof(AttributeList) + NumArgs * sizeof(Expr*));
  23 }
  24
  25 AttributeFactory::AttributeFactory() {
  26   // Go ahead and configure all the inline capacity.  This is just a memset.
  27   FreeLists.resize(InlineFreeListsCapacity);
  28 }
  29 AttributeFactory::~AttributeFactory() {}
  30
  31 static size_t getFreeListIndexForSize(size_t size) {
  32   assert(size >= sizeof(AttributeList));
  33   assert((size % sizeof(void*)) == 0);
  34   return ((size - sizeof(AttributeList)) / sizeof(void*));
  35 }
  36
  37 void *AttributeFactory::allocate(size_t size) {
  38   // Check for a previously reclaimed attribute.
  39   size_t index = getFreeListIndexForSize(size);
  40   if (index < FreeLists.size()) {
  41     if (AttributeList *attr = FreeLists[index]) {
  42       FreeLists[index] = attr->NextInPool;
  43       return attr;
  44     }
  45   }
  46
  47   // Otherwise, allocate something new.
  48   return Alloc.Allocate(size, llvm::AlignOf<AttributeFactory>::Alignment);
  49 }
  50
  51 void AttributeFactory::reclaimPool(AttributeList *cur) {
  52   assert(cur && "reclaiming empty pool!");
  53   do {
  54     // Read this here, because we're going to overwrite NextInPool
  55     // when we toss 'cur' into the appropriate queue.
  56     AttributeList *next = cur->NextInPool;
  57
  58     size_t size = cur->allocated_size();
  59     size_t freeListIndex = getFreeListIndexForSize(size);
  60
  61     // Expand FreeLists to the appropriate size, if required.
  62     if (freeListIndex >= FreeLists.size())
  63       FreeLists.resize(freeListIndex+1);
  64
  65     // Add 'cur' to the appropriate free-list.
  66     cur->NextInPool = FreeLists[freeListIndex];
  67     FreeLists[freeListIndex] = cur;
  68
  69     cur = next;
  70   } while (cur);
  71 }
  72
  73 void AttributePool::takePool(AttributeList *pool) {
  74   assert(pool);
  75
  76   // Fast path:  this pool is empty.
  77   if (!Head) {
  78     Head = pool;
  79     return;
  80   }
  81
  82   // Reverse the pool onto the current head.  This optimizes for the
  83   // pattern of pulling a lot of pools into a single pool.
  84   do {
  85     AttributeList *next = pool->NextInPool;
  86     pool->NextInPool = Head;
  87     Head = pool;
  88     pool = next;
  89   } while (pool);
  90 }
  91
  92 AttributeList *
  93 AttributePool::createIntegerAttribute(ASTContext &C, IdentifierInfo *Name,
  94                                       SourceLocation TokLoc, int Arg) {
  95   Expr *IArg = IntegerLiteral::Create(C, llvm::APInt(32, (uint64_t) Arg),
  96                                       C.IntTy, TokLoc);
  97   return create(Name, TokLoc, 0, TokLoc, 0, TokLoc, &IArg, 1, 0);
  98 }
  99
 100 AttributeList::Kind AttributeList::getKind(const IdentifierInfo *Name) {
 101   StringRef AttrName = Name->getName();
 102
 103   // Normalize the attribute name, __foo__ becomes foo.
 104   if (AttrName.startswith("__") && AttrName.endswith("__"))
 105     AttrName = AttrName.substr(2, AttrName.size() - 4);
 106
 107   return llvm::StringSwitch<AttributeList::Kind>(AttrName)
 108     .Case("weak", AT_weak)
 109     .Case("weakref", AT_weakref)
 110     .Case("objc_arc_weak_reference_unavailable", AT_arc_weakref_unavailable)
 111     .Case("pure", AT_pure)
 112     .Case("mode", AT_mode)
 113     .Case("used", AT_used)
 114     .Case("alias", AT_alias)
 115     .Case("align", AT_aligned)
 116     .Case("cdecl", AT_cdecl)
 117     .Case("const", AT_const)
 118     .Case("__const", AT_const) // some GCC headers do contain this spelling
 119     .Case("blocks", AT_blocks)
 120     .Case("format", AT_format)
 121     .Case("malloc", AT_malloc)
 122     .Case("packed", AT_packed)
 123     .Case("unused", AT_unused)
 124     .Case("aligned", AT_aligned)
 125     .Case("cleanup", AT_cleanup)
 126     .Case("naked", AT_naked)
 127     .Case("nodebug", AT_nodebug)
 128     .Case("nonnull", AT_nonnull)
 129     .Case("nothrow", AT_nothrow)
 130     .Case("objc_gc", AT_objc_gc)
 131     .Case("regparm", AT_regparm)
 132     .Case("section", AT_section)
 133     .Case("stdcall", AT_stdcall)
 134     .Case("annotate", AT_annotate)
 135     .Case("fastcall", AT_fastcall)
 136     .Case("ibaction", AT_IBAction)
 137     .Case("iboutlet", AT_IBOutlet)
 138     .Case("iboutletcollection", AT_IBOutletCollection)
 139     .Case("noreturn", AT_noreturn)
 140     .Case("noinline", AT_noinline)
 141     .Case("sentinel", AT_sentinel)
 142     .Case("NSObject", AT_nsobject)
 143     .Case("dllimport", AT_dllimport)
 144     .Case("dllexport", AT_dllexport)
 145     .Case("may_alias", AT_may_alias)
 146     .Case("base_check", AT_base_check)
 147     .Case("deprecated", AT_deprecated)
 148     .Case("availability", AT_availability)
 149     .Case("visibility", AT_visibility)
 150     .Case("destructor", AT_destructor)
 151     .Case("format_arg", AT_format_arg)
 152     .Case("gnu_inline", AT_gnu_inline)
 153     .Case("weak_import", AT_weak_import)
 154     .Case("vecreturn", AT_vecreturn)
 155     .Case("vector_size", AT_vector_size)
 156     .Case("constructor", AT_constructor)
 157     .Case("unavailable", AT_unavailable)
 158     .Case("overloadable", AT_overloadable)
 159     .Case("address_space", AT_address_space)
 160     .Case("opencl_image_access", AT_opencl_image_access)
 161     .Case("always_inline", AT_always_inline)
 162     .Case("returns_twice", AT_returns_twice)
 163     .Case("vec_type_hint", IgnoredAttribute)
 164     .Case("objc_exception", AT_objc_exception)
 165     .Case("objc_method_family", AT_objc_method_family)
 166     .Case("objc_returns_inner_pointer", AT_objc_returns_inner_pointer)
 167     .Case("ext_vector_type", AT_ext_vector_type)
 168     .Case("neon_vector_type", AT_neon_vector_type)
 169     .Case("neon_polyvector_type", AT_neon_polyvector_type)
 170     .Case("transparent_union", AT_transparent_union)
 171     .Case("analyzer_noreturn", AT_analyzer_noreturn)
 172     .Case("warn_unused_result", AT_warn_unused_result)
 173     .Case("carries_dependency", AT_carries_dependency)
 174     .Case("ns_bridged", AT_ns_bridged)
 175     .Case("ns_consumed", AT_ns_consumed)
 176     .Case("ns_consumes_self", AT_ns_consumes_self)
 177     .Case("ns_returns_autoreleased", AT_ns_returns_autoreleased)
 178     .Case("ns_returns_not_retained", AT_ns_returns_not_retained)
 179     .Case("ns_returns_retained", AT_ns_returns_retained)
 180     .Case("cf_audited_transfer", AT_cf_audited_transfer)
 181     .Case("cf_consumed", AT_cf_consumed)
 182     .Case("cf_returns_not_retained", AT_cf_returns_not_retained)
 183     .Case("cf_returns_retained", AT_cf_returns_retained)
 184     .Case("cf_returns_autoreleased", AT_cf_returns_autoreleased)
 185     .Case("cf_unknown_transfer", AT_cf_unknown_transfer)
 186     .Case("ns_consumes_self", AT_ns_consumes_self)
 187     .Case("ns_consumed", AT_ns_consumed)
 188     .Case("objc_ownership", AT_objc_ownership)
 189     .Case("objc_precise_lifetime", AT_objc_precise_lifetime)
 190     .Case("ownership_returns", AT_ownership_returns)
 191     .Case("ownership_holds", AT_ownership_holds)
 192     .Case("ownership_takes", AT_ownership_takes)
 193     .Case("reqd_work_group_size", AT_reqd_wg_size)
 194     .Case("init_priority", AT_init_priority)
 195     .Case("no_instrument_function", AT_no_instrument_function)
 196     .Case("thiscall", AT_thiscall)
 197     .Case("bounded", IgnoredAttribute)       // OpenBSD
 198     .Case("pascal", AT_pascal)
 199     .Case("__cdecl", AT_cdecl)
 200     .Case("__stdcall", AT_stdcall)
 201     .Case("__fastcall", AT_fastcall)
 202     .Case("__thiscall", AT_thiscall)
 203     .Case("__pascal", AT_pascal)
 204     .Case("constant", AT_constant)
 205     .Case("device", AT_device)
 206     .Case("global", AT_global)
 207     .Case("host", AT_host)
 208     .Case("shared", AT_shared)
 209     .Case("launch_bounds", AT_launch_bounds)
 210     .Case("common", AT_common)
 211     .Case("nocommon", AT_nocommon)
 212     .Case("opencl_kernel_function", AT_opencl_kernel_function)
 213     .Case("uuid", AT_uuid)
 214     .Case("pcs", AT_pcs)
 215     .Case("ms_struct", AT_MsStruct)
 216     .Case("guarded_var", AT_guarded_var)
 217     .Case("pt_guarded_var", AT_pt_guarded_var)
 218     .Case("scoped_lockable", AT_scoped_lockable)
 219     .Case("lockable", AT_lockable)
 220     .Case("no_thread_safety_analysis", AT_no_thread_safety_analysis)
 221     .Case("guarded_by", AT_guarded_by)
 222     .Case("pt_guarded_by", AT_pt_guarded_by)
 223     .Case("acquired_after", AT_acquired_after)
 224     .Case("acquired_before", AT_acquired_before)
 225     .Case("exclusive_lock_function", AT_exclusive_lock_function)
 226     .Case("exclusive_locks_required", AT_exclusive_locks_required)
 227     .Case("exclusive_trylock_function", AT_exclusive_trylock_function)
 228     .Case("lock_returned", AT_lock_returned)
 229     .Case("locks_excluded", AT_locks_excluded)
 230     .Case("shared_lock_function", AT_shared_lock_function)
 231     .Case("shared_locks_required", AT_shared_locks_required)
 232     .Case("shared_trylock_function", AT_shared_trylock_function)
 233     .Case("unlock_function", AT_unlock_function)
 234     .Default(UnknownAttribute);
 235 }