62 :
Value(Ty, MetadataAsValueVal), MD(MD) {
90 if (!
N ||
N->getNumOperands() != 1)
93 if (!
N->getOperand(0))
106 auto *&Entry = Context.pImpl->MetadataAsValues[MD];
115 auto &Store = Context.pImpl->MetadataAsValues;
116 return Store.lookup(MD);
119void MetadataAsValue::handleChangedMetadata(
Metadata *MD) {
122 auto &Store = Context.pImpl->MetadataAsValues;
125 Store.erase(this->MD);
130 auto *&Entry = Store[MD];
142void MetadataAsValue::track() {
147void MetadataAsValue::untrack() {
162 auto OldMD =
static_cast<Metadata **
>(Old);
173void DebugValueUser::trackDebugValue(
size_t Idx) {
174 assert(Idx < 3 &&
"Invalid debug value index.");
180void DebugValueUser::trackDebugValues() {
186void DebugValueUser::untrackDebugValue(
size_t Idx) {
187 assert(Idx < 3 &&
"Invalid debug value index.");
193void DebugValueUser::untrackDebugValues() {
200 assert(DebugValueUser::operator==(
X) &&
"Expected values to match");
204 X.DebugValues.fill(
nullptr);
208 assert(
Ref &&
"Expected live reference");
210 "Reference without owner must be direct");
211 if (
auto *R = ReplaceableMetadataImpl::getOrCreate(MD)) {
212 R->addRef(
Ref, Owner);
216 assert(!PH->Use &&
"Placeholders can only be used once");
217 assert(!Owner &&
"Unexpected callback to owner");
225 assert(
Ref &&
"Expected live reference");
226 if (
auto *R = ReplaceableMetadataImpl::getIfExists(MD))
233 assert(
Ref &&
"Expected live reference");
234 assert(New &&
"Expected live reference");
236 if (
auto *R = ReplaceableMetadataImpl::getIfExists(MD)) {
237 R->moveRef(
Ref, New, MD);
241 "Unexpected move of an MDOperand");
243 "Expected un-replaceable metadata, since we didn't move a reference");
248 return ReplaceableMetadataImpl::isReplaceable(MD);
253 for (
auto Pair : UseMap) {
254 OwnerTy Owner = Pair.second.first;
261 MDUsersWithID.
push_back(&UseMap[Pair.first]);
263 llvm::sort(MDUsersWithID, [](
auto UserA,
auto UserB) {
264 return UserA->second < UserB->second;
267 for (
auto *UserWithID : MDUsersWithID)
275 for (
auto Pair : UseMap) {
276 OwnerTy Owner = Pair.second.first;
281 DVRUsersWithID.
push_back(&UseMap[Pair.first]);
288 llvm::sort(DVRUsersWithID, [](
auto UserA,
auto UserB) {
289 return UserA->second > UserB->second;
292 for (
auto UserWithID : DVRUsersWithID)
297void ReplaceableMetadataImpl::addRef(
void *
Ref, OwnerTy Owner) {
299 UseMap.insert(std::make_pair(
Ref, std::make_pair(Owner, NextIndex)))
302 assert(WasInserted &&
"Expected to add a reference");
305 assert(NextIndex != 0 &&
"Unexpected overflow");
308void ReplaceableMetadataImpl::dropRef(
void *
Ref) {
309 bool WasErased = UseMap.erase(
Ref);
311 assert(WasErased &&
"Expected to drop a reference");
314void ReplaceableMetadataImpl::moveRef(
void *
Ref,
void *New,
316 auto I = UseMap.find(
Ref);
317 assert(
I != UseMap.end() &&
"Expected to move a reference");
318 auto OwnerAndIndex =
I->second;
320 bool WasInserted = UseMap.insert(std::make_pair(New, OwnerAndIndex)).second;
322 assert(WasInserted &&
"Expected to add a reference");
327 "Reference without owner must be direct");
328 assert((OwnerAndIndex.first || *
static_cast<Metadata **
>(New) == &MD) &&
329 "Reference without owner must be direct");
333 if (!
C.isUsedByMetadata()) {
338 auto &Store = Context.pImpl->ValuesAsMetadata;
339 auto I = Store.find(&
C);
342 std::pair<void *, std::pair<MetadataTracking::OwnerTy, uint64_t>>;
347 for (
const auto &Pair :
Uses) {
363 OwnerMD->handleChangedOperand(
374 using UseTy = std::pair<void *, std::pair<OwnerTy, uint64_t>>;
377 return L.second.second < R.second.second;
379 for (
const auto &Pair :
Uses) {
382 if (!UseMap.count(Pair.first))
385 OwnerTy Owner = Pair.second.first;
392 UseMap.erase(Pair.first);
403 DVU->handleChangedValue(Pair.first, MD);
410#define HANDLE_METADATA_LEAF(CLASS) \
411 case Metadata::CLASS##Kind: \
412 cast<CLASS>(OwnerMD)->handleChangedOperand(Pair.first, MD); \
414#include "llvm/IR/Metadata.def"
419 assert(UseMap.empty() &&
"Expected all uses to be replaced");
432 using UseTy = std::pair<void *, std::pair<OwnerTy, uint64_t>>;
435 return L.second.second < R.second.second;
438 for (
const auto &Pair :
Uses) {
439 auto Owner = Pair.second.first;
449 if (OwnerMD->isResolved())
451 OwnerMD->decrementUnresolvedOperandCount();
460 return !
N->isResolved() ||
N->isAlwaysReplaceable()
461 ?
N->Context.getOrCreateReplaceableUses()
471 return !
N->isResolved() ||
N->isAlwaysReplaceable()
472 ?
N->Context.getReplaceableUses()
480bool ReplaceableMetadataImpl::isReplaceable(
const Metadata &MD) {
482 return !
N->isResolved() ||
N->isAlwaysReplaceable();
487 assert(V &&
"Expected value");
489 if (
auto *Fn =
A->getParent())
490 return Fn->getSubprogram();
495 if (
auto *Fn = BB->getParent())
496 return Fn->getSubprogram();
504 assert(V &&
"Unexpected null Value");
506 auto &Context = V->getContext();
507 auto *&Entry = Context.pImpl->ValuesAsMetadata[V];
510 "Expected constant or function-local value");
511 assert(!V->IsUsedByMD &&
"Expected this to be the only metadata use");
512 V->IsUsedByMD =
true;
523 assert(V &&
"Unexpected null Value");
524 return V->getContext().pImpl->ValuesAsMetadata.lookup(V);
528 assert(V &&
"Expected valid value");
530 auto &Store = V->getType()->getContext().pImpl->ValuesAsMetadata;
531 auto I = Store.find(V);
532 if (
I == Store.end())
537 assert(MD &&
"Expected valid metadata");
547 assert(From &&
"Expected valid value");
548 assert(To &&
"Expected valid value");
549 assert(From != To &&
"Expected changed value");
553 auto &Store = Context.pImpl->ValuesAsMetadata;
554 auto I = Store.find(From);
555 if (
I == Store.end()) {
564 assert(MD &&
"Expected valid metadata");
589 auto *&Entry = Store[To];
609 auto &Store = Context.pImpl->MDStringCache;
610 auto I = Store.try_emplace(Str);
611 auto &MapEntry =
I.first->getValue();
614 MapEntry.Entry = &*
I.first;
619 assert(Entry &&
"Expected to find string map entry");
620 return Entry->first();
629#define HANDLE_MDNODE_LEAF(CLASS) \
631 alignof(uint64_t) >= alignof(CLASS), \
632 "Alignment is insufficient after objects prepended to " #CLASS);
633#include "llvm/IR/Metadata.def"
635void *MDNode::operator
new(
size_t Size,
size_t NumOps, StorageType Storage) {
640 char *Mem =
reinterpret_cast<char *
>(::operator
new(AllocSize +
Size));
641 Header *
H =
new (Mem + AllocSize -
sizeof(Header)) Header(
NumOps, Storage);
642 return reinterpret_cast<void *
>(
H + 1);
645void MDNode::operator
delete(
void *
N) {
646 Header *
H =
reinterpret_cast<Header *
>(
N) - 1;
647 void *Mem =
H->getAllocation();
649 ::operator
delete(Mem);
666 countUnresolvedOperands();
673#define HANDLE_MDNODE_LEAF(CLASS) \
675 return cast<CLASS>(this)->cloneImpl();
676#include "llvm/IR/Metadata.def"
680MDNode::Header::Header(
size_t NumOps, StorageType Storage) {
681 IsLarge = isLarge(
NumOps);
682 IsResizable = isResizable(
Storage);
683 SmallSize = getSmallSize(
NumOps, IsResizable, IsLarge);
686 new (getLargePtr()) LargeStorageVector();
696MDNode::Header::~Header() {
698 getLarge().~LargeStorageVector();
701 MDOperand *
O =
reinterpret_cast<MDOperand *
>(
this);
702 for (MDOperand *
E = O - SmallSize;
O !=
E; --
O)
703 (O - 1)->~MDOperand();
706void *MDNode::Header::getSmallPtr() {
707 static_assert(
alignof(MDOperand) <=
alignof(Header),
708 "MDOperand too strongly aligned");
709 return reinterpret_cast<char *
>(
const_cast<Header *
>(
this)) -
710 sizeof(MDOperand) * SmallSize;
713void MDNode::Header::resize(
size_t NumOps) {
714 assert(IsResizable &&
"Node is not resizable");
719 getLarge().resize(
NumOps);
720 else if (
NumOps <= SmallSize)
723 resizeSmallToLarge(
NumOps);
726void MDNode::Header::resizeSmall(
size_t NumOps) {
727 assert(!IsLarge &&
"Expected a small MDNode");
728 assert(
NumOps <= SmallSize &&
"NumOps too large for small resize");
733 int NumNew = (int)
NumOps - (
int)ExistingOps.
size();
734 MDOperand *
O = ExistingOps.
end();
735 for (
int I = 0,
E = NumNew;
I <
E; ++
I)
737 for (
int I = 0,
E = NumNew;
I >
E; --
I)
743void MDNode::Header::resizeSmallToLarge(
size_t NumOps) {
744 assert(!IsLarge &&
"Expected a small MDNode");
745 assert(
NumOps > SmallSize &&
"Expected NumOps to be larger than allocation");
746 LargeStorageVector NewOps;
750 new (getLargePtr()) LargeStorageVector(std::move(NewOps));
756 return !
N->isResolved();
760void MDNode::countUnresolvedOperands() {
766void MDNode::makeUniqued() {
772 Op.reset(
Op.get(),
this);
776 countUnresolvedOperands();
778 dropReplaceableUses();
785void MDNode::makeDistinct() {
790 dropReplaceableUses();
802 dropReplaceableUses();
807void MDNode::dropReplaceableUses() {
811 if (Context.hasReplaceableUses())
812 Context.takeReplaceableUses()->resolveAllUses();
825 decrementUnresolvedOperandCount();
828void MDNode::decrementUnresolvedOperandCount() {
839 dropReplaceableUses();
857 "Expected all forward declarations to be resolved");
858 if (!
N->isResolved())
867MDNode *MDNode::replaceWithPermanentImpl() {
871 return replaceWithDistinctImpl();
873#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
876#include "llvm/IR/Metadata.def"
881 return replaceWithDistinctImpl();
882 return replaceWithUniquedImpl();
885MDNode *MDNode::replaceWithUniquedImpl() {
887 MDNode *UniquedNode = uniquify();
889 if (UniquedNode ==
this) {
900MDNode *MDNode::replaceWithDistinctImpl() {
905void MDTuple::recalculateHash() {
906 setHash(MDTupleInfo::KeyTy::calculateHash(
this));
912 if (Context.hasReplaceableUses()) {
913 Context.getReplaceableUses()->resolveAllUses(
false);
914 (void)Context.takeReplaceableUses();
918void MDNode::handleChangedOperand(
void *
Ref,
Metadata *New) {
946 resolveAfterOperandChange(Old, New);
958 if (Context.hasReplaceableUses())
959 Context.getReplaceableUses()->replaceAllUsesWith(
Uniqued);
968void MDNode::deleteAsSubclass() {
972#define HANDLE_MDNODE_LEAF(CLASS) \
974 delete cast<CLASS>(this); \
976#include "llvm/IR/Metadata.def"
980template <
class T,
class InfoT>
989template <
class NodeTy>
struct MDNode::HasCachedHash {
991 static std::true_type
check(
SameType<
void (U::*)(
unsigned), &U::setHash> *);
992 template <
class U>
static std::false_type
check(...);
997MDNode *MDNode::uniquify() {
1004#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
1005 case CLASS##Kind: { \
1006 CLASS *SubclassThis = cast<CLASS>(this); \
1007 dispatchRecalculateHash(SubclassThis); \
1008 return uniquifyImpl(SubclassThis, getContext().pImpl->CLASS##s); \
1010#include "llvm/IR/Metadata.def"
1014void MDNode::eraseFromStore() {
1018#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
1020 getContext().pImpl->CLASS##s.erase(cast<CLASS>(this)); \
1022#include "llvm/IR/Metadata.def"
1030 MDTupleInfo::KeyTy
Key(MDs);
1035 Hash =
Key.getHash();
1037 assert(ShouldCreate &&
"Expected non-uniqued nodes to always be created");
1041 MDTuple(Context,
Storage, Hash, MDs),
1042 Storage, Context.pImpl->MDTuples);
1046 assert(
N->isTemporary() &&
"Expected temporary node");
1047 N->replaceAllUsesWith(
nullptr);
1048 N->deleteAsSubclass();
1052 assert(!Context.hasReplaceableUses() &&
"Unexpected replaceable uses");
1061#define HANDLE_MDNODE_LEAF(CLASS) \
1062 case CLASS##Kind: { \
1063 dispatchResetHash(cast<CLASS>(this)); \
1066#include "llvm/IR/Metadata.def"
1099 if (
N->getNumOperands() ==
Ops.size() &&
N ==
N->getOperand(0)) {
1100 for (
unsigned I = 1,
E =
Ops.size();
I !=
E; ++
I)
1101 if (
Ops[
I] !=
N->getOperand(
I))
1116 MDs.
insert(
B->op_begin(),
B->op_end());
1164 return MDs.
empty() ? nullptr
1185 assert(
A &&
B && AInstr && BInstr &&
"Caller should guarantee");
1190 assert(
A->getNumOperands() >= 2 &&
B->getNumOperands() >= 2 &&
1191 "!prof annotations should have no less than 2 operands");
1195 assert(AMDS !=
nullptr && BMDS !=
nullptr &&
1196 "first operand should be a non-null MDString");
1205 assert(AInstrWeight && BInstrWeight &&
"verified by LLVM verifier");
1208 MDHelper.createConstant(ConstantInt::get(
1223 switch (
I.getOpcode()) {
1224 case Instruction::Invoke:
1225 case Instruction::Br:
1226 case Instruction::Switch:
1227 case Instruction::Call:
1228 case Instruction::IndirectBr:
1229 case Instruction::Select:
1230 case Instruction::CallBr:
1236 if (AInstr && !IsLegal(*AInstr))
1238 if (BInstr && !IsLegal(*BInstr))
1246 "Caller should guarantee");
1248 "Caller should guarantee");
1256 return mergeDirectCallProfMetadata(
A,
B, AInstr, BInstr);
1264 return A.getUpper() ==
B.getLower() ||
A.getLower() ==
B.getUpper();
1275 const APInt &LB = EndPoints[
Size - 2]->getValue();
1276 const APInt &LE = EndPoints[
Size - 1]->getValue();
1281 EndPoints[
Size - 2] =
1283 EndPoints[
Size - 1] =
1292 if (!EndPoints.
empty())
1307 auto AddUniqueCallees = [&AB, &MergedCallees](
const MDNode *
N) {
1309 if (MergedCallees.
insert(MD).second)
1313 AddUniqueCallees(
A);
1314 AddUniqueCallees(
B);
1334 unsigned AN =
A->getNumOperands() / 2;
1335 unsigned BN =
B->getNumOperands() / 2;
1336 while (AI < AN && BI < BN) {
1369 for (
unsigned i = 0; i <
Size - 2; ++i) {
1370 EndPoints[i] = EndPoints[i + 2];
1378 if (EndPoints.
size() == 2) {
1380 if (
Range.isFullSet())
1386 for (
auto *
I : EndPoints)
1399 for (
unsigned I = 0, E =
A->getNumOperands() / 2;
I != E; ++
I) {
1405 for (
unsigned I = 0, E =
B->getNumOperands() / 2;
I != E; ++
I) {
1420 ConstantInt::get(
A->getContext(), CR.getLower())));
1422 ConstantInt::get(
A->getContext(), CR.getUpper())));
1481NamedMDNode::NamedMDNode(
const Twine &
N)
1490 return (
unsigned)
getNMDOps(Operands).size();
1517 for (
const auto &
A : Attachments)
1524 for (
const auto &
A : Attachments)
1526 Result.push_back(
A.Node);
1531 for (
const auto &
A : Attachments)
1532 Result.emplace_back(
A.MDKind,
A.Node);
1536 if (Result.size() > 1)
1555 if (Attachments.size() == 1 && Attachments.back().MDKind ==
ID) {
1556 Attachments.pop_back();
1560 auto OldSize = Attachments.size();
1563 return OldSize != Attachments.size();
1575 const MDAttachments &Attachements = Ctx.pImpl->ValueMetadata.at(
this);
1576 return Attachements.
lookup(KindID);
1593 "bit out of sync with hash table");
1608 Info.set(KindID,
Node);
1614 "bit out of sync with hash table");
1650 bool Changed = Store.erase(KindID);
1662 assert(!Info.empty() &&
"bit out of sync with hash table");
1664 return Pred(
I.MDKind,
I.Node);
1675 "bit out of sync with hash table");
1688 unsigned KindID = Ctx.getMDKindID(Kind);
1689 if (KindID == LLVMContext::MD_dbg)
1695 if (DbgLoc && Pred(LLVMContext::MD_dbg, DbgLoc.getAsMDNode()))
1708 KnownSet.
insert(LLVMContext::MD_DIAssignID);
1711 return !KnownSet.
count(MDKind);
1715void Instruction::updateDIAssignIDMapping(
DIAssignID *
ID) {
1720 if (
ID == CurrentID)
1724 auto InstrsIt = IDToInstrs.find(CurrentID);
1725 assert(InstrsIt != IDToInstrs.end() &&
1726 "Expect existing attachment to be mapped");
1728 auto &InstVec = InstrsIt->second;
1730 assert(InstIt != InstVec.end() &&
1731 "Expect instruction to be mapped to attachment");
1735 if (InstVec.size() == 1)
1736 IDToInstrs.erase(InstrsIt);
1738 InstVec.erase(InstIt);
1743 IDToInstrs[
ID].push_back(
this);
1751 if (KindID == LLVMContext::MD_dbg) {
1757 if (KindID == LLVMContext::MD_DIAssignID) {
1762 "Temporary DIAssignIDs are invalid");
1771 if (
auto *Existing =
getMetadata(LLVMContext::MD_annotation)) {
1775 for (
auto &
N : Tuple->operands()) {
1781 if (
any_of(MDAnnotationTuple->operands(), [&AnnotationsSet](
auto &
Op) {
1782 return AnnotationsSet.contains(cast<MDString>(Op)->getString());
1801 if (
auto *Existing =
getMetadata(LLVMContext::MD_annotation)) {
1803 for (
auto &
N : Tuple->operands()) {
1823 Result.TBAA = Info.lookup(LLVMContext::MD_tbaa);
1824 Result.TBAAStruct = Info.lookup(LLVMContext::MD_tbaa_struct);
1825 Result.Scope = Info.lookup(LLVMContext::MD_alias_scope);
1826 Result.NoAlias = Info.lookup(LLVMContext::MD_noalias);
1827 Result.NoAliasAddrSpace = Info.lookup(LLVMContext::MD_noalias_addrspace);
1834 setMetadata(LLVMContext::MD_tbaa_struct,
N.TBAAStruct);
1837 setMetadata(LLVMContext::MD_noalias_addrspace,
N.NoAliasAddrSpace);
1845void Instruction::getAllMetadataImpl(
1852 std::make_pair((
unsigned)LLVMContext::MD_dbg, DbgLoc.
getAsMDNode()));
1861 getOpcode() == Instruction::IndirectBr ||
1863 "Looking for branch weights on something besides branch");
1865 return ::extractProfTotalWeight(*
this, TotalVal);
1870 Other->getAllMetadata(MDs);
1871 for (
auto &MD : MDs) {
1873 if (
Offset != 0 && MD.first == LLVMContext::MD_type) {
1876 Metadata *TypeId = MD.second->getOperand(1);
1878 OffsetConst->getType(), OffsetConst->getValue() +
Offset));
1886 auto *Attachment = MD.second;
1887 if (
Offset != 0 && MD.first == LLVMContext::MD_dbg) {
1892 GV = GVE->getVariable();
1893 E = GVE->getExpression();
1897 OrigElements = E->getElements();
1898 std::vector<uint64_t> Elements(OrigElements.
size() + 2);
1899 Elements[0] = dwarf::DW_OP_plus_uconst;
1901 llvm::copy(OrigElements, Elements.begin() + 2);
1911 LLVMContext::MD_type,
1933 assert(Val <= 2 &&
"unknown vcall visibility!");
1950 return CU->getDebugInfoForProfiling();
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file defines the StringMap class.
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
static const Function * getParent(const Value *V)
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This file defines the DenseSet and SmallDenseSet classes.
Module.h This file contains the declarations for the Module class.
const size_t AbstractManglingParser< Derived, Alloc >::NumOps
const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]
mir Rename Register Operands
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
This file contains the declarations for profiling metadata utility functions.
Remove Loads Into Fake Uses
This file implements a set that has insertion order iteration characteristics.
This file defines the SmallPtrSet class.
This file defines the SmallSet class.
This file defines the SmallVector class.
static TableGen::Emitter::OptClass< SkeletonEmitter > X("gen-skeleton-class", "Generate example skeleton class")
Class for arbitrary precision integers.
bool slt(const APInt &RHS) const
Signed less than comparison.
This is a simple wrapper around an MDNode which provides a higher-level interface by hiding the detai...
Annotations lets you mark points and ranges inside source code, for tests:
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
size - Get the array size.
LLVM Basic Block Representation.
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
This class represents a function call, abstracting a target machine's calling convention.
This is the shared class of boolean and integer constants.
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
const APInt & getValue() const
Return the constant as an APInt value reference.
This class represents a list of constant ranges.
LLVM_ABI ConstantRangeList intersectWith(const ConstantRangeList &CRL) const
Return the range list that results from the intersection of this ConstantRangeList with another Const...
This class represents a range of values.
LLVM_ABI ConstantRange unionWith(const ConstantRange &CR, PreferredRangeType Type=Smallest) const
Return the range that results from the union of this range with another range.
This is an important base class in LLVM.
A pair of DIGlobalVariable and DIExpression.
Subprogram description. Uses SubclassData1.
Record of a variable value-assignment, aka a non instruction representation of the dbg....
MDNode * getAsMDNode() const
Return this as a bar MDNode.
Base class for tracking ValueAsMetadata/DIArgLists with user lookups and Owner callbacks outside of V...
LLVM_ABI void handleChangedValue(void *Old, Metadata *NewDebugValue)
To be called by ReplaceableMetadataImpl::replaceAllUsesWith, where Old is a pointer to one of the poi...
std::array< Metadata *, 3 > DebugValues
void resetDebugValue(size_t Idx, Metadata *DebugValue)
LLVM_ABI DbgVariableRecord * getUser()
Implements a dense probed hash-table based set.
void setSubprogram(DISubprogram *SP)
Set the attached subprogram.
DISubprogram * getSubprogram() const
Get the attached subprogram.
bool shouldEmitDebugInfoForProfiling() const
Returns true if we should emit debug info for profiling.
LLVM_ABI void addTypeMetadata(unsigned Offset, Metadata *TypeID)
LLVM_ABI void setMetadata(unsigned KindID, MDNode *Node)
Set a particular kind of metadata attachment.
GlobalObject(Type *Ty, ValueTy VTy, AllocInfo AllocInfo, LinkageTypes Linkage, const Twine &Name, unsigned AddressSpace=0)
LLVM_ABI void copyMetadata(const GlobalObject *Src, unsigned Offset)
Copy metadata from Src, adjusting offsets by Offset.
LLVM_ABI VCallVisibility getVCallVisibility() const
LLVM_ABI bool eraseMetadata(unsigned KindID)
Erase all metadata attachments with the given kind.
LLVM_ABI void addMetadata(unsigned KindID, MDNode &MD)
Add a metadata attachment.
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
LLVM_ABI void setVCallVisibilityMetadata(VCallVisibility Visibility)
LLVM_ABI void getDebugInfo(SmallVectorImpl< DIGlobalVariableExpression * > &GVs) const
Fill the vector with all debug info attachements.
LLVM_ABI void addDebugInfo(DIGlobalVariableExpression *GV)
Attach a DIGlobalVariableExpression.
LLVM_ABI void setAAMetadata(const AAMDNodes &N)
Sets the AA metadata on this instruction from the AAMDNodes structure.
LLVM_ABI bool extractProfTotalWeight(uint64_t &TotalVal) const
Retrieve total raw weight values of a branch.
bool hasMetadata() const
Return true if this instruction has any metadata attached to it.
LLVM_ABI void addAnnotationMetadata(StringRef Annotation)
Adds an !annotation metadata node with Annotation to this instruction.
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
LLVM_ABI void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
LLVM_ABI void setNoSanitizeMetadata()
Sets the nosanitize metadata on this instruction.
LLVM_ABI void dropUnknownNonDebugMetadata(ArrayRef< unsigned > KnownIDs={})
Drop all unknown metadata except for debug locations.
LLVM_ABI AAMDNodes getAAMetadata() const
Returns the AA metadata for this instruction.
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
LLVM_ABI void eraseMetadataIf(function_ref< bool(unsigned, MDNode *)> Pred)
Erase all metadata that matches the predicate.
DenseMap< Metadata *, MetadataAsValue * > MetadataAsValues
DenseMap< DIAssignID *, SmallVector< Instruction *, 1 > > AssignmentIDToInstrs
Map DIAssignID -> Instructions with that attachment.
std::vector< MDNode * > DistinctMDNodes
DenseMap< const Value *, MDAttachments > ValueMetadata
Collection of metadata used in this context.
This is an important class for using LLVM in a threaded context.
LLVM_ABI unsigned getMDKindID(StringRef Name) const
getMDKindID - Return a unique non-zero ID for the specified metadata kind.
LLVMContextImpl *const pImpl
Multimap-like storage for metadata attachments.
void insert(unsigned ID, MDNode &MD)
Adds an attachment to a particular node.
void get(unsigned ID, SmallVectorImpl< MDNode * > &Result) const
Appends all attachments with the given ID to Result in insertion order.
void getAll(SmallVectorImpl< std::pair< unsigned, MDNode * > > &Result) const
Appends all attachments for the global to Result, sorting by attachment ID.
void set(unsigned ID, MDNode *MD)
Set an attachment to a particular node.
MDNode * lookup(unsigned ID) const
Returns the first attachment with the given ID or nullptr if no such attachment exists.
bool erase(unsigned ID)
Remove attachments with the given ID.
LLVM_ABI MDString * createString(StringRef Str)
Return the given string as metadata.
static LLVM_ABI MDNode * getMostGenericAliasScope(MDNode *A, MDNode *B)
LLVM_ABI void replaceOperandWith(unsigned I, Metadata *New)
Replace a specific operand.
LLVM_ABI void resolveCycles()
Resolve cycles.
static LLVM_ABI CaptureComponents toCaptureComponents(const MDNode *MD)
Convert !captures metadata to CaptureComponents. MD may be nullptr.
mutable_op_range mutable_operands()
static LLVM_ABI MDNode * getMergedCalleeTypeMetadata(const MDNode *A, const MDNode *B)
void replaceAllUsesWith(Metadata *MD)
RAUW a temporary.
static LLVM_ABI MDNode * concatenate(MDNode *A, MDNode *B)
Methods for metadata merging.
static LLVM_ABI void deleteTemporary(MDNode *N)
Deallocate a node created by getTemporary.
LLVM_ABI void resolve()
Resolve a unique, unresolved node.
const MDOperand & getOperand(unsigned I) const
static LLVM_ABI MDNode * getMostGenericNoaliasAddrspace(MDNode *A, MDNode *B)
LLVM_ABI void storeDistinctInContext()
ArrayRef< MDOperand > operands() const
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
static LLVM_ABI MDNode * getMergedProfMetadata(MDNode *A, MDNode *B, const Instruction *AInstr, const Instruction *BInstr)
Merge !prof metadata from two instructions.
static LLVM_ABI MDNode * getMostGenericFPMath(MDNode *A, MDNode *B)
void setNumUnresolved(unsigned N)
unsigned getNumOperands() const
Return number of MDNode operands.
MDOperand * mutable_begin()
LLVM_ABI MDNode(LLVMContext &Context, unsigned ID, StorageType Storage, ArrayRef< Metadata * > Ops1, ArrayRef< Metadata * > Ops2={})
LLVM_ABI TempMDNode clone() const
Create a (temporary) clone of this.
static LLVM_ABI MDNode * getMostGenericRange(MDNode *A, MDNode *B)
LLVM_ABI void setOperand(unsigned I, Metadata *New)
Set an operand.
bool isResolved() const
Check if node is fully resolved.
op_iterator op_begin() const
static LLVM_ABI MDNode * intersect(MDNode *A, MDNode *B)
static T * storeImpl(T *N, StorageType Storage, StoreT &Store)
LLVMContext & getContext() const
static LLVM_ABI MDNode * fromCaptureComponents(LLVMContext &Ctx, CaptureComponents CC)
Convert CaptureComponents to !captures metadata.
LLVM_ABI void dropAllReferences()
static LLVM_ABI MDNode * getMostGenericAlignmentOrDereferenceable(MDNode *A, MDNode *B)
unsigned getNumUnresolved() const
Tracking metadata reference owned by Metadata.
LLVM_ABI StringRef getString() const
static LLVM_ABI MDString * get(LLVMContext &Context, StringRef Str)
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
void eraseNamedMetadata(NamedMDNode *NMD)
Remove the given NamedMDNode from this module and delete it.
LLVM_ABI void setOperand(unsigned I, MDNode *New)
LLVM_ABI StringRef getName() const
void dropAllReferences()
Remove all uses and clear node vector.
LLVM_ABI void eraseFromParent()
Drop all references and remove the node from parent module.
LLVM_ABI MDNode * getOperand(unsigned i) const
LLVM_ABI unsigned getNumOperands() const
LLVM_ABI void clearOperands()
Drop all references to this node's operands.
Module * getParent()
Get the module that holds this named metadata collection.
LLVM_ABI void addOperand(MDNode *M)
bool isNull() const
Test if the pointer held in the union is null, regardless of which type it is.
static LLVM_ABI PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
ArrayRef< value_type > getArrayRef() const
bool remove_if(UnaryPredicate P)
Remove items from the set vector based on a predicate function.
bool empty() const
Determine if the SetVector is empty or not.
bool insert(const value_type &X)
Insert a new element into the SetVector.
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
bool contains(ConstPtrType Ptr) const
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
A SetVector that performs no allocations if smaller than a certain size.
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
size_type count(const T &V) const
count - Return 1 if the element is in the set, 0 otherwise.
std::pair< const_iterator, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void reserve(size_type N)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
A switch()-like statement whose cases are string literals.
StringSwitch & Case(StringLiteral S, T Value)
The instances of the Type class are immutable: once they are created, they are never changed.
static LLVM_ABI IntegerType * getInt64Ty(LLVMContext &C)
static LLVM_ABI Type * getMetadataTy(LLVMContext &C)
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
bool hasMetadata() const
Return true if this value has any metadata attached to it.
LLVM_ABI void setMetadata(unsigned KindID, MDNode *Node)
Set a particular kind of metadata attachment.
LLVM_ABI void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
LLVM_ABI void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * > > &MDs) const
Appends all metadata attached to this value to MDs, sorting by KindID.
LLVM_ABI MDNode * getMetadataImpl(unsigned KindID) const
Get metadata for the given kind, if any.
LLVM_ABI bool eraseMetadata(unsigned KindID)
Erase all metadata attachments with the given kind.
LLVM_ABI void addMetadata(unsigned KindID, MDNode &MD)
Add a metadata attachment.
LLVM_ABI void eraseMetadataIf(function_ref< bool(unsigned, MDNode *)> Pred)
Erase all metadata attachments matching the given predicate.
LLVM_ABI LLVMContext & getContext() const
All values hold a context through their type.
LLVM_ABI void clearMetadata()
Erase all metadata attached to this Value.
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
An efficient, type-erasing, non-owning reference to a callable.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
@ C
The default llvm calling convention, compatible with C.
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > dyn_extract(Y &&MD)
Extract a Value from Metadata, if any.
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract(Y &&MD)
Extract a Value from Metadata.
This is an optimization pass for GlobalISel generic memory operations.
@ Low
Lower the current thread's priority such that it does not affect foreground tasks significantly.
detail::zippy< detail::zip_shortest, T, U, Args... > zip(T &&t, U &&u, Args &&...args)
zip iterator for two or more iteratable types.
bool capturesReadProvenanceOnly(CaptureComponents CC)
void stable_sort(R &&Range)
auto find(R &&Range, const T &Val)
Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly.
bool capturesAddressIsNullOnly(CaptureComponents CC)
TypedTrackingMDRef< MDNode > TrackingMDNodeRef
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.
LLVM_ABI unsigned getBranchWeightOffset(const MDNode *ProfileData)
Return the offset to the first branch weight data.
static T * getUniqued(DenseSet< T *, InfoT > &Store, const typename InfoT::KeyTy &Key)
bool capturesAddress(CaptureComponents CC)
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
constexpr from_range_t from_range
auto dyn_cast_if_present(const Y &Val)
dyn_cast_if_present<X> - Functionally identical to dyn_cast, except that a null (or none in the case ...
auto cast_or_null(const Y &Val)
auto dyn_cast_or_null(const Y &Val)
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
bool capturesFullProvenance(CaptureComponents CC)
void sort(IteratorTy Start, IteratorTy End)
CaptureComponents
Components of the pointer that may be captured.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
MutableArrayRef(T &OneElt) -> MutableArrayRef< T >
@ Ref
The access may reference the value stored in memory.
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
DWARFExpression::Operation Op
ArrayRef(const T &OneElt) -> ArrayRef< T >
OutputIt copy(R &&Range, OutputIt Out)
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
auto count_if(R &&Range, UnaryPredicate P)
Wrapper function around std::count_if to count the number of times an element satisfying a given pred...
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
bool capturesAll(CaptureComponents CC)
std::enable_if_t< std::is_unsigned_v< T >, T > SaturatingAdd(T X, T Y, bool *ResultOverflowed=nullptr)
Add two unsigned integers, X and Y, of type T.
bool capturesNothing(CaptureComponents CC)
static constexpr bool value
static std::false_type check(...)
static std::true_type check(SameType< void(U::*)(unsigned), &U::setHash > *)
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
static LLVM_ABI const char * BranchWeights
Function object to check whether the first component of a container supported by std::get (like std::...