contrib/llvm-project/llvm/lib/IR/Attributes.cpp

   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, uint64_t Align) {
 146   assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
 147   assert(Align <= 0x40000000 && "Alignment too large.");
 148   return get(Context, Alignment, Align);
 149 }
 150
 151 Attribute Attribute::getWithStackAlignment(LLVMContext &Context,
 152                                            uint64_t Align) {
 153   assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
 154   assert(Align <= 0x100 && "Alignment too large.");
 155   return get(Context, StackAlignment, Align);
 156 }
 157
 158 Attribute Attribute::getWithDereferenceableBytes(LLVMContext &Context,
 159                                                 uint64_t Bytes) {
 160   assert(Bytes && "Bytes must be non-zero.");
 161   return get(Context, Dereferenceable, Bytes);
 162 }
 163
 164 Attribute Attribute::getWithDereferenceableOrNullBytes(LLVMContext &Context,
 165                                                        uint64_t Bytes) {
 166   assert(Bytes && "Bytes must be non-zero.");
 167   return get(Context, DereferenceableOrNull, Bytes);
 168 }
 169
 170 Attribute Attribute::getWithByValType(LLVMContext &Context, Type *Ty) {
 171   return get(Context, ByVal, Ty);
 172 }
 173
 174 Attribute
 175 Attribute::getWithAllocSizeArgs(LLVMContext &Context, unsigned ElemSizeArg,
 176                                 const Optional<unsigned> &NumElemsArg) {
 177   assert(!(ElemSizeArg == 0 && NumElemsArg && *NumElemsArg == 0) &&
 178          "Invalid allocsize arguments -- given allocsize(0, 0)");
 179   return get(Context, AllocSize, packAllocSizeArgs(ElemSizeArg, NumElemsArg));
 180 }
 181
 182 //===----------------------------------------------------------------------===//
 183 // Attribute Accessor Methods
 184 //===----------------------------------------------------------------------===//
 185
 186 bool Attribute::isEnumAttribute() const {
 187   return pImpl && pImpl->isEnumAttribute();
 188 }
 189
 190 bool Attribute::isIntAttribute() const {
 191   return pImpl && pImpl->isIntAttribute();
 192 }
 193
 194 bool Attribute::isStringAttribute() const {
 195   return pImpl && pImpl->isStringAttribute();
 196 }
 197
 198 bool Attribute::isTypeAttribute() const {
 199   return pImpl && pImpl->isTypeAttribute();
 200 }
 201
 202 Attribute::AttrKind Attribute::getKindAsEnum() const {
 203   if (!pImpl) return None;
 204   assert((isEnumAttribute() || isIntAttribute() || isTypeAttribute()) &&
 205          "Invalid attribute type to get the kind as an enum!");
 206   return pImpl->getKindAsEnum();
 207 }
 208
 209 uint64_t Attribute::getValueAsInt() const {
 210   if (!pImpl) return 0;
 211   assert(isIntAttribute() &&
 212          "Expected the attribute to be an integer attribute!");
 213   return pImpl->getValueAsInt();
 214 }
 215
 216 StringRef Attribute::getKindAsString() const {
 217   if (!pImpl) return {};
 218   assert(isStringAttribute() &&
 219          "Invalid attribute type to get the kind as a string!");
 220   return pImpl->getKindAsString();
 221 }
 222
 223 StringRef Attribute::getValueAsString() const {
 224   if (!pImpl) return {};
 225   assert(isStringAttribute() &&
 226          "Invalid attribute type to get the value as a string!");
 227   return pImpl->getValueAsString();
 228 }
 229
 230 Type *Attribute::getValueAsType() const {
 231   if (!pImpl) return {};
 232   assert(isTypeAttribute() &&
 233          "Invalid attribute type to get the value as a type!");
 234   return pImpl->getValueAsType();
 235 }
 236
 237
 238 bool Attribute::hasAttribute(AttrKind Kind) const {
 239   return (pImpl && pImpl->hasAttribute(Kind)) || (!pImpl && Kind == None);
 240 }
 241
 242 bool Attribute::hasAttribute(StringRef Kind) const {
 243   if (!isStringAttribute()) return false;
 244   return pImpl && pImpl->hasAttribute(Kind);
 245 }
 246
 247 unsigned Attribute::getAlignment() const {
 248   assert(hasAttribute(Attribute::Alignment) &&
 249          "Trying to get alignment from non-alignment attribute!");
 250   return pImpl->getValueAsInt();
 251 }
 252
 253 unsigned Attribute::getStackAlignment() const {
 254   assert(hasAttribute(Attribute::StackAlignment) &&
 255          "Trying to get alignment from non-alignment attribute!");
 256   return pImpl->getValueAsInt();
 257 }
 258
 259 uint64_t Attribute::getDereferenceableBytes() const {
 260   assert(hasAttribute(Attribute::Dereferenceable) &&
 261          "Trying to get dereferenceable bytes from "
 262          "non-dereferenceable attribute!");
 263   return pImpl->getValueAsInt();
 264 }
 265
 266 uint64_t Attribute::getDereferenceableOrNullBytes() const {
 267   assert(hasAttribute(Attribute::DereferenceableOrNull) &&
 268          "Trying to get dereferenceable bytes from "
 269          "non-dereferenceable attribute!");
 270   return pImpl->getValueAsInt();
 271 }
 272
 273 std::pair<unsigned, Optional<unsigned>> Attribute::getAllocSizeArgs() const {
 274   assert(hasAttribute(Attribute::AllocSize) &&
 275          "Trying to get allocsize args from non-allocsize attribute");
 276   return unpackAllocSizeArgs(pImpl->getValueAsInt());
 277 }
 278
 279 std::string Attribute::getAsString(bool InAttrGrp) const {
 280   if (!pImpl) return {};
 281
 282   if (hasAttribute(Attribute::SanitizeAddress))
 283     return "sanitize_address";
 284   if (hasAttribute(Attribute::SanitizeHWAddress))
 285     return "sanitize_hwaddress";
 286   if (hasAttribute(Attribute::SanitizeMemTag))
 287     return "sanitize_memtag";
 288   if (hasAttribute(Attribute::AlwaysInline))
 289     return "alwaysinline";
 290   if (hasAttribute(Attribute::ArgMemOnly))
 291     return "argmemonly";
 292   if (hasAttribute(Attribute::Builtin))
 293     return "builtin";
 294   if (hasAttribute(Attribute::Convergent))
 295     return "convergent";
 296   if (hasAttribute(Attribute::SwiftError))
 297     return "swifterror";
 298   if (hasAttribute(Attribute::SwiftSelf))
 299     return "swiftself";
 300   if (hasAttribute(Attribute::InaccessibleMemOnly))
 301     return "inaccessiblememonly";
 302   if (hasAttribute(Attribute::InaccessibleMemOrArgMemOnly))
 303     return "inaccessiblemem_or_argmemonly";
 304   if (hasAttribute(Attribute::InAlloca))
 305     return "inalloca";
 306   if (hasAttribute(Attribute::InlineHint))
 307     return "inlinehint";
 308   if (hasAttribute(Attribute::InReg))
 309     return "inreg";
 310   if (hasAttribute(Attribute::JumpTable))
 311     return "jumptable";
 312   if (hasAttribute(Attribute::MinSize))
 313     return "minsize";
 314   if (hasAttribute(Attribute::Naked))
 315     return "naked";
 316   if (hasAttribute(Attribute::Nest))
 317     return "nest";
 318   if (hasAttribute(Attribute::NoAlias))
 319     return "noalias";
 320   if (hasAttribute(Attribute::NoBuiltin))
 321     return "nobuiltin";
 322   if (hasAttribute(Attribute::NoCapture))
 323     return "nocapture";
 324   if (hasAttribute(Attribute::NoDuplicate))
 325     return "noduplicate";
 326   if (hasAttribute(Attribute::NoFree))
 327     return "nofree";
 328   if (hasAttribute(Attribute::NoImplicitFloat))
 329     return "noimplicitfloat";
 330   if (hasAttribute(Attribute::NoInline))
 331     return "noinline";
 332   if (hasAttribute(Attribute::NonLazyBind))
 333     return "nonlazybind";
 334   if (hasAttribute(Attribute::NonNull))
 335     return "nonnull";
 336   if (hasAttribute(Attribute::NoRedZone))
 337     return "noredzone";
 338   if (hasAttribute(Attribute::NoReturn))
 339     return "noreturn";
 340   if (hasAttribute(Attribute::NoSync))
 341     return "nosync";
 342   if (hasAttribute(Attribute::WillReturn))
 343     return "willreturn";
 344   if (hasAttribute(Attribute::NoCfCheck))
 345     return "nocf_check";
 346   if (hasAttribute(Attribute::NoRecurse))
 347     return "norecurse";
 348   if (hasAttribute(Attribute::NoUnwind))
 349     return "nounwind";
 350   if (hasAttribute(Attribute::OptForFuzzing))
 351     return "optforfuzzing";
 352   if (hasAttribute(Attribute::OptimizeNone))
 353     return "optnone";
 354   if (hasAttribute(Attribute::OptimizeForSize))
 355     return "optsize";
 356   if (hasAttribute(Attribute::ReadNone))
 357     return "readnone";
 358   if (hasAttribute(Attribute::ReadOnly))
 359     return "readonly";
 360   if (hasAttribute(Attribute::WriteOnly))
 361     return "writeonly";
 362   if (hasAttribute(Attribute::Returned))
 363     return "returned";
 364   if (hasAttribute(Attribute::ReturnsTwice))
 365     return "returns_twice";
 366   if (hasAttribute(Attribute::SExt))
 367     return "signext";
 368   if (hasAttribute(Attribute::SpeculativeLoadHardening))
 369     return "speculative_load_hardening";
 370   if (hasAttribute(Attribute::Speculatable))
 371     return "speculatable";
 372   if (hasAttribute(Attribute::StackProtect))
 373     return "ssp";
 374   if (hasAttribute(Attribute::StackProtectReq))
 375     return "sspreq";
 376   if (hasAttribute(Attribute::StackProtectStrong))
 377     return "sspstrong";
 378   if (hasAttribute(Attribute::SafeStack))
 379     return "safestack";
 380   if (hasAttribute(Attribute::ShadowCallStack))
 381     return "shadowcallstack";
 382   if (hasAttribute(Attribute::StrictFP))
 383     return "strictfp";
 384   if (hasAttribute(Attribute::StructRet))
 385     return "sret";
 386   if (hasAttribute(Attribute::SanitizeThread))
 387     return "sanitize_thread";
 388   if (hasAttribute(Attribute::SanitizeMemory))
 389     return "sanitize_memory";
 390   if (hasAttribute(Attribute::UWTable))
 391     return "uwtable";
 392   if (hasAttribute(Attribute::ZExt))
 393     return "zeroext";
 394   if (hasAttribute(Attribute::Cold))
 395     return "cold";
 396   if (hasAttribute(Attribute::ImmArg))
 397     return "immarg";
 398
 399   if (hasAttribute(Attribute::ByVal)) {
 400     std::string Result;
 401     Result += "byval";
 402     if (Type *Ty = getValueAsType()) {
 403       raw_string_ostream OS(Result);
 404       Result += '(';
 405       Ty->print(OS, false, true);
 406       OS.flush();
 407       Result += ')';
 408     }
 409     return Result;
 410   }
 411
 412   // FIXME: These should be output like this:
 413   //
 414   //   align=4
 415   //   alignstack=8
 416   //
 417   if (hasAttribute(Attribute::Alignment)) {
 418     std::string Result;
 419     Result += "align";
 420     Result += (InAttrGrp) ? "=" : " ";
 421     Result += utostr(getValueAsInt());
 422     return Result;
 423   }
 424
 425   auto AttrWithBytesToString = [&](const char *Name) {
 426     std::string Result;
 427     Result += Name;
 428     if (InAttrGrp) {
 429       Result += "=";
 430       Result += utostr(getValueAsInt());
 431     } else {
 432       Result += "(";
 433       Result += utostr(getValueAsInt());
 434       Result += ")";
 435     }
 436     return Result;
 437   };
 438
 439   if (hasAttribute(Attribute::StackAlignment))
 440     return AttrWithBytesToString("alignstack");
 441
 442   if (hasAttribute(Attribute::Dereferenceable))
 443     return AttrWithBytesToString("dereferenceable");
 444
 445   if (hasAttribute(Attribute::DereferenceableOrNull))
 446     return AttrWithBytesToString("dereferenceable_or_null");
 447
 448   if (hasAttribute(Attribute::AllocSize)) {
 449     unsigned ElemSize;
 450     Optional<unsigned> NumElems;
 451     std::tie(ElemSize, NumElems) = getAllocSizeArgs();
 452
 453     std::string Result = "allocsize(";
 454     Result += utostr(ElemSize);
 455     if (NumElems.hasValue()) {
 456       Result += ',';
 457       Result += utostr(*NumElems);
 458     }
 459     Result += ')';
 460     return Result;
 461   }
 462
 463   // Convert target-dependent attributes to strings of the form:
 464   //
 465   //   "kind"
 466   //   "kind" = "value"
 467   //
 468   if (isStringAttribute()) {
 469     std::string Result;
 470     Result += (Twine('"') + getKindAsString() + Twine('"')).str();
 471
 472     std::string AttrVal = pImpl->getValueAsString();
 473     if (AttrVal.empty()) return Result;
 474
 475     // Since some attribute strings contain special characters that cannot be
 476     // printable, those have to be escaped to make the attribute value printable
 477     // as is.  e.g. "\01__gnu_mcount_nc"
 478     {
 479       raw_string_ostream OS(Result);
 480       OS << "=\"";
 481       printEscapedString(AttrVal, OS);
 482       OS << "\"";
 483     }
 484     return Result;
 485   }
 486
 487   llvm_unreachable("Unknown attribute");
 488 }
 489
 490 bool Attribute::operator<(Attribute A) const {
 491   if (!pImpl && !A.pImpl) return false;
 492   if (!pImpl) return true;
 493   if (!A.pImpl) return false;
 494   return *pImpl < *A.pImpl;
 495 }
 496
 497 //===----------------------------------------------------------------------===//
 498 // AttributeImpl Definition
 499 //===----------------------------------------------------------------------===//
 500
 501 // Pin the vtables to this file.
 502 AttributeImpl::~AttributeImpl() = default;
 503
 504 void EnumAttributeImpl::anchor() {}
 505
 506 void IntAttributeImpl::anchor() {}
 507
 508 void StringAttributeImpl::anchor() {}
 509
 510 void TypeAttributeImpl::anchor() {}
 511
 512 bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const {
 513   if (isStringAttribute()) return false;
 514   return getKindAsEnum() == A;
 515 }
 516
 517 bool AttributeImpl::hasAttribute(StringRef Kind) const {
 518   if (!isStringAttribute()) return false;
 519   return getKindAsString() == Kind;
 520 }
 521
 522 Attribute::AttrKind AttributeImpl::getKindAsEnum() const {
 523   assert(isEnumAttribute() || isIntAttribute() || isTypeAttribute());
 524   return static_cast<const EnumAttributeImpl *>(this)->getEnumKind();
 525 }
 526
 527 uint64_t AttributeImpl::getValueAsInt() const {
 528   assert(isIntAttribute());
 529   return static_cast<const IntAttributeImpl *>(this)->getValue();
 530 }
 531
 532 StringRef AttributeImpl::getKindAsString() const {
 533   assert(isStringAttribute());
 534   return static_cast<const StringAttributeImpl *>(this)->getStringKind();
 535 }
 536
 537 StringRef AttributeImpl::getValueAsString() const {
 538   assert(isStringAttribute());
 539   return static_cast<const StringAttributeImpl *>(this)->getStringValue();
 540 }
 541
 542 Type *AttributeImpl::getValueAsType() const {
 543   assert(isTypeAttribute());
 544   return static_cast<const TypeAttributeImpl *>(this)->getTypeValue();
 545 }
 546
 547 bool AttributeImpl::operator<(const AttributeImpl &AI) const {
 548   // This sorts the attributes with Attribute::AttrKinds coming first (sorted
 549   // relative to their enum value) and then strings.
 550   if (isEnumAttribute()) {
 551     if (AI.isEnumAttribute()) return getKindAsEnum() < AI.getKindAsEnum();
 552     if (AI.isIntAttribute()) return true;
 553     if (AI.isStringAttribute()) return true;
 554     if (AI.isTypeAttribute()) return true;
 555   }
 556
 557   if (isTypeAttribute()) {
 558     if (AI.isEnumAttribute()) return false;
 559     if (AI.isTypeAttribute()) {
 560       assert(getKindAsEnum() != AI.getKindAsEnum() &&
 561              "Comparison of types would be unstable");
 562       return getKindAsEnum() < AI.getKindAsEnum();
 563     }
 564     if (AI.isIntAttribute()) return true;
 565     if (AI.isStringAttribute()) return true;
 566   }
 567
 568   if (isIntAttribute()) {
 569     if (AI.isEnumAttribute()) return false;
 570     if (AI.isTypeAttribute()) return false;
 571     if (AI.isIntAttribute()) {
 572       if (getKindAsEnum() == AI.getKindAsEnum())
 573         return getValueAsInt() < AI.getValueAsInt();
 574       return getKindAsEnum() < AI.getKindAsEnum();
 575     }
 576     if (AI.isStringAttribute()) return true;
 577   }
 578
 579   assert(isStringAttribute());
 580   if (AI.isEnumAttribute()) return false;
 581   if (AI.isTypeAttribute()) return false;
 582   if (AI.isIntAttribute()) return false;
 583   if (getKindAsString() == AI.getKindAsString())
 584     return getValueAsString() < AI.getValueAsString();
 585   return getKindAsString() < AI.getKindAsString();
 586 }
 587
 588 //===----------------------------------------------------------------------===//
 589 // AttributeSet Definition
 590 //===----------------------------------------------------------------------===//
 591
 592 AttributeSet AttributeSet::get(LLVMContext &C, const AttrBuilder &B) {
 593   return AttributeSet(AttributeSetNode::get(C, B));
 594 }
 595
 596 AttributeSet AttributeSet::get(LLVMContext &C, ArrayRef<Attribute> Attrs) {
 597   return AttributeSet(AttributeSetNode::get(C, Attrs));
 598 }
 599
 600 AttributeSet AttributeSet::addAttribute(LLVMContext &C,
 601                                         Attribute::AttrKind Kind) const {
 602   if (hasAttribute(Kind)) return *this;
 603   AttrBuilder B;
 604   B.addAttribute(Kind);
 605   return addAttributes(C, AttributeSet::get(C, B));
 606 }
 607
 608 AttributeSet AttributeSet::addAttribute(LLVMContext &C, StringRef Kind,
 609                                         StringRef Value) const {
 610   AttrBuilder B;
 611   B.addAttribute(Kind, Value);
 612   return addAttributes(C, AttributeSet::get(C, B));
 613 }
 614
 615 AttributeSet AttributeSet::addAttributes(LLVMContext &C,
 616                                          const AttributeSet AS) const {
 617   if (!hasAttributes())
 618     return AS;
 619
 620   if (!AS.hasAttributes())
 621     return *this;
 622
 623   AttrBuilder B(AS);
 624   for (const auto I : *this)
 625     B.addAttribute(I);
 626
 627  return get(C, B);
 628 }
 629
 630 AttributeSet AttributeSet::removeAttribute(LLVMContext &C,
 631                                              Attribute::AttrKind Kind) const {
 632   if (!hasAttribute(Kind)) return *this;
 633   AttrBuilder B(*this);
 634   B.removeAttribute(Kind);
 635   return get(C, B);
 636 }
 637
 638 AttributeSet AttributeSet::removeAttribute(LLVMContext &C,
 639                                              StringRef Kind) const {
 640   if (!hasAttribute(Kind)) return *this;
 641   AttrBuilder B(*this);
 642   B.removeAttribute(Kind);
 643   return get(C, B);
 644 }
 645
 646 AttributeSet AttributeSet::removeAttributes(LLVMContext &C,
 647                                               const AttrBuilder &Attrs) const {
 648   AttrBuilder B(*this);
 649   B.remove(Attrs);
 650   return get(C, B);
 651 }
 652
 653 unsigned AttributeSet::getNumAttributes() const {
 654   return SetNode ? SetNode->getNumAttributes() : 0;
 655 }
 656
 657 bool AttributeSet::hasAttribute(Attribute::AttrKind Kind) const {
 658   return SetNode ? SetNode->hasAttribute(Kind) : false;
 659 }
 660
 661 bool AttributeSet::hasAttribute(StringRef Kind) const {
 662   return SetNode ? SetNode->hasAttribute(Kind) : false;
 663 }
 664
 665 Attribute AttributeSet::getAttribute(Attribute::AttrKind Kind) const {
 666   return SetNode ? SetNode->getAttribute(Kind) : Attribute();
 667 }
 668
 669 Attribute AttributeSet::getAttribute(StringRef Kind) const {
 670   return SetNode ? SetNode->getAttribute(Kind) : Attribute();
 671 }
 672
 673 unsigned AttributeSet::getAlignment() const {
 674   return SetNode ? SetNode->getAlignment() : 0;
 675 }
 676
 677 unsigned AttributeSet::getStackAlignment() const {
 678   return SetNode ? SetNode->getStackAlignment() : 0;
 679 }
 680
 681 uint64_t AttributeSet::getDereferenceableBytes() const {
 682   return SetNode ? SetNode->getDereferenceableBytes() : 0;
 683 }
 684
 685 uint64_t AttributeSet::getDereferenceableOrNullBytes() const {
 686   return SetNode ? SetNode->getDereferenceableOrNullBytes() : 0;
 687 }
 688
 689 Type *AttributeSet::getByValType() const {
 690   return SetNode ? SetNode->getByValType() : nullptr;
 691 }
 692
 693 std::pair<unsigned, Optional<unsigned>> AttributeSet::getAllocSizeArgs() const {
 694   return SetNode ? SetNode->getAllocSizeArgs()
 695                  : std::pair<unsigned, Optional<unsigned>>(0, 0);
 696 }
 697
 698 std::string AttributeSet::getAsString(bool InAttrGrp) const {
 699   return SetNode ? SetNode->getAsString(InAttrGrp) : "";
 700 }
 701
 702 AttributeSet::iterator AttributeSet::begin() const {
 703   return SetNode ? SetNode->begin() : nullptr;
 704 }
 705
 706 AttributeSet::iterator AttributeSet::end() const {
 707   return SetNode ? SetNode->end() : nullptr;
 708 }
 709
 710 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 711 LLVM_DUMP_METHOD void AttributeSet::dump() const {
 712   dbgs() << "AS =\n";
 713     dbgs() << "  { ";
 714     dbgs() << getAsString(true) << " }\n";
 715 }
 716 #endif
 717
 718 //===----------------------------------------------------------------------===//
 719 // AttributeSetNode Definition
 720 //===----------------------------------------------------------------------===//
 721
 722 AttributeSetNode::AttributeSetNode(ArrayRef<Attribute> Attrs)
 723     : NumAttrs(Attrs.size()) {
 724   // There's memory after the node where we can store the entries in.
 725   llvm::copy(Attrs, getTrailingObjects<Attribute>());
 726
 727   static_assert(Attribute::EndAttrKinds <=
 728                     sizeof(AvailableAttrs) * CHAR_BIT,
 729                 "Too many attributes");
 730
 731   for (const auto I : *this) {
 732     if (!I.isStringAttribute()) {
 733       Attribute::AttrKind Kind = I.getKindAsEnum();
 734       AvailableAttrs[Kind / 8] |= 1ULL << (Kind % 8);
 735     }
 736   }
 737 }
 738
 739 AttributeSetNode *AttributeSetNode::get(LLVMContext &C,
 740                                         ArrayRef<Attribute> Attrs) {
 741   if (Attrs.empty())
 742     return nullptr;
 743
 744   // Otherwise, build a key to look up the existing attributes.
 745   LLVMContextImpl *pImpl = C.pImpl;
 746   FoldingSetNodeID ID;
 747
 748   SmallVector<Attribute, 8> SortedAttrs(Attrs.begin(), Attrs.end());
 749   llvm::sort(SortedAttrs);
 750
 751   for (const auto Attr : SortedAttrs)
 752     Attr.Profile(ID);
 753
 754   void *InsertPoint;
 755   AttributeSetNode *PA =
 756     pImpl->AttrsSetNodes.FindNodeOrInsertPos(ID, InsertPoint);
 757
 758   // If we didn't find any existing attributes of the same shape then create a
 759   // new one and insert it.
 760   if (!PA) {
 761     // Coallocate entries after the AttributeSetNode itself.
 762     void *Mem = ::operator new(totalSizeToAlloc<Attribute>(SortedAttrs.size()));
 763     PA = new (Mem) AttributeSetNode(SortedAttrs);
 764     pImpl->AttrsSetNodes.InsertNode(PA, InsertPoint);
 765   }
 766
 767   // Return the AttributeSetNode that we found or created.
 768   return PA;
 769 }
 770
 771 AttributeSetNode *AttributeSetNode::get(LLVMContext &C, const AttrBuilder &B) {
 772   // Add target-independent attributes.
 773   SmallVector<Attribute, 8> Attrs;
 774   for (Attribute::AttrKind Kind = Attribute::None;
 775        Kind != Attribute::EndAttrKinds; Kind = Attribute::AttrKind(Kind + 1)) {
 776     if (!B.contains(Kind))
 777       continue;
 778
 779     Attribute Attr;
 780     switch (Kind) {
 781     case Attribute::ByVal:
 782       Attr = Attribute::getWithByValType(C, B.getByValType());
 783       break;
 784     case Attribute::Alignment:
 785       Attr = Attribute::getWithAlignment(C, B.getAlignment());
 786       break;
 787     case Attribute::StackAlignment:
 788       Attr = Attribute::getWithStackAlignment(C, B.getStackAlignment());
 789       break;
 790     case Attribute::Dereferenceable:
 791       Attr = Attribute::getWithDereferenceableBytes(
 792           C, B.getDereferenceableBytes());
 793       break;
 794     case Attribute::DereferenceableOrNull:
 795       Attr = Attribute::getWithDereferenceableOrNullBytes(
 796           C, B.getDereferenceableOrNullBytes());
 797       break;
 798     case Attribute::AllocSize: {
 799       auto A = B.getAllocSizeArgs();
 800       Attr = Attribute::getWithAllocSizeArgs(C, A.first, A.second);
 801       break;
 802     }
 803     default:
 804       Attr = Attribute::get(C, Kind);
 805     }
 806     Attrs.push_back(Attr);
 807   }
 808
 809   // Add target-dependent (string) attributes.
 810   for (const auto &TDA : B.td_attrs())
 811     Attrs.emplace_back(Attribute::get(C, TDA.first, TDA.second));
 812
 813   return get(C, Attrs);
 814 }
 815
 816 bool AttributeSetNode::hasAttribute(StringRef Kind) const {
 817   for (const auto I : *this)
 818     if (I.hasAttribute(Kind))
 819       return true;
 820   return false;
 821 }
 822
 823 Attribute AttributeSetNode::getAttribute(Attribute::AttrKind Kind) const {
 824   if (hasAttribute(Kind)) {
 825     for (const auto I : *this)
 826       if (I.hasAttribute(Kind))
 827         return I;
 828   }
 829   return {};
 830 }
 831
 832 Attribute AttributeSetNode::getAttribute(StringRef Kind) const {
 833   for (const auto I : *this)
 834     if (I.hasAttribute(Kind))
 835       return I;
 836   return {};
 837 }
 838
 839 unsigned AttributeSetNode::getAlignment() const {
 840   for (const auto I : *this)
 841     if (I.hasAttribute(Attribute::Alignment))
 842       return I.getAlignment();
 843   return 0;
 844 }
 845
 846 unsigned AttributeSetNode::getStackAlignment() const {
 847   for (const auto I : *this)
 848     if (I.hasAttribute(Attribute::StackAlignment))
 849       return I.getStackAlignment();
 850   return 0;
 851 }
 852
 853 Type *AttributeSetNode::getByValType() const {
 854   for (const auto I : *this)
 855     if (I.hasAttribute(Attribute::ByVal))
 856       return I.getValueAsType();
 857   return 0;
 858 }
 859
 860 uint64_t AttributeSetNode::getDereferenceableBytes() const {
 861   for (const auto I : *this)
 862     if (I.hasAttribute(Attribute::Dereferenceable))
 863       return I.getDereferenceableBytes();
 864   return 0;
 865 }
 866
 867 uint64_t AttributeSetNode::getDereferenceableOrNullBytes() const {
 868   for (const auto I : *this)
 869     if (I.hasAttribute(Attribute::DereferenceableOrNull))
 870       return I.getDereferenceableOrNullBytes();
 871   return 0;
 872 }
 873
 874 std::pair<unsigned, Optional<unsigned>>
 875 AttributeSetNode::getAllocSizeArgs() const {
 876   for (const auto I : *this)
 877     if (I.hasAttribute(Attribute::AllocSize))
 878       return I.getAllocSizeArgs();
 879   return std::make_pair(0, 0);
 880 }
 881
 882 std::string AttributeSetNode::getAsString(bool InAttrGrp) const {
 883   std::string Str;
 884   for (iterator I = begin(), E = end(); I != E; ++I) {
 885     if (I != begin())
 886       Str += ' ';
 887     Str += I->getAsString(InAttrGrp);
 888   }
 889   return Str;
 890 }
 891
 892 //===----------------------------------------------------------------------===//
 893 // AttributeListImpl Definition
 894 //===----------------------------------------------------------------------===//
 895
 896 /// Map from AttributeList index to the internal array index. Adding one happens
 897 /// to work, but it relies on unsigned integer wrapping. MSVC warns about
 898 /// unsigned wrapping in constexpr functions, so write out the conditional. LLVM
 899 /// folds it to add anyway.
 900 static constexpr unsigned attrIdxToArrayIdx(unsigned Index) {
 901   return Index == AttributeList::FunctionIndex ? 0 : Index + 1;
 902 }
 903
 904 AttributeListImpl::AttributeListImpl(LLVMContext &C,
 905                                      ArrayRef<AttributeSet> Sets)
 906     : Context(C), NumAttrSets(Sets.size()) {
 907   assert(!Sets.empty() && "pointless AttributeListImpl");
 908
 909   // There's memory after the node where we can store the entries in.
 910   llvm::copy(Sets, getTrailingObjects<AttributeSet>());
 911
 912   // Initialize AvailableFunctionAttrs summary bitset.
 913   static_assert(Attribute::EndAttrKinds <=
 914                     sizeof(AvailableFunctionAttrs) * CHAR_BIT,
 915                 "Too many attributes");
 916   static_assert(attrIdxToArrayIdx(AttributeList::FunctionIndex) == 0U,
 917                 "function should be stored in slot 0");
 918   for (const auto I : Sets[0]) {
 919     if (!I.isStringAttribute()) {
 920       Attribute::AttrKind Kind = I.getKindAsEnum();
 921       AvailableFunctionAttrs[Kind / 8] |= 1ULL << (Kind % 8);
 922     }
 923   }
 924 }
 925
 926 void AttributeListImpl::Profile(FoldingSetNodeID &ID) const {
 927   Profile(ID, makeArrayRef(begin(), end()));
 928 }
 929
 930 void AttributeListImpl::Profile(FoldingSetNodeID &ID,
 931                                 ArrayRef<AttributeSet> Sets) {
 932   for (const auto &Set : Sets)
 933     ID.AddPointer(Set.SetNode);
 934 }
 935
 936 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 937 LLVM_DUMP_METHOD void AttributeListImpl::dump() const {
 938   AttributeList(const_cast<AttributeListImpl *>(this)).dump();
 939 }
 940 #endif
 941
 942 //===----------------------------------------------------------------------===//
 943 // AttributeList Construction and Mutation Methods
 944 //===----------------------------------------------------------------------===//
 945
 946 AttributeList AttributeList::getImpl(LLVMContext &C,
 947                                      ArrayRef<AttributeSet> AttrSets) {
 948   assert(!AttrSets.empty() && "pointless AttributeListImpl");
 949
 950   LLVMContextImpl *pImpl = C.pImpl;
 951   FoldingSetNodeID ID;
 952   AttributeListImpl::Profile(ID, AttrSets);
 953
 954   void *InsertPoint;
 955   AttributeListImpl *PA =
 956       pImpl->AttrsLists.FindNodeOrInsertPos(ID, InsertPoint);
 957
 958   // If we didn't find any existing attributes of the same shape then
 959   // create a new one and insert it.
 960   if (!PA) {
 961     // Coallocate entries after the AttributeListImpl itself.
 962     void *Mem = ::operator new(
 963         AttributeListImpl::totalSizeToAlloc<AttributeSet>(AttrSets.size()));
 964     PA = new (Mem) AttributeListImpl(C, AttrSets);
 965     pImpl->AttrsLists.InsertNode(PA, InsertPoint);
 966   }
 967
 968   // Return the AttributesList that we found or created.
 969   return AttributeList(PA);
 970 }
 971
 972 AttributeList
 973 AttributeList::get(LLVMContext &C,
 974                    ArrayRef<std::pair<unsigned, Attribute>> Attrs) {
 975   // If there are no attributes then return a null AttributesList pointer.
 976   if (Attrs.empty())
 977     return {};
 978
 979   assert(std::is_sorted(Attrs.begin(), Attrs.end(),
 980                         [](const std::pair<unsigned, Attribute> &LHS,
 981                            const std::pair<unsigned, Attribute> &RHS) {
 982                           return LHS.first < RHS.first;
 983                         }) && "Misordered Attributes list!");
 984   assert(llvm::none_of(Attrs,
 985                        [](const std::pair<unsigned, Attribute> &Pair) {
 986                          return Pair.second.hasAttribute(Attribute::None);
 987                        }) &&
 988          "Pointless attribute!");
 989
 990   // Create a vector if (unsigned, AttributeSetNode*) pairs from the attributes
 991   // list.
 992   SmallVector<std::pair<unsigned, AttributeSet>, 8> AttrPairVec;
 993   for (ArrayRef<std::pair<unsigned, Attribute>>::iterator I = Attrs.begin(),
 994          E = Attrs.end(); I != E; ) {
 995     unsigned Index = I->first;
 996     SmallVector<Attribute, 4> AttrVec;
 997     while (I != E && I->first == Index) {
 998       AttrVec.push_back(I->second);
 999       ++I;
1000     }
1001
1002     AttrPairVec.emplace_back(Index, AttributeSet::get(C, AttrVec));
1003   }
1004
1005   return get(C, AttrPairVec);
1006 }
1007
1008 AttributeList
1009 AttributeList::get(LLVMContext &C,
1010                    ArrayRef<std::pair<unsigned, AttributeSet>> Attrs) {
1011   // If there are no attributes then return a null AttributesList pointer.
1012   if (Attrs.empty())
1013     return {};
1014
1015   assert(std::is_sorted(Attrs.begin(), Attrs.end(),
1016                         [](const std::pair<unsigned, AttributeSet> &LHS,
1017                            const std::pair<unsigned, AttributeSet> &RHS) {
1018                           return LHS.first < RHS.first;
1019                         }) &&
1020          "Misordered Attributes list!");
1021   assert(llvm::none_of(Attrs,
1022                        [](const std::pair<unsigned, AttributeSet> &Pair) {
1023                          return !Pair.second.hasAttributes();
1024                        }) &&
1025          "Pointless attribute!");
1026
1027   unsigned MaxIndex = Attrs.back().first;
1028   // If the MaxIndex is FunctionIndex and there are other indices in front
1029   // of it, we need to use the largest of those to get the right size.
1030   if (MaxIndex == FunctionIndex && Attrs.size() > 1)
1031     MaxIndex = Attrs[Attrs.size() - 2].first;
1032
1033   SmallVector<AttributeSet, 4> AttrVec(attrIdxToArrayIdx(MaxIndex) + 1);
1034   for (const auto Pair : Attrs)
1035     AttrVec[attrIdxToArrayIdx(Pair.first)] = Pair.second;
1036
1037   return getImpl(C, AttrVec);
1038 }
1039
1040 AttributeList AttributeList::get(LLVMContext &C, AttributeSet FnAttrs,
1041                                  AttributeSet RetAttrs,
1042                                  ArrayRef<AttributeSet> ArgAttrs) {
1043   // Scan from the end to find the last argument with attributes.  Most
1044   // arguments don't have attributes, so it's nice if we can have fewer unique
1045   // AttributeListImpls by dropping empty attribute sets at the end of the list.
1046   unsigned NumSets = 0;
1047   for (size_t I = ArgAttrs.size(); I != 0; --I) {
1048     if (ArgAttrs[I - 1].hasAttributes()) {
1049       NumSets = I + 2;
1050       break;
1051     }
1052   }
1053   if (NumSets == 0) {
1054     // Check function and return attributes if we didn't have argument
1055     // attributes.
1056     if (RetAttrs.hasAttributes())
1057       NumSets = 2;
1058     else if (FnAttrs.hasAttributes())
1059       NumSets = 1;
1060   }
1061
1062   // If all attribute sets were empty, we can use the empty attribute list.
1063   if (NumSets == 0)
1064     return {};
1065
1066   SmallVector<AttributeSet, 8> AttrSets;
1067   AttrSets.reserve(NumSets);
1068   // If we have any attributes, we always have function attributes.
1069   AttrSets.push_back(FnAttrs);
1070   if (NumSets > 1)
1071     AttrSets.push_back(RetAttrs);
1072   if (NumSets > 2) {
1073     // Drop the empty argument attribute sets at the end.
1074     ArgAttrs = ArgAttrs.take_front(NumSets - 2);
1075     AttrSets.insert(AttrSets.end(), ArgAttrs.begin(), ArgAttrs.end());
1076   }
1077
1078   return getImpl(C, AttrSets);
1079 }
1080
1081 AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
1082                                  const AttrBuilder &B) {
1083   if (!B.hasAttributes())
1084     return {};
1085   Index = attrIdxToArrayIdx(Index);
1086   SmallVector<AttributeSet, 8> AttrSets(Index + 1);
1087   AttrSets[Index] = AttributeSet::get(C, B);
1088   return getImpl(C, AttrSets);
1089 }
1090
1091 AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
1092                                  ArrayRef<Attribute::AttrKind> Kinds) {
1093   SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
1094   for (const auto K : Kinds)
1095     Attrs.emplace_back(Index, Attribute::get(C, K));
1096   return get(C, Attrs);
1097 }
1098
1099 AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
1100                                  ArrayRef<StringRef> Kinds) {
1101   SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
1102   for (const auto K : Kinds)
1103     Attrs.emplace_back(Index, Attribute::get(C, K));
1104   return get(C, Attrs);
1105 }
1106
1107 AttributeList AttributeList::get(LLVMContext &C,
1108                                  ArrayRef<AttributeList> Attrs) {
1109   if (Attrs.empty())
1110     return {};
1111   if (Attrs.size() == 1)
1112     return Attrs[0];
1113
1114   unsigned MaxSize = 0;
1115   for (const auto List : Attrs)
1116     MaxSize = std::max(MaxSize, List.getNumAttrSets());
1117
1118   // If every list was empty, there is no point in merging the lists.
1119   if (MaxSize == 0)
1120     return {};
1121
1122   SmallVector<AttributeSet, 8> NewAttrSets(MaxSize);
1123   for (unsigned I = 0; I < MaxSize; ++I) {
1124     AttrBuilder CurBuilder;
1125     for (const auto List : Attrs)
1126       CurBuilder.merge(List.getAttributes(I - 1));
1127     NewAttrSets[I] = AttributeSet::get(C, CurBuilder);
1128   }
1129
1130   return getImpl(C, NewAttrSets);
1131 }
1132
1133 AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index,
1134                                           Attribute::AttrKind Kind) const {
1135   if (hasAttribute(Index, Kind)) return *this;
1136   AttrBuilder B;
1137   B.addAttribute(Kind);
1138   return addAttributes(C, Index, B);
1139 }
1140
1141 AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index,
1142                                           StringRef Kind,
1143                                           StringRef Value) const {
1144   AttrBuilder B;
1145   B.addAttribute(Kind, Value);
1146   return addAttributes(C, Index, B);
1147 }
1148
1149 AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index,
1150                                           Attribute A) const {
1151   AttrBuilder B;
1152   B.addAttribute(A);
1153   return addAttributes(C, Index, B);
1154 }
1155
1156 AttributeList AttributeList::addAttributes(LLVMContext &C, unsigned Index,
1157                                            const AttrBuilder &B) const {
1158   if (!B.hasAttributes())
1159     return *this;
1160
1161   if (!pImpl)
1162     return AttributeList::get(C, {{Index, AttributeSet::get(C, B)}});
1163
1164 #ifndef NDEBUG
1165   // FIXME it is not obvious how this should work for alignment. For now, say
1166   // we can't change a known alignment.
1167   unsigned OldAlign = getAttributes(Index).getAlignment();
1168   unsigned NewAlign = B.getAlignment();
1169   assert((!OldAlign || !NewAlign || OldAlign == NewAlign) &&
1170          "Attempt to change alignment!");
1171 #endif
1172
1173   Index = attrIdxToArrayIdx(Index);
1174   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
1175   if (Index >= AttrSets.size())
1176     AttrSets.resize(Index + 1);
1177
1178   AttrBuilder Merged(AttrSets[Index]);
1179   Merged.merge(B);
1180   AttrSets[Index] = AttributeSet::get(C, Merged);
1181
1182   return getImpl(C, AttrSets);
1183 }
1184
1185 AttributeList AttributeList::addParamAttribute(LLVMContext &C,
1186                                                ArrayRef<unsigned> ArgNos,
1187                                                Attribute A) const {
1188   assert(std::is_sorted(ArgNos.begin(), ArgNos.end()));
1189
1190   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
1191   unsigned MaxIndex = attrIdxToArrayIdx(ArgNos.back() + FirstArgIndex);
1192   if (MaxIndex >= AttrSets.size())
1193     AttrSets.resize(MaxIndex + 1);
1194
1195   for (unsigned ArgNo : ArgNos) {
1196     unsigned Index = attrIdxToArrayIdx(ArgNo + FirstArgIndex);
1197     AttrBuilder B(AttrSets[Index]);
1198     B.addAttribute(A);
1199     AttrSets[Index] = AttributeSet::get(C, B);
1200   }
1201
1202   return getImpl(C, AttrSets);
1203 }
1204
1205 AttributeList AttributeList::removeAttribute(LLVMContext &C, unsigned Index,
1206                                              Attribute::AttrKind Kind) const {
1207   if (!hasAttribute(Index, Kind)) return *this;
1208
1209   Index = attrIdxToArrayIdx(Index);
1210   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
1211   assert(Index < AttrSets.size());
1212
1213   AttrSets[Index] = AttrSets[Index].removeAttribute(C, Kind);
1214
1215   return getImpl(C, AttrSets);
1216 }
1217
1218 AttributeList AttributeList::removeAttribute(LLVMContext &C, unsigned Index,
1219                                              StringRef Kind) const {
1220   if (!hasAttribute(Index, Kind)) return *this;
1221
1222   Index = attrIdxToArrayIdx(Index);
1223   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
1224   assert(Index < AttrSets.size());
1225
1226   AttrSets[Index] = AttrSets[Index].removeAttribute(C, Kind);
1227
1228   return getImpl(C, AttrSets);
1229 }
1230
1231 AttributeList
1232 AttributeList::removeAttributes(LLVMContext &C, unsigned Index,
1233                                 const AttrBuilder &AttrsToRemove) const {
1234   if (!pImpl)
1235     return {};
1236
1237   Index = attrIdxToArrayIdx(Index);
1238   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
1239   if (Index >= AttrSets.size())
1240     AttrSets.resize(Index + 1);
1241
1242   AttrSets[Index] = AttrSets[Index].removeAttributes(C, AttrsToRemove);
1243
1244   return getImpl(C, AttrSets);
1245 }
1246
1247 AttributeList AttributeList::removeAttributes(LLVMContext &C,
1248                                               unsigned WithoutIndex) const {
1249   if (!pImpl)
1250     return {};
1251   WithoutIndex = attrIdxToArrayIdx(WithoutIndex);
1252   if (WithoutIndex >= getNumAttrSets())
1253     return *this;
1254   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
1255   AttrSets[WithoutIndex] = AttributeSet();
1256   return getImpl(C, AttrSets);
1257 }
1258
1259 AttributeList AttributeList::addDereferenceableAttr(LLVMContext &C,
1260                                                     unsigned Index,
1261                                                     uint64_t Bytes) const {
1262   AttrBuilder B;
1263   B.addDereferenceableAttr(Bytes);
1264   return addAttributes(C, Index, B);
1265 }
1266
1267 AttributeList
1268 AttributeList::addDereferenceableOrNullAttr(LLVMContext &C, unsigned Index,
1269                                             uint64_t Bytes) const {
1270   AttrBuilder B;
1271   B.addDereferenceableOrNullAttr(Bytes);
1272   return addAttributes(C, Index, B);
1273 }
1274
1275 AttributeList
1276 AttributeList::addAllocSizeAttr(LLVMContext &C, unsigned Index,
1277                                 unsigned ElemSizeArg,
1278                                 const Optional<unsigned> &NumElemsArg) {
1279   AttrBuilder B;
1280   B.addAllocSizeAttr(ElemSizeArg, NumElemsArg);
1281   return addAttributes(C, Index, B);
1282 }
1283
1284 //===----------------------------------------------------------------------===//
1285 // AttributeList Accessor Methods
1286 //===----------------------------------------------------------------------===//
1287
1288 LLVMContext &AttributeList::getContext() const { return pImpl->getContext(); }
1289
1290 AttributeSet AttributeList::getParamAttributes(unsigned ArgNo) const {
1291   return getAttributes(ArgNo + FirstArgIndex);
1292 }
1293
1294 AttributeSet AttributeList::getRetAttributes() const {
1295   return getAttributes(ReturnIndex);
1296 }
1297
1298 AttributeSet AttributeList::getFnAttributes() const {
1299   return getAttributes(FunctionIndex);
1300 }
1301
1302 bool AttributeList::hasAttribute(unsigned Index,
1303                                  Attribute::AttrKind Kind) const {
1304   return getAttributes(Index).hasAttribute(Kind);
1305 }
1306
1307 bool AttributeList::hasAttribute(unsigned Index, StringRef Kind) const {
1308   return getAttributes(Index).hasAttribute(Kind);
1309 }
1310
1311 bool AttributeList::hasAttributes(unsigned Index) const {
1312   return getAttributes(Index).hasAttributes();
1313 }
1314
1315 bool AttributeList::hasFnAttribute(Attribute::AttrKind Kind) const {
1316   return pImpl && pImpl->hasFnAttribute(Kind);
1317 }
1318
1319 bool AttributeList::hasFnAttribute(StringRef Kind) const {
1320   return hasAttribute(AttributeList::FunctionIndex, Kind);
1321 }
1322
1323 bool AttributeList::hasParamAttribute(unsigned ArgNo,
1324                                       Attribute::AttrKind Kind) const {
1325   return hasAttribute(ArgNo + FirstArgIndex, Kind);
1326 }
1327
1328 bool AttributeList::hasAttrSomewhere(Attribute::AttrKind Attr,
1329                                      unsigned *Index) const {
1330   if (!pImpl) return false;
1331
1332   for (unsigned I = index_begin(), E = index_end(); I != E; ++I) {
1333     if (hasAttribute(I, Attr)) {
1334       if (Index)
1335         *Index = I;
1336       return true;
1337     }
1338   }
1339
1340   return false;
1341 }
1342
1343 Attribute AttributeList::getAttribute(unsigned Index,
1344                                       Attribute::AttrKind Kind) const {
1345   return getAttributes(Index).getAttribute(Kind);
1346 }
1347
1348 Attribute AttributeList::getAttribute(unsigned Index, StringRef Kind) const {
1349   return getAttributes(Index).getAttribute(Kind);
1350 }
1351
1352 unsigned AttributeList::getRetAlignment() const {
1353   return getAttributes(ReturnIndex).getAlignment();
1354 }
1355
1356 unsigned AttributeList::getParamAlignment(unsigned ArgNo) const {
1357   return getAttributes(ArgNo + FirstArgIndex).getAlignment();
1358 }
1359
1360 Type *AttributeList::getParamByValType(unsigned Index) const {
1361   return getAttributes(Index+FirstArgIndex).getByValType();
1362 }
1363
1364
1365 unsigned AttributeList::getStackAlignment(unsigned Index) const {
1366   return getAttributes(Index).getStackAlignment();
1367 }
1368
1369 uint64_t AttributeList::getDereferenceableBytes(unsigned Index) const {
1370   return getAttributes(Index).getDereferenceableBytes();
1371 }
1372
1373 uint64_t AttributeList::getDereferenceableOrNullBytes(unsigned Index) const {
1374   return getAttributes(Index).getDereferenceableOrNullBytes();
1375 }
1376
1377 std::pair<unsigned, Optional<unsigned>>
1378 AttributeList::getAllocSizeArgs(unsigned Index) const {
1379   return getAttributes(Index).getAllocSizeArgs();
1380 }
1381
1382 std::string AttributeList::getAsString(unsigned Index, bool InAttrGrp) const {
1383   return getAttributes(Index).getAsString(InAttrGrp);
1384 }
1385
1386 AttributeSet AttributeList::getAttributes(unsigned Index) const {
1387   Index = attrIdxToArrayIdx(Index);
1388   if (!pImpl || Index >= getNumAttrSets())
1389     return {};
1390   return pImpl->begin()[Index];
1391 }
1392
1393 AttributeList::iterator AttributeList::begin() const {
1394   return pImpl ? pImpl->begin() : nullptr;
1395 }
1396
1397 AttributeList::iterator AttributeList::end() const {
1398   return pImpl ? pImpl->end() : nullptr;
1399 }
1400
1401 //===----------------------------------------------------------------------===//
1402 // AttributeList Introspection Methods
1403 //===----------------------------------------------------------------------===//
1404
1405 unsigned AttributeList::getNumAttrSets() const {
1406   return pImpl ? pImpl->NumAttrSets : 0;
1407 }
1408
1409 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1410 LLVM_DUMP_METHOD void AttributeList::dump() const {
1411   dbgs() << "PAL[\n";
1412
1413   for (unsigned i = index_begin(), e = index_end(); i != e; ++i) {
1414     if (getAttributes(i).hasAttributes())
1415       dbgs() << "  { " << i << " => " << getAsString(i) << " }\n";
1416   }
1417
1418   dbgs() << "]\n";
1419 }
1420 #endif
1421
1422 //===----------------------------------------------------------------------===//
1423 // AttrBuilder Method Implementations
1424 //===----------------------------------------------------------------------===//
1425
1426 // FIXME: Remove this ctor, use AttributeSet.
1427 AttrBuilder::AttrBuilder(AttributeList AL, unsigned Index) {
1428   AttributeSet AS = AL.getAttributes(Index);
1429   for (const auto &A : AS)
1430     addAttribute(A);
1431 }
1432
1433 AttrBuilder::AttrBuilder(AttributeSet AS) {
1434   for (const auto &A : AS)
1435     addAttribute(A);
1436 }
1437
1438 void AttrBuilder::clear() {
1439   Attrs.reset();
1440   TargetDepAttrs.clear();
1441   Alignment = StackAlignment = 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 = 0;
1490   else if (Val == Attribute::StackAlignment)
1491     StackAlignment = 0;
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(unsigned Align) {
1521   if (Align == 0) return *this;
1522
1523   assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
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(unsigned Align) {
1532   // Default alignment, allow the target to define how to align it.
1533   if (Align == 0) return *this;
1534
1535   assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
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 = 0;
1614
1615   if (B.StackAlignment)
1616     StackAlignment = 0;
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 }