Attributes.cpp revision e94e4ca5fd94de185a840e9237b3b483f62342a8 
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; ++I) {
488    if (TargetIndependent || !I->isStringAttribute()) {
489      if (I != AttrList.begin())
490        Str += ' ';
491      Str += I->getAsString(InAttrGrp);
492    }
493  }
494  return Str;
495}
496
497//===----------------------------------------------------------------------===//
498// AttributeSetImpl Definition
499//===----------------------------------------------------------------------===//
500
501uint64_t AttributeSetImpl::Raw(uint64_t Index) const {
502  for (unsigned I = 0, E = getNumAttributes(); I != E; ++I) {
503    if (getSlotIndex(I) != Index) continue;
504    const AttributeSetNode *ASN = AttrNodes[I].second;
505    uint64_t Mask = 0;
506
507    for (AttributeSetNode::const_iterator II = ASN->begin(),
508           IE = ASN->end(); II != IE; ++II) {
509      Attribute Attr = *II;
510
511      // This cannot handle string attributes.
512      if (Attr.isStringAttribute()) continue;
513
514      Attribute::AttrKind Kind = Attr.getKindAsEnum();
515
516      if (Kind == Attribute::Alignment)
517        Mask |= (Log2_32(ASN->getAlignment()) + 1) << 16;
518      else if (Kind == Attribute::StackAlignment)
519        Mask |= (Log2_32(ASN->getStackAlignment()) + 1) << 26;
520      else
521        Mask |= AttributeImpl::getAttrMask(Kind);
522    }
523
524    return Mask;
525  }
526
527  return 0;
528}
529
530//===----------------------------------------------------------------------===//
531// AttributeSet Construction and Mutation Methods
532//===----------------------------------------------------------------------===//
533
534AttributeSet
535AttributeSet::getImpl(LLVMContext &C,
536                      ArrayRef<std::pair<unsigned, AttributeSetNode*> > Attrs) {
537  LLVMContextImpl *pImpl = C.pImpl;
538  FoldingSetNodeID ID;
539  AttributeSetImpl::Profile(ID, Attrs);
540
541  void *InsertPoint;
542  AttributeSetImpl *PA = pImpl->AttrsLists.FindNodeOrInsertPos(ID, InsertPoint);
543
544  // If we didn't find any existing attributes of the same shape then
545  // create a new one and insert it.
546  if (!PA) {
547    PA = new AttributeSetImpl(C, Attrs);
548    pImpl->AttrsLists.InsertNode(PA, InsertPoint);
549  }
550
551  // Return the AttributesList that we found or created.
552  return AttributeSet(PA);
553}
554
555AttributeSet AttributeSet::get(LLVMContext &C,
556                               ArrayRef<std::pair<unsigned, Attribute> > Attrs){
557  // If there are no attributes then return a null AttributesList pointer.
558  if (Attrs.empty())
559    return AttributeSet();
560
561#ifndef NDEBUG
562  for (unsigned i = 0, e = Attrs.size(); i != e; ++i) {
563    assert((!i || Attrs[i-1].first <= Attrs[i].first) &&
564           "Misordered Attributes list!");
565    assert(!Attrs[i].second.hasAttribute(Attribute::None) &&
566           "Pointless attribute!");
567  }
568#endif
569
570  // Create a vector if (unsigned, AttributeSetNode*) pairs from the attributes
571  // list.
572  SmallVector<std::pair<unsigned, AttributeSetNode*>, 8> AttrPairVec;
573  for (ArrayRef<std::pair<unsigned, Attribute> >::iterator I = Attrs.begin(),
574         E = Attrs.end(); I != E; ) {
575    unsigned Index = I->first;
576    SmallVector<Attribute, 4> AttrVec;
577    while (I != E && I->first == Index) {
578      AttrVec.push_back(I->second);
579      ++I;
580    }
581
582    AttrPairVec.push_back(std::make_pair(Index,
583                                         AttributeSetNode::get(C, AttrVec)));
584  }
585
586  return getImpl(C, AttrPairVec);
587}
588
589AttributeSet AttributeSet::get(LLVMContext &C,
590                               ArrayRef<std::pair<unsigned,
591                                                  AttributeSetNode*> > Attrs) {
592  // If there are no attributes then return a null AttributesList pointer.
593  if (Attrs.empty())
594    return AttributeSet();
595
596  return getImpl(C, Attrs);
597}
598
599AttributeSet AttributeSet::get(LLVMContext &C, unsigned Index, AttrBuilder &B) {
600  if (!B.hasAttributes())
601    return AttributeSet();
602
603  // Add target-independent attributes.
604  SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
605  for (Attribute::AttrKind Kind = Attribute::None;
606       Kind != Attribute::EndAttrKinds; Kind = Attribute::AttrKind(Kind + 1)) {
607    if (!B.contains(Kind))
608      continue;
609
610    if (Kind == Attribute::Alignment)
611      Attrs.push_back(std::make_pair(Index, Attribute::
612                                     getWithAlignment(C, B.getAlignment())));
613    else if (Kind == Attribute::StackAlignment)
614      Attrs.push_back(std::make_pair(Index, Attribute::
615                              getWithStackAlignment(C, B.getStackAlignment())));
616    else
617      Attrs.push_back(std::make_pair(Index, Attribute::get(C, Kind)));
618  }
619
620  // Add target-dependent (string) attributes.
621  for (AttrBuilder::td_iterator I = B.td_begin(), E = B.td_end();
622       I != E; ++I)
623    Attrs.push_back(std::make_pair(Index, Attribute::get(C, I->first,I->second)));
624
625  return get(C, Attrs);
626}
627
628AttributeSet AttributeSet::get(LLVMContext &C, unsigned Index,
629                               ArrayRef<Attribute::AttrKind> Kind) {
630  SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
631  for (ArrayRef<Attribute::AttrKind>::iterator I = Kind.begin(),
632         E = Kind.end(); I != E; ++I)
633    Attrs.push_back(std::make_pair(Index, Attribute::get(C, *I)));
634  return get(C, Attrs);
635}
636
637AttributeSet AttributeSet::get(LLVMContext &C, ArrayRef<AttributeSet> Attrs) {
638  if (Attrs.empty()) return AttributeSet();
639
640  SmallVector<std::pair<unsigned, AttributeSetNode*>, 8> AttrNodeVec;
641  for (unsigned I = 0, E = Attrs.size(); I != E; ++I) {
642    AttributeSet AS = Attrs[I];
643    if (!AS.pImpl) continue;
644    AttrNodeVec.append(AS.pImpl->AttrNodes.begin(), AS.pImpl->AttrNodes.end());
645  }
646
647  return getImpl(C, AttrNodeVec);
648}
649
650AttributeSet AttributeSet::addAttribute(LLVMContext &C, unsigned Index,
651                                        Attribute::AttrKind Attr) const {
652  if (hasAttribute(Index, Attr)) return *this;
653  return addAttributes(C, Index, AttributeSet::get(C, Index, Attr));
654}
655
656AttributeSet AttributeSet::addAttribute(LLVMContext &C, unsigned Index,
657                                        StringRef Kind) const {
658  llvm::AttrBuilder B;
659  B.addAttribute(Kind);
660  return addAttributes(C, Index, AttributeSet::get(C, Index, B));
661}
662
663AttributeSet AttributeSet::addAttributes(LLVMContext &C, unsigned Index,
664                                         AttributeSet Attrs) const {
665  if (!pImpl) return Attrs;
666  if (!Attrs.pImpl) return *this;
667
668#ifndef NDEBUG
669  // FIXME it is not obvious how this should work for alignment. For now, say
670  // we can't change a known alignment.
671  unsigned OldAlign = getParamAlignment(Index);
672  unsigned NewAlign = Attrs.getParamAlignment(Index);
673  assert((!OldAlign || !NewAlign || OldAlign == NewAlign) &&
674         "Attempt to change alignment!");
675#endif
676
677  // Add the attribute slots before the one we're trying to add.
678  SmallVector<AttributeSet, 4> AttrSet;
679  uint64_t NumAttrs = pImpl->getNumAttributes();
680  AttributeSet AS;
681  uint64_t LastIndex = 0;
682  for (unsigned I = 0, E = NumAttrs; I != E; ++I) {
683    if (getSlotIndex(I) >= Index) {
684      if (getSlotIndex(I) == Index) AS = getSlotAttributes(LastIndex++);
685      break;
686    }
687    LastIndex = I + 1;
688    AttrSet.push_back(getSlotAttributes(I));
689  }
690
691  // Now add the attribute into the correct slot. There may already be an
692  // AttributeSet there.
693  AttrBuilder B(AS, Index);
694
695  for (unsigned I = 0, E = Attrs.pImpl->getNumAttributes(); I != E; ++I)
696    if (Attrs.getSlotIndex(I) == Index) {
697      for (AttributeSetImpl::const_iterator II = Attrs.pImpl->begin(I),
698             IE = Attrs.pImpl->end(I); II != IE; ++II)
699        B.addAttribute(*II);
700      break;
701    }
702
703  AttrSet.push_back(AttributeSet::get(C, Index, B));
704
705  // Add the remaining attribute slots.
706  for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I)
707    AttrSet.push_back(getSlotAttributes(I));
708
709  return get(C, AttrSet);
710}
711
712AttributeSet AttributeSet::removeAttribute(LLVMContext &C, unsigned Index,
713                                           Attribute::AttrKind Attr) const {
714  if (!hasAttribute(Index, Attr)) return *this;
715  return removeAttributes(C, Index, AttributeSet::get(C, Index, Attr));
716}
717
718AttributeSet AttributeSet::removeAttributes(LLVMContext &C, unsigned Index,
719                                            AttributeSet Attrs) const {
720  if (!pImpl) return AttributeSet();
721  if (!Attrs.pImpl) return *this;
722
723#ifndef NDEBUG
724  // FIXME it is not obvious how this should work for alignment.
725  // For now, say we can't pass in alignment, which no current use does.
726  assert(!Attrs.hasAttribute(Index, Attribute::Alignment) &&
727         "Attempt to change alignment!");
728#endif
729
730  // Add the attribute slots before the one we're trying to add.
731  SmallVector<AttributeSet, 4> AttrSet;
732  uint64_t NumAttrs = pImpl->getNumAttributes();
733  AttributeSet AS;
734  uint64_t LastIndex = 0;
735  for (unsigned I = 0, E = NumAttrs; I != E; ++I) {
736    if (getSlotIndex(I) >= Index) {
737      if (getSlotIndex(I) == Index) AS = getSlotAttributes(LastIndex++);
738      break;
739    }
740    LastIndex = I + 1;
741    AttrSet.push_back(getSlotAttributes(I));
742  }
743
744  // Now remove the attribute from the correct slot. There may already be an
745  // AttributeSet there.
746  AttrBuilder B(AS, Index);
747
748  for (unsigned I = 0, E = Attrs.pImpl->getNumAttributes(); I != E; ++I)
749    if (Attrs.getSlotIndex(I) == Index) {
750      B.removeAttributes(Attrs.pImpl->getSlotAttributes(I), Index);
751      break;
752    }
753
754  AttrSet.push_back(AttributeSet::get(C, Index, B));
755
756  // Add the remaining attribute slots.
757  for (unsigned I = LastIndex, E = NumAttrs; I < E; ++I)
758    AttrSet.push_back(getSlotAttributes(I));
759
760  return get(C, AttrSet);
761}
762
763//===----------------------------------------------------------------------===//
764// AttributeSet Accessor Methods
765//===----------------------------------------------------------------------===//
766
767LLVMContext &AttributeSet::getContext() const {
768  return pImpl->getContext();
769}
770
771AttributeSet AttributeSet::getParamAttributes(unsigned Index) const {
772  return pImpl && hasAttributes(Index) ?
773    AttributeSet::get(pImpl->getContext(),
774                      ArrayRef<std::pair<unsigned, AttributeSetNode*> >(
775                        std::make_pair(Index, getAttributes(Index)))) :
776    AttributeSet();
777}
778
779AttributeSet AttributeSet::getRetAttributes() const {
780  return pImpl && hasAttributes(ReturnIndex) ?
781    AttributeSet::get(pImpl->getContext(),
782                      ArrayRef<std::pair<unsigned, AttributeSetNode*> >(
783                        std::make_pair(ReturnIndex,
784                                       getAttributes(ReturnIndex)))) :
785    AttributeSet();
786}
787
788AttributeSet AttributeSet::getFnAttributes() const {
789  return pImpl && hasAttributes(FunctionIndex) ?
790    AttributeSet::get(pImpl->getContext(),
791                      ArrayRef<std::pair<unsigned, AttributeSetNode*> >(
792                        std::make_pair(FunctionIndex,
793                                       getAttributes(FunctionIndex)))) :
794    AttributeSet();
795}
796
797bool AttributeSet::hasAttribute(unsigned Index, Attribute::AttrKind Kind) const{
798  AttributeSetNode *ASN = getAttributes(Index);
799  return ASN ? ASN->hasAttribute(Kind) : false;
800}
801
802bool AttributeSet::hasAttribute(unsigned Index, StringRef Kind) const {
803  AttributeSetNode *ASN = getAttributes(Index);
804  return ASN ? ASN->hasAttribute(Kind) : false;
805}
806
807bool AttributeSet::hasAttributes(unsigned Index) const {
808  AttributeSetNode *ASN = getAttributes(Index);
809  return ASN ? ASN->hasAttributes() : false;
810}
811
812/// \brief Return true if the specified attribute is set for at least one
813/// parameter or for the return value.
814bool AttributeSet::hasAttrSomewhere(Attribute::AttrKind Attr) const {
815  if (pImpl == 0) return false;
816
817  for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I)
818    for (AttributeSetImpl::const_iterator II = pImpl->begin(I),
819           IE = pImpl->end(I); II != IE; ++II)
820      if (II->hasAttribute(Attr))
821        return true;
822
823  return false;
824}
825
826Attribute AttributeSet::getAttribute(unsigned Index,
827                                     Attribute::AttrKind Kind) const {
828  AttributeSetNode *ASN = getAttributes(Index);
829  return ASN ? ASN->getAttribute(Kind) : Attribute();
830}
831
832Attribute AttributeSet::getAttribute(unsigned Index,
833                                     StringRef Kind) const {
834  AttributeSetNode *ASN = getAttributes(Index);
835  return ASN ? ASN->getAttribute(Kind) : Attribute();
836}
837
838unsigned AttributeSet::getParamAlignment(unsigned Index) const {
839  AttributeSetNode *ASN = getAttributes(Index);
840  return ASN ? ASN->getAlignment() : 0;
841}
842
843unsigned AttributeSet::getStackAlignment(unsigned Index) const {
844  AttributeSetNode *ASN = getAttributes(Index);
845  return ASN ? ASN->getStackAlignment() : 0;
846}
847
848std::string AttributeSet::getAsString(unsigned Index, bool TargetIndependent,
849                                      bool InAttrGrp) const {
850  AttributeSetNode *ASN = getAttributes(Index);
851  return ASN ? ASN->getAsString(TargetIndependent, InAttrGrp) :
852    std::string("");
853}
854
855/// \brief The attributes for the specified index are returned.
856AttributeSetNode *AttributeSet::getAttributes(unsigned Index) const {
857  if (!pImpl) return 0;
858
859  // Loop through to find the attribute node we want.
860  for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I)
861    if (pImpl->getSlotIndex(I) == Index)
862      return pImpl->getSlotNode(I);
863
864  return 0;
865}
866
867AttributeSet::iterator AttributeSet::begin(unsigned Slot) const {
868  if (!pImpl)
869    return ArrayRef<Attribute>().begin();
870  return pImpl->begin(Slot);
871}
872
873AttributeSet::iterator AttributeSet::end(unsigned Slot) const {
874  if (!pImpl)
875    return ArrayRef<Attribute>().end();
876  return pImpl->end(Slot);
877}
878
879//===----------------------------------------------------------------------===//
880// AttributeSet Introspection Methods
881//===----------------------------------------------------------------------===//
882
883/// \brief Return the number of slots used in this attribute list.  This is the
884/// number of arguments that have an attribute set on them (including the
885/// function itself).
886unsigned AttributeSet::getNumSlots() const {
887  return pImpl ? pImpl->getNumAttributes() : 0;
888}
889
890uint64_t AttributeSet::getSlotIndex(unsigned Slot) const {
891  assert(pImpl && Slot < pImpl->getNumAttributes() &&
892         "Slot # out of range!");
893  return pImpl->getSlotIndex(Slot);
894}
895
896AttributeSet AttributeSet::getSlotAttributes(unsigned Slot) const {
897  assert(pImpl && Slot < pImpl->getNumAttributes() &&
898         "Slot # out of range!");
899  return pImpl->getSlotAttributes(Slot);
900}
901
902uint64_t AttributeSet::Raw(unsigned Index) const {
903  // FIXME: Remove this.
904  return pImpl ? pImpl->Raw(Index) : 0;
905}
906
907void AttributeSet::dump() const {
908  dbgs() << "PAL[\n";
909
910  for (unsigned i = 0, e = getNumSlots(); i < e; ++i) {
911    uint64_t Index = getSlotIndex(i);
912    dbgs() << "  { ";
913    if (Index == ~0U)
914      dbgs() << "~0U";
915    else
916      dbgs() << Index;
917    dbgs() << " => " << getAsString(Index) << " }\n";
918  }
919
920  dbgs() << "]\n";
921}
922
923//===----------------------------------------------------------------------===//
924// AttrBuilder Method Implementations
925//===----------------------------------------------------------------------===//
926
927AttrBuilder::AttrBuilder(AttributeSet AS, unsigned Index)
928  : Attrs(0), Alignment(0), StackAlignment(0) {
929  AttributeSetImpl *pImpl = AS.pImpl;
930  if (!pImpl) return;
931
932  for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I) {
933    if (pImpl->getSlotIndex(I) != Index) continue;
934
935    for (AttributeSetImpl::const_iterator II = pImpl->begin(I),
936           IE = pImpl->end(I); II != IE; ++II)
937      addAttribute(*II);
938
939    break;
940  }
941}
942
943void AttrBuilder::clear() {
944  Attrs.reset();
945  Alignment = StackAlignment = 0;
946}
947
948AttrBuilder &AttrBuilder::addAttribute(Attribute::AttrKind Val) {
949  assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
950  assert(Val != Attribute::Alignment && Val != Attribute::StackAlignment &&
951         "Adding alignment attribute without adding alignment value!");
952  Attrs[Val] = true;
953  return *this;
954}
955
956AttrBuilder &AttrBuilder::addAttribute(Attribute Attr) {
957  if (Attr.isStringAttribute()) {
958    addAttribute(Attr.getKindAsString(), Attr.getValueAsString());
959    return *this;
960  }
961
962  Attribute::AttrKind Kind = Attr.getKindAsEnum();
963  Attrs[Kind] = true;
964
965  if (Kind == Attribute::Alignment)
966    Alignment = Attr.getAlignment();
967  else if (Kind == Attribute::StackAlignment)
968    StackAlignment = Attr.getStackAlignment();
969  return *this;
970}
971
972AttrBuilder &AttrBuilder::addAttribute(StringRef A, StringRef V) {
973  TargetDepAttrs[A] = V;
974  return *this;
975}
976
977AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) {
978  assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
979  Attrs[Val] = false;
980
981  if (Val == Attribute::Alignment)
982    Alignment = 0;
983  else if (Val == Attribute::StackAlignment)
984    StackAlignment = 0;
985
986  return *this;
987}
988
989AttrBuilder &AttrBuilder::removeAttributes(AttributeSet A, uint64_t Index) {
990  unsigned Slot = ~0U;
991  for (unsigned I = 0, E = A.getNumSlots(); I != E; ++I)
992    if (A.getSlotIndex(I) == Index) {
993      Slot = I;
994      break;
995    }
996
997  assert(Slot != ~0U && "Couldn't find index in AttributeSet!");
998
999  for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot); I != E; ++I) {
1000    Attribute Attr = *I;
1001    if (Attr.isEnumAttribute() || Attr.isAlignAttribute()) {
1002      Attribute::AttrKind Kind = I->getKindAsEnum();
1003      Attrs[Kind] = false;
1004
1005      if (Kind == Attribute::Alignment)
1006        Alignment = 0;
1007      else if (Kind == Attribute::StackAlignment)
1008        StackAlignment = 0;
1009    } else {
1010      assert(Attr.isStringAttribute() && "Invalid attribute type!");
1011      std::map<std::string, std::string>::iterator
1012        Iter = TargetDepAttrs.find(Attr.getKindAsString());
1013      if (Iter != TargetDepAttrs.end())
1014        TargetDepAttrs.erase(Iter);
1015    }
1016  }
1017
1018  return *this;
1019}
1020
1021AttrBuilder &AttrBuilder::removeAttribute(StringRef A) {
1022  std::map<std::string, std::string>::iterator I = TargetDepAttrs.find(A);
1023  if (I != TargetDepAttrs.end())
1024    TargetDepAttrs.erase(I);
1025  return *this;
1026}
1027
1028AttrBuilder &AttrBuilder::addAlignmentAttr(unsigned Align) {
1029  if (Align == 0) return *this;
1030
1031  assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
1032  assert(Align <= 0x40000000 && "Alignment too large.");
1033
1034  Attrs[Attribute::Alignment] = true;
1035  Alignment = Align;
1036  return *this;
1037}
1038
1039AttrBuilder &AttrBuilder::addStackAlignmentAttr(unsigned Align) {
1040  // Default alignment, allow the target to define how to align it.
1041  if (Align == 0) return *this;
1042
1043  assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
1044  assert(Align <= 0x100 && "Alignment too large.");
1045
1046  Attrs[Attribute::StackAlignment] = true;
1047  StackAlignment = Align;
1048  return *this;
1049}
1050
1051AttrBuilder &AttrBuilder::merge(const AttrBuilder &B) {
1052  // FIXME: What if both have alignments, but they don't match?!
1053  if (!Alignment)
1054    Alignment = B.Alignment;
1055
1056  if (!StackAlignment)
1057    StackAlignment = B.StackAlignment;
1058
1059  Attrs |= B.Attrs;
1060
1061  for (td_const_iterator I = B.TargetDepAttrs.begin(),
1062         E = B.TargetDepAttrs.end(); I != E; ++I)
1063    TargetDepAttrs[I->first] = I->second;
1064
1065  return *this;
1066}
1067
1068bool AttrBuilder::contains(StringRef A) const {
1069  return TargetDepAttrs.find(A) != TargetDepAttrs.end();
1070}
1071
1072bool AttrBuilder::hasAttributes() const {
1073  return !Attrs.none() || !TargetDepAttrs.empty();
1074}
1075
1076bool AttrBuilder::hasAttributes(AttributeSet A, uint64_t Index) const {
1077  unsigned Slot = ~0U;
1078  for (unsigned I = 0, E = A.getNumSlots(); I != E; ++I)
1079    if (A.getSlotIndex(I) == Index) {
1080      Slot = I;
1081      break;
1082    }
1083
1084  assert(Slot != ~0U && "Couldn't find the index!");
1085
1086  for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot);
1087       I != E; ++I) {
1088    Attribute Attr = *I;
1089    if (Attr.isEnumAttribute() || Attr.isAlignAttribute()) {
1090      if (Attrs[I->getKindAsEnum()])
1091        return true;
1092    } else {
1093      assert(Attr.isStringAttribute() && "Invalid attribute kind!");
1094      return TargetDepAttrs.find(Attr.getKindAsString())!=TargetDepAttrs.end();
1095    }
1096  }
1097
1098  return false;
1099}
1100
1101bool AttrBuilder::hasAlignmentAttr() const {
1102  return Alignment != 0;
1103}
1104
1105bool AttrBuilder::operator==(const AttrBuilder &B) {
1106  if (Attrs != B.Attrs)
1107    return false;
1108
1109  for (td_const_iterator I = TargetDepAttrs.begin(),
1110         E = TargetDepAttrs.end(); I != E; ++I)
1111    if (B.TargetDepAttrs.find(I->first) == B.TargetDepAttrs.end())
1112      return false;
1113
1114  return Alignment == B.Alignment && StackAlignment == B.StackAlignment;
1115}
1116
1117AttrBuilder &AttrBuilder::addRawValue(uint64_t Val) {
1118  // FIXME: Remove this in 4.0.
1119  if (!Val) return *this;
1120
1121  for (Attribute::AttrKind I = Attribute::None; I != Attribute::EndAttrKinds;
1122       I = Attribute::AttrKind(I + 1)) {
1123    if (uint64_t A = (Val & AttributeImpl::getAttrMask(I))) {
1124      Attrs[I] = true;
1125
1126      if (I == Attribute::Alignment)
1127        Alignment = 1ULL << ((A >> 16) - 1);
1128      else if (I == Attribute::StackAlignment)
1129        StackAlignment = 1ULL << ((A >> 26)-1);
1130    }
1131  }
1132
1133  return *this;
1134}
1135
1136//===----------------------------------------------------------------------===//
1137// AttributeFuncs Function Defintions
1138//===----------------------------------------------------------------------===//
1139
1140/// \brief Which attributes cannot be applied to a type.
1141AttributeSet AttributeFuncs::typeIncompatible(Type *Ty, uint64_t Index) {
1142  AttrBuilder Incompatible;
1143
1144  if (!Ty->isIntegerTy())
1145    // Attribute that only apply to integers.
1146    Incompatible.addAttribute(Attribute::SExt)
1147      .addAttribute(Attribute::ZExt);
1148
1149  if (!Ty->isPointerTy())
1150    // Attribute that only apply to pointers.
1151    Incompatible.addAttribute(Attribute::ByVal)
1152      .addAttribute(Attribute::Nest)
1153      .addAttribute(Attribute::NoAlias)
1154      .addAttribute(Attribute::NoCapture)
1155      .addAttribute(Attribute::StructRet);
1156
1157  return AttributeSet::get(Ty->getContext(), Index, Incompatible);
1158}
1159