Attributes.cpp revision 8a6a7bb6a601061031cddd77129532a3b467300b 
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// \file
11// \brief This file implements the Attribute, AttributeImpl, AttrBuilder,
12// AttributeSetImpl, and AttributeSet classes.
13//
14//===----------------------------------------------------------------------===//
15
16#include "llvm/IR/Attributes.h"
17#include "AttributeImpl.h"
18#include "LLVMContextImpl.h"
19#include "llvm/ADT/StringExtras.h"
20#include "llvm/IR/Type.h"
21#include "llvm/Support/Atomic.h"
22#include "llvm/Support/Debug.h"
23#include "llvm/Support/ManagedStatic.h"
24#include "llvm/Support/Mutex.h"
25#include "llvm/Support/raw_ostream.h"
26#include <algorithm>
27using namespace llvm;
28
29//===----------------------------------------------------------------------===//
30// Attribute Construction Methods
31//===----------------------------------------------------------------------===//
32
33Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind,
34                         uint64_t Val) {
35  LLVMContextImpl *pImpl = Context.pImpl;
36  FoldingSetNodeID ID;
37  ID.AddInteger(Kind);
38  if (Val) ID.AddInteger(Val);
39
40  void *InsertPoint;
41  AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);
42
43  if (!PA) {
44    // If we didn't find any existing attributes of the same shape then create a
45    // new one and insert it.
46    PA = !Val ?
47      new AttributeImpl(Context, Kind) :
48      new AttributeImpl(Context, Kind, Val);
49    pImpl->AttrsSet.InsertNode(PA, InsertPoint);
50  }
51
52  // Return the Attribute that we found or created.
53  return Attribute(PA);
54}
55
56Attribute Attribute::get(LLVMContext &Context, StringRef Kind, StringRef Val) {
57  LLVMContextImpl *pImpl = Context.pImpl;
58  FoldingSetNodeID ID;
59  ID.AddString(Kind);
60  if (!Val.empty()) ID.AddString(Val);
61
62  void *InsertPoint;
63  AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);
64
65  if (!PA) {
66    // If we didn't find any existing attributes of the same shape then create a
67    // new one and insert it.
68    PA = new AttributeImpl(Context, Kind, Val);
69    pImpl->AttrsSet.InsertNode(PA, InsertPoint);
70  }
71
72  // Return the Attribute that we found or created.
73  return Attribute(PA);
74}
75
76Attribute Attribute::getWithAlignment(LLVMContext &Context, uint64_t Align) {
77  assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
78  assert(Align <= 0x40000000 && "Alignment too large.");
79  return get(Context, Alignment, Align);
80}
81
82Attribute Attribute::getWithStackAlignment(LLVMContext &Context,
83                                           uint64_t Align) {
84  assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
85  assert(Align <= 0x100 && "Alignment too large.");
86  return get(Context, StackAlignment, Align);
87}
88
89//===----------------------------------------------------------------------===//
90// Attribute Accessor Methods
91//===----------------------------------------------------------------------===//
92
93bool Attribute::isEnumAttribute() const {
94  return pImpl && pImpl->isEnumAttribute();
95}
96
97bool Attribute::isAlignAttribute() const {
98  return pImpl && pImpl->isAlignAttribute();
99}
100
101bool Attribute::isStringAttribute() const {
102  return pImpl && pImpl->isStringAttribute();
103}
104
105Attribute::AttrKind Attribute::getKindAsEnum() const {
106  assert((isEnumAttribute() || isAlignAttribute()) &&
107         "Invalid attribute type to get the kind as an enum!");
108  return pImpl ? pImpl->getKindAsEnum() : None;
109}
110
111uint64_t Attribute::getValueAsInt() const {
112  assert(isAlignAttribute() &&
113         "Expected the attribute to be an alignment attribute!");
114  return pImpl ? pImpl->getValueAsInt() : 0;
115}
116
117StringRef Attribute::getKindAsString() const {
118  assert(isStringAttribute() &&
119         "Invalid attribute type to get the kind as a string!");
120  return pImpl ? pImpl->getKindAsString() : StringRef();
121}
122
123StringRef Attribute::getValueAsString() const {
124  assert(isStringAttribute() &&
125         "Invalid attribute type to get the value as a string!");
126  return pImpl ? pImpl->getValueAsString() : StringRef();
127}
128
129bool Attribute::hasAttribute(AttrKind Kind) const {
130  return (pImpl && pImpl->hasAttribute(Kind)) || (!pImpl && Kind == None);
131}
132
133bool Attribute::hasAttribute(StringRef Kind) const {
134  if (!isStringAttribute()) return false;
135  return pImpl && pImpl->hasAttribute(Kind);
136}
137
138/// This returns the alignment field of an attribute as a byte alignment value.
139unsigned Attribute::getAlignment() const {
140  assert(hasAttribute(Attribute::Alignment) &&
141         "Trying to get alignment from non-alignment attribute!");
142  return pImpl->getValueAsInt();
143}
144
145/// This returns the stack alignment field of an attribute as a byte alignment
146/// value.
147unsigned Attribute::getStackAlignment() const {
148  assert(hasAttribute(Attribute::StackAlignment) &&
149         "Trying to get alignment from non-alignment attribute!");
150  return pImpl->getValueAsInt();
151}
152
153std::string Attribute::getAsString(bool InAttrGrp) const {
154  if (!pImpl) return "";
155
156  if (hasAttribute(Attribute::SanitizeAddress))
157    return "sanitize_address";
158  if (hasAttribute(Attribute::AlwaysInline))
159    return "alwaysinline";
160  if (hasAttribute(Attribute::ByVal))
161    return "byval";
162  if (hasAttribute(Attribute::InlineHint))
163    return "inlinehint";
164  if (hasAttribute(Attribute::InReg))
165    return "inreg";
166  if (hasAttribute(Attribute::MinSize))
167    return "minsize";
168  if (hasAttribute(Attribute::Naked))
169    return "naked";
170  if (hasAttribute(Attribute::Nest))
171    return "nest";
172  if (hasAttribute(Attribute::NoAlias))
173    return "noalias";
174  if (hasAttribute(Attribute::NoBuiltin))
175    return "nobuiltin";
176  if (hasAttribute(Attribute::NoCapture))
177    return "nocapture";
178  if (hasAttribute(Attribute::NoDuplicate))
179    return "noduplicate";
180  if (hasAttribute(Attribute::NoImplicitFloat))
181    return "noimplicitfloat";
182  if (hasAttribute(Attribute::NoInline))
183    return "noinline";
184  if (hasAttribute(Attribute::NonLazyBind))
185    return "nonlazybind";
186  if (hasAttribute(Attribute::NoRedZone))
187    return "noredzone";
188  if (hasAttribute(Attribute::NoReturn))
189    return "noreturn";
190  if (hasAttribute(Attribute::NoUnwind))
191    return "nounwind";
192  if (hasAttribute(Attribute::OptimizeForSize))
193    return "optsize";
194  if (hasAttribute(Attribute::ReadNone))
195    return "readnone";
196  if (hasAttribute(Attribute::ReadOnly))
197    return "readonly";
198  if (hasAttribute(Attribute::ReturnsTwice))
199    return "returns_twice";
200  if (hasAttribute(Attribute::SExt))
201    return "signext";
202  if (hasAttribute(Attribute::StackProtect))
203    return "ssp";
204  if (hasAttribute(Attribute::StackProtectReq))
205    return "sspreq";
206  if (hasAttribute(Attribute::StackProtectStrong))
207    return "sspstrong";
208  if (hasAttribute(Attribute::StructRet))
209    return "sret";
210  if (hasAttribute(Attribute::SanitizeThread))
211    return "sanitize_thread";
212  if (hasAttribute(Attribute::SanitizeMemory))
213    return "sanitize_memory";
214  if (hasAttribute(Attribute::UWTable))
215    return "uwtable";
216  if (hasAttribute(Attribute::ZExt))
217    return "zeroext";
218
219  // FIXME: These should be output like this:
220  //
221  //   align=4
222  //   alignstack=8
223  //
224  if (hasAttribute(Attribute::Alignment)) {
225    std::string Result;
226    Result += "align";
227    Result += (InAttrGrp) ? "=" : " ";
228    Result += utostr(getValueAsInt());
229    return Result;
230  }
231
232  if (hasAttribute(Attribute::StackAlignment)) {
233    std::string Result;
234    Result += "alignstack";
235    if (InAttrGrp) {
236      Result += "=";
237      Result += utostr(getValueAsInt());
238    } else {
239      Result += "(";
240      Result += utostr(getValueAsInt());
241      Result += ")";
242    }
243    return Result;
244  }
245
246  // Convert target-dependent attributes to strings of the form:
247  //
248  //   "kind"
249  //   "kind" = "value"
250  //
251  if (isStringAttribute()) {
252    std::string Result;
253    Result += '\"' + getKindAsString().str() + '"';
254
255    StringRef Val = pImpl->getValueAsString();
256    if (Val.empty()) return Result;
257
258    Result += "=\"" + Val.str() + '"';
259    return Result;
260  }
261
262  llvm_unreachable("Unknown attribute");
263}
264
265bool Attribute::operator<(Attribute A) const {
266  if (!pImpl && !A.pImpl) return false;
267  if (!pImpl) return true;
268  if (!A.pImpl) return false;
269  return *pImpl < *A.pImpl;
270}
271
272//===----------------------------------------------------------------------===//
273// AttributeImpl Definition
274//===----------------------------------------------------------------------===//
275
276AttributeImpl::AttributeImpl(LLVMContext &C, Attribute::AttrKind Kind)
277  : Context(C), Entry(new EnumAttributeEntry(Kind)) {}
278
279AttributeImpl::AttributeImpl(LLVMContext &C, Attribute::AttrKind Kind,
280                             unsigned Align)
281  : Context(C) {
282  assert((Kind == Attribute::Alignment || Kind == Attribute::StackAlignment) &&
283         "Wrong kind for alignment attribute!");
284  Entry = new AlignAttributeEntry(Kind, Align);
285}
286
287AttributeImpl::AttributeImpl(LLVMContext &C, StringRef Kind, StringRef Val)
288  : Context(C), Entry(new StringAttributeEntry(Kind, Val)) {}
289
290AttributeImpl::~AttributeImpl() {
291  delete Entry;
292}
293
294bool AttributeImpl::isEnumAttribute() const {
295  return isa<EnumAttributeEntry>(Entry);
296}
297
298bool AttributeImpl::isAlignAttribute() const {
299  return isa<AlignAttributeEntry>(Entry);
300}
301
302bool AttributeImpl::isStringAttribute() const {
303  return isa<StringAttributeEntry>(Entry);
304}
305
306bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const {
307  if (isStringAttribute()) return false;
308  return getKindAsEnum() == A;
309}
310
311bool AttributeImpl::hasAttribute(StringRef Kind) const {
312  if (!isStringAttribute()) return false;
313  return getKindAsString() == Kind;
314}
315
316Attribute::AttrKind AttributeImpl::getKindAsEnum() const {
317  if (EnumAttributeEntry *E = dyn_cast<EnumAttributeEntry>(Entry))
318    return E->getEnumKind();
319  return cast<AlignAttributeEntry>(Entry)->getEnumKind();
320}
321
322uint64_t AttributeImpl::getValueAsInt() const {
323  return cast<AlignAttributeEntry>(Entry)->getAlignment();
324}
325
326StringRef AttributeImpl::getKindAsString() const {
327  return cast<StringAttributeEntry>(Entry)->getStringKind();
328}
329
330StringRef AttributeImpl::getValueAsString() const {
331  return cast<StringAttributeEntry>(Entry)->getStringValue();
332}
333
334bool AttributeImpl::operator<(const AttributeImpl &AI) const {
335  // This sorts the attributes with Attribute::AttrKinds coming first (sorted
336  // relative to their enum value) and then strings.
337  if (isEnumAttribute()) {
338    if (AI.isEnumAttribute()) return getKindAsEnum() < AI.getKindAsEnum();
339    if (AI.isAlignAttribute()) return true;
340    if (AI.isStringAttribute()) return true;
341  }
342
343  if (isAlignAttribute()) {
344    if (AI.isEnumAttribute()) return false;
345    if (AI.isAlignAttribute()) return getValueAsInt() < AI.getValueAsInt();
346    if (AI.isStringAttribute()) return true;
347  }
348
349  if (AI.isEnumAttribute()) return false;
350  if (AI.isAlignAttribute()) return false;
351  if (getKindAsString() == AI.getKindAsString())
352    return getValueAsString() < AI.getValueAsString();
353  return getKindAsString() < AI.getKindAsString();
354}
355
356uint64_t AttributeImpl::getAttrMask(Attribute::AttrKind Val) {
357  // FIXME: Remove this.
358  switch (Val) {
359  case Attribute::EndAttrKinds:
360    llvm_unreachable("Synthetic enumerators which should never get here");
361
362  case Attribute::None:            return 0;
363  case Attribute::ZExt:            return 1 << 0;
364  case Attribute::SExt:            return 1 << 1;
365  case Attribute::NoReturn:        return 1 << 2;
366  case Attribute::InReg:           return 1 << 3;
367  case Attribute::StructRet:       return 1 << 4;
368  case Attribute::NoUnwind:        return 1 << 5;
369  case Attribute::NoAlias:         return 1 << 6;
370  case Attribute::ByVal:           return 1 << 7;
371  case Attribute::Nest:            return 1 << 8;
372  case Attribute::ReadNone:        return 1 << 9;
373  case Attribute::ReadOnly:        return 1 << 10;
374  case Attribute::NoInline:        return 1 << 11;
375  case Attribute::AlwaysInline:    return 1 << 12;
376  case Attribute::OptimizeForSize: return 1 << 13;
377  case Attribute::StackProtect:    return 1 << 14;
378  case Attribute::StackProtectReq: return 1 << 15;
379  case Attribute::Alignment:       return 31 << 16;
380  case Attribute::NoCapture:       return 1 << 21;
381  case Attribute::NoRedZone:       return 1 << 22;
382  case Attribute::NoImplicitFloat: return 1 << 23;
383  case Attribute::Naked:           return 1 << 24;
384  case Attribute::InlineHint:      return 1 << 25;
385  case Attribute::StackAlignment:  return 7 << 26;
386  case Attribute::ReturnsTwice:    return 1 << 29;
387  case Attribute::UWTable:         return 1 << 30;
388  case Attribute::NonLazyBind:     return 1U << 31;
389  case Attribute::SanitizeAddress: return 1ULL << 32;
390  case Attribute::MinSize:         return 1ULL << 33;
391  case Attribute::NoDuplicate:     return 1ULL << 34;
392  case Attribute::StackProtectStrong: return 1ULL << 35;
393  case Attribute::SanitizeThread:  return 1ULL << 36;
394  case Attribute::SanitizeMemory:  return 1ULL << 37;
395  case Attribute::NoBuiltin:       return 1ULL << 38;
396  }
397  llvm_unreachable("Unsupported attribute type");
398}
399
400//===----------------------------------------------------------------------===//
401// AttributeSetNode Definition
402//===----------------------------------------------------------------------===//
403
404AttributeSetNode *AttributeSetNode::get(LLVMContext &C,
405                                        ArrayRef<Attribute> Attrs) {
406  if (Attrs.empty())
407    return 0;
408
409  // Otherwise, build a key to look up the existing attributes.
410  LLVMContextImpl *pImpl = C.pImpl;
411  FoldingSetNodeID ID;
412
413  SmallVector<Attribute, 8> SortedAttrs(Attrs.begin(), Attrs.end());
414  array_pod_sort(SortedAttrs.begin(), SortedAttrs.end());
415
416  for (SmallVectorImpl<Attribute>::iterator I = SortedAttrs.begin(),
417         E = SortedAttrs.end(); I != E; ++I)
418    I->Profile(ID);
419
420  void *InsertPoint;
421  AttributeSetNode *PA =
422    pImpl->AttrsSetNodes.FindNodeOrInsertPos(ID, InsertPoint);
423
424  // If we didn't find any existing attributes of the same shape then create a
425  // new one and insert it.
426  if (!PA) {
427    PA = new AttributeSetNode(SortedAttrs);
428    pImpl->AttrsSetNodes.InsertNode(PA, InsertPoint);
429  }
430
431  // Return the AttributesListNode that we found or created.
432  return PA;
433}
434
435bool AttributeSetNode::hasAttribute(Attribute::AttrKind Kind) const {
436  for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
437         E = AttrList.end(); I != E; ++I)
438    if (I->hasAttribute(Kind))
439      return true;
440  return false;
441}
442
443bool AttributeSetNode::hasAttribute(StringRef Kind) const {
444  for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
445         E = AttrList.end(); I != E; ++I)
446    if (I->hasAttribute(Kind))
447      return true;
448  return false;
449}
450
451Attribute AttributeSetNode::getAttribute(Attribute::AttrKind Kind) const {
452  for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
453         E = AttrList.end(); I != E; ++I)
454    if (I->hasAttribute(Kind))
455      return *I;
456  return Attribute();
457}
458
459Attribute AttributeSetNode::getAttribute(StringRef Kind) const {
460  for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
461         E = AttrList.end(); I != E; ++I)
462    if (I->hasAttribute(Kind))
463      return *I;
464  return Attribute();
465}
466
467unsigned AttributeSetNode::getAlignment() const {
468  for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
469         E = AttrList.end(); I != E; ++I)
470    if (I->hasAttribute(Attribute::Alignment))
471      return I->getAlignment();
472  return 0;
473}
474
475unsigned AttributeSetNode::getStackAlignment() const {
476  for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
477         E = AttrList.end(); I != E; ++I)
478    if (I->hasAttribute(Attribute::StackAlignment))
479      return I->getStackAlignment();
480  return 0;
481}
482
483std::string AttributeSetNode::getAsString(bool TargetIndependent,
484                                          bool InAttrGrp) const {
485  std::string Str = "";
486  for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
487         E = AttrList.end(); I != E; ) {
488    if (!TargetIndependent || !I->isStringAttribute()) {
489      Str += I->getAsString(InAttrGrp);
490      if (++I != E) Str += " ";
491    } else {
492      ++I;
493    }
494  }
495  return Str;
496}
497
498//===----------------------------------------------------------------------===//
499// AttributeSetImpl Definition
500//===----------------------------------------------------------------------===//
501
502uint64_t AttributeSetImpl::Raw(uint64_t Index) const {
503  for (unsigned I = 0, E = getNumAttributes(); I != E; ++I) {
504    if (getSlotIndex(I) != Index) continue;
505    const AttributeSetNode *ASN = AttrNodes[I].second;
506    uint64_t Mask = 0;
507
508    for (AttributeSetNode::const_iterator II = ASN->begin(),
509           IE = ASN->end(); II != IE; ++II) {
510      Attribute Attr = *II;
511
512      // This cannot handle string attributes.
513      if (Attr.isStringAttribute()) continue;
514
515      Attribute::AttrKind Kind = Attr.getKindAsEnum();
516
517      if (Kind == Attribute::Alignment)
518        Mask |= (Log2_32(ASN->getAlignment()) + 1) << 16;
519      else if (Kind == Attribute::StackAlignment)
520        Mask |= (Log2_32(ASN->getStackAlignment()) + 1) << 26;
521      else
522        Mask |= AttributeImpl::getAttrMask(Kind);
523    }
524
525    return Mask;
526  }
527
528  return 0;
529}
530
531//===----------------------------------------------------------------------===//
532// AttributeSet Construction and Mutation Methods
533//===----------------------------------------------------------------------===//
534
535AttributeSet
536AttributeSet::getImpl(LLVMContext &C,
537                      ArrayRef<std::pair<unsigned, AttributeSetNode*> > Attrs) {
538  LLVMContextImpl *pImpl = C.pImpl;
539  FoldingSetNodeID ID;
540  AttributeSetImpl::Profile(ID, Attrs);
541
542  void *InsertPoint;
543  AttributeSetImpl *PA = pImpl->AttrsLists.FindNodeOrInsertPos(ID, InsertPoint);
544
545  // If we didn't find any existing attributes of the same shape then
546  // create a new one and insert it.
547  if (!PA) {
548    PA = new AttributeSetImpl(C, Attrs);
549    pImpl->AttrsLists.InsertNode(PA, InsertPoint);
550  }
551
552  // Return the AttributesList that we found or created.
553  return AttributeSet(PA);
554}
555
556AttributeSet AttributeSet::get(LLVMContext &C,
557                               ArrayRef<std::pair<unsigned, Attribute> > Attrs){
558  // If there are no attributes then return a null AttributesList pointer.
559  if (Attrs.empty())
560    return AttributeSet();
561
562#ifndef NDEBUG
563  for (unsigned i = 0, e = Attrs.size(); i != e; ++i) {
564    assert((!i || Attrs[i-1].first <= Attrs[i].first) &&
565           "Misordered Attributes list!");
566    assert(!Attrs[i].second.hasAttribute(Attribute::None) &&
567           "Pointless attribute!");
568  }
569#endif
570
571  // Create a vector if (unsigned, AttributeSetNode*) pairs from the attributes
572  // list.
573  SmallVector<std::pair<unsigned, AttributeSetNode*>, 8> AttrPairVec;
574  for (ArrayRef<std::pair<unsigned, Attribute> >::iterator I = Attrs.begin(),
575         E = Attrs.end(); I != E; ) {
576    unsigned Index = I->first;
577    SmallVector<Attribute, 4> AttrVec;
578    while (I != E && I->first == Index) {
579      AttrVec.push_back(I->second);
580      ++I;
581    }
582
583    AttrPairVec.push_back(std::make_pair(Index,
584                                         AttributeSetNode::get(C, AttrVec)));
585  }
586
587  return getImpl(C, AttrPairVec);
588}
589
590AttributeSet AttributeSet::get(LLVMContext &C,
591                               ArrayRef<std::pair<unsigned,
592                                                  AttributeSetNode*> > Attrs) {
593  // If there are no attributes then return a null AttributesList pointer.
594  if (Attrs.empty())
595    return AttributeSet();
596
597  return getImpl(C, Attrs);
598}
599
600AttributeSet AttributeSet::get(LLVMContext &C, unsigned Index, AttrBuilder &B) {
601  if (!B.hasAttributes())
602    return AttributeSet();
603
604  // Add target-independent attributes.
605  SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
606  for (Attribute::AttrKind Kind = Attribute::None;
607       Kind != Attribute::EndAttrKinds; Kind = Attribute::AttrKind(Kind + 1)) {
608    if (!B.contains(Kind))
609      continue;
610
611    if (Kind == Attribute::Alignment)
612      Attrs.push_back(std::make_pair(Index, Attribute::
613                                     getWithAlignment(C, B.getAlignment())));
614    else if (Kind == Attribute::StackAlignment)
615      Attrs.push_back(std::make_pair(Index, Attribute::
616                              getWithStackAlignment(C, B.getStackAlignment())));
617    else
618      Attrs.push_back(std::make_pair(Index, Attribute::get(C, Kind)));
619  }
620
621  // Add target-dependent (string) attributes.
622  for (AttrBuilder::td_iterator I = B.td_begin(), E = B.td_end();
623       I != E; ++I)
624    Attrs.push_back(std::make_pair(Index, Attribute::get(C, I->first,I->second)));
625
626  return get(C, Attrs);
627}
628
629AttributeSet AttributeSet::get(LLVMContext &C, unsigned Index,
630                               ArrayRef<Attribute::AttrKind> Kind) {
631  SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
632  for (ArrayRef<Attribute::AttrKind>::iterator I = Kind.begin(),
633         E = Kind.end(); I != E; ++I)
634    Attrs.push_back(std::make_pair(Index, Attribute::get(C, *I)));
635  return get(C, Attrs);
636}
637
638AttributeSet AttributeSet::get(LLVMContext &C, ArrayRef<AttributeSet> Attrs) {
639  if (Attrs.empty()) return AttributeSet();
640
641  SmallVector<std::pair<unsigned, AttributeSetNode*>, 8> AttrNodeVec;
642  for (unsigned I = 0, E = Attrs.size(); I != E; ++I) {
643    AttributeSet AS = Attrs[I];
644    if (!AS.pImpl) continue;
645    AttrNodeVec.append(AS.pImpl->AttrNodes.begin(), AS.pImpl->AttrNodes.end());
646  }
647
648  return getImpl(C, AttrNodeVec);
649}
650
651AttributeSet AttributeSet::addAttribute(LLVMContext &C, unsigned Index,
652                                        Attribute::AttrKind Attr) const {
653  if (hasAttribute(Index, Attr)) return *this;
654  return addAttributes(C, Index, AttributeSet::get(C, Index, Attr));
655}
656
657AttributeSet AttributeSet::addAttribute(LLVMContext &C, unsigned Index,
658                                        StringRef Kind) const {
659  llvm::AttrBuilder B;
660  B.addAttribute(Kind);
661  return addAttributes(C, Index, AttributeSet::get(C, Index, B));
662}
663
664AttributeSet AttributeSet::addAttributes(LLVMContext &C, unsigned Index,
665                                         AttributeSet Attrs) const {
666  if (!pImpl) return Attrs;
667  if (!Attrs.pImpl) return *this;
668
669#ifndef NDEBUG
670  // FIXME it is not obvious how this should work for alignment. For now, say
671  // we can't change a known alignment.
672  unsigned OldAlign = getParamAlignment(Index);
673  unsigned NewAlign = Attrs.getParamAlignment(Index);
674  assert((!OldAlign || !NewAlign || OldAlign == NewAlign) &&
675         "Attempt to change alignment!");
676#endif
677
678  // Add the attribute slots before the one we're trying to add.
679  SmallVector<AttributeSet, 4> AttrSet;
680  uint64_t NumAttrs = pImpl->getNumAttributes();
681  AttributeSet AS;
682  uint64_t LastIndex = 0;
683  for (unsigned I = 0, E = NumAttrs; I != E; ++I) {
684    if (getSlotIndex(I) >= Index) {
685      if (getSlotIndex(I) == Index) AS = getSlotAttributes(LastIndex++);
686      break;
687    }
688    LastIndex = I + 1;
689    AttrSet.push_back(getSlotAttributes(I));
690  }
691
692  // Now add the attribute into the correct slot. There may already be an
693  // AttributeSet there.
694  AttrBuilder B(AS, Index);
695
696  for (unsigned I = 0, E = Attrs.pImpl->getNumAttributes(); I != E; ++I)
697    if (Attrs.getSlotIndex(I) == Index) {
698      for (AttributeSetImpl::const_iterator II = Attrs.pImpl->begin(I),
699             IE = Attrs.pImpl->end(I); II != IE; ++II)
700        B.addAttribute(*II);
701      break;
702    }
703
704  AttrSet.push_back(AttributeSet::get(C, Index, B));
705
706  // Add the remaining attribute slots.
707  for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I)
708    AttrSet.push_back(getSlotAttributes(I));
709
710  return get(C, AttrSet);
711}
712
713AttributeSet AttributeSet::removeAttribute(LLVMContext &C, unsigned Index,
714                                           Attribute::AttrKind Attr) const {
715  if (!hasAttribute(Index, Attr)) return *this;
716  return removeAttributes(C, Index, AttributeSet::get(C, Index, Attr));
717}
718
719AttributeSet AttributeSet::removeAttributes(LLVMContext &C, unsigned Index,
720                                            AttributeSet Attrs) const {
721  if (!pImpl) return AttributeSet();
722  if (!Attrs.pImpl) return *this;
723
724#ifndef NDEBUG
725  // FIXME it is not obvious how this should work for alignment.
726  // For now, say we can't pass in alignment, which no current use does.
727  assert(!Attrs.hasAttribute(Index, Attribute::Alignment) &&
728         "Attempt to change alignment!");
729#endif
730
731  // Add the attribute slots before the one we're trying to add.
732  SmallVector<AttributeSet, 4> AttrSet;
733  uint64_t NumAttrs = pImpl->getNumAttributes();
734  AttributeSet AS;
735  uint64_t LastIndex = 0;
736  for (unsigned I = 0, E = NumAttrs; I != E; ++I) {
737    if (getSlotIndex(I) >= Index) {
738      if (getSlotIndex(I) == Index) AS = getSlotAttributes(LastIndex++);
739      break;
740    }
741    LastIndex = I + 1;
742    AttrSet.push_back(getSlotAttributes(I));
743  }
744
745  // Now remove the attribute from the correct slot. There may already be an
746  // AttributeSet there.
747  AttrBuilder B(AS, Index);
748
749  for (unsigned I = 0, E = Attrs.pImpl->getNumAttributes(); I != E; ++I)
750    if (Attrs.getSlotIndex(I) == Index) {
751      B.removeAttributes(Attrs.pImpl->getSlotAttributes(I), Index);
752      break;
753    }
754
755  AttrSet.push_back(AttributeSet::get(C, Index, B));
756
757  // Add the remaining attribute slots.
758  for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I)
759    AttrSet.push_back(getSlotAttributes(I));
760
761  return get(C, AttrSet);
762}
763
764//===----------------------------------------------------------------------===//
765// AttributeSet Accessor Methods
766//===----------------------------------------------------------------------===//
767
768LLVMContext &AttributeSet::getContext() const {
769  return pImpl->getContext();
770}
771
772AttributeSet AttributeSet::getParamAttributes(unsigned Index) const {
773  return pImpl && hasAttributes(Index) ?
774    AttributeSet::get(pImpl->getContext(),
775                      ArrayRef<std::pair<unsigned, AttributeSetNode*> >(
776                        std::make_pair(Index, getAttributes(Index)))) :
777    AttributeSet();
778}
779
780AttributeSet AttributeSet::getRetAttributes() const {
781  return pImpl && hasAttributes(ReturnIndex) ?
782    AttributeSet::get(pImpl->getContext(),
783                      ArrayRef<std::pair<unsigned, AttributeSetNode*> >(
784                        std::make_pair(ReturnIndex,
785                                       getAttributes(ReturnIndex)))) :
786    AttributeSet();
787}
788
789AttributeSet AttributeSet::getFnAttributes() const {
790  return pImpl && hasAttributes(FunctionIndex) ?
791    AttributeSet::get(pImpl->getContext(),
792                      ArrayRef<std::pair<unsigned, AttributeSetNode*> >(
793                        std::make_pair(FunctionIndex,
794                                       getAttributes(FunctionIndex)))) :
795    AttributeSet();
796}
797
798bool AttributeSet::hasAttribute(unsigned Index, Attribute::AttrKind Kind) const{
799  AttributeSetNode *ASN = getAttributes(Index);
800  return ASN ? ASN->hasAttribute(Kind) : false;
801}
802
803bool AttributeSet::hasAttribute(unsigned Index, StringRef Kind) const {
804  AttributeSetNode *ASN = getAttributes(Index);
805  return ASN ? ASN->hasAttribute(Kind) : false;
806}
807
808bool AttributeSet::hasAttributes(unsigned Index) const {
809  AttributeSetNode *ASN = getAttributes(Index);
810  return ASN ? ASN->hasAttributes() : false;
811}
812
813/// \brief Return true if the specified attribute is set for at least one
814/// parameter or for the return value.
815bool AttributeSet::hasAttrSomewhere(Attribute::AttrKind Attr) const {
816  if (pImpl == 0) return false;
817
818  for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I)
819    for (AttributeSetImpl::const_iterator II = pImpl->begin(I),
820           IE = pImpl->end(I); II != IE; ++II)
821      if (II->hasAttribute(Attr))
822        return true;
823
824  return false;
825}
826
827Attribute AttributeSet::getAttribute(unsigned Index,
828                                     Attribute::AttrKind Kind) const {
829  AttributeSetNode *ASN = getAttributes(Index);
830  return ASN ? ASN->getAttribute(Kind) : Attribute();
831}
832
833Attribute AttributeSet::getAttribute(unsigned Index,
834                                     StringRef Kind) const {
835  AttributeSetNode *ASN = getAttributes(Index);
836  return ASN ? ASN->getAttribute(Kind) : Attribute();
837}
838
839unsigned AttributeSet::getParamAlignment(unsigned Index) const {
840  AttributeSetNode *ASN = getAttributes(Index);
841  return ASN ? ASN->getAlignment() : 0;
842}
843
844unsigned AttributeSet::getStackAlignment(unsigned Index) const {
845  AttributeSetNode *ASN = getAttributes(Index);
846  return ASN ? ASN->getStackAlignment() : 0;
847}
848
849std::string AttributeSet::getAsString(unsigned Index, bool TargetIndependent,
850                                      bool InAttrGrp) const {
851  AttributeSetNode *ASN = getAttributes(Index);
852  return ASN ? ASN->getAsString(TargetIndependent, InAttrGrp) :
853    std::string("");
854}
855
856/// \brief The attributes for the specified index are returned.
857AttributeSetNode *AttributeSet::getAttributes(unsigned Index) const {
858  if (!pImpl) return 0;
859
860  // Loop through to find the attribute node we want.
861  for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I)
862    if (pImpl->getSlotIndex(I) == Index)
863      return pImpl->getSlotNode(I);
864
865  return 0;
866}
867
868AttributeSet::iterator AttributeSet::begin(unsigned Slot) const {
869  if (!pImpl)
870    return ArrayRef<Attribute>().begin();
871  return pImpl->begin(Slot);
872}
873
874AttributeSet::iterator AttributeSet::end(unsigned Slot) const {
875  if (!pImpl)
876    return ArrayRef<Attribute>().end();
877  return pImpl->end(Slot);
878}
879
880//===----------------------------------------------------------------------===//
881// AttributeSet Introspection Methods
882//===----------------------------------------------------------------------===//
883
884/// \brief Return the number of slots used in this attribute list.  This is the
885/// number of arguments that have an attribute set on them (including the
886/// function itself).
887unsigned AttributeSet::getNumSlots() const {
888  return pImpl ? pImpl->getNumAttributes() : 0;
889}
890
891uint64_t AttributeSet::getSlotIndex(unsigned Slot) const {
892  assert(pImpl && Slot < pImpl->getNumAttributes() &&
893         "Slot # out of range!");
894  return pImpl->getSlotIndex(Slot);
895}
896
897AttributeSet AttributeSet::getSlotAttributes(unsigned Slot) const {
898  assert(pImpl && Slot < pImpl->getNumAttributes() &&
899         "Slot # out of range!");
900  return pImpl->getSlotAttributes(Slot);
901}
902
903uint64_t AttributeSet::Raw(unsigned Index) const {
904  // FIXME: Remove this.
905  return pImpl ? pImpl->Raw(Index) : 0;
906}
907
908void AttributeSet::dump() const {
909  dbgs() << "PAL[\n";
910
911  for (unsigned i = 0, e = getNumSlots(); i < e; ++i) {
912    uint64_t Index = getSlotIndex(i);
913    dbgs() << "  { ";
914    if (Index == ~0U)
915      dbgs() << "~0U";
916    else
917      dbgs() << Index;
918    dbgs() << " => " << getAsString(Index) << " }\n";
919  }
920
921  dbgs() << "]\n";
922}
923
924//===----------------------------------------------------------------------===//
925// AttrBuilder Method Implementations
926//===----------------------------------------------------------------------===//
927
928AttrBuilder::AttrBuilder(AttributeSet AS, unsigned Index)
929  : Attrs(0), Alignment(0), StackAlignment(0) {
930  AttributeSetImpl *pImpl = AS.pImpl;
931  if (!pImpl) return;
932
933  for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I) {
934    if (pImpl->getSlotIndex(I) != Index) continue;
935
936    for (AttributeSetImpl::const_iterator II = pImpl->begin(I),
937           IE = pImpl->end(I); II != IE; ++II)
938      addAttribute(*II);
939
940    break;
941  }
942}
943
944void AttrBuilder::clear() {
945  Attrs.reset();
946  Alignment = StackAlignment = 0;
947}
948
949AttrBuilder &AttrBuilder::addAttribute(Attribute::AttrKind Val) {
950  assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
951  assert(Val != Attribute::Alignment && Val != Attribute::StackAlignment &&
952         "Adding alignment attribute without adding alignment value!");
953  Attrs[Val] = true;
954  return *this;
955}
956
957AttrBuilder &AttrBuilder::addAttribute(Attribute Attr) {
958  if (Attr.isStringAttribute()) {
959    addAttribute(Attr.getKindAsString(), Attr.getValueAsString());
960    return *this;
961  }
962
963  Attribute::AttrKind Kind = Attr.getKindAsEnum();
964  Attrs[Kind] = true;
965
966  if (Kind == Attribute::Alignment)
967    Alignment = Attr.getAlignment();
968  else if (Kind == Attribute::StackAlignment)
969    StackAlignment = Attr.getStackAlignment();
970  return *this;
971}
972
973AttrBuilder &AttrBuilder::addAttribute(StringRef A, StringRef V) {
974  TargetDepAttrs[A] = V;
975  return *this;
976}
977
978AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) {
979  assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
980  Attrs[Val] = false;
981
982  if (Val == Attribute::Alignment)
983    Alignment = 0;
984  else if (Val == Attribute::StackAlignment)
985    StackAlignment = 0;
986
987  return *this;
988}
989
990AttrBuilder &AttrBuilder::removeAttributes(AttributeSet A, uint64_t Index) {
991  unsigned Slot = ~0U;
992  for (unsigned I = 0, E = A.getNumSlots(); I != E; ++I)
993    if (A.getSlotIndex(I) == Index) {
994      Slot = I;
995      break;
996    }
997
998  assert(Slot != ~0U && "Couldn't find index in AttributeSet!");
999
1000  for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot); I != E; ++I) {
1001    Attribute Attr = *I;
1002    if (Attr.isEnumAttribute() || Attr.isAlignAttribute()) {
1003      Attribute::AttrKind Kind = I->getKindAsEnum();
1004      Attrs[Kind] = false;
1005
1006      if (Kind == Attribute::Alignment)
1007        Alignment = 0;
1008      else if (Kind == Attribute::StackAlignment)
1009        StackAlignment = 0;
1010    } else {
1011      assert(Attr.isStringAttribute() && "Invalid attribute type!");
1012      std::map<std::string, std::string>::iterator
1013        Iter = TargetDepAttrs.find(Attr.getKindAsString());
1014      if (Iter != TargetDepAttrs.end())
1015        TargetDepAttrs.erase(Iter);
1016    }
1017  }
1018
1019  return *this;
1020}
1021
1022AttrBuilder &AttrBuilder::removeAttribute(StringRef A) {
1023  std::map<std::string, std::string>::iterator I = TargetDepAttrs.find(A);
1024  if (I != TargetDepAttrs.end())
1025    TargetDepAttrs.erase(I);
1026  return *this;
1027}
1028
1029AttrBuilder &AttrBuilder::addAlignmentAttr(unsigned Align) {
1030  if (Align == 0) return *this;
1031
1032  assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
1033  assert(Align <= 0x40000000 && "Alignment too large.");
1034
1035  Attrs[Attribute::Alignment] = true;
1036  Alignment = Align;
1037  return *this;
1038}
1039
1040AttrBuilder &AttrBuilder::addStackAlignmentAttr(unsigned Align) {
1041  // Default alignment, allow the target to define how to align it.
1042  if (Align == 0) return *this;
1043
1044  assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
1045  assert(Align <= 0x100 && "Alignment too large.");
1046
1047  Attrs[Attribute::StackAlignment] = true;
1048  StackAlignment = Align;
1049  return *this;
1050}
1051
1052AttrBuilder &AttrBuilder::merge(const AttrBuilder &B) {
1053  // FIXME: What if both have alignments, but they don't match?!
1054  if (!Alignment)
1055    Alignment = B.Alignment;
1056
1057  if (!StackAlignment)
1058    StackAlignment = B.StackAlignment;
1059
1060  Attrs |= B.Attrs;
1061
1062  for (td_const_iterator I = B.TargetDepAttrs.begin(),
1063         E = B.TargetDepAttrs.end(); I != E; ++I)
1064    TargetDepAttrs[I->first] = I->second;
1065
1066  return *this;
1067}
1068
1069bool AttrBuilder::contains(StringRef A) const {
1070  return TargetDepAttrs.find(A) != TargetDepAttrs.end();
1071}
1072
1073bool AttrBuilder::hasAttributes() const {
1074  return !Attrs.none() || !TargetDepAttrs.empty();
1075}
1076
1077bool AttrBuilder::hasAttributes(AttributeSet A, uint64_t Index) const {
1078  unsigned Slot = ~0U;
1079  for (unsigned I = 0, E = A.getNumSlots(); I != E; ++I)
1080    if (A.getSlotIndex(I) == Index) {
1081      Slot = I;
1082      break;
1083    }
1084
1085  assert(Slot != ~0U && "Couldn't find the index!");
1086
1087  for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot);
1088       I != E; ++I) {
1089    Attribute Attr = *I;
1090    if (Attr.isEnumAttribute() || Attr.isAlignAttribute()) {
1091      if (Attrs[I->getKindAsEnum()])
1092        return true;
1093    } else {
1094      assert(Attr.isStringAttribute() && "Invalid attribute kind!");
1095      return TargetDepAttrs.find(Attr.getKindAsString())!=TargetDepAttrs.end();
1096    }
1097  }
1098
1099  return false;
1100}
1101
1102bool AttrBuilder::hasAlignmentAttr() const {
1103  return Alignment != 0;
1104}
1105
1106bool AttrBuilder::operator==(const AttrBuilder &B) {
1107  if (Attrs != B.Attrs)
1108    return false;
1109
1110  for (td_const_iterator I = TargetDepAttrs.begin(),
1111         E = TargetDepAttrs.end(); I != E; ++I)
1112    if (B.TargetDepAttrs.find(I->first) == B.TargetDepAttrs.end())
1113      return false;
1114
1115  return Alignment == B.Alignment && StackAlignment == B.StackAlignment;
1116}
1117
1118AttrBuilder &AttrBuilder::addRawValue(uint64_t Val) {
1119  // FIXME: Remove this in 4.0.
1120  if (!Val) return *this;
1121
1122  for (Attribute::AttrKind I = Attribute::None; I != Attribute::EndAttrKinds;
1123       I = Attribute::AttrKind(I + 1)) {
1124    if (uint64_t A = (Val & AttributeImpl::getAttrMask(I))) {
1125      Attrs[I] = true;
1126
1127      if (I == Attribute::Alignment)
1128        Alignment = 1ULL << ((A >> 16) - 1);
1129      else if (I == Attribute::StackAlignment)
1130        StackAlignment = 1ULL << ((A >> 26)-1);
1131    }
1132  }
1133
1134  return *this;
1135}
1136
1137//===----------------------------------------------------------------------===//
1138// AttributeFuncs Function Defintions
1139//===----------------------------------------------------------------------===//
1140
1141/// \brief Which attributes cannot be applied to a type.
1142AttributeSet AttributeFuncs::typeIncompatible(Type *Ty, uint64_t Index) {
1143  AttrBuilder Incompatible;
1144
1145  if (!Ty->isIntegerTy())
1146    // Attribute that only apply to integers.
1147    Incompatible.addAttribute(Attribute::SExt)
1148      .addAttribute(Attribute::ZExt);
1149
1150  if (!Ty->isPointerTy())
1151    // Attribute that only apply to pointers.
1152    Incompatible.addAttribute(Attribute::ByVal)
1153      .addAttribute(Attribute::Nest)
1154      .addAttribute(Attribute::NoAlias)
1155      .addAttribute(Attribute::NoCapture)
1156      .addAttribute(Attribute::StructRet);
1157
1158  return AttributeSet::get(Ty->getContext(), Index, Incompatible);
1159}
1160