15#ifndef LLVM_IR_METADATA_H
16#define LLVM_IR_METADATA_H
44class ModuleSlotTracker;
46class DbgVariableRecord;
47template <
typename T>
class StringMapEntry;
48template <
typename ValueTy>
class StringMapEntryStorage;
66 const unsigned char SubclassID;
81#define HANDLE_METADATA_LEAF(CLASS) CLASS##Kind,
82#include "llvm/IR/Metadata.def"
88 static_assert(
sizeof(*this) == 8,
"Metadata fields poorly packed");
125 bool IsForDebug =
false)
const;
127 bool IsForDebug =
false)
const;
139 const Module *M =
nullptr)
const;
148 return reinterpret_cast<Metadata**
>(MDs);
151#define HANDLE_METADATA(CLASS) class CLASS;
152#include "llvm/IR/Metadata.def"
156#define HANDLE_METADATA_LEAF(CLASS) \
157 template <> struct isa_impl<CLASS, Metadata> { \
158 static inline bool doit(const Metadata &MD) { \
159 return MD.getMetadataID() == Metadata::CLASS##Kind; \
162#include "llvm/IR/Metadata.def"
185 void dropUse() { MD =
nullptr; }
196 return V->getValueID() == MetadataAsValueVal;
200 void handleChangedMetadata(
Metadata *MD);
239 retrackDebugValues(
X);
250 untrackDebugValues();
252 retrackDebugValues(
X);
260 untrackDebugValues();
269 untrackDebugValues();
274 assert(
Idx < 3 &&
"Invalid debug value index.");
275 untrackDebugValue(
Idx);
277 trackDebugValue(
Idx);
288 void trackDebugValue(
size_t Idx);
289 void trackDebugValues();
291 void untrackDebugValue(
size_t Idx);
292 void untrackDebugValues();
361 return retrack(&MD, *MD, &New);
397 assert(UseMap.
empty() &&
"Cannot destroy in-use replaceable metadata");
424 void dropRef(
void *
Ref);
425 void moveRef(
void *
Ref,
void *New,
const Metadata &MD);
439 static bool isReplaceable(
const Metadata &MD);
464 assert(V &&
"Expected valid value");
473 return cast<ConstantAsMetadata>(
get(
C));
477 return cast<LocalAsMetadata>(
get(Local));
483 return cast_or_null<ConstantAsMetadata>(
getIfExists(
C));
487 return cast_or_null<LocalAsMetadata>(
getIfExists(Local));
550 assert(!isa<Constant>(Local) &&
"Expected local value");
625 template <
class U,
class V>
630 sizeof(hasDereference<T, Result>(
nullptr)) ==
sizeof(
Yes);
633 static const bool value = std::is_base_of<Constant, V>::value &&
637 static const bool value = std::is_base_of<Constant, V>::value &&
638 std::is_convertible<M, const Metadata &>::value;
647template <
class X,
class Y>
648inline std::enable_if_t<detail::IsValidPointer<X, Y>::value,
bool>
650 assert(MD &&
"Null pointer sent into hasa");
651 if (
auto *V = dyn_cast<ConstantAsMetadata>(MD))
652 return isa<X>(V->getValue());
655template <
class X,
class Y>
656inline std::enable_if_t<detail::IsValidReference<X, Y &>::value,
bool>
664template <
class X,
class Y>
665inline std::enable_if_t<detail::IsValidPointer<X, Y>::value,
X *>
667 return cast<X>(cast<ConstantAsMetadata>(MD)->getValue());
669template <
class X,
class Y>
670inline std::enable_if_t<detail::IsValidReference<X, Y &>::value,
X *>
679template <
class X,
class Y>
680inline std::enable_if_t<detail::IsValidPointer<X, Y>::value,
X *>
682 if (
auto *V = cast_or_null<ConstantAsMetadata>(MD))
683 return cast<X>(V->getValue());
692template <
class X,
class Y>
693inline std::enable_if_t<detail::IsValidPointer<X, Y>::value,
X *>
695 if (
auto *V = dyn_cast<ConstantAsMetadata>(MD))
696 return dyn_cast<X>(V->getValue());
705template <
class X,
class Y>
706inline std::enable_if_t<detail::IsValidPointer<X, Y>::value,
X *>
708 if (
auto *V = dyn_cast_or_null<ConstantAsMetadata>(MD))
709 return dyn_cast<X>(V->getValue());
772 explicit operator bool()
const {
819 Result.Scope =
Scope;
834 Result.Scope =
Scope;
862 nullptr,
nullptr,
nullptr);
867 nullptr,
nullptr,
nullptr);
912 return isa<MDString>(this->
get()) &&
913 cast<MDString>(this->
get())->getString() == Str;
944 assert(
static_cast<void *
>(
this) == &MD &&
"Expected same address");
972 std::unique_ptr<ReplaceableMetadataImpl> ReplaceableUses)
988 return isa<ReplaceableMetadataImpl *>(
Ptr);
994 return *cast<LLVMContext *>(
Ptr);
999 return cast<ReplaceableMetadataImpl *>(
Ptr);
1016 assert(ReplaceableUses &&
"Expected non-null replaceable uses");
1018 "Expected same context");
1020 Ptr = ReplaceableUses.release();
1028 std::unique_ptr<ReplaceableMetadataImpl> ReplaceableUses(
1030 Ptr = &ReplaceableUses->getContext();
1031 return ReplaceableUses;
1039#define HANDLE_MDNODE_LEAF(CLASS) \
1040 using Temp##CLASS = std::unique_ptr<CLASS, TempMDNodeDeleter>;
1041#define HANDLE_MDNODE_BRANCH(CLASS) HANDLE_MDNODE_LEAF(CLASS)
1042#include "llvm/IR/Metadata.def"
1079 struct alignas(alignof(size_t)) Header {
1080 bool IsResizable : 1;
1082 size_t SmallSize : 4;
1083 size_t SmallNumOps : 4;
1084 size_t :
sizeof(size_t) * CHAR_BIT - 10;
1086 unsigned NumUnresolved = 0;
1089 static constexpr size_t NumOpsFitInVector =
1090 sizeof(LargeStorageVector) /
sizeof(
MDOperand);
1092 NumOpsFitInVector *
sizeof(
MDOperand) ==
sizeof(LargeStorageVector),
1093 "sizeof(LargeStorageVector) must be a multiple of sizeof(MDOperand)");
1095 static constexpr size_t MaxSmallSize = 15;
1097 static constexpr size_t getOpSize(
unsigned NumOps) {
1102 static size_t getSmallSize(
size_t NumOps,
bool IsResizable,
bool IsLarge) {
1103 return IsLarge ? NumOpsFitInVector
1104 : std::max(NumOps, NumOpsFitInVector * IsResizable);
1109 getSmallSize(NumOps, isResizable(
Storage), isLarge(NumOps))) +
1115 static bool isLarge(
size_t NumOps) {
return NumOps > MaxSmallSize; }
1118 return getOpSize(SmallSize) +
sizeof(Header);
1120 void *getAllocation() {
1121 return reinterpret_cast<char *
>(
this + 1) -
1125 void *getLargePtr()
const {
1126 static_assert(
alignof(LargeStorageVector) <=
alignof(Header),
1127 "LargeStorageVector too strongly aligned");
1128 return reinterpret_cast<char *
>(
const_cast<Header *
>(
this)) -
1129 sizeof(LargeStorageVector);
1132 void *getSmallPtr();
1134 LargeStorageVector &getLarge() {
1136 return *
reinterpret_cast<LargeStorageVector *
>(getLargePtr());
1139 const LargeStorageVector &getLarge()
const {
1141 return *
reinterpret_cast<const LargeStorageVector *
>(getLargePtr());
1144 void resizeSmall(
size_t NumOps);
1145 void resizeSmallToLarge(
size_t NumOps);
1146 void resize(
size_t NumOps);
1151 MutableArrayRef<MDOperand> operands() {
1155 reinterpret_cast<MDOperand *
>(
this) - SmallSize, SmallNumOps);
1158 ArrayRef<MDOperand> operands()
const {
1161 return ArrayRef(
reinterpret_cast<const MDOperand *
>(
this) - SmallSize,
1165 unsigned getNumOperands()
const {
1168 return getLarge().size();
1172 Header &getHeader() {
return *(
reinterpret_cast<Header *
>(
this) - 1); }
1174 const Header &getHeader()
const {
1175 return *(
reinterpret_cast<const Header *
>(
this) - 1);
1178 ContextAndReplaceableUses Context;
1182 ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = std::nullopt);
1186 void operator delete(
void *Mem);
1212 void *
operator new(size_t) =
delete;
1223 TempMDNode
clone()
const;
1258 return Context.getReplaceableUses()->getNumUses();
1266 if (
Context.hasReplaceableUses())
1267 Context.getReplaceableUses()->replaceAllUsesWith(MD);
1286 static std::enable_if_t<std::is_base_of<MDNode, T>::value,
T *>
1288 return cast<T>(
N.release()->replaceWithPermanentImpl());
1298 static std::enable_if_t<std::is_base_of<MDNode, T>::value,
T *>
1300 return cast<T>(
N.release()->replaceWithUniquedImpl());
1308 static std::enable_if_t<std::is_base_of<MDNode, T>::value,
T *>
1310 return cast<T>(
N.release()->replaceWithDistinctImpl());
1322 const Module *M =
nullptr)
const;
1339 MDNode *replaceWithPermanentImpl();
1340 MDNode *replaceWithUniquedImpl();
1341 MDNode *replaceWithDistinctImpl();
1353 template <
class T,
class StoreT>
1362 assert(!
isUniqued() &&
"Resizing is not supported for uniqued nodes");
1364 "Resizing is not supported for this node kind");
1365 getHeader().resize(NumOps);
1369 void handleChangedOperand(
void *
Ref,
Metadata *New);
1372 void dropReplaceableUses();
1375 void decrementUnresolvedOperandCount();
1376 void countUnresolvedOperands();
1389 void makeDistinct();
1391 void deleteAsSubclass();
1393 void eraseFromStore();
1395 template <
class NodeTy>
struct HasCachedHash;
1396 template <
class NodeTy>
1397 static void dispatchRecalculateHash(NodeTy *
N, std::true_type) {
1398 N->recalculateHash();
1400 template <
class NodeTy>
1401 static void dispatchRecalculateHash(NodeTy *, std::false_type) {}
1402 template <
class NodeTy>
1403 static void dispatchResetHash(NodeTy *
N, std::true_type) {
1406 template <
class NodeTy>
1407 static void dispatchResetHash(NodeTy *, std::false_type) {}
1410 static MDNode *mergeDirectCallProfMetadata(MDNode *
A, MDNode *
B,
1411 const Instruction *AInstr,
1412 const Instruction *BInstr);
1430 return getHeader().operands()[
I];
1441#define HANDLE_MDNODE_LEAF(CLASS) \
1444#include "llvm/IR/Metadata.def"
1483 void recalculateHash();
1485 static MDTuple *getImpl(LLVMContext &Context, ArrayRef<Metadata *> MDs,
1488 TempMDTuple cloneImpl()
const {
1524 TempMDTuple
clone()
const {
return cloneImpl(); }
1577 if (
Node->getNumOperands() < 2)
1579 return dyn_cast_or_null<MDNode>(
Node->getOperand(1));
1582 if (
Node->getNumOperands() > 2)
1583 if (
MDString *
N = dyn_cast_or_null<MDString>(
Node->getOperand(2)))
1584 return N->getString();
1637 std::enable_if_t<std::is_convertible<U *, T *>::value> * =
nullptr)
1643 std::enable_if_t<!std::is_convertible<U *, T *>::value> * =
nullptr)
1654 unsigned size()
const {
return N ?
N->getNumOperands() : 0u; }
1655 bool empty()
const {
return N ?
N->getNumOperands() == 0 :
true; }
1665#define HANDLE_METADATA(CLASS) \
1666 using CLASS##Array = MDTupleTypedArrayWrapper<CLASS>;
1667#include "llvm/IR/Metadata.def"
1717 assert(!
Use &&
"Use is still being tracked despite being untracked!");
1734 Module *Parent =
nullptr;
1737 void setParent(
Module *M) { Parent = M; }
1741 template <
class T1>
class op_iterator_impl {
1750 using iterator_category = std::bidirectional_iterator_tag;
1751 using value_type =
T1;
1752 using difference_type = std::ptrdiff_t;
1753 using pointer = value_type *;
1754 using reference = value_type;
1756 op_iterator_impl() =
default;
1758 bool operator==(
const op_iterator_impl &o)
const {
return Idx == o.Idx; }
1759 bool operator!=(
const op_iterator_impl &o)
const {
return Idx !=
o.Idx; }
1761 op_iterator_impl &operator++() {
1766 op_iterator_impl operator++(
int) {
1767 op_iterator_impl tmp(*
this);
1778 op_iterator_impl tmp(*
this);
1809 bool IsForDebug =
false)
const;
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
BlockVerifier::State From
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
#define DEFINE_ISA_CONVERSION_FUNCTIONS(ty, ref)
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
This file defines DenseMapInfo traits for DenseMap.
This file defines the DenseMap class.
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
bool operator==(const HTTPRequest &A, const HTTPRequest &B)
mir Rename Register Operands
Machine Check Debug Module
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
This file defines the PointerUnion class, which is a discriminated union of pointer types.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
This is a simple wrapper around an MDNode which provides a higher-level interface by hiding the detai...
AliasScopeNode(const MDNode *N)
const MDNode * getNode() const
Get the MDNode for this AliasScopeNode.
const MDNode * getDomain() const
Get the MDNode for this AliasScopeNode's domain.
StringRef getName() const
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
This is an important base class in LLVM.
Pointer to the context, with optional RAUW support.
ContextAndReplaceableUses & operator=(const ContextAndReplaceableUses &)=delete
ReplaceableMetadataImpl * getReplaceableUses() const
std::unique_ptr< ReplaceableMetadataImpl > takeReplaceableUses()
Drop RAUW support.
ContextAndReplaceableUses & operator=(ContextAndReplaceableUses &&)=delete
ReplaceableMetadataImpl * getOrCreateReplaceableUses()
Ensure that this has RAUW support, and then return it.
void makeReplaceable(std::unique_ptr< ReplaceableMetadataImpl > ReplaceableUses)
Assign RAUW support to this.
ContextAndReplaceableUses(ContextAndReplaceableUses &&)=delete
ContextAndReplaceableUses(const ContextAndReplaceableUses &)=delete
LLVMContext & getContext() const
~ContextAndReplaceableUses()
bool hasReplaceableUses() const
Whether this contains RAUW support.
ContextAndReplaceableUses()=delete
ContextAndReplaceableUses(LLVMContext &Context)
ContextAndReplaceableUses(std::unique_ptr< ReplaceableMetadataImpl > ReplaceableUses)
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Record of a variable value-assignment, aka a non instruction representation of the dbg....
Base class for tracking ValueAsMetadata/DIArgLists with user lookups and Owner callbacks outside of V...
DebugValueUser(const DebugValueUser &X)
DebugValueUser & operator=(DebugValueUser &&X)
void handleChangedValue(void *Old, Metadata *NewDebugValue)
To be called by ReplaceableMetadataImpl::replaceAllUsesWith, where Old is a pointer to one of the poi...
bool operator!=(const DebugValueUser &X) const
DebugValueUser(std::array< Metadata *, 3 > DebugValues)
bool operator==(const DebugValueUser &X) const
ArrayRef< Metadata * > getDebugValues() const
DebugValueUser & operator=(const DebugValueUser &X)
std::array< Metadata *, 3 > DebugValues
void resetDebugValue(size_t Idx, Metadata *DebugValue)
DbgVariableRecord * getUser()
DebugValueUser(DebugValueUser &&X)
Placeholder metadata for operands of distinct MDNodes.
void replaceUseWith(Metadata *MD)
Replace the use of this with MD.
DistinctMDOperandPlaceholder()=delete
~DistinctMDOperandPlaceholder()
DistinctMDOperandPlaceholder(const DistinctMDOperandPlaceholder &)=delete
DistinctMDOperandPlaceholder(unsigned ID)
DistinctMDOperandPlaceholder(DistinctMDOperandPlaceholder &&)=delete
This is an important class for using LLVM in a threaded context.
static MDNode * getMostGenericAliasScope(MDNode *A, MDNode *B)
void printTree(raw_ostream &OS, const Module *M=nullptr) const
Print in tree shape.
void replaceOperandWith(unsigned I, Metadata *New)
Replace a specific operand.
iterator_range< MDOperand * > mutable_op_range
void resolveCycles()
Resolve cycles.
bool isTBAAVtableAccess() const
Check whether MDNode is a vtable access.
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
mutable_op_range mutable_operands()
void replaceAllUsesWith(Metadata *MD)
RAUW a temporary.
static MDNode * concatenate(MDNode *A, MDNode *B)
Methods for metadata merging.
static void deleteTemporary(MDNode *N)
Deallocate a node created by getTemporary.
void resolve()
Resolve a unique, unresolved node.
static MDNode * getMostGenericTBAA(MDNode *A, MDNode *B)
const MDOperand & getOperand(unsigned I) const
void storeDistinctInContext()
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
ArrayRef< MDOperand > operands() const
op_iterator op_end() const
MDNode(const MDNode &)=delete
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
static std::enable_if_t< std::is_base_of< MDNode, T >::value, T * > replaceWithDistinct(std::unique_ptr< T, TempMDNodeDeleter > N)
Replace a temporary node with a distinct one.
static MDNode * getMergedProfMetadata(MDNode *A, MDNode *B, const Instruction *AInstr, const Instruction *BInstr)
Merge !prof metadata from two instructions.
static bool classof(const Metadata *MD)
Methods for support type inquiry through isa, cast, and dyn_cast:
static MDNode * getMostGenericFPMath(MDNode *A, MDNode *B)
void setNumUnresolved(unsigned N)
void resize(size_t NumOps)
Resize the node to hold NumOps operands.
unsigned getNumOperands() const
Return number of MDNode operands.
MDOperand * mutable_begin()
TempMDNode clone() const
Create a (temporary) clone of this.
static MDNode * getMostGenericRange(MDNode *A, MDNode *B)
unsigned getNumTemporaryUses() const
bool isReplaceable() const
void setOperand(unsigned I, Metadata *New)
Set an operand.
MDNode(LLVMContext &Context, unsigned ID, StorageType Storage, ArrayRef< Metadata * > Ops1, ArrayRef< Metadata * > Ops2=std::nullopt)
bool isResolved() const
Check if node is fully resolved.
op_iterator op_begin() const
static MDNode * intersect(MDNode *A, MDNode *B)
static T * storeImpl(T *N, StorageType Storage, StoreT &Store)
LLVMContext & getContext() const
MDOperand * mutable_end()
static MDTuple * getIfExists(LLVMContext &Context, ArrayRef< Metadata * > MDs)
static std::enable_if_t< std::is_base_of< MDNode, T >::value, T * > replaceWithPermanent(std::unique_ptr< T, TempMDNodeDeleter > N)
Replace a temporary node with a permanent one.
void operator=(const MDNode &)=delete
static std::enable_if_t< std::is_base_of< MDNode, T >::value, T * > replaceWithUniqued(std::unique_ptr< T, TempMDNodeDeleter > N)
Replace a temporary node with a uniqued one.
void dumpTree() const
User-friendly dump in tree shape.
static MDNode * getMostGenericAlignmentOrDereferenceable(MDNode *A, MDNode *B)
unsigned getNumUnresolved() const
bool isAlwaysReplaceable() const
Tracking metadata reference owned by Metadata.
bool equalsStr(StringRef Str) const
void reset(Metadata *MD, Metadata *Owner)
Metadata * operator->() const
MDOperand & operator=(const MDOperand &)=delete
Metadata & operator*() const
MDOperand(const MDOperand &)=delete
MDOperand & operator=(MDOperand &&Op)
MDOperand(MDOperand &&Op)
unsigned getLength() const
const unsigned char * bytes_begin() const
MDString(const MDString &)=delete
static MDString * get(LLVMContext &Context, const char *Str)
MDString & operator=(MDString &&)=delete
static bool classof(const Metadata *MD)
Methods for support type inquiry through isa, cast, and dyn_cast.
const unsigned char * bytes_end() const
iterator begin() const
Pointer to the first byte of the string.
MDString & operator=(const MDString &)=delete
StringRef getString() const
iterator end() const
Pointer to one byte past the end of the string.
static MDString * get(LLVMContext &Context, StringRef Str)
Typed, array-like tuple of metadata.
MDTupleTypedArrayWrapper(const MDTupleTypedArrayWrapper< U > &Other, std::enable_if_t<!std::is_convertible< U *, T * >::value > *=nullptr)
MDTupleTypedArrayWrapper()=default
MDTupleTypedArrayWrapper(const MDTuple *N)
T * operator[](unsigned I) const
MDTuple * operator->() const
MDTuple & operator*() const
MDTupleTypedArrayWrapper(const MDTupleTypedArrayWrapper< U > &Other, std::enable_if_t< std::is_convertible< U *, T * >::value > *=nullptr)
TypedMDOperandIterator< T > iterator
TempMDTuple clone() const
Return a (temporary) clone of this.
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Return a distinct node.
static bool classof(const Metadata *MD)
void push_back(Metadata *MD)
Append an element to the tuple. This will resize the node.
unsigned getHash() const
Get the hash, if any.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
static MDTuple * getIfExists(LLVMContext &Context, ArrayRef< Metadata * > MDs)
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Return a temporary node.
void pop_back()
Shrink the operands by 1.
Manage lifetime of a slot tracker for printing IR.
A Module instance is used to store all the information related to an LLVM module.
const_op_iterator op_begin() const
NamedMDNode(const NamedMDNode &)=delete
op_iterator_impl< const MDNode * > const_op_iterator
void setOperand(unsigned I, MDNode *New)
StringRef getName() const
void dropAllReferences()
Remove all uses and clear node vector.
void print(raw_ostream &ROS, bool IsForDebug=false) const
void eraseFromParent()
Drop all references and remove the node from parent module.
const_op_iterator op_end() const
iterator_range< const_op_iterator > operands() const
MDNode * getOperand(unsigned i) const
op_iterator_impl< MDNode * > op_iterator
unsigned getNumOperands() const
const Module * getParent() const
void clearOperands()
Drop all references to this node's operands.
iterator_range< op_iterator > operands()
Module * getParent()
Get the module that holds this named metadata collection.
void addOperand(MDNode *M)
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringMapEntryStorage - Holds the value in a StringMapEntry.
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
StringRef - Represent a constant reference to a string, i.e.
const unsigned char * bytes_end() const
constexpr size_t size() const
size - Get the string size.
const unsigned char * bytes_begin() const
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
The instances of the Type class are immutable: once they are created, they are never changed.
Typed iterator through MDNode operands.
TypedMDOperandIterator operator++(int)
std::ptrdiff_t difference_type
TypedMDOperandIterator()=default
std::input_iterator_tag iterator_category
bool operator==(const TypedMDOperandIterator &X) const
TypedMDOperandIterator & operator++()
TypedMDOperandIterator(MDNode::op_iterator I)
bool operator!=(const TypedMDOperandIterator &X) const
A Use represents the edge between a Value definition and its users.
LLVM Value Representation.
A range adaptor for a pair of iterators.
This class implements an extremely fast bulk output stream that can only output to a stream.
struct LLVMOpaqueNamedMDNode * LLVMNamedMDNodeRef
Represents an LLVM Named Metadata Node.
struct LLVMOpaqueMetadata * LLVMMetadataRef
Represents an LLVM Metadata.
This file defines the ilist_node class template, which is a convenient base class for creating classe...
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
ArchKind & operator--(ArchKind &Kind)
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_or_null(Y &&MD)
Extract a Value from Metadata, if any, allowing null.
std::enable_if_t< detail::IsValidPointer< X, Y >::value, bool > hasa(Y &&MD)
Check whether Metadata has a Value.
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract_or_null(Y &&MD)
Extract a Value from Metadata, allowing null.
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > dyn_extract(Y &&MD)
Extract a Value from Metadata, if any.
This is an optimization pass for GlobalISel generic memory operations.
APInt operator*(APInt a, uint64_t RHS)
bool operator!=(uint64_t V1, const APInt &V2)
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
MutableArrayRef(T &OneElt) -> MutableArrayRef< T >
@ Ref
The access may reference the value stored in memory.
Attribute unwrap(LLVMAttributeRef Attr)
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
ArrayRef(const T &OneElt) -> ArrayRef< T >
std::optional< APInt > getAllocSize(const CallBase *CB, const TargetLibraryInfo *TLI, function_ref< const Value *(const Value *)> Mapper=[](const Value *V) { return V;})
Return the size of the requested allocation.
const uint64_t NOMORE_ICP_MAGICNUM
Magic number in the value profile metadata showing a target has been promoted for the instruction and...
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
AAMDNodes concat(const AAMDNodes &Other) const
Determine the best AAMDNodes after concatenating two different locations together.
static MDNode * shiftTBAAStruct(MDNode *M, size_t off)
bool operator!=(const AAMDNodes &A) const
MDNode * TBAAStruct
The tag for type-based alias analysis (tbaa struct).
MDNode * Scope
The tag for alias scope specification (used with noalias).
static MDNode * extendToTBAA(MDNode *TBAA, ssize_t len)
MDNode * TBAA
The tag for type-based alias analysis.
AAMDNodes shift(size_t Offset) const
Create a new AAMDNode that describes this AAMDNode after applying a constant offset to the start of t...
AAMDNodes merge(const AAMDNodes &Other) const
Given two sets of AAMDNodes applying to potentially different locations, determine the best AAMDNodes...
MDNode * NoAlias
The tag specifying the noalias scope.
AAMDNodes intersect(const AAMDNodes &Other) const
Given two sets of AAMDNodes that apply to the same pointer, give the best AAMDNodes that are compatib...
AAMDNodes(MDNode *T, MDNode *TS, MDNode *S, MDNode *N)
AAMDNodes adjustForAccess(unsigned AccessSize)
Create a new AAMDNode for accessing AccessSize bytes of this AAMDNode.
AAMDNodes extendTo(ssize_t Len) const
Create a new AAMDNode that describes this AAMDNode after extending it to apply to a series of bytes o...
bool operator==(const AAMDNodes &A) const
static MDNode * shiftTBAA(MDNode *M, size_t off)
static AAMDNodes getEmptyKey()
static unsigned getHashValue(const AAMDNodes &Val)
static AAMDNodes getTombstoneKey()
static bool isEqual(const AAMDNodes &LHS, const AAMDNodes &RHS)
An information struct used to provide DenseMap with the various necessary components for a given valu...
void operator()(MDNode *Node) const
static No & hasDereference(...)
static Yes & hasDereference(SFINAE< sizeof(static_cast< V >(*make< U >()))> *=0)
static SimpleType getSimplifiedValue(MDOperand &MD)
static SimpleType getSimplifiedValue(const MDOperand &MD)
Define a template that can be specialized by smart pointers to reflect the fact that they are automat...