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