63 :
Value(Ty, MetadataAsValueVal), MD(MD) {
91 if (!
N ||
N->getNumOperands() != 1)
94 if (!
N->getOperand(0))
107 auto *&Entry = Context.pImpl->MetadataAsValues[MD];
116 auto &
Store = Context.pImpl->MetadataAsValues;
117 return Store.lookup(MD);
120void MetadataAsValue::handleChangedMetadata(
Metadata *MD) {
123 auto &
Store = Context.pImpl->MetadataAsValues;
126 Store.erase(this->MD);
131 auto *&Entry =
Store[MD];
143void MetadataAsValue::track() {
148void MetadataAsValue::untrack() {
163 auto OldMD =
static_cast<Metadata **
>(Old);
174void DebugValueUser::trackDebugValue(
size_t Idx) {
175 assert(Idx < 3 &&
"Invalid debug value index.");
181 ID->Records.push_back(
getUser());
184void DebugValueUser::trackDebugValues() {
189void DebugValueUser::untrackDebugValue(
size_t Idx) {
190 assert(Idx < 3 &&
"Invalid debug value index.");
199void DebugValueUser::untrackDebugValues() {
201 untrackDebugValue(
I);
205 assert(DebugValueUser::operator==(
X) &&
"Expected values to match");
211 X.DebugValues.fill(
nullptr);
215 assert(
Ref &&
"Expected live reference");
217 "Reference without owner must be direct");
218 if (
auto *R = ReplaceableUses::getOrCreate(MD)) {
223 assert(!PH->Use &&
"Placeholders can only be used once");
232 assert(
Ref &&
"Expected live reference");
233 if (
auto *R = ReplaceableUses::getIfExists(MD))
240 assert(
Ref &&
"Expected live reference");
241 assert(New &&
"Expected live reference");
243 if (
auto *R = ReplaceableUses::getIfExists(MD)) {
244 R->moveRef(
Ref, New, MD);
248 "Unexpected move of an MDOperand");
250 "Expected un-replaceable metadata, since we didn't move a reference");
255 return ReplaceableUses::isReplaceable(MD);
260 for (
auto Pair : UseMap) {
268 MDUsersWithID.
push_back(&UseMap[Pair.first]);
270 llvm::sort(MDUsersWithID, [](
auto UserA,
auto UserB) {
271 return UserA->second < UserB->second;
274 for (
auto *UserWithID : MDUsersWithID)
282 for (
auto Pair : UseMap) {
288 DVRUsersWithID.
push_back(&UseMap[Pair.first]);
295 llvm::sort(DVRUsersWithID, [](
auto UserA,
auto UserB) {
296 return UserA->second > UserB->second;
299 for (
auto UserWithID : DVRUsersWithID)
304void ReplaceableUses::addRef(
void *
Ref, OwnerTy
Owner) {
306 UseMap.insert(std::make_pair(
Ref, std::make_pair(
Owner, NextIndex)))
309 assert(WasInserted &&
"Expected to add a reference");
312 assert(NextIndex != 0 &&
"Unexpected overflow");
315void ReplaceableUses::dropRef(
void *
Ref) {
316 bool WasErased = UseMap.erase(
Ref);
318 assert(WasErased &&
"Expected to drop a reference");
321void ReplaceableUses::moveRef(
void *
Ref,
void *New,
const Metadata &MD) {
322 auto I = UseMap.find(
Ref);
323 assert(
I != UseMap.end() &&
"Expected to move a reference");
324 auto OwnerAndIndex =
I->second;
326 bool WasInserted = UseMap.insert(std::make_pair(New, OwnerAndIndex)).second;
328 assert(WasInserted &&
"Expected to add a reference");
333 "Reference without owner must be direct");
334 assert((OwnerAndIndex.first || *
static_cast<Metadata **
>(New) == &MD) &&
335 "Reference without owner must be direct");
339 if (!
C.isUsedByMetadata()) {
344 auto &
Store = Context.pImpl->ValuesAsMetadata;
348 std::pair<void *, std::pair<MetadataTracking::OwnerTy, uint64_t>>;
353 for (
const auto &Pair :
Uses) {
369 OwnerMD->handleChangedOperand(
380 using UseTy = std::pair<void *, std::pair<OwnerTy, uint64_t>>;
383 return L.second.second < R.second.second;
385 for (
const auto &Pair :
Uses) {
388 if (!UseMap.count(Pair.first))
398 UseMap.erase(Pair.first);
409 DVU->handleChangedValue(Pair.first, MD);
416#define HANDLE_METADATA_LEAF(CLASS) \
417 case Metadata::CLASS##Kind: \
418 cast<CLASS>(OwnerMD)->handleChangedOperand(Pair.first, MD); \
420#include "llvm/IR/Metadata.def"
425 assert(UseMap.empty() &&
"Expected all uses to be replaced");
438 using UseTy = std::pair<void *, std::pair<OwnerTy, uint64_t>>;
441 return L.second.second < R.second.second;
444 for (
const auto &Pair :
Uses) {
445 auto Owner = Pair.second.first;
455 if (OwnerMD->isResolved())
457 OwnerMD->decrementUnresolvedOperandCount();
465 return VAM && VAM->getValue()->hasUseList();
473 return N->isResolved() ? nullptr :
N->Context.getOrCreateReplaceableUses();
482 return N->isResolved() ? nullptr :
N->Context.getReplaceableUses();
489bool ReplaceableUses::isReplaceable(
const Metadata &MD) {
491 return !
N->isResolved();
498 if (
auto *Fn =
A->getParent())
499 return Fn->getSubprogram();
504 if (
auto *Fn = BB->getParent())
505 return Fn->getSubprogram();
513 assert(V &&
"Unexpected null Value");
515 auto &Context = V->getContext();
516 auto *&Entry = Context.pImpl->ValuesAsMetadata[V];
519 "Expected constant or function-local value");
520 assert(!V->IsUsedByMD &&
"Expected this to be the only metadata use");
521 V->IsUsedByMD =
true;
532 assert(V &&
"Unexpected null Value");
533 return V->getContext().pImpl->ValuesAsMetadata.lookup(V);
537 assert(V &&
"Expected valid value");
539 auto &
Store = V->getType()->getContext().pImpl->ValuesAsMetadata;
546 assert(MD &&
"Expected valid metadata");
556 assert(From &&
"Expected valid value");
557 assert(To &&
"Expected valid value");
558 assert(From != To &&
"Expected changed value");
563 auto I =
Store.find(From);
572 assert(MD &&
"Expected valid metadata");
584 if (!FromSP || !ToSP || FromSP == ToSP)
596 auto &
Store = Context.pImpl->MDStringCache;
597 auto I =
Store.try_emplace(Str);
598 auto &MapEntry =
I.first->getValue();
601 MapEntry.Entry = &*
I.first;
606 auto &
Store = Context.pImpl->MDStringCache;
610 return &
I->getValue();
614 assert(Entry &&
"Expected to find string map entry");
615 return Entry->first();
624#define HANDLE_MDNODE_LEAF(CLASS) \
626 alignof(uint64_t) >= alignof(CLASS), \
627 "Alignment is insufficient after objects prepended to " #CLASS);
628#include "llvm/IR/Metadata.def"
633 static_assert(
sizeof(Header) ==
sizeof(size_t) + 2 *
sizeof(
uint32_t),
634 "MDNode header fields poorly packed");
637 char *Mem =
reinterpret_cast<char *
>(::operator
new(AllocSize +
Size));
638 Header *
H =
new (Mem + AllocSize -
sizeof(Header)) Header(
NumOps,
Storage);
639 return reinterpret_cast<void *
>(
H + 1);
642void MDNode::operator
delete(
void *
N) {
643 Header *
H =
reinterpret_cast<Header *
>(
N) - 1;
644 void *Mem =
H->getAllocation();
646 ::operator
delete(Mem);
652 getHeader().MetadataPrintID = Context.pImpl->allocateMetadataPrintID();
665 countUnresolvedOperands();
672#define HANDLE_MDNODE_LEAF(CLASS) \
674 return cast<CLASS>(this)->cloneImpl();
675#include "llvm/IR/Metadata.def"
679MDNode::Header::Header(
size_t NumOps, StorageType Storage) {
680 IsLarge = isLarge(
NumOps);
681 IsResizable = isResizable(
Storage);
682 SmallSize = getSmallSize(
NumOps, IsResizable, IsLarge);
685 new (getLargePtr()) LargeStorageVector();
695MDNode::Header::~Header() {
697 getLarge().~LargeStorageVector();
700 MDOperand *
O =
reinterpret_cast<MDOperand *
>(
this);
701 for (MDOperand *
E = O - SmallSize;
O !=
E; --
O)
702 (O - 1)->~MDOperand();
705void *MDNode::Header::getSmallPtr() {
706 static_assert(
alignof(MDOperand) <=
alignof(Header),
707 "MDOperand too strongly aligned");
708 return reinterpret_cast<char *
>(
const_cast<Header *
>(
this)) -
709 sizeof(MDOperand) * SmallSize;
712void MDNode::Header::resize(
size_t NumOps) {
713 assert(IsResizable &&
"Node is not resizable");
718 getLarge().resize(
NumOps);
719 else if (
NumOps <= SmallSize)
722 resizeSmallToLarge(
NumOps);
725void MDNode::Header::resizeSmall(
size_t NumOps) {
726 assert(!IsLarge &&
"Expected a small MDNode");
727 assert(
NumOps <= SmallSize &&
"NumOps too large for small resize");
732 int NumNew = (int)
NumOps - (
int)ExistingOps.
size();
733 MDOperand *
O = ExistingOps.
end();
734 for (
int I = 0,
E = NumNew;
I <
E; ++
I)
736 for (
int I = 0,
E = NumNew;
I >
E; --
I)
742void MDNode::Header::resizeSmallToLarge(
size_t NumOps) {
743 assert(!IsLarge &&
"Expected a small MDNode");
744 assert(
NumOps > SmallSize &&
"Expected NumOps to be larger than allocation");
745 LargeStorageVector NewOps;
749 new (getLargePtr()) LargeStorageVector(std::move(NewOps));
755 return !
N->isResolved();
759void MDNode::countUnresolvedOperands() {
765void MDNode::makeUniqued() {
769 assert(WasTracked &&
"Temporary node not tracked");
774 Op.reset(
Op.get(),
this);
778 countUnresolvedOperands();
780 dropReplaceableUses();
787void MDNode::makeDistinct() {
792 dropReplaceableUses();
804 dropReplaceableUses();
809void MDNode::dropReplaceableUses() {
813 if (Context.hasReplaceableUses())
814 Context.takeReplaceableUses()->resolveAllUses();
827 decrementUnresolvedOperandCount();
830void MDNode::decrementUnresolvedOperandCount() {
841 dropReplaceableUses();
859 "Expected all forward declarations to be resolved");
860 if (!
N->isResolved())
869MDNode *MDNode::replaceWithPermanentImpl() {
873 return replaceWithDistinctImpl();
875#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
878#include "llvm/IR/Metadata.def"
883 return replaceWithDistinctImpl();
884 return replaceWithUniquedImpl();
887MDNode *MDNode::replaceWithUniquedImpl() {
889 MDNode *UniquedNode = uniquify();
891 if (UniquedNode ==
this) {
902MDNode *MDNode::replaceWithDistinctImpl() {
907void MDTuple::recalculateHash() {
908 setHash(MDTupleInfo::KeyTy::calculateHash(
this));
914 if (Context.hasReplaceableUses()) {
915 Context.getReplaceableUses()->resolveAllUses(
false);
916 (void)Context.takeReplaceableUses();
920void MDNode::handleChangedOperand(
void *
Ref,
Metadata *New) {
948 resolveAfterOperandChange(Old, New);
960 if (Context.hasReplaceableUses())
961 Context.getReplaceableUses()->replaceAllUsesWith(
Uniqued);
970void MDNode::deleteAsSubclass() {
973 assert(WasTracked &&
"Temporary node not tracked");
979#define HANDLE_MDNODE_LEAF(CLASS) \
981 delete cast<CLASS>(this); \
983#include "llvm/IR/Metadata.def"
987template <
class T,
class InfoT>
996template <
class NodeTy>
struct MDNode::HasCachedHash {
998 static std::true_type
check(
SameType<
void (U::*)(
unsigned), &U::setHash> *);
999 template <
class U>
static std::false_type
check(...);
1004MDNode *MDNode::uniquify() {
1011#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
1012 case CLASS##Kind: { \
1013 CLASS *SubclassThis = cast<CLASS>(this); \
1014 dispatchRecalculateHash(SubclassThis); \
1015 return uniquifyImpl(SubclassThis, getContext().pImpl->CLASS##s); \
1017#include "llvm/IR/Metadata.def"
1021void MDNode::eraseFromStore() {
1025#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
1027 getContext().pImpl->CLASS##s.erase(cast<CLASS>(this)); \
1029#include "llvm/IR/Metadata.def"
1037 MDTupleInfo::KeyTy
Key(MDs);
1042 Hash =
Key.getHash();
1044 assert(ShouldCreate &&
"Expected non-uniqued nodes to always be created");
1048 MDTuple(Context,
Storage, Hash, MDs),
1049 Storage, Context.pImpl->MDTuples);
1053 assert(
N->isTemporary() &&
"Expected temporary node");
1054 N->replaceAllUsesWith(
nullptr);
1055 N->deleteAsSubclass();
1059 assert(!Context.hasReplaceableUses() &&
"Unexpected replaceable uses");
1063 assert(WasTracked &&
"Temporary node not tracked");
1073#define HANDLE_MDNODE_LEAF(CLASS) \
1074 case CLASS##Kind: { \
1075 dispatchResetHash(cast<CLASS>(this)); \
1078#include "llvm/IR/Metadata.def"
1111 if (
N->getNumOperands() ==
Ops.size() &&
N ==
N->getOperand(0)) {
1112 for (
unsigned I = 1,
E =
Ops.size();
I !=
E; ++
I)
1113 if (
Ops[
I] !=
N->getOperand(
I))
1128 MDs.
insert(
B->op_begin(),
B->op_end());
1176 return MDs.
empty() ? nullptr
1197 assert(
A &&
B && AInstr && BInstr &&
"Caller should guarantee");
1202 assert(
A->getNumOperands() >= 2 &&
B->getNumOperands() >= 2 &&
1203 "!prof annotations should have no less than 2 operands");
1207 assert(AMDS !=
nullptr && BMDS !=
nullptr &&
1208 "first operand should be a non-null MDString");
1217 assert(AInstrWeight && BInstrWeight &&
"verified by LLVM verifier");
1220 MDHelper.createConstant(ConstantInt::get(
1235 switch (
I.getOpcode()) {
1236 case Instruction::Invoke:
1237 case Instruction::CondBr:
1238 case Instruction::Switch:
1239 case Instruction::Call:
1240 case Instruction::IndirectBr:
1241 case Instruction::Select:
1242 case Instruction::CallBr:
1248 if (AInstr && !IsLegal(*AInstr))
1250 if (BInstr && !IsLegal(*BInstr))
1258 "Caller should guarantee");
1260 "Caller should guarantee");
1268 return mergeDirectCallProfMetadata(
A,
B, AInstr, BInstr);
1279 return A.getUpper() ==
B.getLower() ||
A.getLower() ==
B.getUpper();
1290 const APInt &LB = EndPoints[
Size - 2]->getValue();
1291 const APInt &LE = EndPoints[
Size - 1]->getValue();
1296 EndPoints[
Size - 2] =
1298 EndPoints[
Size - 1] =
1307 if (!EndPoints.
empty())
1322 auto AddUniqueCallees = [&AB, &MergedCallees](
const MDNode *
N) {
1324 if (MergedCallees.
insert(MD).second)
1328 AddUniqueCallees(
A);
1329 AddUniqueCallees(
B);
1354 const auto Requests = [](
MDNode *
N) {
1357 for (
size_t I = 0;
I <
Ops.size();) {
1358 const size_t Begin =
I++;
1365 const auto RequestsA = Requests(
A);
1368 return L.get() == R.get();
1374 Ops.append(R.begin(), R.end());
1385 return const_cast<MDNode *
>(
A);
1386 const unsigned NumOps =
A->getNumOperands();
1396 auto MergeNames = [&](
unsigned Idx) ->
Metadata * {
1399 if (!NameA || !NameB)
1405 if (NameA->getString().empty())
1407 if (NameB->getString().empty())
1411 (NameA->getString() +
"|" + NameB->getString()).str());
1414 bool MergedContainsPointer = CIA->isOne() || CIB->isOne();
1419 Ops.push_back(MergeNames(2));
1441 unsigned AN =
A->getNumOperands() / 2;
1442 unsigned BN =
B->getNumOperands() / 2;
1443 while (AI < AN && BI < BN) {
1476 for (
unsigned i = 0; i <
Size - 2; ++i) {
1477 EndPoints[i] = EndPoints[i + 2];
1485 if (EndPoints.
size() == 2) {
1487 if (
Range.isFullSet())
1493 for (
auto *
I : EndPoints)
1512 AVal->
getType(), Intersect)));
1523 for (
unsigned I = 0, E =
A->getNumOperands() / 2;
I != E; ++
I) {
1529 for (
unsigned I = 0, E =
B->getNumOperands() / 2;
I != E; ++
I) {
1544 ConstantInt::get(
A->getContext(), CR.getLower())));
1546 ConstantInt::get(
A->getContext(), CR.getUpper())));
1605NamedMDNode::NamedMDNode(
const Twine &
N)
1614 return (
unsigned)
getNMDOps(Operands).size();
1640unsigned &Value::getMetadataIndex() {
1642 return I->MetadataIndex;
1646unsigned Value::getMetadataIndex()
const {
1647 return const_cast<Value *
>(
this)->getMetadataIndex();
1657 unsigned Idx = getMetadataIndex();
1660 if (
A.MDKind == KindID)
1673 if (
A.MDKind == KindID)
1678 std::reverse(MDs.
begin(), MDs.
end());
1689 unsigned Idx = getMetadataIndex();
1692 MDs.emplace_back(
A.MDKind,
A.Node);
1697 if (MDs.
size() > 1) {
1698 std::reverse(MDs.
begin(), MDs.
end());
1706 if (getMetadataIndex() != 0)
1713 if (!
Node && getMetadataIndex() == 0)
1720 unsigned &Idx = getMetadataIndex();
1721 unsigned NewIdx = Ctx.pImpl->MetadataRecycleHead;
1723 NewIdx = Ctx.pImpl->Metadatas.size();
1726 Ctx.pImpl->Metadatas.resize(NewIdx + 1);
1728 Ctx.pImpl->MetadataRecycleHead = Ctx.pImpl->Metadatas[NewIdx].Next;
1730 Ctx.pImpl->MetadataRecycleSize -= 1;
1733 Ctx.pImpl->Metadatas[NewIdx] =
1746 return MDKind == KindID;
1752 unsigned *Idx = &getMetadataIndex();
1756 if (
Pred(
A.MDKind,
A.Node)) {
1758 unsigned FreeIdx = *Idx;
1760 A.Next = Ctx.pImpl->MetadataRecycleHead;
1761 Ctx.pImpl->MetadataRecycleHead = FreeIdx;
1763 Ctx.pImpl->MetadataRecycleSize += 1;
1776 if (!
Node && MetadataIndex == 0)
1783 unsigned KindID = Ctx.getMDKindID(Kind);
1784 if (KindID == LLVMContext::MD_dbg)
1790 if (DbgLoc &&
Pred(LLVMContext::MD_dbg, DbgLoc.getAsMDNode()))
1803 KnownSet.
insert(LLVMContext::MD_DIAssignID);
1806 return !KnownSet.
count(MDKind);
1810void Instruction::updateDIAssignIDMapping(
DIAssignID *ID) {
1811 if (
auto *CurrentID =
1813 if (ID == CurrentID)
1815 CurrentID->Instrs.erase(
llvm::find(CurrentID->Instrs,
this));
1818 ID->Instrs.push_back(
this);
1826 if (KindID == LLVMContext::MD_dbg) {
1832 if (KindID == LLVMContext::MD_DIAssignID) {
1837 "Temporary DIAssignIDs are invalid");
1846 if (
auto *Existing =
getMetadata(LLVMContext::MD_annotation)) {
1850 for (
auto &
N : Tuple->operands()) {
1856 if (
any_of(MDAnnotationTuple->operands(), [&AnnotationsSet](
auto &
Op) {
1857 return AnnotationsSet.contains(cast<MDString>(Op)->getString());
1876 if (
auto *Existing =
getMetadata(LLVMContext::MD_annotation)) {
1878 for (
auto &
N : Tuple->operands()) {
1895 unsigned Idx = MetadataIndex;
1900 case LLVMContext::MD_tbaa:
1901 Result.TBAA =
A.Node;
1903 case LLVMContext::MD_tbaa_struct:
1904 Result.TBAAStruct =
A.Node;
1906 case LLVMContext::MD_alias_scope:
1907 Result.Scope =
A.Node;
1909 case LLVMContext::MD_noalias:
1910 Result.NoAlias =
A.Node;
1912 case LLVMContext::MD_noalias_addrspace:
1913 Result.NoAliasAddrSpace =
A.Node;
1924 setMetadata(LLVMContext::MD_tbaa_struct,
N.TBAAStruct);
1927 setMetadata(LLVMContext::MD_noalias_addrspace,
N.NoAliasAddrSpace);
1935void Instruction::getAllMetadataImpl(
1942 std::make_pair((
unsigned)LLVMContext::MD_dbg, DbgLoc.
getAsMDNode()));
1952 getOpcode() == Instruction::IndirectBr ||
1954 "Looking for branch weights on something besides branch");
1956 return ::extractProfTotalWeight(*
this, TotalVal);
1961 Other->getAllMetadata(MDs);
1962 for (
auto &MD : MDs) {
1964 if (
Offset != 0 && MD.first == LLVMContext::MD_type) {
1967 Metadata *TypeId = MD.second->getOperand(1);
1969 OffsetConst->getType(), OffsetConst->getValue() +
Offset));
1977 auto *Attachment = MD.second;
1978 if (
Offset != 0 && MD.first == LLVMContext::MD_dbg) {
1983 GV = GVE->getVariable();
1984 E = GVE->getExpression();
1988 OrigElements = E->getElements();
1989 std::vector<uint64_t> Elements(OrigElements.
size() + 2);
1990 Elements[0] = dwarf::DW_OP_plus_uconst;
1992 llvm::copy(OrigElements, Elements.begin() + 2);
2002 LLVMContext::MD_type,
2024 assert(Val <= 2 &&
"unknown vcall visibility!");
2041 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< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
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...
static ManagedStatic< DebugCounterOwner > Owner
This file defines the DenseSet and SmallDenseSet classes.
Module.h This file contains the declarations for the Module class.
static constexpr Value * getValue(Ty &ValueOrUse)
const size_t AbstractManglingParser< Derived, Alloc >::NumOps
const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
This file contains the declarations for profiling metadata utility functions.
Remove Loads Into Fake Uses
SI optimize exec mask operations pre RA
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::Opt Y("gen-skeleton-entry", EmitSkeleton, "Generate example skeleton entry")
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:
Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
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....
LLVM_ABI MDNode * getAsMDNode() const
Return this as a bar MDNode.
Base class for tracking ValueAsMetadata/DIArgLists with user lookups and Owner callbacks outside of V...
static constexpr size_t AssignIDIdx
LLVM_ABI void handleChangedValue(void *Old, Metadata *NewDebugValue)
To be called by ReplaceableUses::replaceAllUsesWith, where Old is a pointer to one of the pointers in...
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)
unsigned MetadataIndex
Index of first metadata attachment in context, or zero.
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 metadata of given kind attached to this GlobalObject.
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 hasMetadataOtherThanDebugLoc() const
Return true if this instruction has metadata attached to it other than a debug location.
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
SmallVector< MDAttachment, 0 > Metadatas
Collection of metadata attachments in this context.
std::vector< MDNode * > DistinctMDNodes
DenseMap< Value *, ValueAsMetadata * > ValuesAsMetadata
DenseSet< MDNode * > TemporaryMDNodes
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
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 * getMergedPCSectionsMetadata(MDNode *A, MDNode *B)
Merge !pcsections of two merged instructions: the result requests every section that either requests.
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 LLVM_ABI MDNode * getMergedCalleesMetadata(MDNode *A, MDNode *B)
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 * getMergedAllocTokenMetadata(const MDNode *A, const MDNode *B)
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 LLVM_ABI MDNode * getMostGenericNoFPClass(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 * getIfExists(LLVMContext &Context, StringRef Str)
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)
static LLVM_ABI PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Shared implementation of use-lists for replaceable metadata.
MetadataTracking::OwnerTy OwnerTy
LLVM_ABI SmallVector< Metadata * > getAllArgListUsers()
Returns the list of all DIArgList users of this.
LLVM_ABI SmallVector< DbgVariableRecord * > getAllDbgVariableRecordUsers()
Returns the list of all DbgVariableRecord users of this.
LLVM_ABI void resolveAllUses(bool ResolveUsers=true)
Resolve all uses of this.
LLVM_ABI void replaceAllUsesWith(Metadata *MD)
Replace all uses of this with MD.
static LLVM_ABI void SalvageDebugInfo(const Constant &C)
Replace all uses of the constant with Undef in debug info metadata.
ArrayRef< value_type > getArrayRef() const
bool remove_if(UnaryPredicate P)
Remove items from the set vector based on a predicate function.
void insert_range(Range &&R)
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)
LLVM_NO_SANITIZE_CFI_UNRELATED_CAST iterator begin()
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
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.
static LLVM_ABI IntegerType * getInt1Ty(LLVMContext &C)
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
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.
LLVMContext & getContext() const
All values hold a context through their type.
LLVM_ABI void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * > > &MDs) const
Appends all metadata attached to this value to MDs, sorting by KindID.
bool hasUseList() const
Check if this Value has a use-list.
LLVM_ABI MDNode * getMetadataImpl(unsigned KindID) const LLVM_READONLY
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 MDNode * getMetadata(StringRef Kind) const LLVM_READONLY
Get the current metadata attachments for the given kind, if any.
LLVM_ABI void eraseMetadataIf(function_ref< bool(unsigned, MDNode *)> Pred)
Erase all metadata attachments matching the given predicate.
LLVM_ABI void clearMetadata()
Erase all metadata attached to this Value.
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.
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > dyn_extract_or_null(Y &&MD)
Extract a Value from Metadata, if any, allowing null.
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.
@ Store
The extracted value is stored (ExtractElement only).
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)
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
constexpr uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
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.
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.
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
bool equal(L &&LRange, R &&RRange)
Wrapper function around std::equal to detect if pair-wise elements between two ranges are the same.
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...
Single metadata attachment, forms linked list ended by index 0.
static LLVM_ABI const char * BranchWeights
Function object to check whether the first component of a container supported by std::get (like std::...