s/AttrListPtr/AttributeSet/g to better label what this class is going to be in the...
[oota-llvm.git] / lib / VMCore / Attributes.cpp
1 //===-- Attributes.cpp - Implement AttributesList -------------------------===//
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 implements the Attributes, AttributeImpl, AttrBuilder,
11 // AttributeListImpl, and AttributeSet classes.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #include "llvm/Attributes.h"
16 #include "AttributesImpl.h"
17 #include "LLVMContextImpl.h"
18 #include "llvm/ADT/FoldingSet.h"
19 #include "llvm/ADT/StringExtras.h"
20 #include "llvm/Support/Atomic.h"
21 #include "llvm/Support/Debug.h"
22 #include "llvm/Support/ManagedStatic.h"
23 #include "llvm/Support/Mutex.h"
24 #include "llvm/Support/raw_ostream.h"
25 #include "llvm/Type.h"
26 using namespace llvm;
27
28 //===----------------------------------------------------------------------===//
29 // Attributes Implementation
30 //===----------------------------------------------------------------------===//
31
32 Attributes Attributes::get(LLVMContext &Context, ArrayRef<AttrVal> Vals) {
33   AttrBuilder B;
34   for (ArrayRef<AttrVal>::iterator I = Vals.begin(), E = Vals.end();
35        I != E; ++I)
36     B.addAttribute(*I);
37   return Attributes::get(Context, B);
38 }
39
40 Attributes Attributes::get(LLVMContext &Context, AttrBuilder &B) {
41   // If there are no attributes, return an empty Attributes class.
42   if (!B.hasAttributes())
43     return Attributes();
44
45   // Otherwise, build a key to look up the existing attributes.
46   LLVMContextImpl *pImpl = Context.pImpl;
47   FoldingSetNodeID ID;
48   ID.AddInteger(B.Raw());
49
50   void *InsertPoint;
51   AttributesImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);
52
53   if (!PA) {
54     // If we didn't find any existing attributes of the same shape then create a
55     // new one and insert it.
56     PA = new AttributesImpl(B.Raw());
57     pImpl->AttrsSet.InsertNode(PA, InsertPoint);
58   }
59
60   // Return the AttributesList that we found or created.
61   return Attributes(PA);
62 }
63
64 bool Attributes::hasAttribute(AttrVal Val) const {
65   return Attrs && Attrs->hasAttribute(Val);
66 }
67
68 bool Attributes::hasAttributes() const {
69   return Attrs && Attrs->hasAttributes();
70 }
71
72 bool Attributes::hasAttributes(const Attributes &A) const {
73   return Attrs && Attrs->hasAttributes(A);
74 }
75
76 /// This returns the alignment field of an attribute as a byte alignment value.
77 unsigned Attributes::getAlignment() const {
78   if (!hasAttribute(Attributes::Alignment))
79     return 0;
80   return 1U << ((Attrs->getAlignment() >> 16) - 1);
81 }
82
83 /// This returns the stack alignment field of an attribute as a byte alignment
84 /// value.
85 unsigned Attributes::getStackAlignment() const {
86   if (!hasAttribute(Attributes::StackAlignment))
87     return 0;
88   return 1U << ((Attrs->getStackAlignment() >> 26) - 1);
89 }
90
91 uint64_t Attributes::Raw() const {
92   return Attrs ? Attrs->Raw() : 0;
93 }
94
95 Attributes Attributes::typeIncompatible(Type *Ty) {
96   AttrBuilder Incompatible;
97
98   if (!Ty->isIntegerTy())
99     // Attributes that only apply to integers.
100     Incompatible.addAttribute(Attributes::SExt)
101       .addAttribute(Attributes::ZExt);
102
103   if (!Ty->isPointerTy())
104     // Attributes that only apply to pointers.
105     Incompatible.addAttribute(Attributes::ByVal)
106       .addAttribute(Attributes::Nest)
107       .addAttribute(Attributes::NoAlias)
108       .addAttribute(Attributes::NoCapture)
109       .addAttribute(Attributes::StructRet);
110
111   return Attributes::get(Ty->getContext(), Incompatible);
112 }
113
114 /// encodeLLVMAttributesForBitcode - This returns an integer containing an
115 /// encoding of all the LLVM attributes found in the given attribute bitset.
116 /// Any change to this encoding is a breaking change to bitcode compatibility.
117 uint64_t Attributes::encodeLLVMAttributesForBitcode(Attributes Attrs) {
118   // FIXME: It doesn't make sense to store the alignment information as an
119   // expanded out value, we should store it as a log2 value.  However, we can't
120   // just change that here without breaking bitcode compatibility.  If this ever
121   // becomes a problem in practice, we should introduce new tag numbers in the
122   // bitcode file and have those tags use a more efficiently encoded alignment
123   // field.
124
125   // Store the alignment in the bitcode as a 16-bit raw value instead of a 5-bit
126   // log2 encoded value. Shift the bits above the alignment up by 11 bits.
127   uint64_t EncodedAttrs = Attrs.Raw() & 0xffff;
128   if (Attrs.hasAttribute(Attributes::Alignment))
129     EncodedAttrs |= Attrs.getAlignment() << 16;
130   EncodedAttrs |= (Attrs.Raw() & (0xffffULL << 21)) << 11;
131   return EncodedAttrs;
132 }
133
134 /// decodeLLVMAttributesForBitcode - This returns an attribute bitset containing
135 /// the LLVM attributes that have been decoded from the given integer.  This
136 /// function must stay in sync with 'encodeLLVMAttributesForBitcode'.
137 Attributes Attributes::decodeLLVMAttributesForBitcode(LLVMContext &C,
138                                                       uint64_t EncodedAttrs) {
139   // The alignment is stored as a 16-bit raw value from bits 31--16.  We shift
140   // the bits above 31 down by 11 bits.
141   unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16;
142   assert((!Alignment || isPowerOf2_32(Alignment)) &&
143          "Alignment must be a power of two.");
144
145   AttrBuilder B(EncodedAttrs & 0xffff);
146   if (Alignment)
147     B.addAlignmentAttr(Alignment);
148   B.addRawValue((EncodedAttrs & (0xffffULL << 32)) >> 11);
149   return Attributes::get(C, B);
150 }
151
152 std::string Attributes::getAsString() const {
153   std::string Result;
154   if (hasAttribute(Attributes::ZExt))
155     Result += "zeroext ";
156   if (hasAttribute(Attributes::SExt))
157     Result += "signext ";
158   if (hasAttribute(Attributes::NoReturn))
159     Result += "noreturn ";
160   if (hasAttribute(Attributes::NoUnwind))
161     Result += "nounwind ";
162   if (hasAttribute(Attributes::UWTable))
163     Result += "uwtable ";
164   if (hasAttribute(Attributes::ReturnsTwice))
165     Result += "returns_twice ";
166   if (hasAttribute(Attributes::InReg))
167     Result += "inreg ";
168   if (hasAttribute(Attributes::NoAlias))
169     Result += "noalias ";
170   if (hasAttribute(Attributes::NoCapture))
171     Result += "nocapture ";
172   if (hasAttribute(Attributes::StructRet))
173     Result += "sret ";
174   if (hasAttribute(Attributes::ByVal))
175     Result += "byval ";
176   if (hasAttribute(Attributes::Nest))
177     Result += "nest ";
178   if (hasAttribute(Attributes::ReadNone))
179     Result += "readnone ";
180   if (hasAttribute(Attributes::ReadOnly))
181     Result += "readonly ";
182   if (hasAttribute(Attributes::OptimizeForSize))
183     Result += "optsize ";
184   if (hasAttribute(Attributes::NoInline))
185     Result += "noinline ";
186   if (hasAttribute(Attributes::InlineHint))
187     Result += "inlinehint ";
188   if (hasAttribute(Attributes::AlwaysInline))
189     Result += "alwaysinline ";
190   if (hasAttribute(Attributes::StackProtect))
191     Result += "ssp ";
192   if (hasAttribute(Attributes::StackProtectReq))
193     Result += "sspreq ";
194   if (hasAttribute(Attributes::NoRedZone))
195     Result += "noredzone ";
196   if (hasAttribute(Attributes::NoImplicitFloat))
197     Result += "noimplicitfloat ";
198   if (hasAttribute(Attributes::Naked))
199     Result += "naked ";
200   if (hasAttribute(Attributes::NonLazyBind))
201     Result += "nonlazybind ";
202   if (hasAttribute(Attributes::AddressSafety))
203     Result += "address_safety ";
204   if (hasAttribute(Attributes::MinSize))
205     Result += "minsize ";
206   if (hasAttribute(Attributes::StackAlignment)) {
207     Result += "alignstack(";
208     Result += utostr(getStackAlignment());
209     Result += ") ";
210   }
211   if (hasAttribute(Attributes::Alignment)) {
212     Result += "align ";
213     Result += utostr(getAlignment());
214     Result += " ";
215   }
216   // Trim the trailing space.
217   assert(!Result.empty() && "Unknown attribute!");
218   Result.erase(Result.end()-1);
219   return Result;
220 }
221
222 //===----------------------------------------------------------------------===//
223 // AttrBuilder Implementation
224 //===----------------------------------------------------------------------===//
225
226 AttrBuilder &AttrBuilder::addAttribute(Attributes::AttrVal Val){
227   Bits |= AttributesImpl::getAttrMask(Val);
228   return *this;
229 }
230
231 AttrBuilder &AttrBuilder::addRawValue(uint64_t Val) {
232   Bits |= Val;
233   return *this;
234 }
235
236 AttrBuilder &AttrBuilder::addAlignmentAttr(unsigned Align) {
237   if (Align == 0) return *this;
238   assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
239   assert(Align <= 0x40000000 && "Alignment too large.");
240   Bits |= (Log2_32(Align) + 1) << 16;
241   return *this;
242 }
243 AttrBuilder &AttrBuilder::addStackAlignmentAttr(unsigned Align){
244   // Default alignment, allow the target to define how to align it.
245   if (Align == 0) return *this;
246   assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
247   assert(Align <= 0x100 && "Alignment too large.");
248   Bits |= (Log2_32(Align) + 1) << 26;
249   return *this;
250 }
251
252 AttrBuilder &AttrBuilder::removeAttribute(Attributes::AttrVal Val) {
253   Bits &= ~AttributesImpl::getAttrMask(Val);
254   return *this;
255 }
256
257 AttrBuilder &AttrBuilder::addAttributes(const Attributes &A) {
258   Bits |= A.Raw();
259   return *this;
260 }
261
262 AttrBuilder &AttrBuilder::removeAttributes(const Attributes &A){
263   Bits &= ~A.Raw();
264   return *this;
265 }
266
267 bool AttrBuilder::hasAttribute(Attributes::AttrVal A) const {
268   return Bits & AttributesImpl::getAttrMask(A);
269 }
270
271 bool AttrBuilder::hasAttributes() const {
272   return Bits != 0;
273 }
274 bool AttrBuilder::hasAttributes(const Attributes &A) const {
275   return Bits & A.Raw();
276 }
277 bool AttrBuilder::hasAlignmentAttr() const {
278   return Bits & AttributesImpl::getAttrMask(Attributes::Alignment);
279 }
280
281 uint64_t AttrBuilder::getAlignment() const {
282   if (!hasAlignmentAttr())
283     return 0;
284   return 1ULL <<
285     (((Bits & AttributesImpl::getAttrMask(Attributes::Alignment)) >> 16) - 1);
286 }
287
288 uint64_t AttrBuilder::getStackAlignment() const {
289   if (!hasAlignmentAttr())
290     return 0;
291   return 1ULL <<
292     (((Bits & AttributesImpl::getAttrMask(Attributes::StackAlignment))>>26)-1);
293 }
294
295 //===----------------------------------------------------------------------===//
296 // AttributeImpl Definition
297 //===----------------------------------------------------------------------===//
298
299 uint64_t AttributesImpl::getAttrMask(uint64_t Val) {
300   switch (Val) {
301   case Attributes::None:            return 0;
302   case Attributes::ZExt:            return 1 << 0;
303   case Attributes::SExt:            return 1 << 1;
304   case Attributes::NoReturn:        return 1 << 2;
305   case Attributes::InReg:           return 1 << 3;
306   case Attributes::StructRet:       return 1 << 4;
307   case Attributes::NoUnwind:        return 1 << 5;
308   case Attributes::NoAlias:         return 1 << 6;
309   case Attributes::ByVal:           return 1 << 7;
310   case Attributes::Nest:            return 1 << 8;
311   case Attributes::ReadNone:        return 1 << 9;
312   case Attributes::ReadOnly:        return 1 << 10;
313   case Attributes::NoInline:        return 1 << 11;
314   case Attributes::AlwaysInline:    return 1 << 12;
315   case Attributes::OptimizeForSize: return 1 << 13;
316   case Attributes::StackProtect:    return 1 << 14;
317   case Attributes::StackProtectReq: return 1 << 15;
318   case Attributes::Alignment:       return 31 << 16;
319   case Attributes::NoCapture:       return 1 << 21;
320   case Attributes::NoRedZone:       return 1 << 22;
321   case Attributes::NoImplicitFloat: return 1 << 23;
322   case Attributes::Naked:           return 1 << 24;
323   case Attributes::InlineHint:      return 1 << 25;
324   case Attributes::StackAlignment:  return 7 << 26;
325   case Attributes::ReturnsTwice:    return 1 << 29;
326   case Attributes::UWTable:         return 1 << 30;
327   case Attributes::NonLazyBind:     return 1U << 31;
328   case Attributes::AddressSafety:   return 1ULL << 32;
329   case Attributes::MinSize:         return 1ULL << 33;
330   }
331   llvm_unreachable("Unsupported attribute type");
332 }
333
334 bool AttributesImpl::hasAttribute(uint64_t A) const {
335   return (Bits & getAttrMask(A)) != 0;
336 }
337
338 bool AttributesImpl::hasAttributes() const {
339   return Bits != 0;
340 }
341
342 bool AttributesImpl::hasAttributes(const Attributes &A) const {
343   return Bits & A.Raw();        // FIXME: Raw() won't work here in the future.
344 }
345
346 uint64_t AttributesImpl::getAlignment() const {
347   return Bits & getAttrMask(Attributes::Alignment);
348 }
349
350 uint64_t AttributesImpl::getStackAlignment() const {
351   return Bits & getAttrMask(Attributes::StackAlignment);
352 }
353
354 //===----------------------------------------------------------------------===//
355 // AttributeListImpl Definition
356 //===----------------------------------------------------------------------===//
357
358 AttributeSet AttributeSet::get(LLVMContext &C,
359                              ArrayRef<AttributeWithIndex> Attrs) {
360   // If there are no attributes then return a null AttributesList pointer.
361   if (Attrs.empty())
362     return AttributeSet();
363
364 #ifndef NDEBUG
365   for (unsigned i = 0, e = Attrs.size(); i != e; ++i) {
366     assert(Attrs[i].Attrs.hasAttributes() &&
367            "Pointless attribute!");
368     assert((!i || Attrs[i-1].Index < Attrs[i].Index) &&
369            "Misordered AttributesList!");
370   }
371 #endif
372
373   // Otherwise, build a key to look up the existing attributes.
374   LLVMContextImpl *pImpl = C.pImpl;
375   FoldingSetNodeID ID;
376   AttributeListImpl::Profile(ID, Attrs);
377
378   void *InsertPoint;
379   AttributeListImpl *PA = pImpl->AttrsLists.FindNodeOrInsertPos(ID,
380                                                                 InsertPoint);
381
382   // If we didn't find any existing attributes of the same shape then
383   // create a new one and insert it.
384   if (!PA) {
385     PA = new AttributeListImpl(Attrs);
386     pImpl->AttrsLists.InsertNode(PA, InsertPoint);
387   }
388
389   // Return the AttributesList that we found or created.
390   return AttributeSet(PA);
391 }
392
393 //===----------------------------------------------------------------------===//
394 // AttributeSet Method Implementations
395 //===----------------------------------------------------------------------===//
396
397 const AttributeSet &AttributeSet::operator=(const AttributeSet &RHS) {
398   if (AttrList == RHS.AttrList) return *this;
399
400   AttrList = RHS.AttrList;
401   return *this;
402 }
403
404 /// getNumSlots - Return the number of slots used in this attribute list.
405 /// This is the number of arguments that have an attribute set on them
406 /// (including the function itself).
407 unsigned AttributeSet::getNumSlots() const {
408   return AttrList ? AttrList->Attrs.size() : 0;
409 }
410
411 /// getSlot - Return the AttributeWithIndex at the specified slot.  This
412 /// holds a number plus a set of attributes.
413 const AttributeWithIndex &AttributeSet::getSlot(unsigned Slot) const {
414   assert(AttrList && Slot < AttrList->Attrs.size() && "Slot # out of range!");
415   return AttrList->Attrs[Slot];
416 }
417
418 /// getAttributes - The attributes for the specified index are returned.
419 /// Attributes for the result are denoted with Idx = 0.  Function notes are
420 /// denoted with idx = ~0.
421 Attributes AttributeSet::getAttributes(unsigned Idx) const {
422   if (AttrList == 0) return Attributes();
423
424   const SmallVector<AttributeWithIndex, 4> &Attrs = AttrList->Attrs;
425   for (unsigned i = 0, e = Attrs.size(); i != e && Attrs[i].Index <= Idx; ++i)
426     if (Attrs[i].Index == Idx)
427       return Attrs[i].Attrs;
428
429   return Attributes();
430 }
431
432 /// hasAttrSomewhere - Return true if the specified attribute is set for at
433 /// least one parameter or for the return value.
434 bool AttributeSet::hasAttrSomewhere(Attributes::AttrVal Attr) const {
435   if (AttrList == 0) return false;
436
437   const SmallVector<AttributeWithIndex, 4> &Attrs = AttrList->Attrs;
438   for (unsigned i = 0, e = Attrs.size(); i != e; ++i)
439     if (Attrs[i].Attrs.hasAttribute(Attr))
440       return true;
441
442   return false;
443 }
444
445 unsigned AttributeSet::getNumAttrs() const {
446   return AttrList ? AttrList->Attrs.size() : 0;
447 }
448
449 Attributes &AttributeSet::getAttributesAtIndex(unsigned i) const {
450   assert(AttrList && "Trying to get an attribute from an empty list!");
451   assert(i < AttrList->Attrs.size() && "Index out of range!");
452   return AttrList->Attrs[i].Attrs;
453 }
454
455 AttributeSet AttributeSet::addAttr(LLVMContext &C, unsigned Idx,
456                                  Attributes Attrs) const {
457   Attributes OldAttrs = getAttributes(Idx);
458 #ifndef NDEBUG
459   // FIXME it is not obvious how this should work for alignment.
460   // For now, say we can't change a known alignment.
461   unsigned OldAlign = OldAttrs.getAlignment();
462   unsigned NewAlign = Attrs.getAlignment();
463   assert((!OldAlign || !NewAlign || OldAlign == NewAlign) &&
464          "Attempt to change alignment!");
465 #endif
466
467   AttrBuilder NewAttrs =
468     AttrBuilder(OldAttrs).addAttributes(Attrs);
469   if (NewAttrs == AttrBuilder(OldAttrs))
470     return *this;
471
472   SmallVector<AttributeWithIndex, 8> NewAttrList;
473   if (AttrList == 0)
474     NewAttrList.push_back(AttributeWithIndex::get(Idx, Attrs));
475   else {
476     const SmallVector<AttributeWithIndex, 4> &OldAttrList = AttrList->Attrs;
477     unsigned i = 0, e = OldAttrList.size();
478     // Copy attributes for arguments before this one.
479     for (; i != e && OldAttrList[i].Index < Idx; ++i)
480       NewAttrList.push_back(OldAttrList[i]);
481
482     // If there are attributes already at this index, merge them in.
483     if (i != e && OldAttrList[i].Index == Idx) {
484       Attrs =
485         Attributes::get(C, AttrBuilder(Attrs).
486                         addAttributes(OldAttrList[i].Attrs));
487       ++i;
488     }
489
490     NewAttrList.push_back(AttributeWithIndex::get(Idx, Attrs));
491
492     // Copy attributes for arguments after this one.
493     NewAttrList.insert(NewAttrList.end(),
494                        OldAttrList.begin()+i, OldAttrList.end());
495   }
496
497   return get(C, NewAttrList);
498 }
499
500 AttributeSet AttributeSet::removeAttr(LLVMContext &C, unsigned Idx,
501                                     Attributes Attrs) const {
502 #ifndef NDEBUG
503   // FIXME it is not obvious how this should work for alignment.
504   // For now, say we can't pass in alignment, which no current use does.
505   assert(!Attrs.hasAttribute(Attributes::Alignment) &&
506          "Attempt to exclude alignment!");
507 #endif
508   if (AttrList == 0) return AttributeSet();
509
510   Attributes OldAttrs = getAttributes(Idx);
511   AttrBuilder NewAttrs =
512     AttrBuilder(OldAttrs).removeAttributes(Attrs);
513   if (NewAttrs == AttrBuilder(OldAttrs))
514     return *this;
515
516   SmallVector<AttributeWithIndex, 8> NewAttrList;
517   const SmallVector<AttributeWithIndex, 4> &OldAttrList = AttrList->Attrs;
518   unsigned i = 0, e = OldAttrList.size();
519
520   // Copy attributes for arguments before this one.
521   for (; i != e && OldAttrList[i].Index < Idx; ++i)
522     NewAttrList.push_back(OldAttrList[i]);
523
524   // If there are attributes already at this index, merge them in.
525   assert(OldAttrList[i].Index == Idx && "Attribute isn't set?");
526   Attrs = Attributes::get(C, AttrBuilder(OldAttrList[i].Attrs).
527                           removeAttributes(Attrs));
528   ++i;
529   if (Attrs.hasAttributes()) // If any attributes left for this param, add them.
530     NewAttrList.push_back(AttributeWithIndex::get(Idx, Attrs));
531
532   // Copy attributes for arguments after this one.
533   NewAttrList.insert(NewAttrList.end(),
534                      OldAttrList.begin()+i, OldAttrList.end());
535
536   return get(C, NewAttrList);
537 }
538
539 void AttributeSet::dump() const {
540   dbgs() << "PAL[ ";
541   for (unsigned i = 0; i < getNumSlots(); ++i) {
542     const AttributeWithIndex &PAWI = getSlot(i);
543     dbgs() << "{" << PAWI.Index << "," << PAWI.Attrs.getAsString() << "} ";
544   }
545
546   dbgs() << "]\n";
547 }