1
//===-- Attributes.cpp - Implement AttributesList -------------------------===//
3
// The LLVM Compiler Infrastructure
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
8
//===----------------------------------------------------------------------===//
10
// This file implements the AttributesList class and Attribute utilities.
12
//===----------------------------------------------------------------------===//
14
#include "llvm/Attributes.h"
15
#include "llvm/Type.h"
16
#include "llvm/ADT/StringExtras.h"
17
#include "llvm/ADT/FoldingSet.h"
18
#include "llvm/System/Atomic.h"
19
#include "llvm/System/Mutex.h"
20
#include "llvm/Support/Debug.h"
21
#include "llvm/Support/ManagedStatic.h"
22
#include "llvm/Support/raw_ostream.h"
25
//===----------------------------------------------------------------------===//
26
// Attribute Function Definitions
27
//===----------------------------------------------------------------------===//
29
std::string Attribute::getAsString(Attributes Attrs) {
31
if (Attrs & Attribute::ZExt)
33
if (Attrs & Attribute::SExt)
35
if (Attrs & Attribute::NoReturn)
36
Result += "noreturn ";
37
if (Attrs & Attribute::NoUnwind)
38
Result += "nounwind ";
39
if (Attrs & Attribute::InReg)
41
if (Attrs & Attribute::NoAlias)
43
if (Attrs & Attribute::NoCapture)
44
Result += "nocapture ";
45
if (Attrs & Attribute::StructRet)
47
if (Attrs & Attribute::ByVal)
49
if (Attrs & Attribute::Nest)
51
if (Attrs & Attribute::ReadNone)
52
Result += "readnone ";
53
if (Attrs & Attribute::ReadOnly)
54
Result += "readonly ";
55
if (Attrs & Attribute::OptimizeForSize)
57
if (Attrs & Attribute::NoInline)
58
Result += "noinline ";
59
if (Attrs & Attribute::InlineHint)
60
Result += "inlinehint ";
61
if (Attrs & Attribute::AlwaysInline)
62
Result += "alwaysinline ";
63
if (Attrs & Attribute::StackProtect)
65
if (Attrs & Attribute::StackProtectReq)
67
if (Attrs & Attribute::NoRedZone)
68
Result += "noredzone ";
69
if (Attrs & Attribute::NoImplicitFloat)
70
Result += "noimplicitfloat ";
71
if (Attrs & Attribute::Naked)
73
if (Attrs & Attribute::StackAlignment) {
74
Result += "alignstack(";
75
Result += utostr(Attribute::getStackAlignmentFromAttrs(Attrs));
78
if (Attrs & Attribute::Alignment) {
80
Result += utostr(Attribute::getAlignmentFromAttrs(Attrs));
83
// Trim the trailing space.
84
assert(!Result.empty() && "Unknown attribute!");
85
Result.erase(Result.end()-1);
89
Attributes Attribute::typeIncompatible(const Type *Ty) {
90
Attributes Incompatible = None;
92
if (!Ty->isIntegerTy())
93
// Attributes that only apply to integers.
94
Incompatible |= SExt | ZExt;
96
if (!Ty->isPointerTy())
97
// Attributes that only apply to pointers.
98
Incompatible |= ByVal | Nest | NoAlias | StructRet | NoCapture;
103
//===----------------------------------------------------------------------===//
104
// AttributeListImpl Definition
105
//===----------------------------------------------------------------------===//
108
class AttributeListImpl : public FoldingSetNode {
109
sys::cas_flag RefCount;
111
// AttributesList is uniqued, these should not be publicly available.
112
void operator=(const AttributeListImpl &); // Do not implement
113
AttributeListImpl(const AttributeListImpl &); // Do not implement
114
~AttributeListImpl(); // Private implementation
116
SmallVector<AttributeWithIndex, 4> Attrs;
118
AttributeListImpl(const AttributeWithIndex *Attr, unsigned NumAttrs)
119
: Attrs(Attr, Attr+NumAttrs) {
123
void AddRef() { sys::AtomicIncrement(&RefCount); }
125
sys::cas_flag old = sys::AtomicDecrement(&RefCount);
126
if (old == 0) delete this;
129
void Profile(FoldingSetNodeID &ID) const {
130
Profile(ID, Attrs.data(), Attrs.size());
132
static void Profile(FoldingSetNodeID &ID, const AttributeWithIndex *Attr,
134
for (unsigned i = 0; i != NumAttrs; ++i)
135
ID.AddInteger(uint64_t(Attr[i].Attrs) << 32 | unsigned(Attr[i].Index));
140
static ManagedStatic<sys::SmartMutex<true> > ALMutex;
141
static ManagedStatic<FoldingSet<AttributeListImpl> > AttributesLists;
143
AttributeListImpl::~AttributeListImpl() {
144
sys::SmartScopedLock<true> Lock(*ALMutex);
145
AttributesLists->RemoveNode(this);
149
AttrListPtr AttrListPtr::get(const AttributeWithIndex *Attrs, unsigned NumAttrs) {
150
// If there are no attributes then return a null AttributesList pointer.
152
return AttrListPtr();
155
for (unsigned i = 0; i != NumAttrs; ++i) {
156
assert(Attrs[i].Attrs != Attribute::None &&
157
"Pointless attribute!");
158
assert((!i || Attrs[i-1].Index < Attrs[i].Index) &&
159
"Misordered AttributesList!");
163
// Otherwise, build a key to look up the existing attributes.
165
AttributeListImpl::Profile(ID, Attrs, NumAttrs);
168
sys::SmartScopedLock<true> Lock(*ALMutex);
170
AttributeListImpl *PAL =
171
AttributesLists->FindNodeOrInsertPos(ID, InsertPos);
173
// If we didn't find any existing attributes of the same shape then
174
// create a new one and insert it.
176
PAL = new AttributeListImpl(Attrs, NumAttrs);
177
AttributesLists->InsertNode(PAL, InsertPos);
180
// Return the AttributesList that we found or created.
181
return AttrListPtr(PAL);
185
//===----------------------------------------------------------------------===//
186
// AttrListPtr Method Implementations
187
//===----------------------------------------------------------------------===//
189
AttrListPtr::AttrListPtr(AttributeListImpl *LI) : AttrList(LI) {
190
if (LI) LI->AddRef();
193
AttrListPtr::AttrListPtr(const AttrListPtr &P) : AttrList(P.AttrList) {
194
if (AttrList) AttrList->AddRef();
197
const AttrListPtr &AttrListPtr::operator=(const AttrListPtr &RHS) {
198
if (AttrList == RHS.AttrList) return *this;
199
if (AttrList) AttrList->DropRef();
200
AttrList = RHS.AttrList;
201
if (AttrList) AttrList->AddRef();
205
AttrListPtr::~AttrListPtr() {
206
if (AttrList) AttrList->DropRef();
209
/// getNumSlots - Return the number of slots used in this attribute list.
210
/// This is the number of arguments that have an attribute set on them
211
/// (including the function itself).
212
unsigned AttrListPtr::getNumSlots() const {
213
return AttrList ? AttrList->Attrs.size() : 0;
216
/// getSlot - Return the AttributeWithIndex at the specified slot. This
217
/// holds a number plus a set of attributes.
218
const AttributeWithIndex &AttrListPtr::getSlot(unsigned Slot) const {
219
assert(AttrList && Slot < AttrList->Attrs.size() && "Slot # out of range!");
220
return AttrList->Attrs[Slot];
224
/// getAttributes - The attributes for the specified index are
225
/// returned. Attributes for the result are denoted with Idx = 0.
226
/// Function notes are denoted with idx = ~0.
227
Attributes AttrListPtr::getAttributes(unsigned Idx) const {
228
if (AttrList == 0) return Attribute::None;
230
const SmallVector<AttributeWithIndex, 4> &Attrs = AttrList->Attrs;
231
for (unsigned i = 0, e = Attrs.size(); i != e && Attrs[i].Index <= Idx; ++i)
232
if (Attrs[i].Index == Idx)
233
return Attrs[i].Attrs;
234
return Attribute::None;
237
/// hasAttrSomewhere - Return true if the specified attribute is set for at
238
/// least one parameter or for the return value.
239
bool AttrListPtr::hasAttrSomewhere(Attributes Attr) const {
240
if (AttrList == 0) return false;
242
const SmallVector<AttributeWithIndex, 4> &Attrs = AttrList->Attrs;
243
for (unsigned i = 0, e = Attrs.size(); i != e; ++i)
244
if (Attrs[i].Attrs & Attr)
250
AttrListPtr AttrListPtr::addAttr(unsigned Idx, Attributes Attrs) const {
251
Attributes OldAttrs = getAttributes(Idx);
253
// FIXME it is not obvious how this should work for alignment.
254
// For now, say we can't change a known alignment.
255
Attributes OldAlign = OldAttrs & Attribute::Alignment;
256
Attributes NewAlign = Attrs & Attribute::Alignment;
257
assert((!OldAlign || !NewAlign || OldAlign == NewAlign) &&
258
"Attempt to change alignment!");
261
Attributes NewAttrs = OldAttrs | Attrs;
262
if (NewAttrs == OldAttrs)
265
SmallVector<AttributeWithIndex, 8> NewAttrList;
267
NewAttrList.push_back(AttributeWithIndex::get(Idx, Attrs));
269
const SmallVector<AttributeWithIndex, 4> &OldAttrList = AttrList->Attrs;
270
unsigned i = 0, e = OldAttrList.size();
271
// Copy attributes for arguments before this one.
272
for (; i != e && OldAttrList[i].Index < Idx; ++i)
273
NewAttrList.push_back(OldAttrList[i]);
275
// If there are attributes already at this index, merge them in.
276
if (i != e && OldAttrList[i].Index == Idx) {
277
Attrs |= OldAttrList[i].Attrs;
281
NewAttrList.push_back(AttributeWithIndex::get(Idx, Attrs));
283
// Copy attributes for arguments after this one.
284
NewAttrList.insert(NewAttrList.end(),
285
OldAttrList.begin()+i, OldAttrList.end());
288
return get(NewAttrList.data(), NewAttrList.size());
291
AttrListPtr AttrListPtr::removeAttr(unsigned Idx, Attributes Attrs) const {
293
// FIXME it is not obvious how this should work for alignment.
294
// For now, say we can't pass in alignment, which no current use does.
295
assert(!(Attrs & Attribute::Alignment) && "Attempt to exclude alignment!");
297
if (AttrList == 0) return AttrListPtr();
299
Attributes OldAttrs = getAttributes(Idx);
300
Attributes NewAttrs = OldAttrs & ~Attrs;
301
if (NewAttrs == OldAttrs)
304
SmallVector<AttributeWithIndex, 8> NewAttrList;
305
const SmallVector<AttributeWithIndex, 4> &OldAttrList = AttrList->Attrs;
306
unsigned i = 0, e = OldAttrList.size();
308
// Copy attributes for arguments before this one.
309
for (; i != e && OldAttrList[i].Index < Idx; ++i)
310
NewAttrList.push_back(OldAttrList[i]);
312
// If there are attributes already at this index, merge them in.
313
assert(OldAttrList[i].Index == Idx && "Attribute isn't set?");
314
Attrs = OldAttrList[i].Attrs & ~Attrs;
316
if (Attrs) // If any attributes left for this parameter, add them.
317
NewAttrList.push_back(AttributeWithIndex::get(Idx, Attrs));
319
// Copy attributes for arguments after this one.
320
NewAttrList.insert(NewAttrList.end(),
321
OldAttrList.begin()+i, OldAttrList.end());
323
return get(NewAttrList.data(), NewAttrList.size());
326
void AttrListPtr::dump() const {
328
for (unsigned i = 0; i < getNumSlots(); ++i) {
329
const AttributeWithIndex &PAWI = getSlot(i);
330
dbgs() << "{" << PAWI.Index << "," << PAWI.Attrs << "} ";