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