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::Returned))
199    return "returned";
200  if (hasAttribute(Attribute::ReturnsTwice))
201    return "returns_twice";
202  if (hasAttribute(Attribute::SExt))
203    return "signext";
204  if (hasAttribute(Attribute::StackProtect))
205    return "ssp";
206  if (hasAttribute(Attribute::StackProtectReq))
207    return "sspreq";
208  if (hasAttribute(Attribute::StackProtectStrong))
209    return "sspstrong";
210  if (hasAttribute(Attribute::StructRet))
211    return "sret";
212  if (hasAttribute(Attribute::SanitizeThread))
213    return "sanitize_thread";
214  if (hasAttribute(Attribute::SanitizeMemory))
215    return "sanitize_memory";
216  if (hasAttribute(Attribute::UWTable))
217    return "uwtable";
218  if (hasAttribute(Attribute::ZExt))
219    return "zeroext";
220
221  // FIXME: These should be output like this:
222  //
223  //   align=4
224  //   alignstack=8
225  //
226  if (hasAttribute(Attribute::Alignment)) {
227    std::string Result;
228    Result += "align";
229    Result += (InAttrGrp) ? "=" : " ";
230    Result += utostr(getValueAsInt());
231    return Result;
232  }
233
234  if (hasAttribute(Attribute::StackAlignment)) {
235    std::string Result;
236    Result += "alignstack";
237    if (InAttrGrp) {
238      Result += "=";
239      Result += utostr(getValueAsInt());
240    } else {
241      Result += "(";
242      Result += utostr(getValueAsInt());
243      Result += ")";
244    }
245    return Result;
246  }
247
248  // Convert target-dependent attributes to strings of the form:
249  //
250  //   "kind"
251  //   "kind" = "value"
252  //
253  if (isStringAttribute()) {
254    std::string Result;
255    Result += '\"' + getKindAsString().str() + '"';
256
257    StringRef Val = pImpl->getValueAsString();
258    if (Val.empty()) return Result;
259
260    Result += "=\"" + Val.str() + '"';
261    return Result;
262  }
263
264  llvm_unreachable("Unknown attribute");
265}
266
267bool Attribute::operator<(Attribute A) const {
268  if (!pImpl && !A.pImpl) return false;
269  if (!pImpl) return true;
270  if (!A.pImpl) return false;
271  return *pImpl < *A.pImpl;
272}
273
274//===----------------------------------------------------------------------===//
275// AttributeImpl Definition
276//===----------------------------------------------------------------------===//
277
278AttributeImpl::AttributeImpl(LLVMContext &C, Attribute::AttrKind Kind)
279  : Context(C), Entry(new EnumAttributeEntry(Kind)) {}
280
281AttributeImpl::AttributeImpl(LLVMContext &C, Attribute::AttrKind Kind,
282                             unsigned Align)
283  : Context(C) {
284  assert((Kind == Attribute::Alignment || Kind == Attribute::StackAlignment) &&
285         "Wrong kind for alignment attribute!");
286  Entry = new AlignAttributeEntry(Kind, Align);
287}
288
289AttributeImpl::AttributeImpl(LLVMContext &C, StringRef Kind, StringRef Val)
290  : Context(C), Entry(new StringAttributeEntry(Kind, Val)) {}
291
292AttributeImpl::~AttributeImpl() {
293  delete Entry;
294}
295
296bool AttributeImpl::isEnumAttribute() const {
297  return isa<EnumAttributeEntry>(Entry);
298}
299
300bool AttributeImpl::isAlignAttribute() const {
301  return isa<AlignAttributeEntry>(Entry);
302}
303
304bool AttributeImpl::isStringAttribute() const {
305  return isa<StringAttributeEntry>(Entry);
306}
307
308bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const {
309  if (isStringAttribute()) return false;
310  return getKindAsEnum() == A;
311}
312
313bool AttributeImpl::hasAttribute(StringRef Kind) const {
314  if (!isStringAttribute()) return false;
315  return getKindAsString() == Kind;
316}
317
318Attribute::AttrKind AttributeImpl::getKindAsEnum() const {
319  if (EnumAttributeEntry *E = dyn_cast<EnumAttributeEntry>(Entry))
320    return E->getEnumKind();
321  return cast<AlignAttributeEntry>(Entry)->getEnumKind();
322}
323
324uint64_t AttributeImpl::getValueAsInt() const {
325  return cast<AlignAttributeEntry>(Entry)->getAlignment();
326}
327
328StringRef AttributeImpl::getKindAsString() const {
329  return cast<StringAttributeEntry>(Entry)->getStringKind();
330}
331
332StringRef AttributeImpl::getValueAsString() const {
333  return cast<StringAttributeEntry>(Entry)->getStringValue();
334}
335
336bool AttributeImpl::operator<(const AttributeImpl &AI) const {
337  // This sorts the attributes with Attribute::AttrKinds coming first (sorted
338  // relative to their enum value) and then strings.
339  if (isEnumAttribute()) {
340    if (AI.isEnumAttribute()) return getKindAsEnum() < AI.getKindAsEnum();
341    if (AI.isAlignAttribute()) return true;
342    if (AI.isStringAttribute()) return true;
343  }
344
345  if (isAlignAttribute()) {
346    if (AI.isEnumAttribute()) return false;
347    if (AI.isAlignAttribute()) return getValueAsInt() < AI.getValueAsInt();
348    if (AI.isStringAttribute()) return true;
349  }
350
351  if (AI.isEnumAttribute()) return false;
352  if (AI.isAlignAttribute()) return false;
353  if (getKindAsString() == AI.getKindAsString())
354    return getValueAsString() < AI.getValueAsString();
355  return getKindAsString() < AI.getKindAsString();
356}
357
358uint64_t AttributeImpl::getAttrMask(Attribute::AttrKind Val) {
359  // FIXME: Remove this.
360  switch (Val) {
361  case Attribute::EndAttrKinds:
362    llvm_unreachable("Synthetic enumerators which should never get here");
363
364  case Attribute::None:            return 0;
365  case Attribute::ZExt:            return 1 << 0;
366  case Attribute::SExt:            return 1 << 1;
367  case Attribute::NoReturn:        return 1 << 2;
368  case Attribute::InReg:           return 1 << 3;
369  case Attribute::StructRet:       return 1 << 4;
370  case Attribute::NoUnwind:        return 1 << 5;
371  case Attribute::NoAlias:         return 1 << 6;
372  case Attribute::ByVal:           return 1 << 7;
373  case Attribute::Nest:            return 1 << 8;
374  case Attribute::ReadNone:        return 1 << 9;
375  case Attribute::ReadOnly:        return 1 << 10;
376  case Attribute::NoInline:        return 1 << 11;
377  case Attribute::AlwaysInline:    return 1 << 12;
378  case Attribute::OptimizeForSize: return 1 << 13;
379  case Attribute::StackProtect:    return 1 << 14;
380  case Attribute::StackProtectReq: return 1 << 15;
381  case Attribute::Alignment:       return 31 << 16;
382  case Attribute::NoCapture:       return 1 << 21;
383  case Attribute::NoRedZone:       return 1 << 22;
384  case Attribute::NoImplicitFloat: return 1 << 23;
385  case Attribute::Naked:           return 1 << 24;
386  case Attribute::InlineHint:      return 1 << 25;
387  case Attribute::StackAlignment:  return 7 << 26;
388  case Attribute::ReturnsTwice:    return 1 << 29;
389  case Attribute::UWTable:         return 1 << 30;
390  case Attribute::NonLazyBind:     return 1U << 31;
391  case Attribute::SanitizeAddress: return 1ULL << 32;
392  case Attribute::MinSize:         return 1ULL << 33;
393  case Attribute::NoDuplicate:     return 1ULL << 34;
394  case Attribute::StackProtectStrong: return 1ULL << 35;
395  case Attribute::SanitizeThread:  return 1ULL << 36;
396  case Attribute::SanitizeMemory:  return 1ULL << 37;
397  case Attribute::NoBuiltin:       return 1ULL << 38;
398  case Attribute::Returned:        return 1ULL << 39;
399  }
400  llvm_unreachable("Unsupported attribute type");
401}
402
403//===----------------------------------------------------------------------===//
404// AttributeSetNode Definition
405//===----------------------------------------------------------------------===//
406
407AttributeSetNode *AttributeSetNode::get(LLVMContext &C,
408                                        ArrayRef<Attribute> Attrs) {
409  if (Attrs.empty())
410    return 0;
411
412  // Otherwise, build a key to look up the existing attributes.
413  LLVMContextImpl *pImpl = C.pImpl;
414  FoldingSetNodeID ID;
415
416  SmallVector<Attribute, 8> SortedAttrs(Attrs.begin(), Attrs.end());
417  array_pod_sort(SortedAttrs.begin(), SortedAttrs.end());
418
419  for (SmallVectorImpl<Attribute>::iterator I = SortedAttrs.begin(),
420         E = SortedAttrs.end(); I != E; ++I)
421    I->Profile(ID);
422
423  void *InsertPoint;
424  AttributeSetNode *PA =
425    pImpl->AttrsSetNodes.FindNodeOrInsertPos(ID, InsertPoint);
426
427  // If we didn't find any existing attributes of the same shape then create a
428  // new one and insert it.
429  if (!PA) {
430    PA = new AttributeSetNode(SortedAttrs);
431    pImpl->AttrsSetNodes.InsertNode(PA, InsertPoint);
432  }
433
434  // Return the AttributesListNode that we found or created.
435  return PA;
436}
437
438bool AttributeSetNode::hasAttribute(Attribute::AttrKind Kind) const {
439  for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
440         E = AttrList.end(); I != E; ++I)
441    if (I->hasAttribute(Kind))
442      return true;
443  return false;
444}
445
446bool AttributeSetNode::hasAttribute(StringRef Kind) const {
447  for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
448         E = AttrList.end(); I != E; ++I)
449    if (I->hasAttribute(Kind))
450      return true;
451  return false;
452}
453
454Attribute AttributeSetNode::getAttribute(Attribute::AttrKind Kind) const {
455  for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
456         E = AttrList.end(); I != E; ++I)
457    if (I->hasAttribute(Kind))
458      return *I;
459  return Attribute();
460}
461
462Attribute AttributeSetNode::getAttribute(StringRef Kind) const {
463  for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
464         E = AttrList.end(); I != E; ++I)
465    if (I->hasAttribute(Kind))
466      return *I;
467  return Attribute();
468}
469
470unsigned AttributeSetNode::getAlignment() const {
471  for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
472         E = AttrList.end(); I != E; ++I)
473    if (I->hasAttribute(Attribute::Alignment))
474      return I->getAlignment();
475  return 0;
476}
477
478unsigned AttributeSetNode::getStackAlignment() const {
479  for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
480         E = AttrList.end(); I != E; ++I)
481    if (I->hasAttribute(Attribute::StackAlignment))
482      return I->getStackAlignment();
483  return 0;
484}
485
486std::string AttributeSetNode::getAsString(bool InAttrGrp) const {
487  std::string Str;
488  for (SmallVectorImpl<Attribute>::const_iterator I = AttrList.begin(),
489         E = AttrList.end(); I != E; ++I) {
490    if (I != AttrList.begin())
491      Str += ' ';
492    Str += I->getAsString(InAttrGrp);
493  }
494  return Str;
495}
496
497//===----------------------------------------------------------------------===//
498// AttributeSetImpl Definition
499//===----------------------------------------------------------------------===//
500
501uint64_t AttributeSetImpl::Raw(unsigned 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,
849                                      bool InAttrGrp) const {
850  AttributeSetNode *ASN = getAttributes(Index);
851  return ASN ? ASN->getAsString(InAttrGrp) : std::string("");
852}
853
854/// \brief The attributes for the specified index are returned.
855AttributeSetNode *AttributeSet::getAttributes(unsigned Index) const {
856  if (!pImpl) return 0;
857
858  // Loop through to find the attribute node we want.
859  for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I)
860    if (pImpl->getSlotIndex(I) == Index)
861      return pImpl->getSlotNode(I);
862
863  return 0;
864}
865
866AttributeSet::iterator AttributeSet::begin(unsigned Slot) const {
867  if (!pImpl)
868    return ArrayRef<Attribute>().begin();
869  return pImpl->begin(Slot);
870}
871
872AttributeSet::iterator AttributeSet::end(unsigned Slot) const {
873  if (!pImpl)
874    return ArrayRef<Attribute>().end();
875  return pImpl->end(Slot);
876}
877
878//===----------------------------------------------------------------------===//
879// AttributeSet Introspection Methods
880//===----------------------------------------------------------------------===//
881
882/// \brief Return the number of slots used in this attribute list.  This is the
883/// number of arguments that have an attribute set on them (including the
884/// function itself).
885unsigned AttributeSet::getNumSlots() const {
886  return pImpl ? pImpl->getNumAttributes() : 0;
887}
888
889unsigned AttributeSet::getSlotIndex(unsigned Slot) const {
890  assert(pImpl && Slot < pImpl->getNumAttributes() &&
891         "Slot # out of range!");
892  return pImpl->getSlotIndex(Slot);
893}
894
895AttributeSet AttributeSet::getSlotAttributes(unsigned Slot) const {
896  assert(pImpl && Slot < pImpl->getNumAttributes() &&
897         "Slot # out of range!");
898  return pImpl->getSlotAttributes(Slot);
899}
900
901uint64_t AttributeSet::Raw(unsigned Index) const {
902  // FIXME: Remove this.
903  return pImpl ? pImpl->Raw(Index) : 0;
904}
905
906void AttributeSet::dump() const {
907  dbgs() << "PAL[\n";
908
909  for (unsigned i = 0, e = getNumSlots(); i < e; ++i) {
910    uint64_t Index = getSlotIndex(i);
911    dbgs() << "  { ";
912    if (Index == ~0U)
913      dbgs() << "~0U";
914    else
915      dbgs() << Index;
916    dbgs() << " => " << getAsString(Index) << " }\n";
917  }
918
919  dbgs() << "]\n";
920}
921
922//===----------------------------------------------------------------------===//
923// AttrBuilder Method Implementations
924//===----------------------------------------------------------------------===//
925
926AttrBuilder::AttrBuilder(AttributeSet AS, unsigned Index)
927  : Attrs(0), Alignment(0), StackAlignment(0) {
928  AttributeSetImpl *pImpl = AS.pImpl;
929  if (!pImpl) return;
930
931  for (unsigned I = 0, E = pImpl->getNumAttributes(); I != E; ++I) {
932    if (pImpl->getSlotIndex(I) != Index) continue;
933
934    for (AttributeSetImpl::const_iterator II = pImpl->begin(I),
935           IE = pImpl->end(I); II != IE; ++II)
936      addAttribute(*II);
937
938    break;
939  }
940}
941
942void AttrBuilder::clear() {
943  Attrs.reset();
944  Alignment = StackAlignment = 0;
945}
946
947AttrBuilder &AttrBuilder::addAttribute(Attribute::AttrKind Val) {
948  assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
949  assert(Val != Attribute::Alignment && Val != Attribute::StackAlignment &&
950         "Adding alignment attribute without adding alignment value!");
951  Attrs[Val] = true;
952  return *this;
953}
954
955AttrBuilder &AttrBuilder::addAttribute(Attribute Attr) {
956  if (Attr.isStringAttribute()) {
957    addAttribute(Attr.getKindAsString(), Attr.getValueAsString());
958    return *this;
959  }
960
961  Attribute::AttrKind Kind = Attr.getKindAsEnum();
962  Attrs[Kind] = true;
963
964  if (Kind == Attribute::Alignment)
965    Alignment = Attr.getAlignment();
966  else if (Kind == Attribute::StackAlignment)
967    StackAlignment = Attr.getStackAlignment();
968  return *this;
969}
970
971AttrBuilder &AttrBuilder::addAttribute(StringRef A, StringRef V) {
972  TargetDepAttrs[A] = V;
973  return *this;
974}
975
976AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) {
977  assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
978  Attrs[Val] = false;
979
980  if (Val == Attribute::Alignment)
981    Alignment = 0;
982  else if (Val == Attribute::StackAlignment)
983    StackAlignment = 0;
984
985  return *this;
986}
987
988AttrBuilder &AttrBuilder::removeAttributes(AttributeSet A, uint64_t Index) {
989  unsigned Slot = ~0U;
990  for (unsigned I = 0, E = A.getNumSlots(); I != E; ++I)
991    if (A.getSlotIndex(I) == Index) {
992      Slot = I;
993      break;
994    }
995
996  assert(Slot != ~0U && "Couldn't find index in AttributeSet!");
997
998  for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot); I != E; ++I) {
999    Attribute Attr = *I;
1000    if (Attr.isEnumAttribute() || Attr.isAlignAttribute()) {
1001      Attribute::AttrKind Kind = I->getKindAsEnum();
1002      Attrs[Kind] = false;
1003
1004      if (Kind == Attribute::Alignment)
1005        Alignment = 0;
1006      else if (Kind == Attribute::StackAlignment)
1007        StackAlignment = 0;
1008    } else {
1009      assert(Attr.isStringAttribute() && "Invalid attribute type!");
1010      std::map<std::string, std::string>::iterator
1011        Iter = TargetDepAttrs.find(Attr.getKindAsString());
1012      if (Iter != TargetDepAttrs.end())
1013        TargetDepAttrs.erase(Iter);
1014    }
1015  }
1016
1017  return *this;
1018}
1019
1020AttrBuilder &AttrBuilder::removeAttribute(StringRef A) {
1021  std::map<std::string, std::string>::iterator I = TargetDepAttrs.find(A);
1022  if (I != TargetDepAttrs.end())
1023    TargetDepAttrs.erase(I);
1024  return *this;
1025}
1026
1027AttrBuilder &AttrBuilder::addAlignmentAttr(unsigned Align) {
1028  if (Align == 0) return *this;
1029
1030  assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
1031  assert(Align <= 0x40000000 && "Alignment too large.");
1032
1033  Attrs[Attribute::Alignment] = true;
1034  Alignment = Align;
1035  return *this;
1036}
1037
1038AttrBuilder &AttrBuilder::addStackAlignmentAttr(unsigned Align) {
1039  // Default alignment, allow the target to define how to align it.
1040  if (Align == 0) return *this;
1041
1042  assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
1043  assert(Align <= 0x100 && "Alignment too large.");
1044
1045  Attrs[Attribute::StackAlignment] = true;
1046  StackAlignment = Align;
1047  return *this;
1048}
1049
1050AttrBuilder &AttrBuilder::merge(const AttrBuilder &B) {
1051  // FIXME: What if both have alignments, but they don't match?!
1052  if (!Alignment)
1053    Alignment = B.Alignment;
1054
1055  if (!StackAlignment)
1056    StackAlignment = B.StackAlignment;
1057
1058  Attrs |= B.Attrs;
1059
1060  for (td_const_iterator I = B.TargetDepAttrs.begin(),
1061         E = B.TargetDepAttrs.end(); I != E; ++I)
1062    TargetDepAttrs[I->first] = I->second;
1063
1064  return *this;
1065}
1066
1067bool AttrBuilder::contains(StringRef A) const {
1068  return TargetDepAttrs.find(A) != TargetDepAttrs.end();
1069}
1070
1071bool AttrBuilder::hasAttributes() const {
1072  return !Attrs.none() || !TargetDepAttrs.empty();
1073}
1074
1075bool AttrBuilder::hasAttributes(AttributeSet A, uint64_t Index) const {
1076  unsigned Slot = ~0U;
1077  for (unsigned I = 0, E = A.getNumSlots(); I != E; ++I)
1078    if (A.getSlotIndex(I) == Index) {
1079      Slot = I;
1080      break;
1081    }
1082
1083  assert(Slot != ~0U && "Couldn't find the index!");
1084
1085  for (AttributeSet::iterator I = A.begin(Slot), E = A.end(Slot);
1086       I != E; ++I) {
1087    Attribute Attr = *I;
1088    if (Attr.isEnumAttribute() || Attr.isAlignAttribute()) {
1089      if (Attrs[I->getKindAsEnum()])
1090        return true;
1091    } else {
1092      assert(Attr.isStringAttribute() && "Invalid attribute kind!");
1093      return TargetDepAttrs.find(Attr.getKindAsString())!=TargetDepAttrs.end();
1094    }
1095  }
1096
1097  return false;
1098}
1099
1100bool AttrBuilder::hasAlignmentAttr() const {
1101  return Alignment != 0;
1102}
1103
1104bool AttrBuilder::operator==(const AttrBuilder &B) {
1105  if (Attrs != B.Attrs)
1106    return false;
1107
1108  for (td_const_iterator I = TargetDepAttrs.begin(),
1109         E = TargetDepAttrs.end(); I != E; ++I)
1110    if (B.TargetDepAttrs.find(I->first) == B.TargetDepAttrs.end())
1111      return false;
1112
1113  return Alignment == B.Alignment && StackAlignment == B.StackAlignment;
1114}
1115
1116AttrBuilder &AttrBuilder::addRawValue(uint64_t Val) {
1117  // FIXME: Remove this in 4.0.
1118  if (!Val) return *this;
1119
1120  for (Attribute::AttrKind I = Attribute::None; I != Attribute::EndAttrKinds;
1121       I = Attribute::AttrKind(I + 1)) {
1122    if (uint64_t A = (Val & AttributeImpl::getAttrMask(I))) {
1123      Attrs[I] = true;
1124
1125      if (I == Attribute::Alignment)
1126        Alignment = 1ULL << ((A >> 16) - 1);
1127      else if (I == Attribute::StackAlignment)
1128        StackAlignment = 1ULL << ((A >> 26)-1);
1129    }
1130  }
1131
1132  return *this;
1133}
1134
1135//===----------------------------------------------------------------------===//
1136// AttributeFuncs Function Defintions
1137//===----------------------------------------------------------------------===//
1138
1139/// \brief Which attributes cannot be applied to a type.
1140AttributeSet AttributeFuncs::typeIncompatible(Type *Ty, uint64_t Index) {
1141  AttrBuilder Incompatible;
1142
1143  if (!Ty->isIntegerTy())
1144    // Attribute that only apply to integers.
1145    Incompatible.addAttribute(Attribute::SExt)
1146      .addAttribute(Attribute::ZExt);
1147
1148  if (!Ty->isPointerTy())
1149    // Attribute that only apply to pointers.
1150    Incompatible.addAttribute(Attribute::ByVal)
1151      .addAttribute(Attribute::Nest)
1152      .addAttribute(Attribute::NoAlias)
1153      .addAttribute(Attribute::NoCapture)
1154      .addAttribute(Attribute::StructRet);
1155
1156  return AttributeSet::get(Ty->getContext(), Index, Incompatible);
1157}
1158