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 // This file implements the Attribute, AttributeImpl, AttrBuilder,
12 // AttributeListImpl, and AttributeList classes.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #include "llvm/IR/Attributes.h"
17 #include "AttributeImpl.h"
18 #include "LLVMContextImpl.h"
19 #include "llvm/ADT/ArrayRef.h"
20 #include "llvm/ADT/FoldingSet.h"
21 #include "llvm/ADT/Optional.h"
22 #include "llvm/ADT/STLExtras.h"
23 #include "llvm/ADT/SmallVector.h"
24 #include "llvm/ADT/StringExtras.h"
25 #include "llvm/ADT/StringRef.h"
26 #include "llvm/ADT/Twine.h"
27 #include "llvm/Config/llvm-config.h"
28 #include "llvm/IR/Function.h"
29 #include "llvm/IR/LLVMContext.h"
30 #include "llvm/IR/Type.h"
31 #include "llvm/Support/Compiler.h"
32 #include "llvm/Support/Debug.h"
33 #include "llvm/Support/ErrorHandling.h"
34 #include "llvm/Support/MathExtras.h"
35 #include "llvm/Support/raw_ostream.h"
36 #include <algorithm>
37 #include <cassert>
38 #include <climits>
39 #include <cstddef>
40 #include <cstdint>
41 #include <limits>
42 #include <string>
43 #include <tuple>
44 #include <utility>
45 
46 using namespace llvm;
47 
48 //===----------------------------------------------------------------------===//
49 // Attribute Construction Methods
50 //===----------------------------------------------------------------------===//
51 
52 // allocsize has two integer arguments, but because they're both 32 bits, we can
53 // pack them into one 64-bit value, at the cost of making said value
54 // nonsensical.
55 //
56 // In order to do this, we need to reserve one value of the second (optional)
57 // allocsize argument to signify "not present."
58 static const unsigned AllocSizeNumElemsNotPresent = -1;
59 
60 static uint64_t packAllocSizeArgs(unsigned ElemSizeArg,
61                                   const Optional<unsigned> &NumElemsArg) {
62   assert((!NumElemsArg.hasValue() ||
63           *NumElemsArg != AllocSizeNumElemsNotPresent) &&
64          "Attempting to pack a reserved value");
65 
66   return uint64_t(ElemSizeArg) << 32 |
67          NumElemsArg.getValueOr(AllocSizeNumElemsNotPresent);
68 }
69 
70 static std::pair<unsigned, Optional<unsigned>>
71 unpackAllocSizeArgs(uint64_t Num) {
72   unsigned NumElems = Num & std::numeric_limits<unsigned>::max();
73   unsigned ElemSizeArg = Num >> 32;
74 
75   Optional<unsigned> NumElemsArg;
76   if (NumElems != AllocSizeNumElemsNotPresent)
77     NumElemsArg = NumElems;
78   return std::make_pair(ElemSizeArg, NumElemsArg);
79 }
80 
81 Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind,
82                          uint64_t Val) {
83   LLVMContextImpl *pImpl = Context.pImpl;
84   FoldingSetNodeID ID;
85   ID.AddInteger(Kind);
86   if (Val) ID.AddInteger(Val);
87 
88   void *InsertPoint;
89   AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);
90 
91   if (!PA) {
92     // If we didn't find any existing attributes of the same shape then create a
93     // new one and insert it.
94     if (!Val)
95       PA = new EnumAttributeImpl(Kind);
96     else
97       PA = new IntAttributeImpl(Kind, Val);
98     pImpl->AttrsSet.InsertNode(PA, InsertPoint);
99   }
100 
101   // Return the Attribute that we found or created.
102   return Attribute(PA);
103 }
104 
105 Attribute Attribute::get(LLVMContext &Context, StringRef Kind, StringRef Val) {
106   LLVMContextImpl *pImpl = Context.pImpl;
107   FoldingSetNodeID ID;
108   ID.AddString(Kind);
109   if (!Val.empty()) ID.AddString(Val);
110 
111   void *InsertPoint;
112   AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);
113 
114   if (!PA) {
115     // If we didn't find any existing attributes of the same shape then create a
116     // new one and insert it.
117     PA = new StringAttributeImpl(Kind, Val);
118     pImpl->AttrsSet.InsertNode(PA, InsertPoint);
119   }
120 
121   // Return the Attribute that we found or created.
122   return Attribute(PA);
123 }
124 
125 Attribute Attribute::getWithAlignment(LLVMContext &Context, uint64_t Align) {
126   assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
127   assert(Align <= 0x40000000 && "Alignment too large.");
128   return get(Context, Alignment, Align);
129 }
130 
131 Attribute Attribute::getWithStackAlignment(LLVMContext &Context,
132                                            uint64_t Align) {
133   assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
134   assert(Align <= 0x100 && "Alignment too large.");
135   return get(Context, StackAlignment, Align);
136 }
137 
138 Attribute Attribute::getWithDereferenceableBytes(LLVMContext &Context,
139                                                 uint64_t Bytes) {
140   assert(Bytes && "Bytes must be non-zero.");
141   return get(Context, Dereferenceable, Bytes);
142 }
143 
144 Attribute Attribute::getWithDereferenceableOrNullBytes(LLVMContext &Context,
145                                                        uint64_t Bytes) {
146   assert(Bytes && "Bytes must be non-zero.");
147   return get(Context, DereferenceableOrNull, Bytes);
148 }
149 
150 Attribute
151 Attribute::getWithAllocSizeArgs(LLVMContext &Context, unsigned ElemSizeArg,
152                                 const Optional<unsigned> &NumElemsArg) {
153   assert(!(ElemSizeArg == 0 && NumElemsArg && *NumElemsArg == 0) &&
154          "Invalid allocsize arguments -- given allocsize(0, 0)");
155   return get(Context, AllocSize, packAllocSizeArgs(ElemSizeArg, NumElemsArg));
156 }
157 
158 //===----------------------------------------------------------------------===//
159 // Attribute Accessor Methods
160 //===----------------------------------------------------------------------===//
161 
162 bool Attribute::isEnumAttribute() const {
163   return pImpl && pImpl->isEnumAttribute();
164 }
165 
166 bool Attribute::isIntAttribute() const {
167   return pImpl && pImpl->isIntAttribute();
168 }
169 
170 bool Attribute::isStringAttribute() const {
171   return pImpl && pImpl->isStringAttribute();
172 }
173 
174 Attribute::AttrKind Attribute::getKindAsEnum() const {
175   if (!pImpl) return None;
176   assert((isEnumAttribute() || isIntAttribute()) &&
177          "Invalid attribute type to get the kind as an enum!");
178   return pImpl->getKindAsEnum();
179 }
180 
181 uint64_t Attribute::getValueAsInt() const {
182   if (!pImpl) return 0;
183   assert(isIntAttribute() &&
184          "Expected the attribute to be an integer attribute!");
185   return pImpl->getValueAsInt();
186 }
187 
188 StringRef Attribute::getKindAsString() const {
189   if (!pImpl) return {};
190   assert(isStringAttribute() &&
191          "Invalid attribute type to get the kind as a string!");
192   return pImpl->getKindAsString();
193 }
194 
195 StringRef Attribute::getValueAsString() const {
196   if (!pImpl) return {};
197   assert(isStringAttribute() &&
198          "Invalid attribute type to get the value as a string!");
199   return pImpl->getValueAsString();
200 }
201 
202 bool Attribute::hasAttribute(AttrKind Kind) const {
203   return (pImpl && pImpl->hasAttribute(Kind)) || (!pImpl && Kind == None);
204 }
205 
206 bool Attribute::hasAttribute(StringRef Kind) const {
207   if (!isStringAttribute()) return false;
208   return pImpl && pImpl->hasAttribute(Kind);
209 }
210 
211 unsigned Attribute::getAlignment() const {
212   assert(hasAttribute(Attribute::Alignment) &&
213          "Trying to get alignment from non-alignment attribute!");
214   return pImpl->getValueAsInt();
215 }
216 
217 unsigned Attribute::getStackAlignment() const {
218   assert(hasAttribute(Attribute::StackAlignment) &&
219          "Trying to get alignment from non-alignment attribute!");
220   return pImpl->getValueAsInt();
221 }
222 
223 uint64_t Attribute::getDereferenceableBytes() const {
224   assert(hasAttribute(Attribute::Dereferenceable) &&
225          "Trying to get dereferenceable bytes from "
226          "non-dereferenceable attribute!");
227   return pImpl->getValueAsInt();
228 }
229 
230 uint64_t Attribute::getDereferenceableOrNullBytes() const {
231   assert(hasAttribute(Attribute::DereferenceableOrNull) &&
232          "Trying to get dereferenceable bytes from "
233          "non-dereferenceable attribute!");
234   return pImpl->getValueAsInt();
235 }
236 
237 std::pair<unsigned, Optional<unsigned>> Attribute::getAllocSizeArgs() const {
238   assert(hasAttribute(Attribute::AllocSize) &&
239          "Trying to get allocsize args from non-allocsize attribute");
240   return unpackAllocSizeArgs(pImpl->getValueAsInt());
241 }
242 
243 std::string Attribute::getAsString(bool InAttrGrp) const {
244   if (!pImpl) return {};
245 
246   if (hasAttribute(Attribute::SanitizeAddress))
247     return "sanitize_address";
248   if (hasAttribute(Attribute::SanitizeHWAddress))
249     return "sanitize_hwaddress";
250   if (hasAttribute(Attribute::AlwaysInline))
251     return "alwaysinline";
252   if (hasAttribute(Attribute::ArgMemOnly))
253     return "argmemonly";
254   if (hasAttribute(Attribute::Builtin))
255     return "builtin";
256   if (hasAttribute(Attribute::ByVal))
257     return "byval";
258   if (hasAttribute(Attribute::Convergent))
259     return "convergent";
260   if (hasAttribute(Attribute::SwiftError))
261     return "swifterror";
262   if (hasAttribute(Attribute::SwiftSelf))
263     return "swiftself";
264   if (hasAttribute(Attribute::InaccessibleMemOnly))
265     return "inaccessiblememonly";
266   if (hasAttribute(Attribute::InaccessibleMemOrArgMemOnly))
267     return "inaccessiblemem_or_argmemonly";
268   if (hasAttribute(Attribute::InAlloca))
269     return "inalloca";
270   if (hasAttribute(Attribute::InlineHint))
271     return "inlinehint";
272   if (hasAttribute(Attribute::InReg))
273     return "inreg";
274   if (hasAttribute(Attribute::JumpTable))
275     return "jumptable";
276   if (hasAttribute(Attribute::MinSize))
277     return "minsize";
278   if (hasAttribute(Attribute::Naked))
279     return "naked";
280   if (hasAttribute(Attribute::Nest))
281     return "nest";
282   if (hasAttribute(Attribute::NoAlias))
283     return "noalias";
284   if (hasAttribute(Attribute::NoBuiltin))
285     return "nobuiltin";
286   if (hasAttribute(Attribute::NoCapture))
287     return "nocapture";
288   if (hasAttribute(Attribute::NoDuplicate))
289     return "noduplicate";
290   if (hasAttribute(Attribute::NoImplicitFloat))
291     return "noimplicitfloat";
292   if (hasAttribute(Attribute::NoInline))
293     return "noinline";
294   if (hasAttribute(Attribute::NonLazyBind))
295     return "nonlazybind";
296   if (hasAttribute(Attribute::NonNull))
297     return "nonnull";
298   if (hasAttribute(Attribute::NoRedZone))
299     return "noredzone";
300   if (hasAttribute(Attribute::NoReturn))
301     return "noreturn";
302   if (hasAttribute(Attribute::NoCfCheck))
303     return "nocf_check";
304   if (hasAttribute(Attribute::NoRecurse))
305     return "norecurse";
306   if (hasAttribute(Attribute::NoUnwind))
307     return "nounwind";
308   if (hasAttribute(Attribute::OptForFuzzing))
309     return "optforfuzzing";
310   if (hasAttribute(Attribute::OptimizeNone))
311     return "optnone";
312   if (hasAttribute(Attribute::OptimizeForSize))
313     return "optsize";
314   if (hasAttribute(Attribute::ReadNone))
315     return "readnone";
316   if (hasAttribute(Attribute::ReadOnly))
317     return "readonly";
318   if (hasAttribute(Attribute::WriteOnly))
319     return "writeonly";
320   if (hasAttribute(Attribute::Returned))
321     return "returned";
322   if (hasAttribute(Attribute::ReturnsTwice))
323     return "returns_twice";
324   if (hasAttribute(Attribute::SExt))
325     return "signext";
326   if (hasAttribute(Attribute::SpeculativeLoadHardening))
327     return "speculative_load_hardening";
328   if (hasAttribute(Attribute::Speculatable))
329     return "speculatable";
330   if (hasAttribute(Attribute::StackProtect))
331     return "ssp";
332   if (hasAttribute(Attribute::StackProtectReq))
333     return "sspreq";
334   if (hasAttribute(Attribute::StackProtectStrong))
335     return "sspstrong";
336   if (hasAttribute(Attribute::SafeStack))
337     return "safestack";
338   if (hasAttribute(Attribute::ShadowCallStack))
339     return "shadowcallstack";
340   if (hasAttribute(Attribute::StrictFP))
341     return "strictfp";
342   if (hasAttribute(Attribute::StructRet))
343     return "sret";
344   if (hasAttribute(Attribute::SanitizeThread))
345     return "sanitize_thread";
346   if (hasAttribute(Attribute::SanitizeMemory))
347     return "sanitize_memory";
348   if (hasAttribute(Attribute::UWTable))
349     return "uwtable";
350   if (hasAttribute(Attribute::ZExt))
351     return "zeroext";
352   if (hasAttribute(Attribute::Cold))
353     return "cold";
354 
355   // FIXME: These should be output like this:
356   //
357   //   align=4
358   //   alignstack=8
359   //
360   if (hasAttribute(Attribute::Alignment)) {
361     std::string Result;
362     Result += "align";
363     Result += (InAttrGrp) ? "=" : " ";
364     Result += utostr(getValueAsInt());
365     return Result;
366   }
367 
368   auto AttrWithBytesToString = [&](const char *Name) {
369     std::string Result;
370     Result += Name;
371     if (InAttrGrp) {
372       Result += "=";
373       Result += utostr(getValueAsInt());
374     } else {
375       Result += "(";
376       Result += utostr(getValueAsInt());
377       Result += ")";
378     }
379     return Result;
380   };
381 
382   if (hasAttribute(Attribute::StackAlignment))
383     return AttrWithBytesToString("alignstack");
384 
385   if (hasAttribute(Attribute::Dereferenceable))
386     return AttrWithBytesToString("dereferenceable");
387 
388   if (hasAttribute(Attribute::DereferenceableOrNull))
389     return AttrWithBytesToString("dereferenceable_or_null");
390 
391   if (hasAttribute(Attribute::AllocSize)) {
392     unsigned ElemSize;
393     Optional<unsigned> NumElems;
394     std::tie(ElemSize, NumElems) = getAllocSizeArgs();
395 
396     std::string Result = "allocsize(";
397     Result += utostr(ElemSize);
398     if (NumElems.hasValue()) {
399       Result += ',';
400       Result += utostr(*NumElems);
401     }
402     Result += ')';
403     return Result;
404   }
405 
406   // Convert target-dependent attributes to strings of the form:
407   //
408   //   "kind"
409   //   "kind" = "value"
410   //
411   if (isStringAttribute()) {
412     std::string Result;
413     Result += (Twine('"') + getKindAsString() + Twine('"')).str();
414 
415     std::string AttrVal = pImpl->getValueAsString();
416     if (AttrVal.empty()) return Result;
417 
418     // Since some attribute strings contain special characters that cannot be
419     // printable, those have to be escaped to make the attribute value printable
420     // as is.  e.g. "\01__gnu_mcount_nc"
421     {
422       raw_string_ostream OS(Result);
423       OS << "=\"";
424       printEscapedString(AttrVal, OS);
425       OS << "\"";
426     }
427     return Result;
428   }
429 
430   llvm_unreachable("Unknown attribute");
431 }
432 
433 bool Attribute::operator<(Attribute A) const {
434   if (!pImpl && !A.pImpl) return false;
435   if (!pImpl) return true;
436   if (!A.pImpl) return false;
437   return *pImpl < *A.pImpl;
438 }
439 
440 //===----------------------------------------------------------------------===//
441 // AttributeImpl Definition
442 //===----------------------------------------------------------------------===//
443 
444 // Pin the vtables to this file.
445 AttributeImpl::~AttributeImpl() = default;
446 
447 void EnumAttributeImpl::anchor() {}
448 
449 void IntAttributeImpl::anchor() {}
450 
451 void StringAttributeImpl::anchor() {}
452 
453 bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const {
454   if (isStringAttribute()) return false;
455   return getKindAsEnum() == A;
456 }
457 
458 bool AttributeImpl::hasAttribute(StringRef Kind) const {
459   if (!isStringAttribute()) return false;
460   return getKindAsString() == Kind;
461 }
462 
463 Attribute::AttrKind AttributeImpl::getKindAsEnum() const {
464   assert(isEnumAttribute() || isIntAttribute());
465   return static_cast<const EnumAttributeImpl *>(this)->getEnumKind();
466 }
467 
468 uint64_t AttributeImpl::getValueAsInt() const {
469   assert(isIntAttribute());
470   return static_cast<const IntAttributeImpl *>(this)->getValue();
471 }
472 
473 StringRef AttributeImpl::getKindAsString() const {
474   assert(isStringAttribute());
475   return static_cast<const StringAttributeImpl *>(this)->getStringKind();
476 }
477 
478 StringRef AttributeImpl::getValueAsString() const {
479   assert(isStringAttribute());
480   return static_cast<const StringAttributeImpl *>(this)->getStringValue();
481 }
482 
483 bool AttributeImpl::operator<(const AttributeImpl &AI) const {
484   // This sorts the attributes with Attribute::AttrKinds coming first (sorted
485   // relative to their enum value) and then strings.
486   if (isEnumAttribute()) {
487     if (AI.isEnumAttribute()) return getKindAsEnum() < AI.getKindAsEnum();
488     if (AI.isIntAttribute()) return true;
489     if (AI.isStringAttribute()) return true;
490   }
491 
492   if (isIntAttribute()) {
493     if (AI.isEnumAttribute()) return false;
494     if (AI.isIntAttribute()) {
495       if (getKindAsEnum() == AI.getKindAsEnum())
496         return getValueAsInt() < AI.getValueAsInt();
497       return getKindAsEnum() < AI.getKindAsEnum();
498     }
499     if (AI.isStringAttribute()) return true;
500   }
501 
502   if (AI.isEnumAttribute()) return false;
503   if (AI.isIntAttribute()) return false;
504   if (getKindAsString() == AI.getKindAsString())
505     return getValueAsString() < AI.getValueAsString();
506   return getKindAsString() < AI.getKindAsString();
507 }
508 
509 //===----------------------------------------------------------------------===//
510 // AttributeSet Definition
511 //===----------------------------------------------------------------------===//
512 
513 AttributeSet AttributeSet::get(LLVMContext &C, const AttrBuilder &B) {
514   return AttributeSet(AttributeSetNode::get(C, B));
515 }
516 
517 AttributeSet AttributeSet::get(LLVMContext &C, ArrayRef<Attribute> Attrs) {
518   return AttributeSet(AttributeSetNode::get(C, Attrs));
519 }
520 
521 AttributeSet AttributeSet::addAttribute(LLVMContext &C,
522                                         Attribute::AttrKind Kind) const {
523   if (hasAttribute(Kind)) return *this;
524   AttrBuilder B;
525   B.addAttribute(Kind);
526   return addAttributes(C, AttributeSet::get(C, B));
527 }
528 
529 AttributeSet AttributeSet::addAttribute(LLVMContext &C, StringRef Kind,
530                                         StringRef Value) const {
531   AttrBuilder B;
532   B.addAttribute(Kind, Value);
533   return addAttributes(C, AttributeSet::get(C, B));
534 }
535 
536 AttributeSet AttributeSet::addAttributes(LLVMContext &C,
537                                          const AttributeSet AS) const {
538   if (!hasAttributes())
539     return AS;
540 
541   if (!AS.hasAttributes())
542     return *this;
543 
544   AttrBuilder B(AS);
545   for (const auto I : *this)
546     B.addAttribute(I);
547 
548  return get(C, B);
549 }
550 
551 AttributeSet AttributeSet::removeAttribute(LLVMContext &C,
552                                              Attribute::AttrKind Kind) const {
553   if (!hasAttribute(Kind)) return *this;
554   AttrBuilder B(*this);
555   B.removeAttribute(Kind);
556   return get(C, B);
557 }
558 
559 AttributeSet AttributeSet::removeAttribute(LLVMContext &C,
560                                              StringRef Kind) const {
561   if (!hasAttribute(Kind)) return *this;
562   AttrBuilder B(*this);
563   B.removeAttribute(Kind);
564   return get(C, B);
565 }
566 
567 AttributeSet AttributeSet::removeAttributes(LLVMContext &C,
568                                               const AttrBuilder &Attrs) const {
569   AttrBuilder B(*this);
570   B.remove(Attrs);
571   return get(C, B);
572 }
573 
574 unsigned AttributeSet::getNumAttributes() const {
575   return SetNode ? SetNode->getNumAttributes() : 0;
576 }
577 
578 bool AttributeSet::hasAttribute(Attribute::AttrKind Kind) const {
579   return SetNode ? SetNode->hasAttribute(Kind) : false;
580 }
581 
582 bool AttributeSet::hasAttribute(StringRef Kind) const {
583   return SetNode ? SetNode->hasAttribute(Kind) : false;
584 }
585 
586 Attribute AttributeSet::getAttribute(Attribute::AttrKind Kind) const {
587   return SetNode ? SetNode->getAttribute(Kind) : Attribute();
588 }
589 
590 Attribute AttributeSet::getAttribute(StringRef Kind) const {
591   return SetNode ? SetNode->getAttribute(Kind) : Attribute();
592 }
593 
594 unsigned AttributeSet::getAlignment() const {
595   return SetNode ? SetNode->getAlignment() : 0;
596 }
597 
598 unsigned AttributeSet::getStackAlignment() const {
599   return SetNode ? SetNode->getStackAlignment() : 0;
600 }
601 
602 uint64_t AttributeSet::getDereferenceableBytes() const {
603   return SetNode ? SetNode->getDereferenceableBytes() : 0;
604 }
605 
606 uint64_t AttributeSet::getDereferenceableOrNullBytes() const {
607   return SetNode ? SetNode->getDereferenceableOrNullBytes() : 0;
608 }
609 
610 std::pair<unsigned, Optional<unsigned>> AttributeSet::getAllocSizeArgs() const {
611   return SetNode ? SetNode->getAllocSizeArgs()
612                  : std::pair<unsigned, Optional<unsigned>>(0, 0);
613 }
614 
615 std::string AttributeSet::getAsString(bool InAttrGrp) const {
616   return SetNode ? SetNode->getAsString(InAttrGrp) : "";
617 }
618 
619 AttributeSet::iterator AttributeSet::begin() const {
620   return SetNode ? SetNode->begin() : nullptr;
621 }
622 
623 AttributeSet::iterator AttributeSet::end() const {
624   return SetNode ? SetNode->end() : nullptr;
625 }
626 
627 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
628 LLVM_DUMP_METHOD void AttributeSet::dump() const {
629   dbgs() << "AS =\n";
630     dbgs() << "  { ";
631     dbgs() << getAsString(true) << " }\n";
632 }
633 #endif
634 
635 //===----------------------------------------------------------------------===//
636 // AttributeSetNode Definition
637 //===----------------------------------------------------------------------===//
638 
639 AttributeSetNode::AttributeSetNode(ArrayRef<Attribute> Attrs)
640     : AvailableAttrs(0), NumAttrs(Attrs.size()) {
641   // There's memory after the node where we can store the entries in.
642   llvm::copy(Attrs, getTrailingObjects<Attribute>());
643 
644   for (const auto I : *this) {
645     if (!I.isStringAttribute()) {
646       AvailableAttrs |= ((uint64_t)1) << I.getKindAsEnum();
647     }
648   }
649 }
650 
651 AttributeSetNode *AttributeSetNode::get(LLVMContext &C,
652                                         ArrayRef<Attribute> Attrs) {
653   if (Attrs.empty())
654     return nullptr;
655 
656   // Otherwise, build a key to look up the existing attributes.
657   LLVMContextImpl *pImpl = C.pImpl;
658   FoldingSetNodeID ID;
659 
660   SmallVector<Attribute, 8> SortedAttrs(Attrs.begin(), Attrs.end());
661   llvm::sort(SortedAttrs);
662 
663   for (const auto Attr : SortedAttrs)
664     Attr.Profile(ID);
665 
666   void *InsertPoint;
667   AttributeSetNode *PA =
668     pImpl->AttrsSetNodes.FindNodeOrInsertPos(ID, InsertPoint);
669 
670   // If we didn't find any existing attributes of the same shape then create a
671   // new one and insert it.
672   if (!PA) {
673     // Coallocate entries after the AttributeSetNode itself.
674     void *Mem = ::operator new(totalSizeToAlloc<Attribute>(SortedAttrs.size()));
675     PA = new (Mem) AttributeSetNode(SortedAttrs);
676     pImpl->AttrsSetNodes.InsertNode(PA, InsertPoint);
677   }
678 
679   // Return the AttributeSetNode that we found or created.
680   return PA;
681 }
682 
683 AttributeSetNode *AttributeSetNode::get(LLVMContext &C, const AttrBuilder &B) {
684   // Add target-independent attributes.
685   SmallVector<Attribute, 8> Attrs;
686   for (Attribute::AttrKind Kind = Attribute::None;
687        Kind != Attribute::EndAttrKinds; Kind = Attribute::AttrKind(Kind + 1)) {
688     if (!B.contains(Kind))
689       continue;
690 
691     Attribute Attr;
692     switch (Kind) {
693     case Attribute::Alignment:
694       Attr = Attribute::getWithAlignment(C, B.getAlignment());
695       break;
696     case Attribute::StackAlignment:
697       Attr = Attribute::getWithStackAlignment(C, B.getStackAlignment());
698       break;
699     case Attribute::Dereferenceable:
700       Attr = Attribute::getWithDereferenceableBytes(
701           C, B.getDereferenceableBytes());
702       break;
703     case Attribute::DereferenceableOrNull:
704       Attr = Attribute::getWithDereferenceableOrNullBytes(
705           C, B.getDereferenceableOrNullBytes());
706       break;
707     case Attribute::AllocSize: {
708       auto A = B.getAllocSizeArgs();
709       Attr = Attribute::getWithAllocSizeArgs(C, A.first, A.second);
710       break;
711     }
712     default:
713       Attr = Attribute::get(C, Kind);
714     }
715     Attrs.push_back(Attr);
716   }
717 
718   // Add target-dependent (string) attributes.
719   for (const auto &TDA : B.td_attrs())
720     Attrs.emplace_back(Attribute::get(C, TDA.first, TDA.second));
721 
722   return get(C, Attrs);
723 }
724 
725 bool AttributeSetNode::hasAttribute(StringRef Kind) const {
726   for (const auto I : *this)
727     if (I.hasAttribute(Kind))
728       return true;
729   return false;
730 }
731 
732 Attribute AttributeSetNode::getAttribute(Attribute::AttrKind Kind) const {
733   if (hasAttribute(Kind)) {
734     for (const auto I : *this)
735       if (I.hasAttribute(Kind))
736         return I;
737   }
738   return {};
739 }
740 
741 Attribute AttributeSetNode::getAttribute(StringRef Kind) const {
742   for (const auto I : *this)
743     if (I.hasAttribute(Kind))
744       return I;
745   return {};
746 }
747 
748 unsigned AttributeSetNode::getAlignment() const {
749   for (const auto I : *this)
750     if (I.hasAttribute(Attribute::Alignment))
751       return I.getAlignment();
752   return 0;
753 }
754 
755 unsigned AttributeSetNode::getStackAlignment() const {
756   for (const auto I : *this)
757     if (I.hasAttribute(Attribute::StackAlignment))
758       return I.getStackAlignment();
759   return 0;
760 }
761 
762 uint64_t AttributeSetNode::getDereferenceableBytes() const {
763   for (const auto I : *this)
764     if (I.hasAttribute(Attribute::Dereferenceable))
765       return I.getDereferenceableBytes();
766   return 0;
767 }
768 
769 uint64_t AttributeSetNode::getDereferenceableOrNullBytes() const {
770   for (const auto I : *this)
771     if (I.hasAttribute(Attribute::DereferenceableOrNull))
772       return I.getDereferenceableOrNullBytes();
773   return 0;
774 }
775 
776 std::pair<unsigned, Optional<unsigned>>
777 AttributeSetNode::getAllocSizeArgs() const {
778   for (const auto I : *this)
779     if (I.hasAttribute(Attribute::AllocSize))
780       return I.getAllocSizeArgs();
781   return std::make_pair(0, 0);
782 }
783 
784 std::string AttributeSetNode::getAsString(bool InAttrGrp) const {
785   std::string Str;
786   for (iterator I = begin(), E = end(); I != E; ++I) {
787     if (I != begin())
788       Str += ' ';
789     Str += I->getAsString(InAttrGrp);
790   }
791   return Str;
792 }
793 
794 //===----------------------------------------------------------------------===//
795 // AttributeListImpl Definition
796 //===----------------------------------------------------------------------===//
797 
798 /// Map from AttributeList index to the internal array index. Adding one happens
799 /// to work, but it relies on unsigned integer wrapping. MSVC warns about
800 /// unsigned wrapping in constexpr functions, so write out the conditional. LLVM
801 /// folds it to add anyway.
802 static constexpr unsigned attrIdxToArrayIdx(unsigned Index) {
803   return Index == AttributeList::FunctionIndex ? 0 : Index + 1;
804 }
805 
806 AttributeListImpl::AttributeListImpl(LLVMContext &C,
807                                      ArrayRef<AttributeSet> Sets)
808     : AvailableFunctionAttrs(0), Context(C), NumAttrSets(Sets.size()) {
809   assert(!Sets.empty() && "pointless AttributeListImpl");
810 
811   // There's memory after the node where we can store the entries in.
812   llvm::copy(Sets, getTrailingObjects<AttributeSet>());
813 
814   // Initialize AvailableFunctionAttrs summary bitset.
815   static_assert(Attribute::EndAttrKinds <=
816                     sizeof(AvailableFunctionAttrs) * CHAR_BIT,
817                 "Too many attributes");
818   static_assert(attrIdxToArrayIdx(AttributeList::FunctionIndex) == 0U,
819                 "function should be stored in slot 0");
820   for (const auto I : Sets[0]) {
821     if (!I.isStringAttribute())
822       AvailableFunctionAttrs |= 1ULL << I.getKindAsEnum();
823   }
824 }
825 
826 void AttributeListImpl::Profile(FoldingSetNodeID &ID) const {
827   Profile(ID, makeArrayRef(begin(), end()));
828 }
829 
830 void AttributeListImpl::Profile(FoldingSetNodeID &ID,
831                                 ArrayRef<AttributeSet> Sets) {
832   for (const auto &Set : Sets)
833     ID.AddPointer(Set.SetNode);
834 }
835 
836 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
837 LLVM_DUMP_METHOD void AttributeListImpl::dump() const {
838   AttributeList(const_cast<AttributeListImpl *>(this)).dump();
839 }
840 #endif
841 
842 //===----------------------------------------------------------------------===//
843 // AttributeList Construction and Mutation Methods
844 //===----------------------------------------------------------------------===//
845 
846 AttributeList AttributeList::getImpl(LLVMContext &C,
847                                      ArrayRef<AttributeSet> AttrSets) {
848   assert(!AttrSets.empty() && "pointless AttributeListImpl");
849 
850   LLVMContextImpl *pImpl = C.pImpl;
851   FoldingSetNodeID ID;
852   AttributeListImpl::Profile(ID, AttrSets);
853 
854   void *InsertPoint;
855   AttributeListImpl *PA =
856       pImpl->AttrsLists.FindNodeOrInsertPos(ID, InsertPoint);
857 
858   // If we didn't find any existing attributes of the same shape then
859   // create a new one and insert it.
860   if (!PA) {
861     // Coallocate entries after the AttributeListImpl itself.
862     void *Mem = ::operator new(
863         AttributeListImpl::totalSizeToAlloc<AttributeSet>(AttrSets.size()));
864     PA = new (Mem) AttributeListImpl(C, AttrSets);
865     pImpl->AttrsLists.InsertNode(PA, InsertPoint);
866   }
867 
868   // Return the AttributesList that we found or created.
869   return AttributeList(PA);
870 }
871 
872 AttributeList
873 AttributeList::get(LLVMContext &C,
874                    ArrayRef<std::pair<unsigned, Attribute>> Attrs) {
875   // If there are no attributes then return a null AttributesList pointer.
876   if (Attrs.empty())
877     return {};
878 
879   assert(std::is_sorted(Attrs.begin(), Attrs.end(),
880                         [](const std::pair<unsigned, Attribute> &LHS,
881                            const std::pair<unsigned, Attribute> &RHS) {
882                           return LHS.first < RHS.first;
883                         }) && "Misordered Attributes list!");
884   assert(llvm::none_of(Attrs,
885                        [](const std::pair<unsigned, Attribute> &Pair) {
886                          return Pair.second.hasAttribute(Attribute::None);
887                        }) &&
888          "Pointless attribute!");
889 
890   // Create a vector if (unsigned, AttributeSetNode*) pairs from the attributes
891   // list.
892   SmallVector<std::pair<unsigned, AttributeSet>, 8> AttrPairVec;
893   for (ArrayRef<std::pair<unsigned, Attribute>>::iterator I = Attrs.begin(),
894          E = Attrs.end(); I != E; ) {
895     unsigned Index = I->first;
896     SmallVector<Attribute, 4> AttrVec;
897     while (I != E && I->first == Index) {
898       AttrVec.push_back(I->second);
899       ++I;
900     }
901 
902     AttrPairVec.emplace_back(Index, AttributeSet::get(C, AttrVec));
903   }
904 
905   return get(C, AttrPairVec);
906 }
907 
908 AttributeList
909 AttributeList::get(LLVMContext &C,
910                    ArrayRef<std::pair<unsigned, AttributeSet>> Attrs) {
911   // If there are no attributes then return a null AttributesList pointer.
912   if (Attrs.empty())
913     return {};
914 
915   assert(std::is_sorted(Attrs.begin(), Attrs.end(),
916                         [](const std::pair<unsigned, AttributeSet> &LHS,
917                            const std::pair<unsigned, AttributeSet> &RHS) {
918                           return LHS.first < RHS.first;
919                         }) &&
920          "Misordered Attributes list!");
921   assert(llvm::none_of(Attrs,
922                        [](const std::pair<unsigned, AttributeSet> &Pair) {
923                          return !Pair.second.hasAttributes();
924                        }) &&
925          "Pointless attribute!");
926 
927   unsigned MaxIndex = Attrs.back().first;
928   // If the MaxIndex is FunctionIndex and there are other indices in front
929   // of it, we need to use the largest of those to get the right size.
930   if (MaxIndex == FunctionIndex && Attrs.size() > 1)
931     MaxIndex = Attrs[Attrs.size() - 2].first;
932 
933   SmallVector<AttributeSet, 4> AttrVec(attrIdxToArrayIdx(MaxIndex) + 1);
934   for (const auto Pair : Attrs)
935     AttrVec[attrIdxToArrayIdx(Pair.first)] = Pair.second;
936 
937   return getImpl(C, AttrVec);
938 }
939 
940 AttributeList AttributeList::get(LLVMContext &C, AttributeSet FnAttrs,
941                                  AttributeSet RetAttrs,
942                                  ArrayRef<AttributeSet> ArgAttrs) {
943   // Scan from the end to find the last argument with attributes.  Most
944   // arguments don't have attributes, so it's nice if we can have fewer unique
945   // AttributeListImpls by dropping empty attribute sets at the end of the list.
946   unsigned NumSets = 0;
947   for (size_t I = ArgAttrs.size(); I != 0; --I) {
948     if (ArgAttrs[I - 1].hasAttributes()) {
949       NumSets = I + 2;
950       break;
951     }
952   }
953   if (NumSets == 0) {
954     // Check function and return attributes if we didn't have argument
955     // attributes.
956     if (RetAttrs.hasAttributes())
957       NumSets = 2;
958     else if (FnAttrs.hasAttributes())
959       NumSets = 1;
960   }
961 
962   // If all attribute sets were empty, we can use the empty attribute list.
963   if (NumSets == 0)
964     return {};
965 
966   SmallVector<AttributeSet, 8> AttrSets;
967   AttrSets.reserve(NumSets);
968   // If we have any attributes, we always have function attributes.
969   AttrSets.push_back(FnAttrs);
970   if (NumSets > 1)
971     AttrSets.push_back(RetAttrs);
972   if (NumSets > 2) {
973     // Drop the empty argument attribute sets at the end.
974     ArgAttrs = ArgAttrs.take_front(NumSets - 2);
975     AttrSets.insert(AttrSets.end(), ArgAttrs.begin(), ArgAttrs.end());
976   }
977 
978   return getImpl(C, AttrSets);
979 }
980 
981 AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
982                                  const AttrBuilder &B) {
983   if (!B.hasAttributes())
984     return {};
985   Index = attrIdxToArrayIdx(Index);
986   SmallVector<AttributeSet, 8> AttrSets(Index + 1);
987   AttrSets[Index] = AttributeSet::get(C, B);
988   return getImpl(C, AttrSets);
989 }
990 
991 AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
992                                  ArrayRef<Attribute::AttrKind> Kinds) {
993   SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
994   for (const auto K : Kinds)
995     Attrs.emplace_back(Index, Attribute::get(C, K));
996   return get(C, Attrs);
997 }
998 
999 AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
1000                                  ArrayRef<StringRef> Kinds) {
1001   SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
1002   for (const auto K : Kinds)
1003     Attrs.emplace_back(Index, Attribute::get(C, K));
1004   return get(C, Attrs);
1005 }
1006 
1007 AttributeList AttributeList::get(LLVMContext &C,
1008                                  ArrayRef<AttributeList> Attrs) {
1009   if (Attrs.empty())
1010     return {};
1011   if (Attrs.size() == 1)
1012     return Attrs[0];
1013 
1014   unsigned MaxSize = 0;
1015   for (const auto List : Attrs)
1016     MaxSize = std::max(MaxSize, List.getNumAttrSets());
1017 
1018   // If every list was empty, there is no point in merging the lists.
1019   if (MaxSize == 0)
1020     return {};
1021 
1022   SmallVector<AttributeSet, 8> NewAttrSets(MaxSize);
1023   for (unsigned I = 0; I < MaxSize; ++I) {
1024     AttrBuilder CurBuilder;
1025     for (const auto List : Attrs)
1026       CurBuilder.merge(List.getAttributes(I - 1));
1027     NewAttrSets[I] = AttributeSet::get(C, CurBuilder);
1028   }
1029 
1030   return getImpl(C, NewAttrSets);
1031 }
1032 
1033 AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index,
1034                                           Attribute::AttrKind Kind) const {
1035   if (hasAttribute(Index, Kind)) return *this;
1036   AttrBuilder B;
1037   B.addAttribute(Kind);
1038   return addAttributes(C, Index, B);
1039 }
1040 
1041 AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index,
1042                                           StringRef Kind,
1043                                           StringRef Value) const {
1044   AttrBuilder B;
1045   B.addAttribute(Kind, Value);
1046   return addAttributes(C, Index, B);
1047 }
1048 
1049 AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index,
1050                                           Attribute A) const {
1051   AttrBuilder B;
1052   B.addAttribute(A);
1053   return addAttributes(C, Index, B);
1054 }
1055 
1056 AttributeList AttributeList::addAttributes(LLVMContext &C, unsigned Index,
1057                                            const AttrBuilder &B) const {
1058   if (!B.hasAttributes())
1059     return *this;
1060 
1061   if (!pImpl)
1062     return AttributeList::get(C, {{Index, AttributeSet::get(C, B)}});
1063 
1064 #ifndef NDEBUG
1065   // FIXME it is not obvious how this should work for alignment. For now, say
1066   // we can't change a known alignment.
1067   unsigned OldAlign = getAttributes(Index).getAlignment();
1068   unsigned NewAlign = B.getAlignment();
1069   assert((!OldAlign || !NewAlign || OldAlign == NewAlign) &&
1070          "Attempt to change alignment!");
1071 #endif
1072 
1073   Index = attrIdxToArrayIdx(Index);
1074   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
1075   if (Index >= AttrSets.size())
1076     AttrSets.resize(Index + 1);
1077 
1078   AttrBuilder Merged(AttrSets[Index]);
1079   Merged.merge(B);
1080   AttrSets[Index] = AttributeSet::get(C, Merged);
1081 
1082   return getImpl(C, AttrSets);
1083 }
1084 
1085 AttributeList AttributeList::addParamAttribute(LLVMContext &C,
1086                                                ArrayRef<unsigned> ArgNos,
1087                                                Attribute A) const {
1088   assert(std::is_sorted(ArgNos.begin(), ArgNos.end()));
1089 
1090   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
1091   unsigned MaxIndex = attrIdxToArrayIdx(ArgNos.back() + FirstArgIndex);
1092   if (MaxIndex >= AttrSets.size())
1093     AttrSets.resize(MaxIndex + 1);
1094 
1095   for (unsigned ArgNo : ArgNos) {
1096     unsigned Index = attrIdxToArrayIdx(ArgNo + FirstArgIndex);
1097     AttrBuilder B(AttrSets[Index]);
1098     B.addAttribute(A);
1099     AttrSets[Index] = AttributeSet::get(C, B);
1100   }
1101 
1102   return getImpl(C, AttrSets);
1103 }
1104 
1105 AttributeList AttributeList::removeAttribute(LLVMContext &C, unsigned Index,
1106                                              Attribute::AttrKind Kind) const {
1107   if (!hasAttribute(Index, Kind)) return *this;
1108 
1109   Index = attrIdxToArrayIdx(Index);
1110   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
1111   assert(Index < AttrSets.size());
1112 
1113   AttrSets[Index] = AttrSets[Index].removeAttribute(C, Kind);
1114 
1115   return getImpl(C, AttrSets);
1116 }
1117 
1118 AttributeList AttributeList::removeAttribute(LLVMContext &C, unsigned Index,
1119                                              StringRef Kind) const {
1120   if (!hasAttribute(Index, Kind)) return *this;
1121 
1122   Index = attrIdxToArrayIdx(Index);
1123   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
1124   assert(Index < AttrSets.size());
1125 
1126   AttrSets[Index] = AttrSets[Index].removeAttribute(C, Kind);
1127 
1128   return getImpl(C, AttrSets);
1129 }
1130 
1131 AttributeList
1132 AttributeList::removeAttributes(LLVMContext &C, unsigned Index,
1133                                 const AttrBuilder &AttrsToRemove) const {
1134   if (!pImpl)
1135     return {};
1136 
1137   Index = attrIdxToArrayIdx(Index);
1138   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
1139   if (Index >= AttrSets.size())
1140     AttrSets.resize(Index + 1);
1141 
1142   AttrSets[Index] = AttrSets[Index].removeAttributes(C, AttrsToRemove);
1143 
1144   return getImpl(C, AttrSets);
1145 }
1146 
1147 AttributeList AttributeList::removeAttributes(LLVMContext &C,
1148                                               unsigned WithoutIndex) const {
1149   if (!pImpl)
1150     return {};
1151   WithoutIndex = attrIdxToArrayIdx(WithoutIndex);
1152   if (WithoutIndex >= getNumAttrSets())
1153     return *this;
1154   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
1155   AttrSets[WithoutIndex] = AttributeSet();
1156   return getImpl(C, AttrSets);
1157 }
1158 
1159 AttributeList AttributeList::addDereferenceableAttr(LLVMContext &C,
1160                                                     unsigned Index,
1161                                                     uint64_t Bytes) const {
1162   AttrBuilder B;
1163   B.addDereferenceableAttr(Bytes);
1164   return addAttributes(C, Index, B);
1165 }
1166 
1167 AttributeList
1168 AttributeList::addDereferenceableOrNullAttr(LLVMContext &C, unsigned Index,
1169                                             uint64_t Bytes) const {
1170   AttrBuilder B;
1171   B.addDereferenceableOrNullAttr(Bytes);
1172   return addAttributes(C, Index, B);
1173 }
1174 
1175 AttributeList
1176 AttributeList::addAllocSizeAttr(LLVMContext &C, unsigned Index,
1177                                 unsigned ElemSizeArg,
1178                                 const Optional<unsigned> &NumElemsArg) {
1179   AttrBuilder B;
1180   B.addAllocSizeAttr(ElemSizeArg, NumElemsArg);
1181   return addAttributes(C, Index, B);
1182 }
1183 
1184 //===----------------------------------------------------------------------===//
1185 // AttributeList Accessor Methods
1186 //===----------------------------------------------------------------------===//
1187 
1188 LLVMContext &AttributeList::getContext() const { return pImpl->getContext(); }
1189 
1190 AttributeSet AttributeList::getParamAttributes(unsigned ArgNo) const {
1191   return getAttributes(ArgNo + FirstArgIndex);
1192 }
1193 
1194 AttributeSet AttributeList::getRetAttributes() const {
1195   return getAttributes(ReturnIndex);
1196 }
1197 
1198 AttributeSet AttributeList::getFnAttributes() const {
1199   return getAttributes(FunctionIndex);
1200 }
1201 
1202 bool AttributeList::hasAttribute(unsigned Index,
1203                                  Attribute::AttrKind Kind) const {
1204   return getAttributes(Index).hasAttribute(Kind);
1205 }
1206 
1207 bool AttributeList::hasAttribute(unsigned Index, StringRef Kind) const {
1208   return getAttributes(Index).hasAttribute(Kind);
1209 }
1210 
1211 bool AttributeList::hasAttributes(unsigned Index) const {
1212   return getAttributes(Index).hasAttributes();
1213 }
1214 
1215 bool AttributeList::hasFnAttribute(Attribute::AttrKind Kind) const {
1216   return pImpl && pImpl->hasFnAttribute(Kind);
1217 }
1218 
1219 bool AttributeList::hasFnAttribute(StringRef Kind) const {
1220   return hasAttribute(AttributeList::FunctionIndex, Kind);
1221 }
1222 
1223 bool AttributeList::hasParamAttribute(unsigned ArgNo,
1224                                       Attribute::AttrKind Kind) const {
1225   return hasAttribute(ArgNo + FirstArgIndex, Kind);
1226 }
1227 
1228 bool AttributeList::hasAttrSomewhere(Attribute::AttrKind Attr,
1229                                      unsigned *Index) const {
1230   if (!pImpl) return false;
1231 
1232   for (unsigned I = index_begin(), E = index_end(); I != E; ++I) {
1233     if (hasAttribute(I, Attr)) {
1234       if (Index)
1235         *Index = I;
1236       return true;
1237     }
1238   }
1239 
1240   return false;
1241 }
1242 
1243 Attribute AttributeList::getAttribute(unsigned Index,
1244                                       Attribute::AttrKind Kind) const {
1245   return getAttributes(Index).getAttribute(Kind);
1246 }
1247 
1248 Attribute AttributeList::getAttribute(unsigned Index, StringRef Kind) const {
1249   return getAttributes(Index).getAttribute(Kind);
1250 }
1251 
1252 unsigned AttributeList::getRetAlignment() const {
1253   return getAttributes(ReturnIndex).getAlignment();
1254 }
1255 
1256 unsigned AttributeList::getParamAlignment(unsigned ArgNo) const {
1257   return getAttributes(ArgNo + FirstArgIndex).getAlignment();
1258 }
1259 
1260 unsigned AttributeList::getStackAlignment(unsigned Index) const {
1261   return getAttributes(Index).getStackAlignment();
1262 }
1263 
1264 uint64_t AttributeList::getDereferenceableBytes(unsigned Index) const {
1265   return getAttributes(Index).getDereferenceableBytes();
1266 }
1267 
1268 uint64_t AttributeList::getDereferenceableOrNullBytes(unsigned Index) const {
1269   return getAttributes(Index).getDereferenceableOrNullBytes();
1270 }
1271 
1272 std::pair<unsigned, Optional<unsigned>>
1273 AttributeList::getAllocSizeArgs(unsigned Index) const {
1274   return getAttributes(Index).getAllocSizeArgs();
1275 }
1276 
1277 std::string AttributeList::getAsString(unsigned Index, bool InAttrGrp) const {
1278   return getAttributes(Index).getAsString(InAttrGrp);
1279 }
1280 
1281 AttributeSet AttributeList::getAttributes(unsigned Index) const {
1282   Index = attrIdxToArrayIdx(Index);
1283   if (!pImpl || Index >= getNumAttrSets())
1284     return {};
1285   return pImpl->begin()[Index];
1286 }
1287 
1288 AttributeList::iterator AttributeList::begin() const {
1289   return pImpl ? pImpl->begin() : nullptr;
1290 }
1291 
1292 AttributeList::iterator AttributeList::end() const {
1293   return pImpl ? pImpl->end() : nullptr;
1294 }
1295 
1296 //===----------------------------------------------------------------------===//
1297 // AttributeList Introspection Methods
1298 //===----------------------------------------------------------------------===//
1299 
1300 unsigned AttributeList::getNumAttrSets() const {
1301   return pImpl ? pImpl->NumAttrSets : 0;
1302 }
1303 
1304 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1305 LLVM_DUMP_METHOD void AttributeList::dump() const {
1306   dbgs() << "PAL[\n";
1307 
1308   for (unsigned i = index_begin(), e = index_end(); i != e; ++i) {
1309     if (getAttributes(i).hasAttributes())
1310       dbgs() << "  { " << i << " => " << getAsString(i) << " }\n";
1311   }
1312 
1313   dbgs() << "]\n";
1314 }
1315 #endif
1316 
1317 //===----------------------------------------------------------------------===//
1318 // AttrBuilder Method Implementations
1319 //===----------------------------------------------------------------------===//
1320 
1321 // FIXME: Remove this ctor, use AttributeSet.
1322 AttrBuilder::AttrBuilder(AttributeList AL, unsigned Index) {
1323   AttributeSet AS = AL.getAttributes(Index);
1324   for (const auto &A : AS)
1325     addAttribute(A);
1326 }
1327 
1328 AttrBuilder::AttrBuilder(AttributeSet AS) {
1329   for (const auto &A : AS)
1330     addAttribute(A);
1331 }
1332 
1333 void AttrBuilder::clear() {
1334   Attrs.reset();
1335   TargetDepAttrs.clear();
1336   Alignment = StackAlignment = DerefBytes = DerefOrNullBytes = 0;
1337   AllocSizeArgs = 0;
1338 }
1339 
1340 AttrBuilder &AttrBuilder::addAttribute(Attribute::AttrKind Val) {
1341   assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
1342   assert(Val != Attribute::Alignment && Val != Attribute::StackAlignment &&
1343          Val != Attribute::Dereferenceable && Val != Attribute::AllocSize &&
1344          "Adding integer attribute without adding a value!");
1345   Attrs[Val] = true;
1346   return *this;
1347 }
1348 
1349 AttrBuilder &AttrBuilder::addAttribute(Attribute Attr) {
1350   if (Attr.isStringAttribute()) {
1351     addAttribute(Attr.getKindAsString(), Attr.getValueAsString());
1352     return *this;
1353   }
1354 
1355   Attribute::AttrKind Kind = Attr.getKindAsEnum();
1356   Attrs[Kind] = true;
1357 
1358   if (Kind == Attribute::Alignment)
1359     Alignment = Attr.getAlignment();
1360   else if (Kind == Attribute::StackAlignment)
1361     StackAlignment = Attr.getStackAlignment();
1362   else if (Kind == Attribute::Dereferenceable)
1363     DerefBytes = Attr.getDereferenceableBytes();
1364   else if (Kind == Attribute::DereferenceableOrNull)
1365     DerefOrNullBytes = Attr.getDereferenceableOrNullBytes();
1366   else if (Kind == Attribute::AllocSize)
1367     AllocSizeArgs = Attr.getValueAsInt();
1368   return *this;
1369 }
1370 
1371 AttrBuilder &AttrBuilder::addAttribute(StringRef A, StringRef V) {
1372   TargetDepAttrs[A] = V;
1373   return *this;
1374 }
1375 
1376 AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) {
1377   assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
1378   Attrs[Val] = false;
1379 
1380   if (Val == Attribute::Alignment)
1381     Alignment = 0;
1382   else if (Val == Attribute::StackAlignment)
1383     StackAlignment = 0;
1384   else if (Val == Attribute::Dereferenceable)
1385     DerefBytes = 0;
1386   else if (Val == Attribute::DereferenceableOrNull)
1387     DerefOrNullBytes = 0;
1388   else if (Val == Attribute::AllocSize)
1389     AllocSizeArgs = 0;
1390 
1391   return *this;
1392 }
1393 
1394 AttrBuilder &AttrBuilder::removeAttributes(AttributeList A, uint64_t Index) {
1395   remove(A.getAttributes(Index));
1396   return *this;
1397 }
1398 
1399 AttrBuilder &AttrBuilder::removeAttribute(StringRef A) {
1400   auto I = TargetDepAttrs.find(A);
1401   if (I != TargetDepAttrs.end())
1402     TargetDepAttrs.erase(I);
1403   return *this;
1404 }
1405 
1406 std::pair<unsigned, Optional<unsigned>> AttrBuilder::getAllocSizeArgs() const {
1407   return unpackAllocSizeArgs(AllocSizeArgs);
1408 }
1409 
1410 AttrBuilder &AttrBuilder::addAlignmentAttr(unsigned Align) {
1411   if (Align == 0) return *this;
1412 
1413   assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
1414   assert(Align <= 0x40000000 && "Alignment too large.");
1415 
1416   Attrs[Attribute::Alignment] = true;
1417   Alignment = Align;
1418   return *this;
1419 }
1420 
1421 AttrBuilder &AttrBuilder::addStackAlignmentAttr(unsigned Align) {
1422   // Default alignment, allow the target to define how to align it.
1423   if (Align == 0) return *this;
1424 
1425   assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
1426   assert(Align <= 0x100 && "Alignment too large.");
1427 
1428   Attrs[Attribute::StackAlignment] = true;
1429   StackAlignment = Align;
1430   return *this;
1431 }
1432 
1433 AttrBuilder &AttrBuilder::addDereferenceableAttr(uint64_t Bytes) {
1434   if (Bytes == 0) return *this;
1435 
1436   Attrs[Attribute::Dereferenceable] = true;
1437   DerefBytes = Bytes;
1438   return *this;
1439 }
1440 
1441 AttrBuilder &AttrBuilder::addDereferenceableOrNullAttr(uint64_t Bytes) {
1442   if (Bytes == 0)
1443     return *this;
1444 
1445   Attrs[Attribute::DereferenceableOrNull] = true;
1446   DerefOrNullBytes = Bytes;
1447   return *this;
1448 }
1449 
1450 AttrBuilder &AttrBuilder::addAllocSizeAttr(unsigned ElemSize,
1451                                            const Optional<unsigned> &NumElems) {
1452   return addAllocSizeAttrFromRawRepr(packAllocSizeArgs(ElemSize, NumElems));
1453 }
1454 
1455 AttrBuilder &AttrBuilder::addAllocSizeAttrFromRawRepr(uint64_t RawArgs) {
1456   // (0, 0) is our "not present" value, so we need to check for it here.
1457   assert(RawArgs && "Invalid allocsize arguments -- given allocsize(0, 0)");
1458 
1459   Attrs[Attribute::AllocSize] = true;
1460   // Reuse existing machinery to store this as a single 64-bit integer so we can
1461   // save a few bytes over using a pair<unsigned, Optional<unsigned>>.
1462   AllocSizeArgs = RawArgs;
1463   return *this;
1464 }
1465 
1466 AttrBuilder &AttrBuilder::merge(const AttrBuilder &B) {
1467   // FIXME: What if both have alignments, but they don't match?!
1468   if (!Alignment)
1469     Alignment = B.Alignment;
1470 
1471   if (!StackAlignment)
1472     StackAlignment = B.StackAlignment;
1473 
1474   if (!DerefBytes)
1475     DerefBytes = B.DerefBytes;
1476 
1477   if (!DerefOrNullBytes)
1478     DerefOrNullBytes = B.DerefOrNullBytes;
1479 
1480   if (!AllocSizeArgs)
1481     AllocSizeArgs = B.AllocSizeArgs;
1482 
1483   Attrs |= B.Attrs;
1484 
1485   for (auto I : B.td_attrs())
1486     TargetDepAttrs[I.first] = I.second;
1487 
1488   return *this;
1489 }
1490 
1491 AttrBuilder &AttrBuilder::remove(const AttrBuilder &B) {
1492   // FIXME: What if both have alignments, but they don't match?!
1493   if (B.Alignment)
1494     Alignment = 0;
1495 
1496   if (B.StackAlignment)
1497     StackAlignment = 0;
1498 
1499   if (B.DerefBytes)
1500     DerefBytes = 0;
1501 
1502   if (B.DerefOrNullBytes)
1503     DerefOrNullBytes = 0;
1504 
1505   if (B.AllocSizeArgs)
1506     AllocSizeArgs = 0;
1507 
1508   Attrs &= ~B.Attrs;
1509 
1510   for (auto I : B.td_attrs())
1511     TargetDepAttrs.erase(I.first);
1512 
1513   return *this;
1514 }
1515 
1516 bool AttrBuilder::overlaps(const AttrBuilder &B) const {
1517   // First check if any of the target independent attributes overlap.
1518   if ((Attrs & B.Attrs).any())
1519     return true;
1520 
1521   // Then check if any target dependent ones do.
1522   for (const auto &I : td_attrs())
1523     if (B.contains(I.first))
1524       return true;
1525 
1526   return false;
1527 }
1528 
1529 bool AttrBuilder::contains(StringRef A) const {
1530   return TargetDepAttrs.find(A) != TargetDepAttrs.end();
1531 }
1532 
1533 bool AttrBuilder::hasAttributes() const {
1534   return !Attrs.none() || !TargetDepAttrs.empty();
1535 }
1536 
1537 bool AttrBuilder::hasAttributes(AttributeList AL, uint64_t Index) const {
1538   AttributeSet AS = AL.getAttributes(Index);
1539 
1540   for (const auto Attr : AS) {
1541     if (Attr.isEnumAttribute() || Attr.isIntAttribute()) {
1542       if (contains(Attr.getKindAsEnum()))
1543         return true;
1544     } else {
1545       assert(Attr.isStringAttribute() && "Invalid attribute kind!");
1546       return contains(Attr.getKindAsString());
1547     }
1548   }
1549 
1550   return false;
1551 }
1552 
1553 bool AttrBuilder::hasAlignmentAttr() const {
1554   return Alignment != 0;
1555 }
1556 
1557 bool AttrBuilder::operator==(const AttrBuilder &B) {
1558   if (Attrs != B.Attrs)
1559     return false;
1560 
1561   for (td_const_iterator I = TargetDepAttrs.begin(),
1562          E = TargetDepAttrs.end(); I != E; ++I)
1563     if (B.TargetDepAttrs.find(I->first) == B.TargetDepAttrs.end())
1564       return false;
1565 
1566   return Alignment == B.Alignment && StackAlignment == B.StackAlignment &&
1567          DerefBytes == B.DerefBytes;
1568 }
1569 
1570 //===----------------------------------------------------------------------===//
1571 // AttributeFuncs Function Defintions
1572 //===----------------------------------------------------------------------===//
1573 
1574 /// Which attributes cannot be applied to a type.
1575 AttrBuilder AttributeFuncs::typeIncompatible(Type *Ty) {
1576   AttrBuilder Incompatible;
1577 
1578   if (!Ty->isIntegerTy())
1579     // Attribute that only apply to integers.
1580     Incompatible.addAttribute(Attribute::SExt)
1581       .addAttribute(Attribute::ZExt);
1582 
1583   if (!Ty->isPointerTy())
1584     // Attribute that only apply to pointers.
1585     Incompatible.addAttribute(Attribute::ByVal)
1586       .addAttribute(Attribute::Nest)
1587       .addAttribute(Attribute::NoAlias)
1588       .addAttribute(Attribute::NoCapture)
1589       .addAttribute(Attribute::NonNull)
1590       .addDereferenceableAttr(1) // the int here is ignored
1591       .addDereferenceableOrNullAttr(1) // the int here is ignored
1592       .addAttribute(Attribute::ReadNone)
1593       .addAttribute(Attribute::ReadOnly)
1594       .addAttribute(Attribute::StructRet)
1595       .addAttribute(Attribute::InAlloca);
1596 
1597   return Incompatible;
1598 }
1599 
1600 template<typename AttrClass>
1601 static bool isEqual(const Function &Caller, const Function &Callee) {
1602   return Caller.getFnAttribute(AttrClass::getKind()) ==
1603          Callee.getFnAttribute(AttrClass::getKind());
1604 }
1605 
1606 /// Compute the logical AND of the attributes of the caller and the
1607 /// callee.
1608 ///
1609 /// This function sets the caller's attribute to false if the callee's attribute
1610 /// is false.
1611 template<typename AttrClass>
1612 static void setAND(Function &Caller, const Function &Callee) {
1613   if (AttrClass::isSet(Caller, AttrClass::getKind()) &&
1614       !AttrClass::isSet(Callee, AttrClass::getKind()))
1615     AttrClass::set(Caller, AttrClass::getKind(), false);
1616 }
1617 
1618 /// Compute the logical OR of the attributes of the caller and the
1619 /// callee.
1620 ///
1621 /// This function sets the caller's attribute to true if the callee's attribute
1622 /// is true.
1623 template<typename AttrClass>
1624 static void setOR(Function &Caller, const Function &Callee) {
1625   if (!AttrClass::isSet(Caller, AttrClass::getKind()) &&
1626       AttrClass::isSet(Callee, AttrClass::getKind()))
1627     AttrClass::set(Caller, AttrClass::getKind(), true);
1628 }
1629 
1630 /// If the inlined function had a higher stack protection level than the
1631 /// calling function, then bump up the caller's stack protection level.
1632 static void adjustCallerSSPLevel(Function &Caller, const Function &Callee) {
1633   // If upgrading the SSP attribute, clear out the old SSP Attributes first.
1634   // Having multiple SSP attributes doesn't actually hurt, but it adds useless
1635   // clutter to the IR.
1636   AttrBuilder OldSSPAttr;
1637   OldSSPAttr.addAttribute(Attribute::StackProtect)
1638       .addAttribute(Attribute::StackProtectStrong)
1639       .addAttribute(Attribute::StackProtectReq);
1640 
1641   if (Callee.hasFnAttribute(Attribute::StackProtectReq)) {
1642     Caller.removeAttributes(AttributeList::FunctionIndex, OldSSPAttr);
1643     Caller.addFnAttr(Attribute::StackProtectReq);
1644   } else if (Callee.hasFnAttribute(Attribute::StackProtectStrong) &&
1645              !Caller.hasFnAttribute(Attribute::StackProtectReq)) {
1646     Caller.removeAttributes(AttributeList::FunctionIndex, OldSSPAttr);
1647     Caller.addFnAttr(Attribute::StackProtectStrong);
1648   } else if (Callee.hasFnAttribute(Attribute::StackProtect) &&
1649              !Caller.hasFnAttribute(Attribute::StackProtectReq) &&
1650              !Caller.hasFnAttribute(Attribute::StackProtectStrong))
1651     Caller.addFnAttr(Attribute::StackProtect);
1652 }
1653 
1654 /// If the inlined function required stack probes, then ensure that
1655 /// the calling function has those too.
1656 static void adjustCallerStackProbes(Function &Caller, const Function &Callee) {
1657   if (!Caller.hasFnAttribute("probe-stack") &&
1658       Callee.hasFnAttribute("probe-stack")) {
1659     Caller.addFnAttr(Callee.getFnAttribute("probe-stack"));
1660   }
1661 }
1662 
1663 /// If the inlined function defines the size of guard region
1664 /// on the stack, then ensure that the calling function defines a guard region
1665 /// that is no larger.
1666 static void
1667 adjustCallerStackProbeSize(Function &Caller, const Function &Callee) {
1668   if (Callee.hasFnAttribute("stack-probe-size")) {
1669     uint64_t CalleeStackProbeSize;
1670     Callee.getFnAttribute("stack-probe-size")
1671           .getValueAsString()
1672           .getAsInteger(0, CalleeStackProbeSize);
1673     if (Caller.hasFnAttribute("stack-probe-size")) {
1674       uint64_t CallerStackProbeSize;
1675       Caller.getFnAttribute("stack-probe-size")
1676             .getValueAsString()
1677             .getAsInteger(0, CallerStackProbeSize);
1678       if (CallerStackProbeSize > CalleeStackProbeSize) {
1679         Caller.addFnAttr(Callee.getFnAttribute("stack-probe-size"));
1680       }
1681     } else {
1682       Caller.addFnAttr(Callee.getFnAttribute("stack-probe-size"));
1683     }
1684   }
1685 }
1686 
1687 /// If the inlined function defines a min legal vector width, then ensure
1688 /// the calling function has the same or larger min legal vector width. If the
1689 /// caller has the attribute, but the callee doesn't, we need to remove the
1690 /// attribute from the caller since we can't make any guarantees about the
1691 /// caller's requirements.
1692 /// This function is called after the inlining decision has been made so we have
1693 /// to merge the attribute this way. Heuristics that would use
1694 /// min-legal-vector-width to determine inline compatibility would need to be
1695 /// handled as part of inline cost analysis.
1696 static void
1697 adjustMinLegalVectorWidth(Function &Caller, const Function &Callee) {
1698   if (Caller.hasFnAttribute("min-legal-vector-width")) {
1699     if (Callee.hasFnAttribute("min-legal-vector-width")) {
1700       uint64_t CallerVectorWidth;
1701       Caller.getFnAttribute("min-legal-vector-width")
1702             .getValueAsString()
1703             .getAsInteger(0, CallerVectorWidth);
1704       uint64_t CalleeVectorWidth;
1705       Callee.getFnAttribute("min-legal-vector-width")
1706             .getValueAsString()
1707             .getAsInteger(0, CalleeVectorWidth);
1708       if (CallerVectorWidth < CalleeVectorWidth)
1709         Caller.addFnAttr(Callee.getFnAttribute("min-legal-vector-width"));
1710     } else {
1711       // If the callee doesn't have the attribute then we don't know anything
1712       // and must drop the attribute from the caller.
1713       Caller.removeFnAttr("min-legal-vector-width");
1714     }
1715   }
1716 }
1717 
1718 /// If the inlined function has "null-pointer-is-valid=true" attribute,
1719 /// set this attribute in the caller post inlining.
1720 static void
1721 adjustNullPointerValidAttr(Function &Caller, const Function &Callee) {
1722   if (Callee.nullPointerIsDefined() && !Caller.nullPointerIsDefined()) {
1723     Caller.addFnAttr(Callee.getFnAttribute("null-pointer-is-valid"));
1724   }
1725 }
1726 
1727 #define GET_ATTR_COMPAT_FUNC
1728 #include "AttributesCompatFunc.inc"
1729 
1730 bool AttributeFuncs::areInlineCompatible(const Function &Caller,
1731                                          const Function &Callee) {
1732   return hasCompatibleFnAttrs(Caller, Callee);
1733 }
1734 
1735 void AttributeFuncs::mergeAttributesForInlining(Function &Caller,
1736                                                 const Function &Callee) {
1737   mergeFnAttrs(Caller, Callee);
1738 }
1739