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 } 236
