LLVM  14.0.0git
Attributes.cpp
Go to the documentation of this file.
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/StringSwitch.h"
26 #include "llvm/ADT/Twine.h"
27 #include "llvm/Config/llvm-config.h"
28 #include "llvm/IR/Function.h"
29 #include "llvm/IR/LLVMContext.h"
30 #include "llvm/IR/Type.h"
31 #include "llvm/Support/Compiler.h"
32 #include "llvm/Support/Debug.h"
36 #include <algorithm>
37 #include <cassert>
38 #include <climits>
39 #include <cstddef>
40 #include <cstdint>
41 #include <limits>
42 #include <string>
43 #include <tuple>
44 #include <utility>
45 
46 using namespace llvm;
47 
48 //===----------------------------------------------------------------------===//
49 // Attribute Construction Methods
50 //===----------------------------------------------------------------------===//
51 
52 // allocsize has two integer arguments, but because they're both 32 bits, we can
53 // pack them into one 64-bit value, at the cost of making said value
54 // nonsensical.
55 //
56 // In order to do this, we need to reserve one value of the second (optional)
57 // allocsize argument to signify "not present."
58 static const unsigned AllocSizeNumElemsNotPresent = -1;
59 
60 static uint64_t packAllocSizeArgs(unsigned ElemSizeArg,
61  const Optional<unsigned> &NumElemsArg) {
62  assert((!NumElemsArg.hasValue() ||
63  *NumElemsArg != AllocSizeNumElemsNotPresent) &&
64  "Attempting to pack a reserved value");
65 
66  return uint64_t(ElemSizeArg) << 32 |
68 }
69 
70 static std::pair<unsigned, Optional<unsigned>>
72  unsigned NumElems = Num & std::numeric_limits<unsigned>::max();
73  unsigned ElemSizeArg = Num >> 32;
74 
75  Optional<unsigned> NumElemsArg;
76  if (NumElems != AllocSizeNumElemsNotPresent)
77  NumElemsArg = NumElems;
78  return std::make_pair(ElemSizeArg, NumElemsArg);
79 }
80 
81 static uint64_t packVScaleRangeArgs(unsigned MinValue, unsigned MaxValue) {
82  return uint64_t(MinValue) << 32 | MaxValue;
83 }
84 
85 static std::pair<unsigned, unsigned> unpackVScaleRangeArgs(uint64_t Value) {
86  unsigned MaxValue = Value & std::numeric_limits<unsigned>::max();
87  unsigned MinValue = Value >> 32;
88 
89  return std::make_pair(MinValue, MaxValue);
90 }
91 
93  uint64_t Val) {
94  if (Val)
95  assert(Attribute::isIntAttrKind(Kind) && "Not an int attribute");
96  else
97  assert(Attribute::isEnumAttrKind(Kind) && "Not an enum attribute");
98 
99  LLVMContextImpl *pImpl = Context.pImpl;
101  ID.AddInteger(Kind);
102  if (Val) ID.AddInteger(Val);
103 
104  void *InsertPoint;
105  AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);
106 
107  if (!PA) {
108  // If we didn't find any existing attributes of the same shape then create a
109  // new one and insert it.
110  if (!Val)
111  PA = new (pImpl->Alloc) EnumAttributeImpl(Kind);
112  else
113  PA = new (pImpl->Alloc) IntAttributeImpl(Kind, Val);
114  pImpl->AttrsSet.InsertNode(PA, InsertPoint);
115  }
116 
117  // Return the Attribute that we found or created.
118  return Attribute(PA);
119 }
120 
122  LLVMContextImpl *pImpl = Context.pImpl;
124  ID.AddString(Kind);
125  if (!Val.empty()) ID.AddString(Val);
126 
127  void *InsertPoint;
128  AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);
129 
130  if (!PA) {
131  // If we didn't find any existing attributes of the same shape then create a
132  // new one and insert it.
133  void *Mem =
135  alignof(StringAttributeImpl));
136  PA = new (Mem) StringAttributeImpl(Kind, Val);
137  pImpl->AttrsSet.InsertNode(PA, InsertPoint);
138  }
139 
140  // Return the Attribute that we found or created.
141  return Attribute(PA);
142 }
143 
145  Type *Ty) {
146  assert(Attribute::isTypeAttrKind(Kind) && "Not a type attribute");
147  LLVMContextImpl *pImpl = Context.pImpl;
149  ID.AddInteger(Kind);
150  ID.AddPointer(Ty);
151 
152  void *InsertPoint;
153  AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);
154 
155  if (!PA) {
156  // If we didn't find any existing attributes of the same shape then create a
157  // new one and insert it.
158  PA = new (pImpl->Alloc) TypeAttributeImpl(Kind, Ty);
159  pImpl->AttrsSet.InsertNode(PA, InsertPoint);
160  }
161 
162  // Return the Attribute that we found or created.
163  return Attribute(PA);
164 }
165 
167  assert(A <= llvm::Value::MaximumAlignment && "Alignment too large.");
168  return get(Context, Alignment, A.value());
169 }
170 
172  assert(A <= 0x100 && "Alignment too large.");
173  return get(Context, StackAlignment, A.value());
174 }
175 
177  uint64_t Bytes) {
178  assert(Bytes && "Bytes must be non-zero.");
179  return get(Context, Dereferenceable, Bytes);
180 }
181 
183  uint64_t Bytes) {
184  assert(Bytes && "Bytes must be non-zero.");
185  return get(Context, DereferenceableOrNull, Bytes);
186 }
187 
189  return get(Context, ByVal, Ty);
190 }
191 
193  return get(Context, StructRet, Ty);
194 }
195 
197  return get(Context, ByRef, Ty);
198 }
199 
201  return get(Context, Preallocated, Ty);
202 }
203 
205  return get(Context, InAlloca, Ty);
206 }
207 
208 Attribute
210  const Optional<unsigned> &NumElemsArg) {
211  assert(!(ElemSizeArg == 0 && NumElemsArg && *NumElemsArg == 0) &&
212  "Invalid allocsize arguments -- given allocsize(0, 0)");
213  return get(Context, AllocSize, packAllocSizeArgs(ElemSizeArg, NumElemsArg));
214 }
215 
217  unsigned MinValue,
218  unsigned MaxValue) {
219  return get(Context, VScaleRange, packVScaleRangeArgs(MinValue, MaxValue));
220 }
221 
223  return StringSwitch<Attribute::AttrKind>(AttrName)
224 #define GET_ATTR_NAMES
225 #define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \
226  .Case(#DISPLAY_NAME, Attribute::ENUM_NAME)
227 #include "llvm/IR/Attributes.inc"
229 }
230 
232  switch (AttrKind) {
233 #define GET_ATTR_NAMES
234 #define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \
235  case Attribute::ENUM_NAME: \
236  return #DISPLAY_NAME;
237 #include "llvm/IR/Attributes.inc"
238  case Attribute::None:
239  return "none";
240  default:
241  llvm_unreachable("invalid Kind");
242  }
243 }
244 
246  return StringSwitch<bool>(Name)
247 #define GET_ATTR_NAMES
248 #define ATTRIBUTE_ALL(ENUM_NAME, DISPLAY_NAME) .Case(#DISPLAY_NAME, true)
249 #include "llvm/IR/Attributes.inc"
250  .Default(false);
251 }
252 
253 //===----------------------------------------------------------------------===//
254 // Attribute Accessor Methods
255 //===----------------------------------------------------------------------===//
256 
258  return pImpl && pImpl->isEnumAttribute();
259 }
260 
262  return pImpl && pImpl->isIntAttribute();
263 }
264 
266  return pImpl && pImpl->isStringAttribute();
267 }
268 
270  return pImpl && pImpl->isTypeAttribute();
271 }
272 
274  if (!pImpl) return None;
276  "Invalid attribute type to get the kind as an enum!");
277  return pImpl->getKindAsEnum();
278 }
279 
281  if (!pImpl) return 0;
283  "Expected the attribute to be an integer attribute!");
284  return pImpl->getValueAsInt();
285 }
286 
288  if (!pImpl) return false;
290  "Expected the attribute to be a string attribute!");
291  return pImpl->getValueAsBool();
292 }
293 
295  if (!pImpl) return {};
297  "Invalid attribute type to get the kind as a string!");
298  return pImpl->getKindAsString();
299 }
300 
302  if (!pImpl) return {};
304  "Invalid attribute type to get the value as a string!");
305  return pImpl->getValueAsString();
306 }
307 
309  if (!pImpl) return {};
311  "Invalid attribute type to get the value as a type!");
312  return pImpl->getValueAsType();
313 }
314 
315 
317  return (pImpl && pImpl->hasAttribute(Kind)) || (!pImpl && Kind == None);
318 }
319 
321  if (!isStringAttribute()) return false;
322  return pImpl && pImpl->hasAttribute(Kind);
323 }
324 
326  assert(hasAttribute(Attribute::Alignment) &&
327  "Trying to get alignment from non-alignment attribute!");
328  return MaybeAlign(pImpl->getValueAsInt());
329 }
330 
332  assert(hasAttribute(Attribute::StackAlignment) &&
333  "Trying to get alignment from non-alignment attribute!");
334  return MaybeAlign(pImpl->getValueAsInt());
335 }
336 
338  assert(hasAttribute(Attribute::Dereferenceable) &&
339  "Trying to get dereferenceable bytes from "
340  "non-dereferenceable attribute!");
341  return pImpl->getValueAsInt();
342 }
343 
345  assert(hasAttribute(Attribute::DereferenceableOrNull) &&
346  "Trying to get dereferenceable bytes from "
347  "non-dereferenceable attribute!");
348  return pImpl->getValueAsInt();
349 }
350 
351 std::pair<unsigned, Optional<unsigned>> Attribute::getAllocSizeArgs() const {
352  assert(hasAttribute(Attribute::AllocSize) &&
353  "Trying to get allocsize args from non-allocsize attribute");
354  return unpackAllocSizeArgs(pImpl->getValueAsInt());
355 }
356 
357 std::pair<unsigned, unsigned> Attribute::getVScaleRangeArgs() const {
358  assert(hasAttribute(Attribute::VScaleRange) &&
359  "Trying to get vscale args from non-vscale attribute");
360  return unpackVScaleRangeArgs(pImpl->getValueAsInt());
361 }
362 
363 std::string Attribute::getAsString(bool InAttrGrp) const {
364  if (!pImpl) return {};
365 
366  if (isEnumAttribute())
368 
369  if (isTypeAttribute()) {
370  std::string Result = getNameFromAttrKind(getKindAsEnum()).str();
371  Result += '(';
372  raw_string_ostream OS(Result);
373  getValueAsType()->print(OS, false, true);
374  OS.flush();
375  Result += ')';
376  return Result;
377  }
378 
379  // FIXME: These should be output like this:
380  //
381  // align=4
382  // alignstack=8
383  //
384  if (hasAttribute(Attribute::Alignment)) {
385  std::string Result;
386  Result += "align";
387  Result += (InAttrGrp) ? "=" : " ";
388  Result += utostr(getValueAsInt());
389  return Result;
390  }
391 
392  auto AttrWithBytesToString = [&](const char *Name) {
393  std::string Result;
394  Result += Name;
395  if (InAttrGrp) {
396  Result += "=";
397  Result += utostr(getValueAsInt());
398  } else {
399  Result += "(";
400  Result += utostr(getValueAsInt());
401  Result += ")";
402  }
403  return Result;
404  };
405 
406  if (hasAttribute(Attribute::StackAlignment))
407  return AttrWithBytesToString("alignstack");
408 
409  if (hasAttribute(Attribute::Dereferenceable))
410  return AttrWithBytesToString("dereferenceable");
411 
412  if (hasAttribute(Attribute::DereferenceableOrNull))
413  return AttrWithBytesToString("dereferenceable_or_null");
414 
415  if (hasAttribute(Attribute::AllocSize)) {
416  unsigned ElemSize;
417  Optional<unsigned> NumElems;
418  std::tie(ElemSize, NumElems) = getAllocSizeArgs();
419 
420  std::string Result = "allocsize(";
421  Result += utostr(ElemSize);
422  if (NumElems.hasValue()) {
423  Result += ',';
424  Result += utostr(*NumElems);
425  }
426  Result += ')';
427  return Result;
428  }
429 
430  if (hasAttribute(Attribute::VScaleRange)) {
431  unsigned MinValue, MaxValue;
432  std::tie(MinValue, MaxValue) = getVScaleRangeArgs();
433 
434  std::string Result = "vscale_range(";
435  Result += utostr(MinValue);
436  Result += ',';
437  Result += utostr(MaxValue);
438  Result += ')';
439  return Result;
440  }
441 
442  // Convert target-dependent attributes to strings of the form:
443  //
444  // "kind"
445  // "kind" = "value"
446  //
447  if (isStringAttribute()) {
448  std::string Result;
449  {
450  raw_string_ostream OS(Result);
451  OS << '"' << getKindAsString() << '"';
452 
453  // Since some attribute strings contain special characters that cannot be
454  // printable, those have to be escaped to make the attribute value
455  // printable as is. e.g. "\01__gnu_mcount_nc"
456  const auto &AttrVal = pImpl->getValueAsString();
457  if (!AttrVal.empty()) {
458  OS << "=\"";
459  printEscapedString(AttrVal, OS);
460  OS << "\"";
461  }
462  }
463  return Result;
464  }
465 
466  llvm_unreachable("Unknown attribute");
467 }
468 
470  assert(isValid() && "invalid Attribute doesn't refer to any context");
472  pImpl->Profile(ID);
473  void *Unused;
474  return C.pImpl->AttrsSet.FindNodeOrInsertPos(ID, Unused) == pImpl;
475 }
476 
478  if (!pImpl && !A.pImpl) return false;
479  if (!pImpl) return true;
480  if (!A.pImpl) return false;
481  return *pImpl < *A.pImpl;
482 }
483 
485  ID.AddPointer(pImpl);
486 }
487 
489  FnAttr = (1 << 0),
490  ParamAttr = (1 << 1),
491  RetAttr = (1 << 2),
492 };
493 
494 #define GET_ATTR_PROP_TABLE
495 #include "llvm/IR/Attributes.inc"
496 
498  AttributeProperty Prop) {
499  unsigned Index = Kind - 1;
500  assert(Index < sizeof(AttrPropTable) / sizeof(AttrPropTable[0]) &&
501  "Invalid attribute kind");
502  return AttrPropTable[Index] & Prop;
503 }
504 
507 }
508 
511 }
512 
515 }
516 
517 //===----------------------------------------------------------------------===//
518 // AttributeImpl Definition
519 //===----------------------------------------------------------------------===//
520 
522  if (isStringAttribute()) return false;
523  return getKindAsEnum() == A;
524 }
525 
527  if (!isStringAttribute()) return false;
528  return getKindAsString() == Kind;
529 }
530 
533  return static_cast<const EnumAttributeImpl *>(this)->getEnumKind();
534 }
535 
538  return static_cast<const IntAttributeImpl *>(this)->getValue();
539 }
540 
542  assert(getValueAsString().empty() || getValueAsString() == "false" || getValueAsString() == "true");
543  return getValueAsString() == "true";
544 }
545 
548  return static_cast<const StringAttributeImpl *>(this)->getStringKind();
549 }
550 
553  return static_cast<const StringAttributeImpl *>(this)->getStringValue();
554 }
555 
558  return static_cast<const TypeAttributeImpl *>(this)->getTypeValue();
559 }
560 
562  if (this == &AI)
563  return false;
564 
565  // This sorts the attributes with Attribute::AttrKinds coming first (sorted
566  // relative to their enum value) and then strings.
567  if (!isStringAttribute()) {
568  if (AI.isStringAttribute())
569  return true;
570  if (getKindAsEnum() != AI.getKindAsEnum())
571  return getKindAsEnum() < AI.getKindAsEnum();
572  assert(!AI.isEnumAttribute() && "Non-unique attribute");
573  assert(!AI.isTypeAttribute() && "Comparison of types would be unstable");
574  // TODO: Is this actually needed?
575  assert(AI.isIntAttribute() && "Only possibility left");
576  return getValueAsInt() < AI.getValueAsInt();
577  }
578 
579  if (!AI.isStringAttribute())
580  return false;
581  if (getKindAsString() == AI.getKindAsString())
582  return getValueAsString() < AI.getValueAsString();
583  return getKindAsString() < AI.getKindAsString();
584 }
585 
586 //===----------------------------------------------------------------------===//
587 // AttributeSet Definition
588 //===----------------------------------------------------------------------===//
589 
592 }
593 
596 }
597 
599  Attribute::AttrKind Kind) const {
600  if (hasAttribute(Kind)) return *this;
601  AttrBuilder B;
602  B.addAttribute(Kind);
603  return addAttributes(C, AttributeSet::get(C, B));
604 }
605 
607  StringRef Value) const {
608  AttrBuilder B;
609  B.addAttribute(Kind, Value);
610  return addAttributes(C, AttributeSet::get(C, B));
611 }
612 
614  const AttributeSet AS) const {
615  if (!hasAttributes())
616  return AS;
617 
618  if (!AS.hasAttributes())
619  return *this;
620 
621  AttrBuilder B(AS);
622  for (const auto &I : *this)
623  B.addAttribute(I);
624 
625  return get(C, B);
626 }
627 
629  Attribute::AttrKind Kind) const {
630  if (!hasAttribute(Kind)) return *this;
631  AttrBuilder B(*this);
632  B.removeAttribute(Kind);
633  return get(C, B);
634 }
635 
637  StringRef Kind) const {
638  if (!hasAttribute(Kind)) return *this;
639  AttrBuilder B(*this);
640  B.removeAttribute(Kind);
641  return get(C, B);
642 }
643 
645  const AttrBuilder &Attrs) const {
646  AttrBuilder B(*this);
647  // If there is nothing to remove, directly return the original set.
648  if (!B.overlaps(Attrs))
649  return *this;
650 
651  B.remove(Attrs);
652  return get(C, B);
653 }
654 
656  return SetNode ? SetNode->getNumAttributes() : 0;
657 }
658 
660  return SetNode ? SetNode->hasAttribute(Kind) : false;
661 }
662 
664  return SetNode ? SetNode->hasAttribute(Kind) : false;
665 }
666 
668  return SetNode ? SetNode->getAttribute(Kind) : Attribute();
669 }
670 
672  return SetNode ? SetNode->getAttribute(Kind) : Attribute();
673 }
674 
676  return SetNode ? SetNode->getAlignment() : None;
677 }
678 
680  return SetNode ? SetNode->getStackAlignment() : None;
681 }
682 
684  return SetNode ? SetNode->getDereferenceableBytes() : 0;
685 }
686 
688  return SetNode ? SetNode->getDereferenceableOrNullBytes() : 0;
689 }
690 
692  return SetNode ? SetNode->getAttributeType(Attribute::ByRef) : nullptr;
693 }
694 
696  return SetNode ? SetNode->getAttributeType(Attribute::ByVal) : nullptr;
697 }
698 
700  return SetNode ? SetNode->getAttributeType(Attribute::StructRet) : nullptr;
701 }
702 
704  return SetNode ? SetNode->getAttributeType(Attribute::Preallocated) : nullptr;
705 }
706 
708  return SetNode ? SetNode->getAttributeType(Attribute::InAlloca) : nullptr;
709 }
710 
712  return SetNode ? SetNode->getAttributeType(Attribute::ElementType) : nullptr;
713 }
714 
715 std::pair<unsigned, Optional<unsigned>> AttributeSet::getAllocSizeArgs() const {
716  return SetNode ? SetNode->getAllocSizeArgs()
717  : std::pair<unsigned, Optional<unsigned>>(0, 0);
718 }
719 
720 std::pair<unsigned, unsigned> AttributeSet::getVScaleRangeArgs() const {
721  return SetNode ? SetNode->getVScaleRangeArgs()
722  : std::pair<unsigned, unsigned>(0, 0);
723 }
724 
725 std::string AttributeSet::getAsString(bool InAttrGrp) const {
726  return SetNode ? SetNode->getAsString(InAttrGrp) : "";
727 }
728 
730  assert(hasAttributes() && "empty AttributeSet doesn't refer to any context");
732  SetNode->Profile(ID);
733  void *Unused;
734  return C.pImpl->AttrsSetNodes.FindNodeOrInsertPos(ID, Unused) == SetNode;
735 }
736 
738  return SetNode ? SetNode->begin() : nullptr;
739 }
740 
742  return SetNode ? SetNode->end() : nullptr;
743 }
744 
745 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
747  dbgs() << "AS =\n";
748  dbgs() << " { ";
749  dbgs() << getAsString(true) << " }\n";
750 }
751 #endif
752 
753 //===----------------------------------------------------------------------===//
754 // AttributeSetNode Definition
755 //===----------------------------------------------------------------------===//
756 
757 AttributeSetNode::AttributeSetNode(ArrayRef<Attribute> Attrs)
758  : NumAttrs(Attrs.size()) {
759  // There's memory after the node where we can store the entries in.
760  llvm::copy(Attrs, getTrailingObjects<Attribute>());
761 
762  for (const auto &I : *this) {
763  if (I.isStringAttribute())
764  StringAttrs.insert({ I.getKindAsString(), I });
765  else
766  AvailableAttrs.addAttribute(I.getKindAsEnum());
767  }
768 }
769 
772  SmallVector<Attribute, 8> SortedAttrs(Attrs.begin(), Attrs.end());
773  llvm::sort(SortedAttrs);
774  return getSorted(C, SortedAttrs);
775 }
776 
777 AttributeSetNode *AttributeSetNode::getSorted(LLVMContext &C,
778  ArrayRef<Attribute> SortedAttrs) {
779  if (SortedAttrs.empty())
780  return nullptr;
781 
782  // Build a key to look up the existing attributes.
783  LLVMContextImpl *pImpl = C.pImpl;
785 
786  assert(llvm::is_sorted(SortedAttrs) && "Expected sorted attributes!");
787  for (const auto &Attr : SortedAttrs)
788  Attr.Profile(ID);
789 
790  void *InsertPoint;
791  AttributeSetNode *PA =
792  pImpl->AttrsSetNodes.FindNodeOrInsertPos(ID, InsertPoint);
793 
794  // If we didn't find any existing attributes of the same shape then create a
795  // new one and insert it.
796  if (!PA) {
797  // Coallocate entries after the AttributeSetNode itself.
798  void *Mem = ::operator new(totalSizeToAlloc<Attribute>(SortedAttrs.size()));
799  PA = new (Mem) AttributeSetNode(SortedAttrs);
800  pImpl->AttrsSetNodes.InsertNode(PA, InsertPoint);
801  }
802 
803  // Return the AttributeSetNode that we found or created.
804  return PA;
805 }
806 
808  // Add target-independent attributes.
812  if (!B.contains(Kind))
813  continue;
814 
815  Attribute Attr;
817  Attr = Attribute::get(C, Kind, B.getTypeAttr(Kind));
818  else if (Attribute::isIntAttrKind(Kind))
819  Attr = Attribute::get(C, Kind, B.getRawIntAttr(Kind));
820  else
821  Attr = Attribute::get(C, Kind);
822  Attrs.push_back(Attr);
823  }
824 
825  // Add target-dependent (string) attributes.
826  for (const auto &TDA : B.td_attrs())
827  Attrs.emplace_back(Attribute::get(C, TDA.first, TDA.second));
828 
829  return getSorted(C, Attrs);
830 }
831 
833  return StringAttrs.count(Kind);
834 }
835 
837 AttributeSetNode::findEnumAttribute(Attribute::AttrKind Kind) const {
838  // Do a quick presence check.
839  if (!hasAttribute(Kind))
840  return None;
841 
842  // Attributes in a set are sorted by enum value, followed by string
843  // attributes. Binary search the one we want.
844  const Attribute *I =
845  std::lower_bound(begin(), end() - StringAttrs.size(), Kind,
847  return A.getKindAsEnum() < Kind;
848  });
849  assert(I != end() && I->hasAttribute(Kind) && "Presence check failed?");
850  return *I;
851 }
852 
854  if (auto A = findEnumAttribute(Kind))
855  return *A;
856  return {};
857 }
858 
860  return StringAttrs.lookup(Kind);
861 }
862 
864  if (auto A = findEnumAttribute(Attribute::Alignment))
865  return A->getAlignment();
866  return None;
867 }
868 
870  if (auto A = findEnumAttribute(Attribute::StackAlignment))
871  return A->getStackAlignment();
872  return None;
873 }
874 
876  if (auto A = findEnumAttribute(Kind))
877  return A->getValueAsType();
878  return nullptr;
879 }
880 
882  if (auto A = findEnumAttribute(Attribute::Dereferenceable))
883  return A->getDereferenceableBytes();
884  return 0;
885 }
886 
888  if (auto A = findEnumAttribute(Attribute::DereferenceableOrNull))
889  return A->getDereferenceableOrNullBytes();
890  return 0;
891 }
892 
893 std::pair<unsigned, Optional<unsigned>>
895  if (auto A = findEnumAttribute(Attribute::AllocSize))
896  return A->getAllocSizeArgs();
897  return std::make_pair(0, 0);
898 }
899 
900 std::pair<unsigned, unsigned> AttributeSetNode::getVScaleRangeArgs() const {
901  if (auto A = findEnumAttribute(Attribute::VScaleRange))
902  return A->getVScaleRangeArgs();
903  return std::make_pair(0, 0);
904 }
905 
906 std::string AttributeSetNode::getAsString(bool InAttrGrp) const {
907  std::string Str;
908  for (iterator I = begin(), E = end(); I != E; ++I) {
909  if (I != begin())
910  Str += ' ';
911  Str += I->getAsString(InAttrGrp);
912  }
913  return Str;
914 }
915 
916 //===----------------------------------------------------------------------===//
917 // AttributeListImpl Definition
918 //===----------------------------------------------------------------------===//
919 
920 /// Map from AttributeList index to the internal array index. Adding one happens
921 /// to work, because -1 wraps around to 0.
922 static unsigned attrIdxToArrayIdx(unsigned Index) {
923  return Index + 1;
924 }
925 
927  : NumAttrSets(Sets.size()) {
928  assert(!Sets.empty() && "pointless AttributeListImpl");
929 
930  // There's memory after the node where we can store the entries in.
931  llvm::copy(Sets, getTrailingObjects<AttributeSet>());
932 
933  // Initialize AvailableFunctionAttrs and AvailableSomewhereAttrs
934  // summary bitsets.
935  for (const auto &I : Sets[attrIdxToArrayIdx(AttributeList::FunctionIndex)])
936  if (!I.isStringAttribute())
937  AvailableFunctionAttrs.addAttribute(I.getKindAsEnum());
938 
939  for (const auto &Set : Sets)
940  for (const auto &I : Set)
941  if (!I.isStringAttribute())
942  AvailableSomewhereAttrs.addAttribute(I.getKindAsEnum());
943 }
944 
946  Profile(ID, makeArrayRef(begin(), end()));
947 }
948 
950  ArrayRef<AttributeSet> Sets) {
951  for (const auto &Set : Sets)
952  ID.AddPointer(Set.SetNode);
953 }
954 
956  unsigned *Index) const {
957  if (!AvailableSomewhereAttrs.hasAttribute(Kind))
958  return false;
959 
960  if (Index) {
961  for (unsigned I = 0, E = NumAttrSets; I != E; ++I) {
962  if (begin()[I].hasAttribute(Kind)) {
963  *Index = I - 1;
964  break;
965  }
966  }
967  }
968 
969  return true;
970 }
971 
972 
973 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
975  AttributeList(const_cast<AttributeListImpl *>(this)).dump();
976 }
977 #endif
978 
979 //===----------------------------------------------------------------------===//
980 // AttributeList Construction and Mutation Methods
981 //===----------------------------------------------------------------------===//
982 
984  ArrayRef<AttributeSet> AttrSets) {
985  assert(!AttrSets.empty() && "pointless AttributeListImpl");
986 
987  LLVMContextImpl *pImpl = C.pImpl;
989  AttributeListImpl::Profile(ID, AttrSets);
990 
991  void *InsertPoint;
992  AttributeListImpl *PA =
993  pImpl->AttrsLists.FindNodeOrInsertPos(ID, InsertPoint);
994 
995  // If we didn't find any existing attributes of the same shape then
996  // create a new one and insert it.
997  if (!PA) {
998  // Coallocate entries after the AttributeListImpl itself.
999  void *Mem = pImpl->Alloc.Allocate(
1000  AttributeListImpl::totalSizeToAlloc<AttributeSet>(AttrSets.size()),
1001  alignof(AttributeListImpl));
1002  PA = new (Mem) AttributeListImpl(AttrSets);
1003  pImpl->AttrsLists.InsertNode(PA, InsertPoint);
1004  }
1005 
1006  // Return the AttributesList that we found or created.
1007  return AttributeList(PA);
1008 }
1009 
1012  ArrayRef<std::pair<unsigned, Attribute>> Attrs) {
1013  // If there are no attributes then return a null AttributesList pointer.
1014  if (Attrs.empty())
1015  return {};
1016 
1018  [](const std::pair<unsigned, Attribute> &LHS,
1019  const std::pair<unsigned, Attribute> &RHS) {
1020  return LHS.first < RHS.first;
1021  }) &&
1022  "Misordered Attributes list!");
1024  [](const std::pair<unsigned, Attribute> &Pair) {
1025  return Pair.second.isValid();
1026  }) &&
1027  "Pointless attribute!");
1028 
1029  // Create a vector if (unsigned, AttributeSetNode*) pairs from the attributes
1030  // list.
1032  for (ArrayRef<std::pair<unsigned, Attribute>>::iterator I = Attrs.begin(),
1033  E = Attrs.end(); I != E; ) {
1034  unsigned Index = I->first;
1035  SmallVector<Attribute, 4> AttrVec;
1036  while (I != E && I->first == Index) {
1037  AttrVec.push_back(I->second);
1038  ++I;
1039  }
1040 
1041  AttrPairVec.emplace_back(Index, AttributeSet::get(C, AttrVec));
1042  }
1043 
1044  return get(C, AttrPairVec);
1045 }
1046 
1049  ArrayRef<std::pair<unsigned, AttributeSet>> Attrs) {
1050  // If there are no attributes then return a null AttributesList pointer.
1051  if (Attrs.empty())
1052  return {};
1053 
1055  [](const std::pair<unsigned, AttributeSet> &LHS,
1056  const std::pair<unsigned, AttributeSet> &RHS) {
1057  return LHS.first < RHS.first;
1058  }) &&
1059  "Misordered Attributes list!");
1061  [](const std::pair<unsigned, AttributeSet> &Pair) {
1062  return !Pair.second.hasAttributes();
1063  }) &&
1064  "Pointless attribute!");
1065 
1066  unsigned MaxIndex = Attrs.back().first;
1067  // If the MaxIndex is FunctionIndex and there are other indices in front
1068  // of it, we need to use the largest of those to get the right size.
1069  if (MaxIndex == FunctionIndex && Attrs.size() > 1)
1070  MaxIndex = Attrs[Attrs.size() - 2].first;
1071 
1072  SmallVector<AttributeSet, 4> AttrVec(attrIdxToArrayIdx(MaxIndex) + 1);
1073  for (const auto &Pair : Attrs)
1074  AttrVec[attrIdxToArrayIdx(Pair.first)] = Pair.second;
1075 
1076  return getImpl(C, AttrVec);
1077 }
1078 
1080  AttributeSet RetAttrs,
1081  ArrayRef<AttributeSet> ArgAttrs) {
1082  // Scan from the end to find the last argument with attributes. Most
1083  // arguments don't have attributes, so it's nice if we can have fewer unique
1084  // AttributeListImpls by dropping empty attribute sets at the end of the list.
1085  unsigned NumSets = 0;
1086  for (size_t I = ArgAttrs.size(); I != 0; --I) {
1087  if (ArgAttrs[I - 1].hasAttributes()) {
1088  NumSets = I + 2;
1089  break;
1090  }
1091  }
1092  if (NumSets == 0) {
1093  // Check function and return attributes if we didn't have argument
1094  // attributes.
1095  if (RetAttrs.hasAttributes())
1096  NumSets = 2;
1097  else if (FnAttrs.hasAttributes())
1098  NumSets = 1;
1099  }
1100 
1101  // If all attribute sets were empty, we can use the empty attribute list.
1102  if (NumSets == 0)
1103  return {};
1104 
1106  AttrSets.reserve(NumSets);
1107  // If we have any attributes, we always have function attributes.
1108  AttrSets.push_back(FnAttrs);
1109  if (NumSets > 1)
1110  AttrSets.push_back(RetAttrs);
1111  if (NumSets > 2) {
1112  // Drop the empty argument attribute sets at the end.
1113  ArgAttrs = ArgAttrs.take_front(NumSets - 2);
1114  llvm::append_range(AttrSets, ArgAttrs);
1115  }
1116 
1117  return getImpl(C, AttrSets);
1118 }
1119 
1121  const AttrBuilder &B) {
1122  if (!B.hasAttributes())
1123  return {};
1125  SmallVector<AttributeSet, 8> AttrSets(Index + 1);
1126  AttrSets[Index] = AttributeSet::get(C, B);
1127  return getImpl(C, AttrSets);
1128 }
1129 
1133  for (const auto K : Kinds)
1134  Attrs.emplace_back(Index, Attribute::get(C, K));
1135  return get(C, Attrs);
1136 }
1137 
1140  ArrayRef<uint64_t> Values) {
1141  assert(Kinds.size() == Values.size() && "Mismatched attribute values.");
1143  auto VI = Values.begin();
1144  for (const auto K : Kinds)
1145  Attrs.emplace_back(Index, Attribute::get(C, K, *VI++));
1146  return get(C, Attrs);
1147 }
1148 
1150  ArrayRef<StringRef> Kinds) {
1152  for (const auto &K : Kinds)
1153  Attrs.emplace_back(Index, Attribute::get(C, K));
1154  return get(C, Attrs);
1155 }
1156 
1159  if (Attrs.empty())
1160  return {};
1161  if (Attrs.size() == 1)
1162  return Attrs[0];
1163 
1164  unsigned MaxSize = 0;
1165  for (const auto &List : Attrs)
1166  MaxSize = std::max(MaxSize, List.getNumAttrSets());
1167 
1168  // If every list was empty, there is no point in merging the lists.
1169  if (MaxSize == 0)
1170  return {};
1171 
1172  SmallVector<AttributeSet, 8> NewAttrSets(MaxSize);
1173  for (unsigned I = 0; I < MaxSize; ++I) {
1174  AttrBuilder CurBuilder;
1175  for (const auto &List : Attrs)
1176  CurBuilder.merge(List.getAttributes(I - 1));
1177  NewAttrSets[I] = AttributeSet::get(C, CurBuilder);
1178  }
1179 
1180  return getImpl(C, NewAttrSets);
1181 }
1182 
1185  Attribute::AttrKind Kind) const {
1187  return *this;
1189  // TODO: Insert at correct position and avoid sort.
1191  NewAttrs.push_back(Attribute::get(C, Kind));
1192  return setAttributesAtIndex(C, Index, AttributeSet::get(C, NewAttrs));
1193 }
1194 
1196  StringRef Kind,
1197  StringRef Value) const {
1198  AttrBuilder B;
1199  B.addAttribute(Kind, Value);
1200  return addAttributesAtIndex(C, Index, B);
1201 }
1202 
1204  Attribute A) const {
1205  AttrBuilder B;
1206  B.addAttribute(A);
1207  return addAttributesAtIndex(C, Index, B);
1208 }
1209 
1210 AttributeList AttributeList::setAttributesAtIndex(LLVMContext &C,
1211  unsigned Index,
1212  AttributeSet Attrs) const {
1214  SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
1215  if (Index >= AttrSets.size())
1216  AttrSets.resize(Index + 1);
1217  AttrSets[Index] = Attrs;
1218  return AttributeList::getImpl(C, AttrSets);
1219 }
1220 
1222  unsigned Index,
1223  const AttrBuilder &B) const {
1224  if (!B.hasAttributes())
1225  return *this;
1226 
1227  if (!pImpl)
1228  return AttributeList::get(C, {{Index, AttributeSet::get(C, B)}});
1229 
1230 #ifndef NDEBUG
1231  // FIXME it is not obvious how this should work for alignment. For now, say
1232  // we can't change a known alignment.
1233  const MaybeAlign OldAlign = getAttributes(Index).getAlignment();
1234  const MaybeAlign NewAlign = B.getAlignment();
1235  assert((!OldAlign || !NewAlign || OldAlign == NewAlign) &&
1236  "Attempt to change alignment!");
1237 #endif
1238 
1239  AttrBuilder Merged(getAttributes(Index));
1240  Merged.merge(B);
1241  return setAttributesAtIndex(C, Index, AttributeSet::get(C, Merged));
1242 }
1243 
1245  ArrayRef<unsigned> ArgNos,
1246  Attribute A) const {
1247  assert(llvm::is_sorted(ArgNos));
1248 
1249  SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
1250  unsigned MaxIndex = attrIdxToArrayIdx(ArgNos.back() + FirstArgIndex);
1251  if (MaxIndex >= AttrSets.size())
1252  AttrSets.resize(MaxIndex + 1);
1253 
1254  for (unsigned ArgNo : ArgNos) {
1255  unsigned Index = attrIdxToArrayIdx(ArgNo + FirstArgIndex);
1256  AttrBuilder B(AttrSets[Index]);
1257  B.addAttribute(A);
1258  AttrSets[Index] = AttributeSet::get(C, B);
1259  }
1260 
1261  return getImpl(C, AttrSets);
1262 }
1263 
1266  Attribute::AttrKind Kind) const {
1268  return *this;
1269 
1271  SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
1272  assert(Index < AttrSets.size());
1273 
1274  AttrSets[Index] = AttrSets[Index].removeAttribute(C, Kind);
1275 
1276  return getImpl(C, AttrSets);
1277 }
1278 
1280  unsigned Index,
1281  StringRef Kind) const {
1283  return *this;
1284 
1286  SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
1287  assert(Index < AttrSets.size());
1288 
1289  AttrSets[Index] = AttrSets[Index].removeAttribute(C, Kind);
1290 
1291  return getImpl(C, AttrSets);
1292 }
1293 
1296  const AttrBuilder &AttrsToRemove) const {
1298  AttributeSet NewAttrs = Attrs.removeAttributes(C, AttrsToRemove);
1299  // If nothing was removed, return the original list.
1300  if (Attrs == NewAttrs)
1301  return *this;
1302  return setAttributesAtIndex(C, Index, NewAttrs);
1303 }
1304 
1307  unsigned WithoutIndex) const {
1308  if (!pImpl)
1309  return {};
1310  WithoutIndex = attrIdxToArrayIdx(WithoutIndex);
1311  if (WithoutIndex >= getNumAttrSets())
1312  return *this;
1313  SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
1314  AttrSets[WithoutIndex] = AttributeSet();
1315  return getImpl(C, AttrSets);
1316 }
1317 
1319  uint64_t Bytes) const {
1320  AttrBuilder B;
1321  B.addDereferenceableAttr(Bytes);
1322  return addRetAttributes(C, B);
1323 }
1324 
1326  unsigned Index,
1327  uint64_t Bytes) const {
1328  AttrBuilder B;
1329  B.addDereferenceableAttr(Bytes);
1330  return addParamAttributes(C, Index, B);
1331 }
1332 
1335  uint64_t Bytes) const {
1336  AttrBuilder B;
1337  B.addDereferenceableOrNullAttr(Bytes);
1338  return addParamAttributes(C, Index, B);
1339 }
1340 
1343  unsigned ElemSizeArg,
1344  const Optional<unsigned> &NumElemsArg) {
1345  AttrBuilder B;
1346  B.addAllocSizeAttr(ElemSizeArg, NumElemsArg);
1347  return addParamAttributes(C, Index, B);
1348 }
1349 
1350 //===----------------------------------------------------------------------===//
1351 // AttributeList Accessor Methods
1352 //===----------------------------------------------------------------------===//
1353 
1355  return getAttributes(ArgNo + FirstArgIndex);
1356 }
1357 
1359  return getAttributes(ReturnIndex);
1360 }
1361 
1363  return getAttributes(FunctionIndex);
1364 }
1365 
1367  Attribute::AttrKind Kind) const {
1369 }
1370 
1373 }
1374 
1376  return getAttributes(Index).hasAttributes();
1377 }
1378 
1380  return pImpl && pImpl->hasFnAttribute(Kind);
1381 }
1382 
1385 }
1386 
1388  unsigned *Index) const {
1389  return pImpl && pImpl->hasAttrSomewhere(Attr, Index);
1390 }
1391 
1393  Attribute::AttrKind Kind) const {
1395 }
1396 
1398  StringRef Kind) const {
1400 }
1401 
1404 }
1405 
1407  return getAttributes(ArgNo + FirstArgIndex).getAlignment();
1408 }
1409 
1411  return getAttributes(ArgNo + FirstArgIndex).getStackAlignment();
1412 }
1413 
1416 }
1417 
1420 }
1421 
1424 }
1425 
1428 }
1429 
1432 }
1433 
1436 }
1437 
1439  return getFnAttrs().getStackAlignment();
1440 }
1441 
1443  return getRetAttrs().getStackAlignment();
1444 }
1445 
1448 }
1449 
1452 }
1453 
1456 }
1457 
1458 uint64_t
1461 }
1462 
1463 std::string AttributeList::getAsString(unsigned Index, bool InAttrGrp) const {
1464  return getAttributes(Index).getAsString(InAttrGrp);
1465 }
1466 
1469  if (!pImpl || Index >= getNumAttrSets())
1470  return {};
1471  return pImpl->begin()[Index];
1472 }
1473 
1475  assert(!isEmpty() && "an empty attribute list has no parent context");
1477  pImpl->Profile(ID);
1478  void *Unused;
1479  return C.pImpl->AttrsLists.FindNodeOrInsertPos(ID, Unused) == pImpl;
1480 }
1481 
1483  return pImpl ? pImpl->begin() : nullptr;
1484 }
1485 
1487  return pImpl ? pImpl->end() : nullptr;
1488 }
1489 
1490 //===----------------------------------------------------------------------===//
1491 // AttributeList Introspection Methods
1492 //===----------------------------------------------------------------------===//
1493 
1495  return pImpl ? pImpl->NumAttrSets : 0;
1496 }
1497 
1499  O << "AttributeList[\n";
1500 
1501  for (unsigned i : indexes()) {
1502  if (!getAttributes(i).hasAttributes())
1503  continue;
1504  O << " { ";
1505  switch (i) {
1506  case AttrIndex::ReturnIndex:
1507  O << "return";
1508  break;
1509  case AttrIndex::FunctionIndex:
1510  O << "function";
1511  break;
1512  default:
1513  O << "arg(" << i - AttrIndex::FirstArgIndex << ")";
1514  }
1515  O << " => " << getAsString(i) << " }\n";
1516  }
1517 
1518  O << "]\n";
1519 }
1520 
1521 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1523 #endif
1524 
1525 //===----------------------------------------------------------------------===//
1526 // AttrBuilder Method Implementations
1527 //===----------------------------------------------------------------------===//
1528 
1529 // FIXME: Remove this ctor, use AttributeSet.
1531  AttributeSet AS = AL.getAttributes(Index);
1532  for (const auto &A : AS)
1533  addAttribute(A);
1534 }
1535 
1537  for (const auto &A : AS)
1538  addAttribute(A);
1539 }
1540 
1542  Attrs.reset();
1543  TargetDepAttrs.clear();
1544  IntAttrs = {};
1545  TypeAttrs = {};
1546 }
1547 
1549 AttrBuilder::kindToIntIndex(Attribute::AttrKind Kind) const {
1551  return Kind - Attribute::FirstIntAttr;
1552  return None;
1553 }
1554 
1556 AttrBuilder::kindToTypeIndex(Attribute::AttrKind Kind) const {
1558  return Kind - Attribute::FirstTypeAttr;
1559  return None;
1560 }
1561 
1563  if (Attr.isStringAttribute()) {
1565  return *this;
1566  }
1567 
1569  Attrs[Kind] = true;
1570 
1571  if (Optional<unsigned> TypeIndex = kindToTypeIndex(Kind))
1572  TypeAttrs[*TypeIndex] = Attr.getValueAsType();
1573  else if (Optional<unsigned> IntIndex = kindToIntIndex(Kind))
1574  IntAttrs[*IntIndex] = Attr.getValueAsInt();
1575 
1576  return *this;
1577 }
1578 
1580  TargetDepAttrs[A] = V;
1581  return *this;
1582 }
1583 
1585  assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
1586  Attrs[Val] = false;
1587 
1588  if (Optional<unsigned> TypeIndex = kindToTypeIndex(Val))
1589  TypeAttrs[*TypeIndex] = nullptr;
1590  else if (Optional<unsigned> IntIndex = kindToIntIndex(Val))
1591  IntAttrs[*IntIndex] = 0;
1592 
1593  return *this;
1594 }
1595 
1597  remove(A.getAttributes(Index));
1598  return *this;
1599 }
1600 
1602  TargetDepAttrs.erase(A);
1603  return *this;
1604 }
1605 
1607  Optional<unsigned> IntIndex = kindToIntIndex(Kind);
1608  assert(IntIndex && "Not an int attribute");
1609  return IntAttrs[*IntIndex];
1610 }
1611 
1613  uint64_t Value) {
1614  Optional<unsigned> IntIndex = kindToIntIndex(Kind);
1615  assert(IntIndex && "Not an int attribute");
1616  assert(Value && "Value cannot be zero");
1617  Attrs[Kind] = true;
1618  IntAttrs[*IntIndex] = Value;
1619  return *this;
1620 }
1621 
1622 std::pair<unsigned, Optional<unsigned>> AttrBuilder::getAllocSizeArgs() const {
1623  return unpackAllocSizeArgs(getRawIntAttr(Attribute::AllocSize));
1624 }
1625 
1626 std::pair<unsigned, unsigned> AttrBuilder::getVScaleRangeArgs() const {
1627  return unpackVScaleRangeArgs(getRawIntAttr(Attribute::VScaleRange));
1628 }
1629 
1631  if (!Align)
1632  return *this;
1633 
1634  assert(*Align <= llvm::Value::MaximumAlignment && "Alignment too large.");
1635  return addRawIntAttr(Attribute::Alignment, Align->value());
1636 }
1637 
1639  // Default alignment, allow the target to define how to align it.
1640  if (!Align)
1641  return *this;
1642 
1643  assert(*Align <= 0x100 && "Alignment too large.");
1644  return addRawIntAttr(Attribute::StackAlignment, Align->value());
1645 }
1646 
1648  if (Bytes == 0) return *this;
1649 
1650  return addRawIntAttr(Attribute::Dereferenceable, Bytes);
1651 }
1652 
1654  if (Bytes == 0)
1655  return *this;
1656 
1657  return addRawIntAttr(Attribute::DereferenceableOrNull, Bytes);
1658 }
1659 
1661  const Optional<unsigned> &NumElems) {
1662  return addAllocSizeAttrFromRawRepr(packAllocSizeArgs(ElemSize, NumElems));
1663 }
1664 
1666  // (0, 0) is our "not present" value, so we need to check for it here.
1667  assert(RawArgs && "Invalid allocsize arguments -- given allocsize(0, 0)");
1668  return addRawIntAttr(Attribute::AllocSize, RawArgs);
1669 }
1670 
1672  unsigned MaxValue) {
1673  return addVScaleRangeAttrFromRawRepr(packVScaleRangeArgs(MinValue, MaxValue));
1674 }
1675 
1677  // (0, 0) is not present hence ignore this case
1678  if (RawArgs == 0)
1679  return *this;
1680 
1681  return addRawIntAttr(Attribute::VScaleRange, RawArgs);
1682 }
1683 
1685  Optional<unsigned> TypeIndex = kindToTypeIndex(Kind);
1686  assert(TypeIndex && "Not a type attribute");
1687  return TypeAttrs[*TypeIndex];
1688 }
1689 
1691  Optional<unsigned> TypeIndex = kindToTypeIndex(Kind);
1692  assert(TypeIndex && "Not a type attribute");
1693  Attrs[Kind] = true;
1694  TypeAttrs[*TypeIndex] = Ty;
1695  return *this;
1696 }
1697 
1699  return addTypeAttr(Attribute::ByVal, Ty);
1700 }
1701 
1703  return addTypeAttr(Attribute::StructRet, Ty);
1704 }
1705 
1707  return addTypeAttr(Attribute::ByRef, Ty);
1708 }
1709 
1711  return addTypeAttr(Attribute::Preallocated, Ty);
1712 }
1713 
1715  return addTypeAttr(Attribute::InAlloca, Ty);
1716 }
1717 
1719  // FIXME: What if both have an int/type attribute, but they don't match?!
1720  for (unsigned Index = 0; Index < Attribute::NumIntAttrKinds; ++Index)
1721  if (!IntAttrs[Index])
1722  IntAttrs[Index] = B.IntAttrs[Index];
1723 
1724  for (unsigned Index = 0; Index < Attribute::NumTypeAttrKinds; ++Index)
1725  if (!TypeAttrs[Index])
1726  TypeAttrs[Index] = B.TypeAttrs[Index];
1727 
1728  Attrs |= B.Attrs;
1729 
1730  for (const auto &I : B.td_attrs())
1731  TargetDepAttrs[I.first] = I.second;
1732 
1733  return *this;
1734 }
1735 
1737  // FIXME: What if both have an int/type attribute, but they don't match?!
1738  for (unsigned Index = 0; Index < Attribute::NumIntAttrKinds; ++Index)
1739  if (B.IntAttrs[Index])
1740  IntAttrs[Index] = 0;
1741 
1742  for (unsigned Index = 0; Index < Attribute::NumTypeAttrKinds; ++Index)
1743  if (B.TypeAttrs[Index])
1744  TypeAttrs[Index] = nullptr;
1745 
1746  Attrs &= ~B.Attrs;
1747 
1748  for (const auto &I : B.td_attrs())
1749  TargetDepAttrs.erase(I.first);
1750 
1751  return *this;
1752 }
1753 
1755  // First check if any of the target independent attributes overlap.
1756  if ((Attrs & B.Attrs).any())
1757  return true;
1758 
1759  // Then check if any target dependent ones do.
1760  for (const auto &I : td_attrs())
1761  if (B.contains(I.first))
1762  return true;
1763 
1764  return false;
1765 }
1766 
1768  return TargetDepAttrs.find(A) != TargetDepAttrs.end();
1769 }
1770 
1772  return !Attrs.none() || !TargetDepAttrs.empty();
1773 }
1774 
1776  AttributeSet AS = AL.getAttributes(Index);
1777 
1778  for (const auto &Attr : AS) {
1779  if (Attr.isEnumAttribute() || Attr.isIntAttribute()) {
1780  if (contains(Attr.getKindAsEnum()))
1781  return true;
1782  } else {
1783  assert(Attr.isStringAttribute() && "Invalid attribute kind!");
1784  return contains(Attr.getKindAsString());
1785  }
1786  }
1787 
1788  return false;
1789 }
1790 
1792  return getRawIntAttr(Attribute::Alignment) != 0;
1793 }
1794 
1796  if (Attrs != B.Attrs)
1797  return false;
1798 
1799  for (const auto &TDA : TargetDepAttrs)
1800  if (B.TargetDepAttrs.find(TDA.first) == B.TargetDepAttrs.end())
1801  return false;
1802 
1803  return IntAttrs == B.IntAttrs && TypeAttrs == B.TypeAttrs;
1804 }
1805 
1806 //===----------------------------------------------------------------------===//
1807 // AttributeFuncs Function Defintions
1808 //===----------------------------------------------------------------------===//
1809 
1810 /// Which attributes cannot be applied to a type.
1812  AttrBuilder Incompatible;
1813 
1814  if (!Ty->isIntegerTy())
1815  // Attribute that only apply to integers.
1816  Incompatible.addAttribute(Attribute::SExt)
1817  .addAttribute(Attribute::ZExt);
1818 
1819  if (!Ty->isPointerTy())
1820  // Attribute that only apply to pointers.
1821  Incompatible.addAttribute(Attribute::Nest)
1822  .addAttribute(Attribute::NoAlias)
1823  .addAttribute(Attribute::NoCapture)
1824  .addAttribute(Attribute::NonNull)
1825  .addAttribute(Attribute::ReadNone)
1826  .addAttribute(Attribute::ReadOnly)
1827  .addAttribute(Attribute::SwiftError)
1828  .addAlignmentAttr(1) // the int here is ignored
1829  .addDereferenceableAttr(1) // the int here is ignored
1830  .addDereferenceableOrNullAttr(1) // the int here is ignored
1831  .addPreallocatedAttr(Ty)
1832  .addInAllocaAttr(Ty)
1833  .addByValAttr(Ty)
1834  .addStructRetAttr(Ty)
1835  .addByRefAttr(Ty)
1836  .addTypeAttr(Attribute::ElementType, Ty);
1837 
1838  // Some attributes can apply to all "values" but there are no `void` values.
1839  if (Ty->isVoidTy())
1840  Incompatible.addAttribute(Attribute::NoUndef);
1841 
1842  return Incompatible;
1843 }
1844 
1846  AttrBuilder B;
1847  B.addAttribute(Attribute::NoUndef);
1848  B.addDereferenceableAttr(1);
1849  B.addDereferenceableOrNullAttr(1);
1850  return B;
1851 }
1852 
1853 template<typename AttrClass>
1854 static bool isEqual(const Function &Caller, const Function &Callee) {
1855  return Caller.getFnAttribute(AttrClass::getKind()) ==
1856  Callee.getFnAttribute(AttrClass::getKind());
1857 }
1858 
1859 /// Compute the logical AND of the attributes of the caller and the
1860 /// callee.
1861 ///
1862 /// This function sets the caller's attribute to false if the callee's attribute
1863 /// is false.
1864 template<typename AttrClass>
1865 static void setAND(Function &Caller, const Function &Callee) {
1866  if (AttrClass::isSet(Caller, AttrClass::getKind()) &&
1867  !AttrClass::isSet(Callee, AttrClass::getKind()))
1868  AttrClass::set(Caller, AttrClass::getKind(), false);
1869 }
1870 
1871 /// Compute the logical OR of the attributes of the caller and the
1872 /// callee.
1873 ///
1874 /// This function sets the caller's attribute to true if the callee's attribute
1875 /// is true.
1876 template<typename AttrClass>
1877 static void setOR(Function &Caller, const Function &Callee) {
1878  if (!AttrClass::isSet(Caller, AttrClass::getKind()) &&
1879  AttrClass::isSet(Callee, AttrClass::getKind()))
1880  AttrClass::set(Caller, AttrClass::getKind(), true);
1881 }
1882 
1883 /// If the inlined function had a higher stack protection level than the
1884 /// calling function, then bump up the caller's stack protection level.
1885 static void adjustCallerSSPLevel(Function &Caller, const Function &Callee) {
1886  // If upgrading the SSP attribute, clear out the old SSP Attributes first.
1887  // Having multiple SSP attributes doesn't actually hurt, but it adds useless
1888  // clutter to the IR.
1889  AttrBuilder OldSSPAttr;
1890  OldSSPAttr.addAttribute(Attribute::StackProtect)
1891  .addAttribute(Attribute::StackProtectStrong)
1892  .addAttribute(Attribute::StackProtectReq);
1893 
1894  if (Callee.hasFnAttribute(Attribute::StackProtectReq)) {
1895  Caller.removeFnAttrs(OldSSPAttr);
1896  Caller.addFnAttr(Attribute::StackProtectReq);
1897  } else if (Callee.hasFnAttribute(Attribute::StackProtectStrong) &&
1898  !Caller.hasFnAttribute(Attribute::StackProtectReq)) {
1899  Caller.removeFnAttrs(OldSSPAttr);
1900  Caller.addFnAttr(Attribute::StackProtectStrong);
1901  } else if (Callee.hasFnAttribute(Attribute::StackProtect) &&
1902  !Caller.hasFnAttribute(Attribute::StackProtectReq) &&
1903  !Caller.hasFnAttribute(Attribute::StackProtectStrong))
1904  Caller.addFnAttr(Attribute::StackProtect);
1905 }
1906 
1907 /// If the inlined function required stack probes, then ensure that
1908 /// the calling function has those too.
1909 static void adjustCallerStackProbes(Function &Caller, const Function &Callee) {
1910  if (!Caller.hasFnAttribute("probe-stack") &&
1911  Callee.hasFnAttribute("probe-stack")) {
1912  Caller.addFnAttr(Callee.getFnAttribute("probe-stack"));
1913  }
1914 }
1915 
1916 /// If the inlined function defines the size of guard region
1917 /// on the stack, then ensure that the calling function defines a guard region
1918 /// that is no larger.
1919 static void
1921  Attribute CalleeAttr = Callee.getFnAttribute("stack-probe-size");
1922  if (CalleeAttr.isValid()) {
1923  Attribute CallerAttr = Caller.getFnAttribute("stack-probe-size");
1924  if (CallerAttr.isValid()) {
1925  uint64_t CallerStackProbeSize, CalleeStackProbeSize;
1926  CallerAttr.getValueAsString().getAsInteger(0, CallerStackProbeSize);
1927  CalleeAttr.getValueAsString().getAsInteger(0, CalleeStackProbeSize);
1928 
1929  if (CallerStackProbeSize > CalleeStackProbeSize) {
1930  Caller.addFnAttr(CalleeAttr);
1931  }
1932  } else {
1933  Caller.addFnAttr(CalleeAttr);
1934  }
1935  }
1936 }
1937 
1938 /// If the inlined function defines a min legal vector width, then ensure
1939 /// the calling function has the same or larger min legal vector width. If the
1940 /// caller has the attribute, but the callee doesn't, we need to remove the
1941 /// attribute from the caller since we can't make any guarantees about the
1942 /// caller's requirements.
1943 /// This function is called after the inlining decision has been made so we have
1944 /// to merge the attribute this way. Heuristics that would use
1945 /// min-legal-vector-width to determine inline compatibility would need to be
1946 /// handled as part of inline cost analysis.
1947 static void
1949  Attribute CallerAttr = Caller.getFnAttribute("min-legal-vector-width");
1950  if (CallerAttr.isValid()) {
1951  Attribute CalleeAttr = Callee.getFnAttribute("min-legal-vector-width");
1952  if (CalleeAttr.isValid()) {
1953  uint64_t CallerVectorWidth, CalleeVectorWidth;
1954  CallerAttr.getValueAsString().getAsInteger(0, CallerVectorWidth);
1955  CalleeAttr.getValueAsString().getAsInteger(0, CalleeVectorWidth);
1956  if (CallerVectorWidth < CalleeVectorWidth)
1957  Caller.addFnAttr(CalleeAttr);
1958  } else {
1959  // If the callee doesn't have the attribute then we don't know anything
1960  // and must drop the attribute from the caller.
1961  Caller.removeFnAttr("min-legal-vector-width");
1962  }
1963  }
1964 }
1965 
1966 /// If the inlined function has null_pointer_is_valid attribute,
1967 /// set this attribute in the caller post inlining.
1968 static void
1970  if (Callee.nullPointerIsDefined() && !Caller.nullPointerIsDefined()) {
1971  Caller.addFnAttr(Attribute::NullPointerIsValid);
1972  }
1973 }
1974 
1975 struct EnumAttr {
1976  static bool isSet(const Function &Fn,
1978  return Fn.hasFnAttribute(Kind);
1979  }
1980 
1981  static void set(Function &Fn,
1982  Attribute::AttrKind Kind, bool Val) {
1983  if (Val)
1984  Fn.addFnAttr(Kind);
1985  else
1986  Fn.removeFnAttr(Kind);
1987  }
1988 };
1989 
1990 struct StrBoolAttr {
1991  static bool isSet(const Function &Fn,
1992  StringRef Kind) {
1993  auto A = Fn.getFnAttribute(Kind);
1994  return A.getValueAsString().equals("true");
1995  }
1996 
1997  static void set(Function &Fn,
1998  StringRef Kind, bool Val) {
1999  Fn.addFnAttr(Kind, Val ? "true" : "false");
2000  }
2001 };
2002 
2003 #define GET_ATTR_NAMES
2004 #define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \
2005  struct ENUM_NAME##Attr : EnumAttr { \
2006  static enum Attribute::AttrKind getKind() { \
2007  return llvm::Attribute::ENUM_NAME; \
2008  } \
2009  };
2010 #define ATTRIBUTE_STRBOOL(ENUM_NAME, DISPLAY_NAME) \
2011  struct ENUM_NAME##Attr : StrBoolAttr { \
2012  static StringRef getKind() { return #DISPLAY_NAME; } \
2013  };
2014 #include "llvm/IR/Attributes.inc"
2015 
2016 #define GET_ATTR_COMPAT_FUNC
2017 #include "llvm/IR/Attributes.inc"
2018 
2020  const Function &Callee) {
2021  return hasCompatibleFnAttrs(Caller, Callee);
2022 }
2023 
2025  const Function &B) {
2026  return hasCompatibleFnAttrs(A, B);
2027 }
2028 
2030  const Function &Callee) {
2031  mergeFnAttrs(Caller, Callee);
2032 }
2033 
2035  const Function &ToMerge) {
2036 
2037  // We merge functions so that they meet the most general case.
2038  // For example, if the NoNansFPMathAttr is set in one function, but not in
2039  // the other, in the merged function we can say that the NoNansFPMathAttr
2040  // is not set.
2041  // However if we have the SpeculativeLoadHardeningAttr set true in one
2042  // function, but not the other, we make sure that the function retains
2043  // that aspect in the merged function.
2044  mergeFnAttrs(Base, ToMerge);
2045 }
llvm::AttributeList::removeAttributeAtIndex
LLVM_NODISCARD AttributeList removeAttributeAtIndex(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const
Remove the specified attribute at the specified index from this attribute list.
Definition: Attributes.cpp:1265
llvm::AttrBuilder::addDereferenceableOrNullAttr
AttrBuilder & addDereferenceableOrNullAttr(uint64_t Bytes)
This turns the number of dereferenceable_or_null bytes into the form used internally in Attribute.
Definition: Attributes.cpp:1653
llvm::AttributeList::getRetDereferenceableOrNullBytes
uint64_t getRetDereferenceableOrNullBytes() const
Get the number of dereferenceable_or_null bytes (or zero if unknown) of the return value.
Definition: Attributes.cpp:1454
i
i
Definition: README.txt:29
llvm::AttributeList::getParamInAllocaType
Type * getParamInAllocaType(unsigned ArgNo) const
Return the inalloca type for the specified function parameter.
Definition: Attributes.cpp:1430
llvm::AttributeList::print
void print(raw_ostream &O) const
Definition: Attributes.cpp:1498
llvm::Attribute::getWithPreallocatedType
static Attribute getWithPreallocatedType(LLVMContext &Context, Type *Ty)
Definition: Attributes.cpp:200
llvm::LLVMContextImpl::Alloc
BumpPtrAllocator Alloc
Definition: LLVMContextImpl.h:1451
llvm::Attribute::EndAttrKinds
@ EndAttrKinds
Sentinal value useful for loops.
Definition: Attributes.h:76
set
We currently generate a but we really shouldn eax ecx xorl edx divl ecx eax divl ecx movl eax ret A similar code sequence works for division We currently compile i32 v2 eax eax jo LBB1_2 atomic and others It is also currently not done for read modify write instructions It is also current not done if the OF or CF flags are needed The shift operators have the complication that when the shift count is EFLAGS is not set
Definition: README.txt:1277
llvm::LLVMContext::pImpl
LLVMContextImpl *const pImpl
Definition: LLVMContext.h:70
llvm::AttributeImpl
Definition: AttributeImpl.h:39
llvm::AttributeSet::AttributeSet
AttributeSet()=default
AttributeSet is a trivially copyable value type.
Attrs
Function Attrs
Definition: README_ALTIVEC.txt:215
llvm::AttributeFuncs::mergeAttributesForOutlining
void mergeAttributesForOutlining(Function &Base, const Function &ToMerge)
Merges the functions attributes from ToMerge into function Base.
Definition: Attributes.cpp:2034
llvm::AttributeFuncs::getUBImplyingAttributes
AttrBuilder getUBImplyingAttributes()
Get param/return attributes which imply immediate undefined behavior if an invalid value is passed.
Definition: Attributes.cpp:1845
LLVM_DUMP_METHOD
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Definition: Compiler.h:506
MathExtras.h
llvm
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
llvm::Attribute::isEnumAttribute
bool isEnumAttribute() const
Return true if the attribute is an Attribute::AttrKind type.
Definition: Attributes.cpp:257
llvm::AttributeList::addRetAttributes
LLVM_NODISCARD AttributeList addRetAttributes(LLVMContext &C, const AttrBuilder &B) const
Add a return value attribute to the list.
Definition: Attributes.h:526
llvm::Attribute::isValid
bool isValid() const
Return true if the attribute is any kind of attribute.
Definition: Attributes.h:168
llvm::AttributeList::addDereferenceableParamAttr
LLVM_NODISCARD AttributeList addDereferenceableParamAttr(LLVMContext &C, unsigned ArgNo, uint64_t Bytes) const
Add the dereferenceable attribute to the attribute set at the given arg index.
Definition: Attributes.cpp:1325
llvm::AArch64CC::AL
@ AL
Definition: AArch64BaseInfo.h:269
llvm::AttributeSet::hasAttributes
bool hasAttributes() const
Return true if attributes exists in this set.
Definition: Attributes.h:327
llvm::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
llvm::yaml::getStringValue
static StringRef getStringValue(IO &IO, const char *Key)
Definition: ELFYAML.cpp:1443
llvm::none_of
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:1565
llvm::AttributeList::hasAttributesAtIndex
bool hasAttributesAtIndex(unsigned Index) const
Return true if attribute exists at the given index.
Definition: Attributes.cpp:1375
Optional.h
attrIdxToArrayIdx
static unsigned attrIdxToArrayIdx(unsigned Index)
Map from AttributeList index to the internal array index.
Definition: Attributes.cpp:922
llvm::AttrBuilder::hasAlignmentAttr
bool hasAlignmentAttr() const
Return true if the builder has an alignment attribute.
Definition: Attributes.cpp:1791
llvm::Attribute::getStackAlignment
MaybeAlign getStackAlignment() const
Returns the stack alignment field of an attribute as a byte alignment value.
Definition: Attributes.cpp:331
llvm::AttrBuilder::overlaps
bool overlaps(const AttrBuilder &B) const
Return true if the builder has any attribute that's in the specified builder.
Definition: Attributes.cpp:1754
llvm::Attribute::getWithAllocSizeArgs
static Attribute getWithAllocSizeArgs(LLVMContext &Context, unsigned ElemSizeArg, const Optional< unsigned > &NumElemsArg)
Definition: Attributes.cpp:209
llvm::Function::end
iterator end()
Definition: Function.h:736
llvm::AttributeList::hasAttrSomewhere
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.
Definition: Attributes.cpp:1387
llvm::Value::MaximumAlignment
static constexpr uint64_t MaximumAlignment
Definition: Value.h:793
llvm::AttributeListImpl::end
iterator end() const
Definition: AttributeImpl.h:317
llvm::AttrBuilder::addTypeAttr
AttrBuilder & addTypeAttr(Attribute::AttrKind Kind, Type *Ty)
Add a type attribute with the given type.
Definition: Attributes.cpp:1690
llvm::Type::isPointerTy
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:217
llvm::AttributeSet::getDereferenceableOrNullBytes
uint64_t getDereferenceableOrNullBytes() const
Definition: Attributes.cpp:687
llvm::Function::empty
bool empty() const
Definition: Function.h:740
llvm::Attribute::hasAttribute
bool hasAttribute(AttrKind Val) const
Return true if the attribute is present.
Definition: Attributes.cpp:316
llvm::AttributeList::AttributeList
AttributeList()=default
llvm::Function
Definition: Function.h:62
llvm::AttrBuilder::removeAttributes
AttrBuilder & removeAttributes(AttributeList A, uint64_t WithoutIndex)
Remove the attributes from the builder.
Definition: Attributes.cpp:1596
llvm::Attribute
Definition: Attributes.h:52
llvm::lower_bound
auto lower_bound(R &&Range, T &&Value)
Provide wrappers to std::lower_bound which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1661
StringRef.h
llvm::AttrBuilder::hasAttributes
bool hasAttributes() const
Return true if the builder has IR-level attributes.
Definition: Attributes.cpp:1771
llvm::AttributeSetNode::getNumAttributes
unsigned getNumAttributes() const
Return the number of attributes this AttributeList contains.
Definition: AttributeImpl.h:240
llvm::StringSwitch::Default
LLVM_NODISCARD R Default(T Value)
Definition: StringSwitch.h:181
EnumAttr::set
static void set(Function &Fn, Attribute::AttrKind Kind, bool Val)
Definition: Attributes.cpp:1981
llvm::raw_string_ostream
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:625
llvm::AttributeSet::removeAttributes
LLVM_NODISCARD AttributeSet removeAttributes(LLVMContext &C, const AttrBuilder &AttrsToRemove) const
Remove the specified attributes from this set.
Definition: Attributes.cpp:644
llvm::AttributeList::removeAttributesAtIndex
LLVM_NODISCARD AttributeList removeAttributesAtIndex(LLVMContext &C, unsigned Index, const AttrBuilder &AttrsToRemove) const
Remove the specified attributes at the specified index from this attribute list.
Definition: Attributes.cpp:1295
llvm::AttributeList::getParamPreallocatedType
Type * getParamPreallocatedType(unsigned ArgNo) const
Return the preallocated type for the specified function parameter.
Definition: Attributes.cpp:1426
llvm::Attribute::getAttrKindFromName
static Attribute::AttrKind getAttrKindFromName(StringRef AttrName)
Definition: Attributes.cpp:222
llvm::Attribute::get
static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)
Return a uniquified Attribute object.
Definition: Attributes.cpp:92
llvm::Attribute::isTypeAttribute
bool isTypeAttribute() const
Return true if the attribute is a type attribute.
Definition: Attributes.cpp:269
llvm::Attribute::isIntAttrKind
static bool isIntAttrKind(AttrKind Kind)
Definition: Attributes.h:87
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
getImpl
static LazyValueInfoImpl & getImpl(void *&PImpl, AssumptionCache *AC, const Module *M)
This lazily constructs the LazyValueInfoImpl.
Definition: LazyValueInfo.cpp:1506
llvm::AttributeList::addParamAttribute
LLVM_NODISCARD AttributeList addParamAttribute(LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const
Add an argument attribute to the list.
Definition: Attributes.h:533
llvm::AttributeSetNode::getVScaleRangeArgs
std::pair< unsigned, unsigned > getVScaleRangeArgs() const
Definition: Attributes.cpp:900
adjustCallerStackProbes
static void adjustCallerStackProbes(Function &Caller, const Function &Callee)
If the inlined function required stack probes, then ensure that the calling function has those too.
Definition: Attributes.cpp:1909
ErrorHandling.h
llvm::AttributeSet::addAttributes
LLVM_NODISCARD AttributeSet addAttributes(LLVMContext &C, AttributeSet AS) const
Add attributes to the attribute set.
Definition: Attributes.cpp:613
llvm::AttributeList::end
iterator end() const
Definition: Attributes.cpp:1486
llvm::AttributeList::get
static AttributeList get(LLVMContext &C, ArrayRef< std::pair< unsigned, Attribute >> Attrs)
Create an AttributeList with the specified parameters in it.
Definition: Attributes.cpp:1011
AllocSizeNumElemsNotPresent
static const unsigned AllocSizeNumElemsNotPresent
Definition: Attributes.cpp:58
llvm::Attribute::getWithStackAlignment
static Attribute getWithStackAlignment(LLVMContext &Context, Align Alignment)
Definition: Attributes.cpp:171
setOR
static void setOR(Function &Caller, const Function &Callee)
Compute the logical OR of the attributes of the caller and the callee.
Definition: Attributes.cpp:1877
llvm::AttributeFuncs::typeIncompatible
AttrBuilder typeIncompatible(Type *Ty)
Which attributes cannot be applied to a type.
Definition: Attributes.cpp:1811
llvm::AttributeList::getParamByValType
Type * getParamByValType(unsigned ArgNo) const
Return the byval type for the specified function parameter.
Definition: Attributes.cpp:1414
llvm::AttrBuilder::addAllocSizeAttr
AttrBuilder & addAllocSizeAttr(unsigned ElemSizeArg, const Optional< unsigned > &NumElemsArg)
This turns one (or two) ints into the form used internally in Attribute.
Definition: Attributes.cpp:1660
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::Attribute::getWithVScaleRangeArgs
static Attribute getWithVScaleRangeArgs(LLVMContext &Context, unsigned MinValue, unsigned MaxValue)
Definition: Attributes.cpp:216
llvm::AttributeList
Definition: Attributes.h:399
llvm::AttributeList::addDereferenceableRetAttr
LLVM_NODISCARD AttributeList addDereferenceableRetAttr(LLVMContext &C, uint64_t Bytes) const
Add the dereferenceable attribute to the attribute set at the given index.
Definition: Attributes.cpp:1318
llvm::Attribute::isTypeAttrKind
static bool isTypeAttrKind(AttrKind Kind)
Definition: Attributes.h:90
llvm::copy
OutputIt copy(R &&Range, OutputIt Out)
Definition: STLExtras.h:1602
llvm::AttributeList::getFnAttrs
AttributeSet getFnAttrs() const
The function attributes are returned.
Definition: Attributes.cpp:1362
llvm::TypeAttributeImpl
Definition: AttributeImpl.h:182
llvm::Optional< unsigned >
llvm::AttributeBitSet::hasAttribute
bool hasAttribute(Attribute::AttrKind Kind) const
Definition: AttributeImpl.h:199
llvm::AttrBuilder::addPreallocatedAttr
AttrBuilder & addPreallocatedAttr(Type *Ty)
This turns a preallocated type into the form used internally in Attribute.
Definition: Attributes.cpp:1710
setAND
static void setAND(Function &Caller, const Function &Callee)
Compute the logical AND of the attributes of the caller and the callee.
Definition: Attributes.cpp:1865
llvm::Attribute::getAlignment
MaybeAlign getAlignment() const
Returns the alignment field of an attribute as a byte alignment value.
Definition: Attributes.cpp:325
llvm::AttributeListImpl::begin
iterator begin() const
Definition: AttributeImpl.h:316
adjustMinLegalVectorWidth
static void adjustMinLegalVectorWidth(Function &Caller, const Function &Callee)
If the inlined function defines a min legal vector width, then ensure the calling function has the sa...
Definition: Attributes.cpp:1948
llvm::AttrBuilder::addRawIntAttr
AttrBuilder & addRawIntAttr(Attribute::AttrKind Kind, uint64_t Value)
Add integer attribute with raw value (packed/encoded if necessary).
Definition: Attributes.cpp:1612
llvm::AttributeSetNode::getDereferenceableBytes
uint64_t getDereferenceableBytes() const
Definition: Attributes.cpp:881
STLExtras.h
llvm::AttrBuilder::AttrBuilder
AttrBuilder()=default
llvm::AttrBuilder::merge
AttrBuilder & merge(const AttrBuilder &B)
Add the attributes from the builder.
Definition: Attributes.cpp:1718
llvm::Attribute::getValueAsBool
bool getValueAsBool() const
Return the attribute's value as a boolean.
Definition: Attributes.cpp:287
adjustNullPointerValidAttr
static void adjustNullPointerValidAttr(Function &Caller, const Function &Callee)
If the inlined function has null_pointer_is_valid attribute, set this attribute in the caller post in...
Definition: Attributes.cpp:1969
llvm::isEqual
bool isEqual(const GCNRPTracker::LiveRegSet &S1, const GCNRPTracker::LiveRegSet &S2)
Definition: GCNRegPressure.cpp:55
llvm::LLVMContextImpl::AttrsSet
FoldingSet< AttributeImpl > AttrsSet
Definition: LLVMContextImpl.h:1389
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
llvm::dwarf::Attribute
Attribute
Attributes.
Definition: Dwarf.h:124
adjustCallerSSPLevel
static void adjustCallerSSPLevel(Function &Caller, const Function &Callee)
If the inlined function had a higher stack protection level than the calling function,...
Definition: Attributes.cpp:1885
llvm::AttrBuilder::removeAttribute
AttrBuilder & removeAttribute(Attribute::AttrKind Val)
Remove an attribute from the builder.
Definition: Attributes.cpp:1584
llvm::Attribute::NumIntAttrKinds
static const unsigned NumIntAttrKinds
Definition: Attributes.h:81
llvm::AttributeSetNode::getAlignment
MaybeAlign getAlignment() const
Definition: Attributes.cpp:863
llvm::Optional::hasValue
constexpr bool hasValue() const
Definition: Optional.h:288
llvm::AttributeList::getParamDereferenceableBytes
uint64_t getParamDereferenceableBytes(unsigned Index) const
Get the number of dereferenceable bytes (or zero if unknown) of an arg.
Definition: Attributes.cpp:1450
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::AttrBuilder::getVScaleRangeArgs
std::pair< unsigned, unsigned > getVScaleRangeArgs() const
Retrieve the vscale_range args, if the vscale_range attribute exists.
Definition: Attributes.cpp:1626
llvm::AttributeList::getParamStackAlignment
MaybeAlign getParamStackAlignment(unsigned ArgNo) const
Return the stack alignment for the specified function parameter.
Definition: Attributes.cpp:1410
llvm::Attribute::getValueAsInt
uint64_t getValueAsInt() const
Return the attribute's value as an integer.
Definition: Attributes.cpp:280
llvm::AttributeSet::addAttribute
LLVM_NODISCARD AttributeSet addAttribute(LLVMContext &C, Attribute::AttrKind Kind) const
Add an argument attribute.
Definition: Attributes.cpp:598
llvm::AttributeList::hasAttributeAtIndex
bool hasAttributeAtIndex(unsigned Index, Attribute::AttrKind Kind) const
Return true if the attribute exists at the given index.
Definition: Attributes.cpp:1366
llvm::all_of
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1551
unpackVScaleRangeArgs
static std::pair< unsigned, unsigned > unpackVScaleRangeArgs(uint64_t Value)
Definition: Attributes.cpp:85
llvm::ArrayRef::back
const T & back() const
back - Get the last element.
Definition: ArrayRef.h:174
llvm::Attribute::getWithInAllocaType
static Attribute getWithInAllocaType(LLVMContext &Context, Type *Ty)
Definition: Attributes.cpp:204
llvm::AttrBuilder::getRawIntAttr
uint64_t getRawIntAttr(Attribute::AttrKind Kind) const
Return raw (possibly packed/encoded) value of integer attribute or 0 if not set.
Definition: Attributes.cpp:1606
llvm::AttrBuilder::getTypeAttr
Type * getTypeAttr(Attribute::AttrKind Kind) const
Retrieve type for the given type attribute.
Definition: Attributes.cpp:1684
llvm::AttributeList::hasParentContext
bool hasParentContext(LLVMContext &C) const
Return true if this attribute list belongs to the LLVMContext.
Definition: Attributes.cpp:1474
llvm::AttributeListImpl
Definition: AttributeImpl.h:279
llvm::BumpPtrAllocatorImpl::Allocate
LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void * Allocate(size_t Size, Align Alignment)
Allocate space at the specified alignment.
Definition: Allocator.h:145
llvm::AttrBuilder::addByValAttr
AttrBuilder & addByValAttr(Type *Ty)
This turns a byval type into the form used internally in Attribute.
Definition: Attributes.cpp:1698
llvm::AttributeSet::getAsString
std::string getAsString(bool InAttrGrp=false) const
Definition: Attributes.cpp:725
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::AttributeList::begin
iterator begin() const
Definition: Attributes.cpp:1482
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::AttributeList::getParamDereferenceableOrNullBytes
uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const
Get the number of dereferenceable_or_null bytes (or zero if unknown) of an arg.
Definition: Attributes.cpp:1459
llvm::LLVMContextImpl
Definition: LLVMContextImpl.h:1341
llvm::AttributeSet::hasAttribute
bool hasAttribute(Attribute::AttrKind Kind) const
Return true if the attribute exists in this set.
Definition: Attributes.cpp:659
llvm::AttributeImpl::isEnumAttribute
bool isEnumAttribute() const
Definition: AttributeImpl.h:57
llvm::AttrBuilder::operator==
bool operator==(const AttrBuilder &B) const
Definition: Attributes.cpp:1795
Twine.h
llvm::AttributeImpl::getKindAsString
StringRef getKindAsString() const
Definition: Attributes.cpp:546
llvm::Type::print
void print(raw_ostream &O, bool IsForDebug=false, bool NoDetails=false) const
Print the current type.
Definition: AsmWriter.cpp:4567
StrBoolAttr::set
static void set(Function &Fn, StringRef Kind, bool Val)
Definition: Attributes.cpp:1997
llvm::IntAttributeImpl
Definition: AttributeImpl.h:133
llvm::AttributeImpl::hasAttribute
bool hasAttribute(Attribute::AttrKind A) const
Definition: Attributes.cpp:521
llvm::AttributeImpl::getKindAsEnum
Attribute::AttrKind getKindAsEnum() const
Definition: Attributes.cpp:531
llvm::AttributeImpl::isIntAttribute
bool isIntAttribute() const
Definition: AttributeImpl.h:58
llvm::AttributeSet::getDereferenceableBytes
uint64_t getDereferenceableBytes() const
Definition: Attributes.cpp:683
llvm::AttributeFuncs::areOutlineCompatible
bool areOutlineCompatible(const Function &A, const Function &B)
Checks if there are any incompatible function attributes between A and B.
Definition: Attributes.cpp:2024
llvm::MaybeAlign
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:109
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::Function::getFnAttribute
Attribute getFnAttribute(Attribute::AttrKind Kind) const
Return the attribute for the given attribute kind.
Definition: Function.cpp:652
llvm::Attribute::getVScaleRangeArgs
std::pair< unsigned, unsigned > getVScaleRangeArgs() const
Returns the argument numbers for the vscale_range attribute (or pair(0, 0) if not known).
Definition: Attributes.cpp:357
AttributeProperty
AttributeProperty
Definition: Attributes.cpp:488
llvm::AttributeList::hasFnAttr
bool hasFnAttr(Attribute::AttrKind Kind) const
Return true if the attribute exists for the function.
Definition: Attributes.cpp:1379
LLVMContextImpl.h
llvm::AttributeSet::getVScaleRangeArgs
std::pair< unsigned, unsigned > getVScaleRangeArgs() const
Definition: Attributes.cpp:720
llvm::AttributeSetNode::hasAttribute
bool hasAttribute(Attribute::AttrKind Kind) const
Definition: AttributeImpl.h:242
StrBoolAttr::isSet
static bool isSet(const Function &Fn, StringRef Kind)
Definition: Attributes.cpp:1991
llvm::AttributeList::getAttributes
AttributeSet getAttributes(unsigned Index) const
The attributes for the specified index are returned.
Definition: Attributes.cpp:1467
llvm::AttributeList::getRetAlignment
MaybeAlign getRetAlignment() const
Return the alignment of the return value.
Definition: Attributes.cpp:1402
packAllocSizeArgs
static uint64_t packAllocSizeArgs(unsigned ElemSizeArg, const Optional< unsigned > &NumElemsArg)
Definition: Attributes.cpp:60
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::SmallVectorImpl::resize
void resize(size_type N)
Definition: SmallVector.h:606
llvm::raw_ostream::flush
void flush()
Definition: raw_ostream.h:186
llvm::AttributeSet::getInAllocaType
Type * getInAllocaType() const
Definition: Attributes.cpp:707
llvm::Attribute::getKindAsString
StringRef getKindAsString() const
Return the attribute's kind as a string.
Definition: Attributes.cpp:294
llvm::Attribute::isStringAttribute
bool isStringAttribute() const
Return true if the attribute is a string (target-dependent) attribute.
Definition: Attributes.cpp:265
llvm::AttributeList::getParamElementType
Type * getParamElementType(unsigned ArgNo) const
Return the elementtype type for the specified function parameter.
Definition: Attributes.cpp:1434
llvm::AttributeList::addDereferenceableOrNullParamAttr
LLVM_NODISCARD AttributeList addDereferenceableOrNullParamAttr(LLVMContext &C, unsigned ArgNo, uint64_t Bytes) const
Add the dereferenceable_or_null attribute to the attribute set at the given arg index.
Definition: Attributes.cpp:1334
StrBoolAttr
Definition: Attributes.cpp:1990
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::Attribute::getWithStructRetType
static Attribute getWithStructRetType(LLVMContext &Context, Type *Ty)
Definition: Attributes.cpp:192
llvm::AttrBuilder::clear
void clear()
Definition: Attributes.cpp:1541
llvm::StringRef::str
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:245
llvm::Attribute::isEnumAttrKind
static bool isEnumAttrKind(AttrKind Kind)
Definition: Attributes.h:84
llvm::AttrBuilder::contains
bool contains(Attribute::AttrKind A) const
Return true if the builder has the specified attribute.
Definition: Attributes.h:988
hasAttributeProperty
static bool hasAttributeProperty(Attribute::AttrKind Kind, AttributeProperty Prop)
Definition: Attributes.cpp:497
llvm::Attribute::getValueAsString
StringRef getValueAsString() const
Return the attribute's value as a string.
Definition: Attributes.cpp:301
llvm::StringRef::getAsInteger
std::enable_if_t< std::numeric_limits< T >::is_signed, bool > getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition: StringRef.h:510
llvm::None
const NoneType None
Definition: None.h:23
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::AttrBuilder::addAlignmentAttr
AttrBuilder & addAlignmentAttr(MaybeAlign Align)
This turns an alignment into the form used internally in Attribute.
Definition: Attributes.cpp:1630
Type.h
llvm::AttributeSetNode::begin
iterator begin() const
Definition: AttributeImpl.h:262
llvm::AttributeSet::end
iterator end() const
Definition: Attributes.cpp:741
llvm::Type::isIntegerTy
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:190
llvm::Optional::getValueOr
constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION
Definition: Optional.h:297
llvm::Function::hasFnAttribute
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.cpp:626
llvm::AttributeList::ReturnIndex
@ ReturnIndex
Definition: Attributes.h:402
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:197
llvm::AttributeList::getRetAttrs
AttributeSet getRetAttrs() const
The attributes for the ret value are returned.
Definition: Attributes.cpp:1358
VI
@ VI
Definition: SIInstrInfo.cpp:7695
llvm::AttrBuilder::addStackAlignmentAttr
AttrBuilder & addStackAlignmentAttr(MaybeAlign Align)
This turns a stack alignment into the form used internally in Attribute.
Definition: Attributes.cpp:1638
llvm::Attribute::canUseAsFnAttr
static bool canUseAsFnAttr(AttrKind Kind)
Definition: Attributes.cpp:505
Index
uint32_t Index
Definition: ELFObjHandler.cpp:84
EnumAttr
Definition: Attributes.cpp:1975
uint64_t
llvm::Attribute::None
@ None
No attributes have been set.
Definition: Attributes.h:73
llvm::AttributeList::getRetDereferenceableBytes
uint64_t getRetDereferenceableBytes() const
Get the number of dereferenceable bytes (or zero if unknown) of the return value.
Definition: Attributes.cpp:1446
ParamAttr
@ ParamAttr
Definition: Attributes.cpp:490
llvm::AttributeListImpl::AttributeList
friend class AttributeList
Definition: AttributeImpl.h:282
llvm::AttrBuilder::addVScaleRangeAttrFromRawRepr
AttrBuilder & addVScaleRangeAttrFromRawRepr(uint64_t RawVScaleRangeRepr)
Add a vscale_range attribute, using the representation returned by Attribute.getIntValue().
Definition: Attributes.cpp:1676
llvm::AttributeList::addParamAttributes
LLVM_NODISCARD AttributeList addParamAttributes(LLVMContext &C, unsigned ArgNo, const AttrBuilder &B) const
Add an argument attribute to the list.
Definition: Attributes.h:554
llvm::AttributeListImpl::dump
void dump() const
Definition: Attributes.cpp:974
llvm::AttributeSet::get
static AttributeSet get(LLVMContext &C, const AttrBuilder &B)
Definition: Attributes.cpp:590
llvm::AttrBuilder::addInAllocaAttr
AttrBuilder & addInAllocaAttr(Type *Ty)
This turns an inalloca type into the form used internally in Attribute.
Definition: Attributes.cpp:1714
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
llvm::AttributeList::getAsString
std::string getAsString(unsigned Index, bool InAttrGrp=false) const
Return the attributes at the index as a string.
Definition: Attributes.cpp:1463
llvm::AttributeList::dump
void dump() const
Definition: Attributes.cpp:1522
llvm::AttributeSetNode::getAttributeType
Type * getAttributeType(Attribute::AttrKind Kind) const
Definition: Attributes.cpp:875
llvm::Attribute::getKindAsEnum
Attribute::AttrKind getKindAsEnum() const
Return the attribute's kind as an enum (Attribute::AttrKind).
Definition: Attributes.cpp:273
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::AttrBuilder
Definition: Attributes.h:931
StringExtras.h
llvm::Attribute::AttrKind
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results,...
Definition: Attributes.h:71
llvm::Attribute::getWithDereferenceableBytes
static Attribute getWithDereferenceableBytes(LLVMContext &Context, uint64_t Bytes)
Definition: Attributes.cpp:176
llvm::AttributeSetNode::Profile
void Profile(FoldingSetNodeID &ID) const
Definition: AttributeImpl.h:265
llvm::AttributeList::getParamAlignment
MaybeAlign getParamAlignment(unsigned ArgNo) const
Return the alignment for the specified function parameter.
Definition: Attributes.cpp:1406
ArrayRef.h
llvm::Attribute::canUseAsParamAttr
static bool canUseAsParamAttr(AttrKind Kind)
Definition: Attributes.cpp:509
llvm::AttributeImpl::getValueAsString
StringRef getValueAsString() const
Definition: Attributes.cpp:551
llvm::AttributeSet::hasParentContext
bool hasParentContext(LLVMContext &C) const
Return true if this attribute set belongs to the LLVMContext.
Definition: Attributes.cpp:729
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::AttrBuilder::addByRefAttr
AttrBuilder & addByRefAttr(Type *Ty)
This turns a byref type into the form used internally in Attribute.
Definition: Attributes.cpp:1706
llvm::Attribute::getAsString
std::string getAsString(bool InAttrGrp=false) const
The Attribute is converted to a string of equivalent mnemonic.
Definition: Attributes.cpp:363
llvm::AttributeSetNode::getDereferenceableOrNullBytes
uint64_t getDereferenceableOrNullBytes() const
Definition: Attributes.cpp:887
llvm::LLVMContextImpl::AttrsLists
FoldingSet< AttributeListImpl > AttrsLists
Definition: LLVMContextImpl.h:1390
llvm::Type::isVoidTy
bool isVoidTy() const
Return true if this is 'void'.
Definition: Type.h:138
llvm::AttributeSet::removeAttribute
LLVM_NODISCARD AttributeSet removeAttribute(LLVMContext &C, Attribute::AttrKind Kind) const
Remove the specified attribute from this set.
Definition: Attributes.cpp:628
FnAttr
@ FnAttr
Definition: Attributes.cpp:489
llvm::AttributeImpl::isTypeAttribute
bool isTypeAttribute() const
Definition: AttributeImpl.h:60
llvm::AttributeSet::getNumAttributes
unsigned getNumAttributes() const
Return the number of attributes in this set.
Definition: Attributes.cpp:655
llvm::AttributeSetNode::getStackAlignment
MaybeAlign getStackAlignment() const
Definition: Attributes.cpp:869
llvm::StringAttributeImpl
Definition: AttributeImpl.h:146
llvm::size
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
Definition: STLExtras.h:1532
AttributeImpl.h
llvm::AttributeImpl::operator<
bool operator<(const AttributeImpl &AI) const
Used when sorting the attributes.
Definition: Attributes.cpp:561
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::AttributeList::AttributeListImpl
friend class AttributeListImpl
Definition: Attributes.h:409
packVScaleRangeArgs
static uint64_t packVScaleRangeArgs(unsigned MinValue, unsigned MaxValue)
Definition: Attributes.cpp:81
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:134
llvm::AttributeSetNode::getAttribute
Attribute getAttribute(Attribute::AttrKind Kind) const
Definition: Attributes.cpp:853
llvm::AttributeSet::dump
void dump() const
Definition: Attributes.cpp:746
A
* A
Definition: README_ALTIVEC.txt:89
llvm::Attribute::getDereferenceableOrNullBytes
uint64_t getDereferenceableOrNullBytes() const
Returns the number of dereferenceable_or_null bytes from the dereferenceable_or_null attribute.
Definition: Attributes.cpp:344
Compiler.h
llvm::append_range
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Definition: STLExtras.h:1748
llvm::AttributeList::getParamByRefType
Type * getParamByRefType(unsigned ArgNo) const
Return the byref type for the specified function parameter.
Definition: Attributes.cpp:1422
llvm::FoldingSetNodeID
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
Definition: FoldingSet.h:313
llvm::AttributeSetNode
Definition: AttributeImpl.h:212
adjustCallerStackProbeSize
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...
Definition: Attributes.cpp:1920
llvm::AttrBuilder::addAllocSizeAttrFromRawRepr
AttrBuilder & addAllocSizeAttrFromRawRepr(uint64_t RawAllocSizeRepr)
Add an allocsize attribute, using the representation returned by Attribute.getIntValue().
Definition: Attributes.cpp:1665
llvm::AttributeSet::getAllocSizeArgs
std::pair< unsigned, Optional< unsigned > > getAllocSizeArgs() const
Definition: Attributes.cpp:715
llvm::Attribute::getWithDereferenceableOrNullBytes
static Attribute getWithDereferenceableOrNullBytes(LLVMContext &Context, uint64_t Bytes)
Definition: Attributes.cpp:182
llvm::AttributeList::getRetStackAlignment
MaybeAlign getRetStackAlignment() const
Get the stack alignment of the return value.
Definition: Attributes.cpp:1442
llvm::AttributeListImpl::Profile
void Profile(FoldingSetNodeID &ID) const
Definition: Attributes.cpp:945
llvm::StringAttributeImpl::totalSizeToAlloc
static size_t totalSizeToAlloc(StringRef Kind, StringRef Val)
Definition: AttributeImpl.h:176
unpackAllocSizeArgs
static std::pair< unsigned, Optional< unsigned > > unpackAllocSizeArgs(uint64_t Num)
Definition: Attributes.cpp:71
llvm::Function::begin
iterator begin()
Definition: Function.h:734
FoldingSet.h
llvm::AttrBuilder::addStructRetAttr
AttrBuilder & addStructRetAttr(Type *Ty)
This turns a sret type into the form used internally in Attribute.
Definition: Attributes.cpp:1702
llvm::AttributeList::addAttributesAtIndex
LLVM_NODISCARD AttributeList addAttributesAtIndex(LLVMContext &C, unsigned Index, const AttrBuilder &B) const
Add attributes to the attribute set at the given index.
Definition: Attributes.cpp:1221
Callee
amdgpu Simplify well known AMD library false FunctionCallee Callee
Definition: AMDGPULibCalls.cpp:206
llvm::Attribute::getWithAlignment
static Attribute getWithAlignment(LLVMContext &Context, Align Alignment)
Return a uniquified Attribute object that has the specific alignment set.
Definition: Attributes.cpp:166
Attributes.h
llvm::AttributeImpl::getValueAsBool
bool getValueAsBool() const
Definition: Attributes.cpp:541
llvm::Attribute::getDereferenceableBytes
uint64_t getDereferenceableBytes() const
Returns the number of dereferenceable bytes from the dereferenceable attribute.
Definition: Attributes.cpp:337
llvm::Attribute::hasParentContext
bool hasParentContext(LLVMContext &C) const
Return true if this attribute belongs to the LLVMContext.
Definition: Attributes.cpp:469
llvm::AttributeListImpl::AttributeListImpl
AttributeListImpl(ArrayRef< AttributeSet > Sets)
Definition: Attributes.cpp:926
llvm::AttributeSet::getPreallocatedType
Type * getPreallocatedType() const
Definition: Attributes.cpp:703
llvm::empty
constexpr bool empty(const T &RangeOrContainer)
Test whether RangeOrContainer is empty. Similar to C++17 std::empty.
Definition: STLExtras.h:254
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::AttrBuilder::remove
AttrBuilder & remove(const AttrBuilder &B)
Remove the attributes from the builder.
Definition: Attributes.cpp:1736
llvm::AttributeSet::getByRefType
Type * getByRefType() const
Definition: Attributes.cpp:691
llvm::Attribute::isExistingAttribute
static bool isExistingAttribute(StringRef Name)
Return true if the provided string matches the IR name of an attribute.
Definition: Attributes.cpp:245
llvm::EnumAttributeImpl
Definition: AttributeImpl.h:116
llvm::Attribute::Attribute
Attribute()=default
llvm::AttributeSet::getByValType
Type * getByValType() const
Definition: Attributes.cpp:695
llvm::ArrayRef::begin
iterator begin() const
Definition: ArrayRef.h:153
llvm::ArrayRef::take_front
ArrayRef< T > take_front(size_t N=1) const
Return a copy of *this with only the first N elements.
Definition: ArrayRef.h:228
llvm::Align::value
uint64_t value() const
This is a hole in the type system and should not be abused.
Definition: Alignment.h:85
llvm::Function::back
const BasicBlock & back() const
Definition: Function.h:743
llvm::AttributeList::getParamStructRetType
Type * getParamStructRetType(unsigned ArgNo) const
Return the sret type for the specified function parameter.
Definition: Attributes.cpp:1418
llvm::Attribute::getValueAsType
Type * getValueAsType() const
Return the attribute's value as a Type.
Definition: Attributes.cpp:308
Function.h
llvm::sort
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1492
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::is_sorted
bool is_sorted(R &&Range, Compare C)
Wrapper function around std::is_sorted to check if elements in a range R are sorted with respect to a...
Definition: STLExtras.h:1622
llvm::AttributeList::getNumAttrSets
unsigned getNumAttrSets() const
Definition: Attributes.cpp:1494
llvm::AttributeSet::begin
iterator begin() const
Definition: Attributes.cpp:737
llvm::LLVMContextImpl::AttrsSetNodes
FoldingSet< AttributeSetNode > AttrsSetNodes
Definition: LLVMContextImpl.h:1391
llvm::AttributeList::getAttributeAtIndex
Attribute getAttributeAtIndex(unsigned Index, Attribute::AttrKind Kind) const
Return the attribute object that exists at the given index.
Definition: Attributes.cpp:1392
llvm::AttributeSet::getElementType
Type * getElementType() const
Definition: Attributes.cpp:711
StringSwitch.h
llvm::AttributeList::addAllocSizeParamAttr
LLVM_NODISCARD AttributeList addAllocSizeParamAttr(LLVMContext &C, unsigned ArgNo, unsigned ElemSizeArg, const Optional< unsigned > &NumElemsArg)
Add the allocsize attribute to the attribute set at the given arg index.
Definition: Attributes.cpp:1342
llvm::AttributeSetNode::end
iterator end() const
Definition: AttributeImpl.h:263
llvm::Attribute::NumTypeAttrKinds
static const unsigned NumTypeAttrKinds
Definition: Attributes.h:82
llvm::AttrBuilder::addDereferenceableAttr
AttrBuilder & addDereferenceableAttr(uint64_t Bytes)
This turns the number of dereferenceable bytes into the form used internally in Attribute.
Definition: Attributes.cpp:1647
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:476
llvm::Attribute::getWithByRefType
static Attribute getWithByRefType(LLVMContext &Context, Type *Ty)
Definition: Attributes.cpp:196
llvm::AttributeList::FunctionIndex
@ FunctionIndex
Definition: Attributes.h:403
llvm::Attribute::getNameFromAttrKind
static StringRef getNameFromAttrKind(Attribute::AttrKind AttrKind)
Definition: Attributes.cpp:231
llvm::AttrBuilder::addAttribute
AttrBuilder & addAttribute(Attribute::AttrKind Val)
Add an attribute to the builder.
Definition: Attributes.h:953
llvm::AttributeFuncs::areInlineCompatible
bool areInlineCompatible(const Function &Caller, const Function &Callee)
Definition: Attributes.cpp:2019
llvm::AttributeSet
Definition: Attributes.h:267
RetAttr
@ RetAttr
Definition: Attributes.cpp:491
SmallVector.h
llvm::AttributeSet::getAttribute
Attribute getAttribute(Attribute::AttrKind Kind) const
Return the attribute object.
Definition: Attributes.cpp:667
List
const NodeList & List
Definition: RDFGraph.cpp:201
llvm::AttributeSetNode::getAsString
std::string getAsString(bool InAttrGrp) const
Definition: Attributes.cpp:906
llvm::Function::removeFnAttr
void removeFnAttr(Attribute::AttrKind Kind)
Remove function attributes from this function.
Definition: Function.cpp:584
llvm::AttributeBitSet::addAttribute
void addAttribute(Attribute::AttrKind Kind)
Definition: AttributeImpl.h:203
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
llvm::max
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:340
llvm::Function::addFnAttr
void addFnAttr(Attribute::AttrKind Kind)
Add function attributes to this function.
Definition: Function.cpp:536
llvm::AttributeList::indexes
index_iterator indexes() const
Use this to iterate over the valid attribute indexes.
Definition: Attributes.h:880
llvm::AttributeList::AttributeSet
friend class AttributeSet
Definition: Attributes.h:410
llvm::AttributeList::addAttributeAtIndex
LLVM_NODISCARD AttributeList addAttributeAtIndex(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const
Add an attribute to the attribute set at the given index.
Definition: Attributes.cpp:1184
llvm::AttributeImpl::getValueAsType
Type * getValueAsType() const
Definition: Attributes.cpp:556
llvm::Attribute::Profile
void Profile(FoldingSetNodeID &ID) const
Definition: Attributes.cpp:484
llvm::AttributeSet::getStackAlignment
MaybeAlign getStackAlignment() const
Definition: Attributes.cpp:679
llvm::Attribute::isIntAttribute
bool isIntAttribute() const
Return true if the attribute is an integer attribute.
Definition: Attributes.cpp:261
llvm::AttributeSet::getStructRetType
Type * getStructRetType() const
Definition: Attributes.cpp:699
llvm::StringSwitch
A switch()-like statement whose cases are string literals.
Definition: StringSwitch.h:42
llvm::AttrBuilder::addVScaleRangeAttr
AttrBuilder & addVScaleRangeAttr(unsigned MinValue, unsigned MaxValue)
This turns two ints into the form used internally in Attribute.
Definition: Attributes.cpp:1671
LLVMContext.h
llvm::AttributeFuncs::mergeAttributesForInlining
void mergeAttributesForInlining(Function &Caller, const Function &Callee)
Merge caller's and callee's attributes.
Definition: Attributes.cpp:2029
llvm::AttributeImpl::Profile
void Profile(FoldingSetNodeID &ID) const
Definition: AttributeImpl.h:77
raw_ostream.h
llvm::AttributeSet::getAlignment
MaybeAlign getAlignment() const
Definition: Attributes.cpp:675
llvm::Attribute::getWithByValType
static Attribute getWithByValType(LLVMContext &Context, Type *Ty)
Definition: Attributes.cpp:188
llvm::AttributeList::getParamAttrs
AttributeSet getParamAttrs(unsigned ArgNo) const
The attributes for the argument or parameter at the given index are returned.
Definition: Attributes.cpp:1354
llvm::SmallVectorImpl::reserve
void reserve(size_type N)
Definition: SmallVector.h:624
llvm::AttrBuilder::getAllocSizeArgs
std::pair< unsigned, Optional< unsigned > > getAllocSizeArgs() const
Retrieve the allocsize args, if the allocsize attribute exists.
Definition: Attributes.cpp:1622
llvm::AttributeListImpl::hasAttrSomewhere
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.
Definition: Attributes.cpp:955
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
Debug.h
llvm::AttributeList::FirstArgIndex
@ FirstArgIndex
Definition: Attributes.h:404
llvm::AttributeImpl::isStringAttribute
bool isStringAttribute() const
Definition: AttributeImpl.h:59
EnumAttr::isSet
static bool isSet(const Function &Fn, Attribute::AttrKind Kind)
Definition: Attributes.cpp:1976
llvm::Attribute::operator<
bool operator<(Attribute A) const
Less-than operator. Useful for sorting the attributes list.
Definition: Attributes.cpp:477
llvm::AttributeList::isEmpty
bool isEmpty() const
Return true if there are no attributes.
Definition: Attributes.h:892
llvm::AttributeImpl::getValueAsInt
uint64_t getValueAsInt() const
Definition: Attributes.cpp:536
llvm::AttributeSetNode::get
static AttributeSetNode * get(LLVMContext &C, const AttrBuilder &B)
Definition: Attributes.cpp:807
llvm::Attribute::canUseAsRetAttr
static bool canUseAsRetAttr(AttrKind Kind)
Definition: Attributes.cpp:513
llvm::sampleprof::Base
@ Base
Definition: Discriminator.h:58
llvm::Attribute::getAllocSizeArgs
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:351
llvm::SmallVectorImpl::emplace_back
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:908
llvm::Function::size
size_t size() const
Definition: Function.h:739
llvm::AttributeList::getFnStackAlignment
MaybeAlign getFnStackAlignment() const
Get the stack alignment of the function.
Definition: Attributes.cpp:1438
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37
llvm::AttributeSetNode::getAllocSizeArgs
std::pair< unsigned, Optional< unsigned > > getAllocSizeArgs() const
Definition: Attributes.cpp:894
llvm::AttrBuilder::td_attrs
td_range td_attrs()
Definition: Attributes.h:1146