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