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