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