Instead, we're going to separate metadata from the Value hierarchy. See
PR21532.
This reverts commit r221375.
This reverts commit r221373.
This reverts commit r221359.
This reverts commit r221167.
This reverts commit r221027.
This reverts commit r221024.
This reverts commit r221023.
This reverts commit r220995.
This reverts commit r220994.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@221711
91177308-0d34-0410-b5e6-
96231b3b80d8
46 files changed:
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/LLVMContext.h"
-#include "llvm/IR/Metadata.h"
#include "llvm/IR/Operator.h"
#include "llvm/IR/ValueHandle.h"
#include "llvm/Support/CBindingWrapping.h"
namespace llvm {
#include "llvm/IR/Operator.h"
#include "llvm/IR/ValueHandle.h"
#include "llvm/Support/CBindingWrapping.h"
namespace llvm {
/// \brief This provides the default implementation of the IRBuilder
/// 'InsertHelper' method that is called whenever an instruction is created by
/// \brief This provides the default implementation of the IRBuilder
/// 'InsertHelper' method that is called whenever an instruction is created by
/// getMetadata - Get the metadata of given kind attached to this Instruction.
/// If the metadata is not found then return null.
/// getMetadata - Get the metadata of given kind attached to this Instruction.
/// If the metadata is not found then return null.
- Value *getMetadata(unsigned KindID) const {
+ MDNode *getMetadata(unsigned KindID) const {
if (!hasMetadata()) return nullptr;
return getMetadataImpl(KindID);
}
/// getMetadata - Get the metadata of given kind attached to this Instruction.
/// If the metadata is not found then return null.
if (!hasMetadata()) return nullptr;
return getMetadataImpl(KindID);
}
/// getMetadata - Get the metadata of given kind attached to this Instruction.
/// If the metadata is not found then return null.
- Value *getMetadata(StringRef Kind) const {
+ MDNode *getMetadata(StringRef Kind) const {
if (!hasMetadata()) return nullptr;
return getMetadataImpl(Kind);
}
if (!hasMetadata()) return nullptr;
return getMetadataImpl(Kind);
}
- /// Get the the metadata as an MDNode.
- ///
- /// \pre Any KindID metadata is implemented using \a MDNode.
- MDNode *getMDNode(unsigned KindID) const {
- if (!hasMetadata())
- return nullptr;
- return getMDNodeImpl(KindID);
- }
-
- /// Get the the metadata as an MDNode.
- ///
- /// \pre Any KindID metadata is implemented using \a MDNode.
- MDNode *getMDNode(StringRef Kind) const {
- if (!hasMetadata())
- return nullptr;
- return getMDNodeImpl(Kind);
- }
-
/// getAllMetadata - Get all metadata attached to this Instruction. The first
/// element of each pair returned is the KindID, the second element is the
/// metadata value. This list is returned sorted by the KindID.
void
/// getAllMetadata - Get all metadata attached to this Instruction. The first
/// element of each pair returned is the KindID, the second element is the
/// metadata value. This list is returned sorted by the KindID.
void
- getAllMetadata(SmallVectorImpl<std::pair<unsigned, Value *>> &MDs) const {
+ getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const {
if (hasMetadata())
getAllMetadataImpl(MDs);
}
if (hasMetadata())
getAllMetadataImpl(MDs);
}
/// getAllMetadataOtherThanDebugLoc - This does the same thing as
/// getAllMetadata, except that it filters out the debug location.
void getAllMetadataOtherThanDebugLoc(
/// getAllMetadataOtherThanDebugLoc - This does the same thing as
/// getAllMetadata, except that it filters out the debug location.
void getAllMetadataOtherThanDebugLoc(
- SmallVectorImpl<std::pair<unsigned, Value *>> &MDs) const {
+ SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const {
if (hasMetadataOtherThanDebugLoc())
getAllMetadataOtherThanDebugLocImpl(MDs);
}
if (hasMetadataOtherThanDebugLoc())
getAllMetadataOtherThanDebugLocImpl(MDs);
}
/// setMetadata - Set the metadata of the specified kind to the specified
/// node. This updates/replaces metadata if already present, or removes it if
/// setMetadata - Set the metadata of the specified kind to the specified
/// node. This updates/replaces metadata if already present, or removes it if
- /// MD is null.
- void setMetadata(unsigned KindID, Value *MD);
- void setMetadata(StringRef Kind, Value *MD);
+ /// Node is null.
+ void setMetadata(unsigned KindID, MDNode *Node);
+ void setMetadata(StringRef Kind, MDNode *Node);
/// \brief Drop unknown metadata.
/// Passes are required to drop metadata they don't understand. This is a
/// \brief Drop unknown metadata.
/// Passes are required to drop metadata they don't understand. This is a
}
// These are all implemented in Metadata.cpp.
}
// These are all implemented in Metadata.cpp.
- Value *getMetadataImpl(unsigned KindID) const;
- Value *getMetadataImpl(StringRef Kind) const;
- MDNode *getMDNodeImpl(unsigned KindID) const;
- MDNode *getMDNodeImpl(StringRef Kind) const;
+ MDNode *getMetadataImpl(unsigned KindID) const;
+ MDNode *getMetadataImpl(StringRef Kind) const;
- getAllMetadataImpl(SmallVectorImpl<std::pair<unsigned, Value *>> &) const;
+ getAllMetadataImpl(SmallVectorImpl<std::pair<unsigned, MDNode *>> &) const;
void getAllMetadataOtherThanDebugLocImpl(
void getAllMetadataOtherThanDebugLocImpl(
- SmallVectorImpl<std::pair<unsigned, Value *>> &) const;
+ SmallVectorImpl<std::pair<unsigned, MDNode *>> &) const;
void clearMetadataHashEntries();
public:
//===--------------------------------------------------------------------===//
void clearMetadataHashEntries();
public:
//===--------------------------------------------------------------------===//
};
//===----------------------------------------------------------------------===//
};
//===----------------------------------------------------------------------===//
-/// \brief A tuple of metadata nodes.
+/// \brief A tuple of MDNodes.
///
/// Despite its name, a NamedMDNode isn't itself an MDNode. NamedMDNodes belong
///
/// Despite its name, a NamedMDNode isn't itself an MDNode. NamedMDNodes belong
-/// to modules, have names, and contain lists of metadata nodes.
+/// to modules, have names, and contain lists of MDNodes.
class NamedMDNode : public ilist_node<NamedMDNode> {
friend class SymbolTableListTraits<NamedMDNode, Module>;
friend struct ilist_traits<NamedMDNode>;
class NamedMDNode : public ilist_node<NamedMDNode> {
friend class SymbolTableListTraits<NamedMDNode, Module>;
friend struct ilist_traits<NamedMDNode>;
std::string Name;
Module *Parent;
std::string Name;
Module *Parent;
- void *Operands; // SmallVector<TrackingVH<Value>, 4>
+ void *Operands; // SmallVector<TrackingVH<MDNode>, 4>
void setParent(Module *M) { Parent = M; }
void setParent(Module *M) { Parent = M; }
inline Module *getParent() { return Parent; }
inline const Module *getParent() const { return Parent; }
inline Module *getParent() { return Parent; }
inline const Module *getParent() const { return Parent; }
- Value *getOperand(unsigned i) const;
- MDNode *getOperandAsMDNode(unsigned i) const {
- return cast_or_null<MDNode>(getOperand(i));
- }
+ MDNode *getOperand(unsigned i) const;
unsigned getNumOperands() const;
unsigned getNumOperands() const;
- void addOperand(Value *M);
+ void addOperand(MDNode *M);
StringRef getName() const;
void print(raw_ostream &ROS) const;
void dump() const;
StringRef getName() const;
void print(raw_ostream &ROS) const;
void dump() const;
// ---------------------------------------------------------------------------
// Operand Iterator interface...
//
// ---------------------------------------------------------------------------
// Operand Iterator interface...
//
- typedef op_iterator_impl<Value *, Value> op_iterator;
+ typedef op_iterator_impl<MDNode *, MDNode> op_iterator;
op_iterator op_begin() { return op_iterator(this, 0); }
op_iterator op_end() { return op_iterator(this, getNumOperands()); }
op_iterator op_begin() { return op_iterator(this, 0); }
op_iterator op_end() { return op_iterator(this, getNumOperands()); }
- typedef op_iterator_impl<const Value *, Value> const_op_iterator;
+ typedef op_iterator_impl<const MDNode *, MDNode> const_op_iterator;
const_op_iterator op_begin() const { return const_op_iterator(this, 0); }
const_op_iterator op_end() const { return const_op_iterator(this, getNumOperands()); }
const_op_iterator op_begin() const { return const_op_iterator(this, 0); }
const_op_iterator op_end() const { return const_op_iterator(this, getNumOperands()); }
if (!isa<BranchInst>(TI) && !isa<SwitchInst>(TI))
return false;
if (!isa<BranchInst>(TI) && !isa<SwitchInst>(TI))
return false;
- MDNode *WeightsNode = TI->getMDNode(LLVMContext::MD_prof);
+ MDNode *WeightsNode = TI->getMetadata(LLVMContext::MD_prof);
if (!WeightsNode)
return false;
if (!WeightsNode)
return false;
MDNode *Loop::getLoopID() const {
MDNode *LoopID = nullptr;
if (isLoopSimplifyForm()) {
MDNode *Loop::getLoopID() const {
MDNode *LoopID = nullptr;
if (isLoopSimplifyForm()) {
- LoopID = getLoopLatch()->getTerminator()->getMDNode(LoopMDName);
+ LoopID = getLoopLatch()->getTerminator()->getMetadata(LoopMDName);
} else {
// Go through each predecessor of the loop header and check the
// terminator for the metadata.
} else {
// Go through each predecessor of the loop header and check the
// terminator for the metadata.
// Check if this terminator branches to the loop header.
for (unsigned i = 0, ie = TI->getNumSuccessors(); i != ie; ++i) {
if (TI->getSuccessor(i) == H) {
// Check if this terminator branches to the loop header.
for (unsigned i = 0, ie = TI->getNumSuccessors(); i != ie; ++i) {
if (TI->getSuccessor(i) == H) {
- MD = TI->getMDNode(LoopMDName);
+ MD = TI->getMetadata(LoopMDName);
// nested parallel loops). The loop identifier metadata refers to
// itself so we can check both cases with the same routine.
MDNode *loopIdMD =
// nested parallel loops). The loop identifier metadata refers to
// itself so we can check both cases with the same routine.
MDNode *loopIdMD =
- II->getMDNode(LLVMContext::MD_mem_parallel_loop_access);
+ II->getMetadata(LLVMContext::MD_mem_parallel_loop_access);
if (!loopIdMD)
return false;
if (!loopIdMD)
return false;
/// metadata present in the IR.
static Optional<ConstantRange> GetRangeFromMetadata(Value *V) {
if (Instruction *I = dyn_cast<Instruction>(V)) {
/// metadata present in the IR.
static Optional<ConstantRange> GetRangeFromMetadata(Value *V) {
if (Instruction *I = dyn_cast<Instruction>(V)) {
- if (MDNode *MD = I->getMDNode(LLVMContext::MD_range)) {
+ if (MDNode *MD = I->getMetadata(LLVMContext::MD_range)) {
ConstantRange TotalRange(
cast<IntegerType>(I->getType())->getBitWidth(), false);
ConstantRange TotalRange(
cast<IntegerType>(I->getType())->getBitWidth(), false);
if (!EnableScopedNoAlias)
return AliasAnalysis::getModRefInfo(CS, Loc);
if (!EnableScopedNoAlias)
return AliasAnalysis::getModRefInfo(CS, Loc);
- if (!mayAliasInScopes(Loc.AATags.Scope, CS.getInstruction()->getMDNode(
+ if (!mayAliasInScopes(Loc.AATags.Scope, CS.getInstruction()->getMetadata(
LLVMContext::MD_noalias)))
return NoModRef;
if (!mayAliasInScopes(
LLVMContext::MD_noalias)))
return NoModRef;
if (!mayAliasInScopes(
- CS.getInstruction()->getMDNode(LLVMContext::MD_alias_scope),
+ CS.getInstruction()->getMetadata(LLVMContext::MD_alias_scope),
Loc.AATags.NoAlias))
return NoModRef;
Loc.AATags.NoAlias))
return NoModRef;
return AliasAnalysis::getModRefInfo(CS1, CS2);
if (!mayAliasInScopes(
return AliasAnalysis::getModRefInfo(CS1, CS2);
if (!mayAliasInScopes(
- CS1.getInstruction()->getMDNode(LLVMContext::MD_alias_scope),
- CS2.getInstruction()->getMDNode(LLVMContext::MD_noalias)))
+ CS1.getInstruction()->getMetadata(LLVMContext::MD_alias_scope),
+ CS2.getInstruction()->getMetadata(LLVMContext::MD_noalias)))
return NoModRef;
if (!mayAliasInScopes(
return NoModRef;
if (!mayAliasInScopes(
- CS2.getInstruction()->getMDNode(LLVMContext::MD_alias_scope),
- CS1.getInstruction()->getMDNode(LLVMContext::MD_noalias)))
+ CS2.getInstruction()->getMetadata(LLVMContext::MD_alias_scope),
+ CS1.getInstruction()->getMetadata(LLVMContext::MD_noalias)))
return NoModRef;
return AliasAnalysis::getModRefInfo(CS1, CS2);
return NoModRef;
return AliasAnalysis::getModRefInfo(CS1, CS2);
// If this is an "immutable" type, we can assume the call doesn't write
// to memory.
// If this is an "immutable" type, we can assume the call doesn't write
// to memory.
- if (const MDNode *M = CS.getInstruction()->getMDNode(LLVMContext::MD_tbaa))
+ if (const MDNode *M = CS.getInstruction()->getMetadata(LLVMContext::MD_tbaa))
if ((!isStructPathTBAA(M) && TBAANode(M).TypeIsImmutable()) ||
(isStructPathTBAA(M) && TBAAStructTagNode(M).TypeIsImmutable()))
Min = OnlyReadsMemory;
if ((!isStructPathTBAA(M) && TBAANode(M).TypeIsImmutable()) ||
(isStructPathTBAA(M) && TBAAStructTagNode(M).TypeIsImmutable()))
Min = OnlyReadsMemory;
return AliasAnalysis::getModRefInfo(CS, Loc);
if (const MDNode *L = Loc.AATags.TBAA)
return AliasAnalysis::getModRefInfo(CS, Loc);
if (const MDNode *L = Loc.AATags.TBAA)
- if (const MDNode *M = CS.getInstruction()->getMDNode(LLVMContext::MD_tbaa))
+ if (const MDNode *M =
+ CS.getInstruction()->getMetadata(LLVMContext::MD_tbaa))
if (!Aliases(L, M))
return NoModRef;
if (!Aliases(L, M))
return NoModRef;
if (!EnableTBAA)
return AliasAnalysis::getModRefInfo(CS1, CS2);
if (!EnableTBAA)
return AliasAnalysis::getModRefInfo(CS1, CS2);
- if (const MDNode *M1 = CS1.getInstruction()->getMDNode(LLVMContext::MD_tbaa))
+ if (const MDNode *M1 =
+ CS1.getInstruction()->getMetadata(LLVMContext::MD_tbaa))
- CS2.getInstruction()->getMDNode(LLVMContext::MD_tbaa))
+ CS2.getInstruction()->getMetadata(LLVMContext::MD_tbaa))
if (!Aliases(M1, M2))
return NoModRef;
if (!Aliases(M1, M2))
return NoModRef;
void Instruction::getAAMetadata(AAMDNodes &N, bool Merge) const {
if (Merge)
N.TBAA =
void Instruction::getAAMetadata(AAMDNodes &N, bool Merge) const {
if (Merge)
N.TBAA =
- MDNode::getMostGenericTBAA(N.TBAA, getMDNode(LLVMContext::MD_tbaa));
+ MDNode::getMostGenericTBAA(N.TBAA, getMetadata(LLVMContext::MD_tbaa));
- N.TBAA = getMDNode(LLVMContext::MD_tbaa);
+ N.TBAA = getMetadata(LLVMContext::MD_tbaa);
- MDNode::intersect(N.Scope, getMDNode(LLVMContext::MD_alias_scope));
+ MDNode::intersect(N.Scope, getMetadata(LLVMContext::MD_alias_scope));
- N.Scope = getMDNode(LLVMContext::MD_alias_scope);
+ N.Scope = getMetadata(LLVMContext::MD_alias_scope);
- MDNode::intersect(N.NoAlias, getMDNode(LLVMContext::MD_noalias));
+ MDNode::intersect(N.NoAlias, getMetadata(LLVMContext::MD_noalias));
- N.NoAlias = getMDNode(LLVMContext::MD_noalias);
+ N.NoAlias = getMetadata(LLVMContext::MD_noalias);
switch (I->getOpcode()) {
default: break;
case Instruction::Load:
switch (I->getOpcode()) {
default: break;
case Instruction::Load:
- if (MDNode *MD = cast<LoadInst>(I)->getMDNode(LLVMContext::MD_range))
+ if (MDNode *MD = cast<LoadInst>(I)->getMetadata(LLVMContext::MD_range))
computeKnownBitsFromRangeMetadata(*MD, KnownZero);
break;
case Instruction::And: {
computeKnownBitsFromRangeMetadata(*MD, KnownZero);
break;
case Instruction::And: {
}
case Instruction::Call:
case Instruction::Invoke:
}
case Instruction::Call:
case Instruction::Invoke:
- if (MDNode *MD = cast<Instruction>(I)->getMDNode(LLVMContext::MD_range))
+ if (MDNode *MD = cast<Instruction>(I)->getMetadata(LLVMContext::MD_range))
computeKnownBitsFromRangeMetadata(*MD, KnownZero);
// If a range metadata is attached to this IntrinsicInst, intersect the
// explicit range specified by the metadata and the implicit range of
computeKnownBitsFromRangeMetadata(*MD, KnownZero);
// If a range metadata is attached to this IntrinsicInst, intersect the
// explicit range specified by the metadata and the implicit range of
}
if (Instruction* I = dyn_cast<Instruction>(V)) {
}
if (Instruction* I = dyn_cast<Instruction>(V)) {
- if (MDNode *Ranges = I->getMDNode(LLVMContext::MD_range)) {
+ if (MDNode *Ranges = I->getMetadata(LLVMContext::MD_range)) {
// If the possible ranges don't contain zero, then the value is
// definitely non-zero.
if (IntegerType* Ty = dyn_cast<IntegerType>(V->getType())) {
// If the possible ranges don't contain zero, then the value is
// definitely non-zero.
if (IntegerType* Ty = dyn_cast<IntegerType>(V->getType())) {
// Write metadata attachments
// METADATA_ATTACHMENT - [m x [value, [n x [id, mdnode]]]
// Write metadata attachments
// METADATA_ATTACHMENT - [m x [value, [n x [id, mdnode]]]
- SmallVector<std::pair<unsigned, Value *>, 4> MDs;
+ SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();
for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();
EnumerateValueSymbolTable(M->getValueSymbolTable());
EnumerateNamedMetadata(M);
EnumerateValueSymbolTable(M->getValueSymbolTable());
EnumerateNamedMetadata(M);
- SmallVector<std::pair<unsigned, Value *>, 8> MDs;
+ SmallVector<std::pair<unsigned, MDNode *>, 8> MDs;
// Enumerate types used by function bodies and argument lists.
for (const Function &F : *M) {
// Enumerate types used by function bodies and argument lists.
for (const Function &F : *M) {
MDs.clear();
I.getAllMetadataOtherThanDebugLoc(MDs);
for (unsigned i = 0, e = MDs.size(); i != e; ++i)
MDs.clear();
I.getAllMetadataOtherThanDebugLoc(MDs);
for (unsigned i = 0, e = MDs.size(); i != e; ++i)
- EnumerateMetadata(cast<MDNode>(MDs[i].second));
+ EnumerateMetadata(MDs[i].second);
if (!I.getDebugLoc().isUnknown()) {
MDNode *Scope, *IA;
if (!I.getDebugLoc().isUnknown()) {
MDNode *Scope, *IA;
FnLocalMDVector.push_back(MD);
}
FnLocalMDVector.push_back(MD);
}
- SmallVector<std::pair<unsigned, Value *>, 8> MDs;
+ SmallVector<std::pair<unsigned, MDNode *>, 8> MDs;
I->getAllMetadataOtherThanDebugLoc(MDs);
for (unsigned i = 0, e = MDs.size(); i != e; ++i) {
I->getAllMetadataOtherThanDebugLoc(MDs);
for (unsigned i = 0, e = MDs.size(); i != e; ++i) {
- auto *N = cast<MDNode>(MDs[i].second);
+ MDNode *N = MDs[i].second;
if (N->isFunctionLocal() && N->getFunction())
FnLocalMDVector.push_back(N);
}
if (N->isFunctionLocal() && N->getFunction())
FnLocalMDVector.push_back(N);
}
if (const NamedMDNode *NMD = M.getNamedMetadata("llvm.ident")) {
for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
if (const NamedMDNode *NMD = M.getNamedMetadata("llvm.ident")) {
for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
- const MDNode *N = NMD->getOperandAsMDNode(i);
+ const MDNode *N = NMD->getOperand(i);
assert(N->getNumOperands() == 1 &&
"llvm.ident metadata entry can have only one operand");
const MDString *S = cast<MDString>(N->getOperand(0));
assert(N->getNumOperands() == 1 &&
"llvm.ident metadata entry can have only one operand");
const MDString *S = cast<MDString>(N->getOperand(0));
SingleCU = CU_Nodes->getNumOperands() == 1;
SingleCU = CU_Nodes->getNumOperands() == 1;
- for (Value *N : CU_Nodes->operands()) {
- DICompileUnit CUNode(cast<MDNode>(N));
+ for (MDNode *N : CU_Nodes->operands()) {
+ DICompileUnit CUNode(N);
DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
DIArray ImportedEntities = CUNode.getImportedEntities();
for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
DIArray ImportedEntities = CUNode.getImportedEntities();
for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
const Module *M = MMI->getModule();
if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
const Module *M = MMI->getModule();
if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
- for (Value *N : CU_Nodes->operands()) {
- DICompileUnit TheCU(cast<MDNode>(N));
+ for (MDNode *N : CU_Nodes->operands()) {
+ DICompileUnit TheCU(N);
// Construct subprogram DIE and add variables DIEs.
DwarfCompileUnit *SPCU =
static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
// Construct subprogram DIE and add variables DIEs.
DwarfCompileUnit *SPCU =
static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
- bool IsNonTemporal = I->getMDNode(LLVMContext::MD_nontemporal) != nullptr;
- bool IsInvariant = I->getMDNode(LLVMContext::MD_invariant_load) != nullptr;
- const MDNode *Ranges = I->getMDNode(LLVMContext::MD_range);
+ bool IsNonTemporal = I->getMetadata(LLVMContext::MD_nontemporal) != nullptr;
+ bool IsInvariant = I->getMetadata(LLVMContext::MD_invariant_load) != nullptr;
+ const MDNode *Ranges = I->getMetadata(LLVMContext::MD_range);
AAMDNodes AAInfo;
I->getAAMetadata(AAInfo);
AAMDNodes AAInfo;
I->getAAMetadata(AAInfo);
Type *Ty = I.getType();
bool isVolatile = I.isVolatile();
Type *Ty = I.getType();
bool isVolatile = I.isVolatile();
- bool isNonTemporal = I.getMDNode(LLVMContext::MD_nontemporal) != nullptr;
- bool isInvariant = I.getMDNode(LLVMContext::MD_invariant_load) != nullptr;
+ bool isNonTemporal = I.getMetadata(LLVMContext::MD_nontemporal) != nullptr;
+ bool isInvariant = I.getMetadata(LLVMContext::MD_invariant_load) != nullptr;
unsigned Alignment = I.getAlignment();
AAMDNodes AAInfo;
I.getAAMetadata(AAInfo);
unsigned Alignment = I.getAlignment();
AAMDNodes AAInfo;
I.getAAMetadata(AAInfo);
- const MDNode *Ranges = I.getMDNode(LLVMContext::MD_range);
+ const MDNode *Ranges = I.getMetadata(LLVMContext::MD_range);
const TargetLowering &TLI = DAG.getTargetLoweringInfo();
SmallVector<EVT, 4> ValueVTs;
const TargetLowering &TLI = DAG.getTargetLoweringInfo();
SmallVector<EVT, 4> ValueVTs;
NumValues));
EVT PtrVT = Ptr.getValueType();
bool isVolatile = I.isVolatile();
NumValues));
EVT PtrVT = Ptr.getValueType();
bool isVolatile = I.isVolatile();
- bool isNonTemporal = I.getMDNode(LLVMContext::MD_nontemporal) != nullptr;
+ bool isNonTemporal = I.getMetadata(LLVMContext::MD_nontemporal) != nullptr;
unsigned Alignment = I.getAlignment();
AAMDNodes AAInfo;
unsigned Alignment = I.getAlignment();
AAMDNodes AAInfo;
// If we have a !srcloc metadata node associated with it, we want to attach
// this to the ultimately generated inline asm machineinstr. To do this, we
// pass in the third operand as this (potentially null) inline asm MDNode.
// If we have a !srcloc metadata node associated with it, we want to attach
// this to the ultimately generated inline asm machineinstr. To do this, we
// pass in the third operand as this (potentially null) inline asm MDNode.
- const MDNode *SrcLoc = CS.getInstruction()->getMDNode("srcloc");
+ const MDNode *SrcLoc = CS.getInstruction()->getMetadata("srcloc");
AsmNodeOperands.push_back(DAG.getMDNode(SrcLoc));
// Remember the HasSideEffect, AlignStack, AsmDialect, MayLoad and MayStore
AsmNodeOperands.push_back(DAG.getMDNode(SrcLoc));
// Remember the HasSideEffect, AlignStack, AsmDialect, MayLoad and MayStore
/// plane. If something is not in the SlotTracker, return -1.
int getLocalSlot(const Value *V);
int getGlobalSlot(const GlobalValue *V);
/// plane. If something is not in the SlotTracker, return -1.
int getLocalSlot(const Value *V);
int getGlobalSlot(const GlobalValue *V);
- int getMetadataSlot(const Value *MD);
+ int getMetadataSlot(const MDNode *N);
int getAttributeGroupSlot(AttributeSet AS);
/// If you'd like to deal with a function instead of just a module, use
int getAttributeGroupSlot(AttributeSet AS);
/// If you'd like to deal with a function instead of just a module, use
void CreateModuleSlot(const GlobalValue *V);
/// CreateMetadataSlot - Insert the specified MDNode* into the slot table.
void CreateModuleSlot(const GlobalValue *V);
/// CreateMetadataSlot - Insert the specified MDNode* into the slot table.
- void CreateMetadataSlot(const Value *MD);
+ void CreateMetadataSlot(const MDNode *N);
/// CreateFunctionSlot - Insert the specified Value* into the slot table.
void CreateFunctionSlot(const Value *V);
/// CreateFunctionSlot - Insert the specified Value* into the slot table.
void CreateFunctionSlot(const Value *V);
ST_DEBUG("Inserting Instructions:\n");
ST_DEBUG("Inserting Instructions:\n");
- SmallVector<std::pair<unsigned, Value *>, 4> MDForInst;
+ SmallVector<std::pair<unsigned, MDNode *>, 4> MDForInst;
// Add all of the basic blocks and instructions with no names.
for (Function::const_iterator BB = TheFunction->begin(),
// Add all of the basic blocks and instructions with no names.
for (Function::const_iterator BB = TheFunction->begin(),
// Process metadata attached with this instruction.
I->getAllMetadata(MDForInst);
for (unsigned i = 0, e = MDForInst.size(); i != e; ++i)
// Process metadata attached with this instruction.
I->getAllMetadata(MDForInst);
for (unsigned i = 0, e = MDForInst.size(); i != e; ++i)
- CreateMetadataSlot(cast<MDNode>(MDForInst[i].second));
+ CreateMetadataSlot(MDForInst[i].second);
return MI == mMap.end() ? -1 : (int)MI->second;
}
return MI == mMap.end() ? -1 : (int)MI->second;
}
-/// getMetadataSlot - Get the slot number of a metadata node.
-int SlotTracker::getMetadataSlot(const Value *MD) {
+/// getMetadataSlot - Get the slot number of a MDNode.
+int SlotTracker::getMetadataSlot(const MDNode *N) {
// Check for uninitialized state and do lazy initialization.
initialize();
// Find the MDNode in the module map
// Check for uninitialized state and do lazy initialization.
initialize();
// Find the MDNode in the module map
- mdn_iterator MI = mdnMap.find(cast<MDNode>(MD));
+ mdn_iterator MI = mdnMap.find(N);
return MI == mdnMap.end() ? -1 : (int)MI->second;
}
return MI == mdnMap.end() ? -1 : (int)MI->second;
}
-/// CreateModuleSlot - Insert the specified metadata into the slot table.
-void SlotTracker::CreateMetadataSlot(const Value *MD) {
- assert(MD && "Can't insert a null Value into SlotTracker!");
- const MDNode *N = cast<MDNode>(MD);
+/// CreateModuleSlot - Insert the specified MDNode* into the slot table.
+void SlotTracker::CreateMetadataSlot(const MDNode *N) {
+ assert(N && "Can't insert a null Value into SlotTracker!");
// Don't insert if N is a function-local metadata, these are always printed
// inline.
// Don't insert if N is a function-local metadata, these are always printed
// inline.
}
// Print Metadata info.
}
// Print Metadata info.
- SmallVector<std::pair<unsigned, Value *>, 4> InstMD;
+ SmallVector<std::pair<unsigned, MDNode *>, 4> InstMD;
I.getAllMetadata(InstMD);
if (!InstMD.empty()) {
SmallVector<StringRef, 8> MDNames;
I.getAllMetadata(InstMD);
if (!InstMD.empty()) {
SmallVector<StringRef, 8> MDNames;
Out << ", !<unknown kind #" << Kind << ">";
}
Out << ' ';
Out << ", !<unknown kind #" << Kind << ">";
}
Out << ' ';
- WriteAsOperandInternal(Out, cast<MDNode>(InstMD[i].second), &TypePrinter,
- &Machine, TheModule);
+ WriteAsOperandInternal(Out, InstMD[i].second, &TypePrinter, &Machine,
+ TheModule);
}
void llvm::UpgradeInstWithTBAATag(Instruction *I) {
}
void llvm::UpgradeInstWithTBAATag(Instruction *I) {
- MDNode *MD = I->getMDNode(LLVMContext::MD_tbaa);
+ MDNode *MD = I->getMetadata(LLVMContext::MD_tbaa);
assert(MD && "UpgradeInstWithTBAATag should have a TBAA tag");
// Check if the tag uses struct-path aware TBAA format.
if (isa<MDNode>(MD->getOperand(0)) && MD->getNumOperands() >= 3)
assert(MD && "UpgradeInstWithTBAATag should have a TBAA tag");
// Check if the tag uses struct-path aware TBAA format.
if (isa<MDNode>(MD->getOperand(0)) && MD->getNumOperands() >= 3)
void LLVMSetMetadata(LLVMValueRef Inst, unsigned KindID, LLVMValueRef MD) {
unwrap<Instruction>(Inst)
void LLVMSetMetadata(LLVMValueRef Inst, unsigned KindID, LLVMValueRef MD) {
unwrap<Instruction>(Inst)
- ->setMetadata(KindID, MD ? unwrap<Value>(MD) : nullptr);
+ ->setMetadata(KindID, MD ? unwrap<MDNode>(MD) : nullptr);
}
/*--.. Conversion functions ................................................--*/
}
/*--.. Conversion functions ................................................--*/
NamedMDNode *N = unwrap(M)->getOrInsertNamedMetadata(name);
if (!N)
return;
NamedMDNode *N = unwrap(M)->getOrInsertNamedMetadata(name);
if (!N)
return;
- Value *Op = Val ? unwrap<Value>(Val) : nullptr;
+ MDNode *Op = Val ? unwrap<MDNode>(Val) : nullptr;
if (Op)
N->addOperand(Op);
}
if (Op)
N->addOperand(Op);
}
llvm::generateDITypeIdentifierMap(const NamedMDNode *CU_Nodes) {
DITypeIdentifierMap Map;
for (unsigned CUi = 0, CUe = CU_Nodes->getNumOperands(); CUi != CUe; ++CUi) {
llvm::generateDITypeIdentifierMap(const NamedMDNode *CU_Nodes) {
DITypeIdentifierMap Map;
for (unsigned CUi = 0, CUe = CU_Nodes->getNumOperands(); CUi != CUe; ++CUi) {
- DICompileUnit CU(CU_Nodes->getOperandAsMDNode(CUi));
+ DICompileUnit CU(CU_Nodes->getOperand(CUi));
DIArray Retain = CU.getRetainedTypes();
for (unsigned Ti = 0, Te = Retain.getNumElements(); Ti != Te; ++Ti) {
if (!Retain.getElement(Ti).isCompositeType())
DIArray Retain = CU.getRetainedTypes();
for (unsigned Ti = 0, Te = Retain.getNumElements(); Ti != Te; ++Ti) {
if (!Retain.getElement(Ti).isCompositeType())
InitializeTypeMap(M);
if (NamedMDNode *CU_Nodes = M.getNamedMetadata("llvm.dbg.cu")) {
for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
InitializeTypeMap(M);
if (NamedMDNode *CU_Nodes = M.getNamedMetadata("llvm.dbg.cu")) {
for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
- DICompileUnit CU(CU_Nodes->getOperandAsMDNode(i));
+ DICompileUnit CU(CU_Nodes->getOperand(i));
addCompileUnit(CU);
DIArray GVs = CU.getGlobalVariables();
for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i) {
addCompileUnit(CU);
DIArray GVs = CU.getGlobalVariables();
for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i) {
- for (Value *N : CU_Nodes->operands()) {
- DICompileUnit CUNode(cast<MDNode>(N));
+ for (MDNode *N : CU_Nodes->operands()) {
+ DICompileUnit CUNode(N);
DIArray SPs = CUNode.getSubprograms();
for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
DISubprogram SP(SPs.getElement(i));
DIArray SPs = CUNode.getSubprograms();
for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
DISubprogram SP(SPs.getElement(i));
DiagnosticSeverity Severity)
: DiagnosticInfo(DK_InlineAsm, Severity), LocCookie(0), MsgStr(MsgStr),
Instr(&I) {
DiagnosticSeverity Severity)
: DiagnosticInfo(DK_InlineAsm, Severity), LocCookie(0), MsgStr(MsgStr),
Instr(&I) {
- if (const MDNode *SrcLoc = I.getMDNode("srcloc")) {
+ if (const MDNode *SrcLoc = I.getMetadata("srcloc")) {
if (SrcLoc->getNumOperands() != 0)
if (const ConstantInt *CI = dyn_cast<ConstantInt>(SrcLoc->getOperand(0)))
LocCookie = CI->getZExtValue();
if (SrcLoc->getNumOperands() != 0)
if (const ConstantInt *CI = dyn_cast<ConstantInt>(SrcLoc->getOperand(0)))
LocCookie = CI->getZExtValue();
// Otherwise, enumerate and copy over metadata from the old instruction to the
// new one.
// Otherwise, enumerate and copy over metadata from the old instruction to the
// new one.
- SmallVector<std::pair<unsigned, Value *>, 4> TheMDs;
+ SmallVector<std::pair<unsigned, MDNode *>, 4> TheMDs;
getAllMetadataOtherThanDebugLoc(TheMDs);
for (const auto &MD : TheMDs)
New->setMetadata(MD.first, MD.second);
getAllMetadataOtherThanDebugLoc(TheMDs);
for (const auto &MD : TheMDs)
New->setMetadata(MD.first, MD.second);
// Update profile metadata if present and it matches our structural
// expectations.
// Update profile metadata if present and it matches our structural
// expectations.
- MDNode *ProfileData = getMDNode(LLVMContext::MD_prof);
+ MDNode *ProfileData = getMetadata(LLVMContext::MD_prof);
if (!ProfileData || ProfileData->getNumOperands() != 3)
return;
if (!ProfileData || ProfileData->getNumOperands() != 3)
return;
/// An accuracy of 0.0 means that the operation should be performed with the
/// default precision.
float FPMathOperator::getFPAccuracy() const {
/// An accuracy of 0.0 means that the operation should be performed with the
/// default precision.
float FPMathOperator::getFPAccuracy() const {
- const MDNode *MD = cast<Instruction>(this)->getMDNode(LLVMContext::MD_fpmath);
+ const MDNode *MD =
+ cast<Instruction>(this)->getMetadata(LLVMContext::MD_fpmath);
if (!MD)
return 0.0;
ConstantFP *Accuracy = cast<ConstantFP>(MD->getOperand(0));
if (!MD)
return 0.0;
ConstantFP *Accuracy = cast<ConstantFP>(MD->getOperand(0));
// NamedMDNode implementation.
//
// NamedMDNode implementation.
//
-static SmallVector<TrackingVH<Value>, 4> &getNMDOps(void *Operands) {
- return *(SmallVector<TrackingVH<Value>, 4> *)Operands;
+static SmallVector<TrackingVH<MDNode>, 4> &getNMDOps(void *Operands) {
+ return *(SmallVector<TrackingVH<MDNode>, 4> *)Operands;
}
NamedMDNode::NamedMDNode(const Twine &N)
: Name(N.str()), Parent(nullptr),
}
NamedMDNode::NamedMDNode(const Twine &N)
: Name(N.str()), Parent(nullptr),
- Operands(new SmallVector<TrackingVH<Value>, 4>()) {}
+ Operands(new SmallVector<TrackingVH<MDNode>, 4>()) {}
NamedMDNode::~NamedMDNode() {
dropAllReferences();
NamedMDNode::~NamedMDNode() {
dropAllReferences();
return (unsigned)getNMDOps(Operands).size();
}
return (unsigned)getNMDOps(Operands).size();
}
-Value *NamedMDNode::getOperand(unsigned i) const {
+MDNode *NamedMDNode::getOperand(unsigned i) const {
assert(i < getNumOperands() && "Invalid Operand number!");
return &*getNMDOps(Operands)[i];
}
assert(i < getNumOperands() && "Invalid Operand number!");
return &*getNMDOps(Operands)[i];
}
-void NamedMDNode::addOperand(Value *V) {
- auto *M = cast<MDNode>(V);
+void NamedMDNode::addOperand(MDNode *M) {
assert(!M->isFunctionLocal() &&
"NamedMDNode operands must not be function-local!");
assert(!M->isFunctionLocal() &&
"NamedMDNode operands must not be function-local!");
- getNMDOps(Operands).push_back(TrackingVH<Value>(M));
+ getNMDOps(Operands).push_back(TrackingVH<MDNode>(M));
}
void NamedMDNode::eraseFromParent() {
}
void NamedMDNode::eraseFromParent() {
// Instruction Metadata method implementations.
//
// Instruction Metadata method implementations.
//
-void Instruction::setMetadata(StringRef Kind, Value *MD) {
- if (!MD && !hasMetadata()) return;
- setMetadata(getContext().getMDKindID(Kind), MD);
+void Instruction::setMetadata(StringRef Kind, MDNode *Node) {
+ if (!Node && !hasMetadata())
+ return;
+ setMetadata(getContext().getMDKindID(Kind), Node);
-Value *Instruction::getMetadataImpl(StringRef Kind) const {
+MDNode *Instruction::getMetadataImpl(StringRef Kind) const {
return getMetadataImpl(getContext().getMDKindID(Kind));
}
return getMetadataImpl(getContext().getMDKindID(Kind));
}
-MDNode *Instruction::getMDNodeImpl(unsigned KindID) const {
- return cast_or_null<MDNode>(getMetadataImpl(KindID));
-}
-
-MDNode *Instruction::getMDNodeImpl(StringRef Kind) const {
- return cast_or_null<MDNode>(getMetadataImpl(Kind));
-}
-
void Instruction::dropUnknownMetadata(ArrayRef<unsigned> KnownIDs) {
SmallSet<unsigned, 5> KnownSet;
KnownSet.insert(KnownIDs.begin(), KnownIDs.end());
void Instruction::dropUnknownMetadata(ArrayRef<unsigned> KnownIDs) {
SmallSet<unsigned, 5> KnownSet;
KnownSet.insert(KnownIDs.begin(), KnownIDs.end());
/// setMetadata - Set the metadata of of the specified kind to the specified
/// node. This updates/replaces metadata if already present, or removes it if
/// setMetadata - Set the metadata of of the specified kind to the specified
/// node. This updates/replaces metadata if already present, or removes it if
-/// MD is null.
-void Instruction::setMetadata(unsigned KindID, Value *MD) {
- if (!MD && !hasMetadata()) return;
-
- // For now, we only expect MDNodes here.
- MDNode *Node = cast_or_null<MDNode>(MD);
+/// Node is null.
+void Instruction::setMetadata(unsigned KindID, MDNode *Node) {
+ if (!Node && !hasMetadata())
+ return;
// Handle 'dbg' as a special case since it is not stored in the hash table.
if (KindID == LLVMContext::MD_dbg) {
// Handle 'dbg' as a special case since it is not stored in the hash table.
if (KindID == LLVMContext::MD_dbg) {
setMetadata(LLVMContext::MD_noalias, N.NoAlias);
}
setMetadata(LLVMContext::MD_noalias, N.NoAlias);
}
-Value *Instruction::getMetadataImpl(unsigned KindID) const {
+MDNode *Instruction::getMetadataImpl(unsigned KindID) const {
// Handle 'dbg' as a special case since it is not stored in the hash table.
if (KindID == LLVMContext::MD_dbg)
return DbgLoc.getAsMDNode(getContext());
// Handle 'dbg' as a special case since it is not stored in the hash table.
if (KindID == LLVMContext::MD_dbg)
return DbgLoc.getAsMDNode(getContext());
}
void Instruction::getAllMetadataImpl(
}
void Instruction::getAllMetadataImpl(
- SmallVectorImpl<std::pair<unsigned, Value *>> &Result) const {
+ SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const {
Result.clear();
// Handle 'dbg' as a special case since it is not stored in the hash table.
Result.clear();
// Handle 'dbg' as a special case since it is not stored in the hash table.
}
void Instruction::getAllMetadataOtherThanDebugLocImpl(
}
void Instruction::getAllMetadataOtherThanDebugLocImpl(
- SmallVectorImpl<std::pair<unsigned, Value *>> &Result) const {
+ SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const {
Result.clear();
assert(hasMetadataHashEntry() &&
getContext().pImpl->MetadataStore.count(this) &&
Result.clear();
assert(hasMetadataHashEntry() &&
getContext().pImpl->MetadataStore.count(this) &&
const NamedMDNode *ModFlags = getModuleFlagsMetadata();
if (!ModFlags) return;
const NamedMDNode *ModFlags = getModuleFlagsMetadata();
if (!ModFlags) return;
- for (const Value *FlagMD : ModFlags->operands()) {
- const MDNode *Flag = cast<MDNode>(FlagMD);
+ for (const MDNode *Flag : ModFlags->operands()) {
ModFlagBehavior MFB;
if (Flag->getNumOperands() >= 3 &&
isValidModFlagBehavior(Flag->getOperand(0), MFB) &&
ModFlagBehavior MFB;
if (Flag->getNumOperands() >= 3 &&
isValidModFlagBehavior(Flag->getOperand(0), MFB) &&
}
// Get types from functions.
}
// Get types from functions.
- SmallVector<std::pair<unsigned, Value *>, 4> MDForInst;
+ SmallVector<std::pair<unsigned, MDNode *>, 4> MDForInst;
for (Module::const_iterator FI = M.begin(), E = M.end(); FI != E; ++FI) {
incorporateType(FI->getType());
for (Module::const_iterator FI = M.begin(), E = M.end(); FI != E; ++FI) {
incorporateType(FI->getType());
// Incorporate types hiding in metadata.
I.getAllMetadataOtherThanDebugLoc(MDForInst);
for (unsigned i = 0, e = MDForInst.size(); i != e; ++i)
// Incorporate types hiding in metadata.
I.getAllMetadataOtherThanDebugLoc(MDForInst);
for (unsigned i = 0, e = MDForInst.size(); i != e; ++i)
- incorporateMDNode(cast<MDNode>(MDForInst[i].second));
+ incorporateMDNode(MDForInst[i].second);
E = M.named_metadata_end(); I != E; ++I) {
const NamedMDNode *NMD = I;
for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
E = M.named_metadata_end(); I != E; ++I) {
const NamedMDNode *NMD = I;
for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
- incorporateMDNode(NMD->getOperandAsMDNode(i));
+ incorporateMDNode(NMD->getOperand(i));
void Verifier::visitNamedMDNode(const NamedMDNode &NMD) {
for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i) {
void Verifier::visitNamedMDNode(const NamedMDNode &NMD) {
for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i) {
- MDNode *MD = NMD.getOperandAsMDNode(i);
+ MDNode *MD = NMD.getOperand(i);
// llvm.ident takes a list of metadata entry. Each entry has only one string.
// Scan each llvm.ident entry and make sure that this requirement is met.
for (unsigned i = 0, e = Idents->getNumOperands(); i != e; ++i) {
// llvm.ident takes a list of metadata entry. Each entry has only one string.
// Scan each llvm.ident entry and make sure that this requirement is met.
for (unsigned i = 0, e = Idents->getNumOperands(); i != e; ++i) {
- const MDNode *N = Idents->getOperandAsMDNode(i);
+ const MDNode *N = Idents->getOperand(i);
Assert1(N->getNumOperands() == 1,
"incorrect number of operands in llvm.ident metadata", N);
Assert1(isa<MDString>(N->getOperand(0)),
Assert1(N->getNumOperands() == 1,
"incorrect number of operands in llvm.ident metadata", N);
Assert1(isa<MDString>(N->getOperand(0)),
DenseMap<const MDString*, const MDNode*> SeenIDs;
SmallVector<const MDNode*, 16> Requirements;
for (unsigned I = 0, E = Flags->getNumOperands(); I != E; ++I) {
DenseMap<const MDString*, const MDNode*> SeenIDs;
SmallVector<const MDNode*, 16> Requirements;
for (unsigned I = 0, E = Flags->getNumOperands(); I != E; ++I) {
- visitModuleFlag(Flags->getOperandAsMDNode(I), SeenIDs, Requirements);
+ visitModuleFlag(Flags->getOperand(I), SeenIDs, Requirements);
}
// Validate that the requirements in the module are valid.
}
// Validate that the requirements in the module are valid.
- if (MDNode *MD = I.getMDNode(LLVMContext::MD_fpmath)) {
+ if (MDNode *MD = I.getMetadata(LLVMContext::MD_fpmath)) {
Assert1(I.getType()->isFPOrFPVectorTy(),
"fpmath requires a floating point result!", &I);
Assert1(MD->getNumOperands() == 1, "fpmath takes one operand!", &I);
Assert1(I.getType()->isFPOrFPVectorTy(),
"fpmath requires a floating point result!", &I);
Assert1(MD->getNumOperands() == 1, "fpmath takes one operand!", &I);
- if (MDNode *Range = I.getMDNode(LLVMContext::MD_range)) {
+ if (MDNode *Range = I.getMetadata(LLVMContext::MD_range)) {
Assert1(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I),
"Ranges are only for loads, calls and invokes!", &I);
visitRangeMetadata(I, Range, I.getType());
Assert1(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I),
"Ranges are only for loads, calls and invokes!", &I);
visitRangeMetadata(I, Range, I.getType());
void DebugInfoVerifier::processInstructions(DebugInfoFinder &Finder) {
for (const Function &F : *M)
for (auto I = inst_begin(&F), E = inst_end(&F); I != E; ++I) {
void DebugInfoVerifier::processInstructions(DebugInfoFinder &Finder) {
for (const Function &F : *M)
for (auto I = inst_begin(&F), E = inst_end(&F); I != E; ++I) {
- if (MDNode *MD = I->getMDNode(LLVMContext::MD_dbg))
+ if (MDNode *MD = I->getMetadata(LLVMContext::MD_dbg))
Finder.processLocation(*M, DILocation(MD));
if (const CallInst *CI = dyn_cast<CallInst>(&*I))
processCallInst(Finder, *CI);
Finder.processLocation(*M, DILocation(MD));
if (const CallInst *CI = dyn_cast<CallInst>(&*I))
processCallInst(Finder, *CI);
DenseMap<MDString*, MDNode*> Flags;
SmallSetVector<MDNode*, 16> Requirements;
for (unsigned I = 0, E = DstModFlags->getNumOperands(); I != E; ++I) {
DenseMap<MDString*, MDNode*> Flags;
SmallSetVector<MDNode*, 16> Requirements;
for (unsigned I = 0, E = DstModFlags->getNumOperands(); I != E; ++I) {
- MDNode *Op = DstModFlags->getOperandAsMDNode(I);
+ MDNode *Op = DstModFlags->getOperand(I);
ConstantInt *Behavior = cast<ConstantInt>(Op->getOperand(0));
MDString *ID = cast<MDString>(Op->getOperand(1));
ConstantInt *Behavior = cast<ConstantInt>(Op->getOperand(0));
MDString *ID = cast<MDString>(Op->getOperand(1));
// requirements.
bool HasErr = false;
for (unsigned I = 0, E = SrcModFlags->getNumOperands(); I != E; ++I) {
// requirements.
bool HasErr = false;
for (unsigned I = 0, E = SrcModFlags->getNumOperands(); I != E; ++I) {
- MDNode *SrcOp = SrcModFlags->getOperandAsMDNode(I);
+ MDNode *SrcOp = SrcModFlags->getOperand(I);
ConstantInt *SrcBehavior = cast<ConstantInt>(SrcOp->getOperand(0));
MDString *ID = cast<MDString>(SrcOp->getOperand(1));
MDNode *DstOp = Flags.lookup(ID);
ConstantInt *SrcBehavior = cast<ConstantInt>(SrcOp->getOperand(0));
MDString *ID = cast<MDString>(SrcOp->getOperand(1));
MDNode *DstOp = Flags.lookup(ID);
// Check if any operand is or contains a global variable in GVMap, and thus
// converted to another value.
for (unsigned i = 0; i < NumOperands; ++i) {
// Check if any operand is or contains a global variable in GVMap, and thus
// converted to another value.
for (unsigned i = 0; i < NumOperands; ++i) {
- MDNode *Operand = cast<MDNode>(N->getOperand(i));
+ MDNode *Operand = N->getOperand(i);
MDNode *NewOperand = remapMDNode(M, Operand);
OperandChanged |= Operand != NewOperand;
NewOperands.push_back(NewOperand);
MDNode *NewOperand = remapMDNode(M, Operand);
OperandChanged |= Operand != NewOperand;
NewOperands.push_back(NewOperand);
return;
key_val_pair_t tmp;
for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
return;
key_val_pair_t tmp;
for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
- const MDNode *elem = NMD->getOperandAsMDNode(i);
+ const MDNode *elem = NMD->getOperand(i);
Value *entity = elem->getOperand(0);
// entity may be null due to DCE
Value *entity = elem->getOperand(0);
// entity may be null due to DCE
}
bool llvm::getAlign(const CallInst &I, unsigned index, unsigned &align) {
}
bool llvm::getAlign(const CallInst &I, unsigned index, unsigned &align) {
- if (MDNode *alignNode = I.getMDNode("callalign")) {
+ if (MDNode *alignNode = I.getMetadata("callalign")) {
for (int i = 0, n = alignNode->getNumOperands(); i < n; i++) {
if (const ConstantInt *CI =
dyn_cast<ConstantInt>(alignNode->getOperand(i))) {
for (int i = 0, n = alignNode->getNumOperands(); i < n; i++) {
if (const ConstantInt *CI =
dyn_cast<ConstantInt>(alignNode->getOperand(i))) {
Value *BitCast = Builder.CreateBitCast(Ptr,
PointerType::get(v4i32,PtrTy->getPointerAddressSpace()));
LoadInst *Load = Builder.CreateLoad(BitCast);
Value *BitCast = Builder.CreateBitCast(Ptr,
PointerType::get(v4i32,PtrTy->getPointerAddressSpace()));
LoadInst *Load = Builder.CreateLoad(BitCast);
- // FIXME: Should the DebugLoc really get dropped here?
- SmallVector<std::pair<unsigned, Value *>, 8> MD;
+ SmallVector<std::pair<unsigned, MDNode *>, 8> MD;
I.getAllMetadataOtherThanDebugLoc(MD);
for (unsigned i = 0, e = MD.size(); i != e; ++i) {
Load->setMetadata(MD[i].first, MD[i].second);
I.getAllMetadataOtherThanDebugLoc(MD);
for (unsigned i = 0, e = MD.size(); i != e; ++i) {
Load->setMetadata(MD[i].first, MD[i].second);
// If the memcpy has metadata describing the members, see if we can
// get the TBAA tag describing our copy.
// If the memcpy has metadata describing the members, see if we can
// get the TBAA tag describing our copy.
- if (MDNode *M = MI->getMDNode(LLVMContext::MD_tbaa_struct)) {
+ if (MDNode *M = MI->getMetadata(LLVMContext::MD_tbaa_struct)) {
if (M->getNumOperands() == 3 &&
M->getOperand(0) &&
isa<ConstantInt>(M->getOperand(0)) &&
if (M->getNumOperands() == 3 &&
M->getOperand(0) &&
isa<ConstantInt>(M->getOperand(0)) &&
static LoadInst *combineLoadToNewType(InstCombiner &IC, LoadInst &LI, Type *NewTy) {
Value *Ptr = LI.getPointerOperand();
unsigned AS = LI.getPointerAddressSpace();
static LoadInst *combineLoadToNewType(InstCombiner &IC, LoadInst &LI, Type *NewTy) {
Value *Ptr = LI.getPointerOperand();
unsigned AS = LI.getPointerAddressSpace();
- SmallVector<std::pair<unsigned, Value *>, 8> MD;
+ SmallVector<std::pair<unsigned, MDNode *>, 8> MD;
LI.getAllMetadata(MD);
LoadInst *NewLoad = IC.Builder->CreateAlignedLoad(
LI.getAllMetadata(MD);
LoadInst *NewLoad = IC.Builder->CreateAlignedLoad(
LI.getAlignment(), LI.getName());
for (const auto &MDPair : MD) {
unsigned ID = MDPair.first;
LI.getAlignment(), LI.getName());
for (const auto &MDPair : MD) {
unsigned ID = MDPair.first;
- Value *N = MDPair.second;
+ MDNode *N = MDPair.second;
// Note, essentially every kind of metadata should be preserved here! This
// routine is supposed to clone a load instruction changing *only its type*.
// The only metadata it makes sense to drop is metadata which is invalidated
// Note, essentially every kind of metadata should be preserved here! This
// routine is supposed to clone a load instruction changing *only its type*.
// The only metadata it makes sense to drop is metadata which is invalidated
NamedMDNode *Globals = M.getNamedMetadata("llvm.asan.globals");
if (!Globals)
return;
NamedMDNode *Globals = M.getNamedMetadata("llvm.asan.globals");
if (!Globals)
return;
- for (const Value *MDV : Globals->operands()) {
- const MDNode *MDN = cast<MDNode>(MDV);
-
+ for (auto MDN : Globals->operands()) {
// Metadata node contains the global and the fields of "Entry".
assert(MDN->getNumOperands() == 5);
Value *V = MDN->getOperand(0);
// Metadata node contains the global and the fields of "Entry".
assert(MDN->getNumOperands() == 5);
Value *V = MDN->getOperand(0);
if (!CUNode || CUNode->getNumOperands() == 0)
return false;
if (!CUNode || CUNode->getNumOperands() == 0)
return false;
- DICompileUnit CU(cast<MDNode>(CUNode->getOperand(0)));
+ DICompileUnit CU(CUNode->getOperand(0));
if (!CU.Verify())
return false;
if (!CU.Verify())
return false;
std::string GCOVProfiler::mangleName(DICompileUnit CU, const char *NewStem) {
if (NamedMDNode *GCov = M->getNamedMetadata("llvm.gcov")) {
for (int i = 0, e = GCov->getNumOperands(); i != e; ++i) {
std::string GCOVProfiler::mangleName(DICompileUnit CU, const char *NewStem) {
if (NamedMDNode *GCov = M->getNamedMetadata("llvm.gcov")) {
for (int i = 0, e = GCov->getNumOperands(); i != e; ++i) {
- MDNode *N = GCov->getOperandAsMDNode(i);
+ MDNode *N = GCov->getOperand(i);
if (N->getNumOperands() != 2) continue;
MDString *GCovFile = dyn_cast<MDString>(N->getOperand(0));
MDNode *CompileUnit = dyn_cast<MDNode>(N->getOperand(1));
if (N->getNumOperands() != 2) continue;
MDString *GCovFile = dyn_cast<MDString>(N->getOperand(0));
MDNode *CompileUnit = dyn_cast<MDNode>(N->getOperand(1));
// this pass over the original .o's as they're produced, or run it after
// LTO, we'll generate the same .gcno files.
// this pass over the original .o's as they're produced, or run it after
// LTO, we'll generate the same .gcno files.
- DICompileUnit CU(CU_Nodes->getOperandAsMDNode(i));
+ DICompileUnit CU(CU_Nodes->getOperand(i));
std::error_code EC;
raw_fd_ostream out(mangleName(CU, "gcno"), EC, sys::fs::F_None);
std::string EdgeDestinations;
std::error_code EC;
raw_fd_ostream out(mangleName(CU, "gcno"), EC, sys::fs::F_None);
std::string EdgeDestinations;
bool Result = false;
bool InsertIndCounterIncrCode = false;
for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
bool Result = false;
bool InsertIndCounterIncrCode = false;
for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
- DICompileUnit CU(CU_Nodes->getOperandAsMDNode(i));
+ DICompileUnit CU(CU_Nodes->getOperand(i));
DIArray SPs = CU.getSubprograms();
SmallVector<std::pair<GlobalVariable *, MDNode *>, 8> CountersBySP;
for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
DIArray SPs = CU.getSubprograms();
SmallVector<std::pair<GlobalVariable *, MDNode *>, 8> CountersBySP;
for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
if (CU_Nodes) {
for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
if (CU_Nodes) {
for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
- DICompileUnit CU(CU_Nodes->getOperandAsMDNode(i));
+ DICompileUnit CU(CU_Nodes->getOperand(i));
std::string FilenameGcda = mangleName(CU, "gcda");
uint32_t CfgChecksum = FileChecksums.empty() ? 0 : FileChecksums[i];
Builder.CreateCall3(StartFile,
std::string FilenameGcda = mangleName(CU, "gcda");
uint32_t CfgChecksum = FileChecksums.empty() ? 0 : FileChecksums[i];
Builder.CreateCall3(StartFile,
}
static bool isVtableAccess(Instruction *I) {
}
static bool isVtableAccess(Instruction *I) {
- if (MDNode *Tag = I->getMDNode(LLVMContext::MD_tbaa))
+ if (MDNode *Tag = I->getMetadata(LLVMContext::MD_tbaa))
return Tag->isTBAAVtableAccess();
return false;
}
return Tag->isTBAAVtableAccess();
return false;
}
if (NamedMDNode *NMD =
M.getNamedMetadata("clang.arc.retainAutoreleasedReturnValueMarker"))
if (NMD->getNumOperands() == 1) {
if (NamedMDNode *NMD =
M.getNamedMetadata("clang.arc.retainAutoreleasedReturnValueMarker"))
if (NMD->getNumOperands() == 1) {
- const MDNode *N = NMD->getOperandAsMDNode(0);
+ const MDNode *N = NMD->getOperand(0);
if (N->getNumOperands() == 1)
if (const MDString *S = dyn_cast<MDString>(N->getOperand(0)))
RetainRVMarker = S;
if (N->getNumOperands() == 1)
if (const MDString *S = dyn_cast<MDString>(N->getOperand(0)))
RetainRVMarker = S;
// reference to said Node. Otherwise just return 0.
if (Instruction *Inst = dyn_cast<Instruction>(Ptr)) {
MDNode *Node;
// reference to said Node. Otherwise just return 0.
if (Instruction *Inst = dyn_cast<Instruction>(Ptr)) {
MDNode *Node;
- if (!(Node = Inst->getMDNode(NodeId))) {
+ if (!(Node = Inst->getMetadata(NodeId))) {
// We do not have any node. Generate and attatch the hash MDString to the
// instruction.
// We do not have any node. Generate and attatch the hash MDString to the
// instruction.
NestingDetected = true;
}
NestingDetected = true;
}
- MDNode *ReleaseMetadata = Inst->getMDNode(ImpreciseReleaseMDKind);
+ MDNode *ReleaseMetadata = Inst->getMetadata(ImpreciseReleaseMDKind);
Sequence NewSeq = ReleaseMetadata ? S_MovableRelease : S_Release;
ANNOTATE_BOTTOMUP(Inst, Arg, S.GetSeq(), NewSeq);
S.ResetSequenceProgress(NewSeq);
Sequence NewSeq = ReleaseMetadata ? S_MovableRelease : S_Release;
ANNOTATE_BOTTOMUP(Inst, Arg, S.GetSeq(), NewSeq);
S.ResetSequenceProgress(NewSeq);
Sequence OldSeq = S.GetSeq();
Sequence OldSeq = S.GetSeq();
- MDNode *ReleaseMetadata = Inst->getMDNode(ImpreciseReleaseMDKind);
+ MDNode *ReleaseMetadata = Inst->getMetadata(ImpreciseReleaseMDKind);
switch (OldSeq) {
case S_Retain:
switch (OldSeq) {
case S_Retain:
// Transfer metadata from Op to the instructions in CV if it is known
// to be safe to do so.
void Scalarizer::transferMetadata(Instruction *Op, const ValueVector &CV) {
// Transfer metadata from Op to the instructions in CV if it is known
// to be safe to do so.
void Scalarizer::transferMetadata(Instruction *Op, const ValueVector &CV) {
- SmallVector<std::pair<unsigned, Value *>, 4> MDs;
+ SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
Op->getAllMetadataOtherThanDebugLoc(MDs);
for (unsigned I = 0, E = CV.size(); I != E; ++I) {
if (Instruction *New = dyn_cast<Instruction>(CV[I])) {
Op->getAllMetadataOtherThanDebugLoc(MDs);
for (unsigned I = 0, E = CV.size(); I != E; ++I) {
if (Instruction *New = dyn_cast<Instruction>(CV[I])) {
- for (auto MI = MDs.begin(), ME = MDs.end(); MI != ME; ++MI)
+ for (SmallVectorImpl<std::pair<unsigned, MDNode *>>::iterator
+ MI = MDs.begin(),
+ ME = MDs.end();
+ MI != ME; ++MI)
if (canTransferMetadata(MI->first))
New->setMetadata(MI->first, MI->second);
New->setDebugLoc(Op->getDebugLoc());
if (canTransferMetadata(MI->first))
New->setMetadata(MI->first, MI->second);
New->setDebugLoc(Op->getDebugLoc());
for (Function::const_iterator I = CalledFunc->begin(), IE = CalledFunc->end();
I != IE; ++I)
for (BasicBlock::const_iterator J = I->begin(), JE = I->end(); J != JE; ++J) {
for (Function::const_iterator I = CalledFunc->begin(), IE = CalledFunc->end();
I != IE; ++I)
for (BasicBlock::const_iterator J = I->begin(), JE = I->end(); J != JE; ++J) {
- if (const MDNode *M = J->getMDNode(LLVMContext::MD_alias_scope))
+ if (const MDNode *M = J->getMetadata(LLVMContext::MD_alias_scope))
- if (const MDNode *M = J->getMDNode(LLVMContext::MD_noalias))
+ if (const MDNode *M = J->getMetadata(LLVMContext::MD_noalias))
- if (MDNode *M = NI->getMDNode(LLVMContext::MD_alias_scope)) {
+ if (MDNode *M = NI->getMetadata(LLVMContext::MD_alias_scope)) {
MDNode *NewMD = MDMap[M];
// If the call site also had alias scope metadata (a list of scopes to
// which instructions inside it might belong), propagate those scopes to
// the inlined instructions.
if (MDNode *CSM =
MDNode *NewMD = MDMap[M];
// If the call site also had alias scope metadata (a list of scopes to
// which instructions inside it might belong), propagate those scopes to
// the inlined instructions.
if (MDNode *CSM =
- CS.getInstruction()->getMDNode(LLVMContext::MD_alias_scope))
+ CS.getInstruction()->getMetadata(LLVMContext::MD_alias_scope))
NewMD = MDNode::concatenate(NewMD, CSM);
NI->setMetadata(LLVMContext::MD_alias_scope, NewMD);
} else if (NI->mayReadOrWriteMemory()) {
if (MDNode *M =
NewMD = MDNode::concatenate(NewMD, CSM);
NI->setMetadata(LLVMContext::MD_alias_scope, NewMD);
} else if (NI->mayReadOrWriteMemory()) {
if (MDNode *M =
- CS.getInstruction()->getMDNode(LLVMContext::MD_alias_scope))
+ CS.getInstruction()->getMetadata(LLVMContext::MD_alias_scope))
NI->setMetadata(LLVMContext::MD_alias_scope, M);
}
NI->setMetadata(LLVMContext::MD_alias_scope, M);
}
- if (MDNode *M = NI->getMDNode(LLVMContext::MD_noalias)) {
+ if (MDNode *M = NI->getMetadata(LLVMContext::MD_noalias)) {
MDNode *NewMD = MDMap[M];
// If the call site also had noalias metadata (a list of scopes with
// which instructions inside it don't alias), propagate those scopes to
// the inlined instructions.
MDNode *NewMD = MDMap[M];
// If the call site also had noalias metadata (a list of scopes with
// which instructions inside it don't alias), propagate those scopes to
// the inlined instructions.
- if (MDNode *CSM = CS.getInstruction()->getMDNode(LLVMContext::MD_noalias))
+ if (MDNode *CSM =
+ CS.getInstruction()->getMetadata(LLVMContext::MD_noalias))
NewMD = MDNode::concatenate(NewMD, CSM);
NI->setMetadata(LLVMContext::MD_noalias, NewMD);
} else if (NI->mayReadOrWriteMemory()) {
NewMD = MDNode::concatenate(NewMD, CSM);
NI->setMetadata(LLVMContext::MD_noalias, NewMD);
} else if (NI->mayReadOrWriteMemory()) {
- if (MDNode *M = CS.getInstruction()->getMDNode(LLVMContext::MD_noalias))
+ if (MDNode *M = CS.getInstruction()->getMetadata(LLVMContext::MD_noalias))
NI->setMetadata(LLVMContext::MD_noalias, M);
}
}
NI->setMetadata(LLVMContext::MD_noalias, M);
}
}
if (!NoAliases.empty())
NI->setMetadata(LLVMContext::MD_noalias,
MDNode::concatenate(
if (!NoAliases.empty())
NI->setMetadata(LLVMContext::MD_noalias,
MDNode::concatenate(
- NI->getMDNode(LLVMContext::MD_noalias),
+ NI->getMetadata(LLVMContext::MD_noalias),
MDNode::get(CalledFunc->getContext(), NoAliases)));
// Next, we want to figure out all of the sets to which we might belong.
MDNode::get(CalledFunc->getContext(), NoAliases)));
// Next, we want to figure out all of the sets to which we might belong.
if (!Scopes.empty())
NI->setMetadata(
LLVMContext::MD_alias_scope,
if (!Scopes.empty())
NI->setMetadata(
LLVMContext::MD_alias_scope,
- MDNode::concatenate(NI->getMDNode(LLVMContext::MD_alias_scope),
+ MDNode::concatenate(NI->getMetadata(LLVMContext::MD_alias_scope),
MDNode::get(CalledFunc->getContext(), Scopes)));
}
}
MDNode::get(CalledFunc->getContext(), Scopes)));
}
}
// Check to see if this branch is going to the same place as the default
// dest. If so, eliminate it as an explicit compare.
if (i.getCaseSuccessor() == DefaultDest) {
// Check to see if this branch is going to the same place as the default
// dest. If so, eliminate it as an explicit compare.
if (i.getCaseSuccessor() == DefaultDest) {
- MDNode *MD = SI->getMDNode(LLVMContext::MD_prof);
+ MDNode *MD = SI->getMetadata(LLVMContext::MD_prof);
unsigned NCases = SI->getNumCases();
// Fold the case metadata into the default if there will be any branches
// left, unless the metadata doesn't match the switch.
unsigned NCases = SI->getNumCases();
// Fold the case metadata into the default if there will be any branches
// left, unless the metadata doesn't match the switch.
BranchInst *NewBr = Builder.CreateCondBr(Cond,
FirstCase.getCaseSuccessor(),
SI->getDefaultDest());
BranchInst *NewBr = Builder.CreateCondBr(Cond,
FirstCase.getCaseSuccessor(),
SI->getDefaultDest());
- MDNode *MD = SI->getMDNode(LLVMContext::MD_prof);
+ MDNode *MD = SI->getMetadata(LLVMContext::MD_prof);
if (MD && MD->getNumOperands() == 3) {
ConstantInt *SICase = dyn_cast<ConstantInt>(MD->getOperand(2));
ConstantInt *SIDef = dyn_cast<ConstantInt>(MD->getOperand(1));
if (MD && MD->getNumOperands() == 3) {
ConstantInt *SICase = dyn_cast<ConstantInt>(MD->getOperand(2));
ConstantInt *SIDef = dyn_cast<ConstantInt>(MD->getOperand(1));
}
void llvm::combineMetadata(Instruction *K, const Instruction *J, ArrayRef<unsigned> KnownIDs) {
}
void llvm::combineMetadata(Instruction *K, const Instruction *J, ArrayRef<unsigned> KnownIDs) {
- SmallVector<std::pair<unsigned, Value *>, 4> Metadata;
+ SmallVector<std::pair<unsigned, MDNode *>, 4> Metadata;
K->dropUnknownMetadata(KnownIDs);
K->getAllMetadataOtherThanDebugLoc(Metadata);
for (unsigned i = 0, n = Metadata.size(); i < n; ++i) {
unsigned Kind = Metadata[i].first;
K->dropUnknownMetadata(KnownIDs);
K->getAllMetadataOtherThanDebugLoc(Metadata);
for (unsigned i = 0, n = Metadata.size(); i < n; ++i) {
unsigned Kind = Metadata[i].first;
- MDNode *JMD = J->getMDNode(Kind);
- MDNode *KMD = cast<MDNode>(Metadata[i].second);
+ MDNode *JMD = J->getMetadata(Kind);
+ MDNode *KMD = Metadata[i].second;
// Collect branch weights into a vector.
SmallVector<uint32_t, 8> Weights;
// Collect branch weights into a vector.
SmallVector<uint32_t, 8> Weights;
- MDNode *MD = SI->getMDNode(LLVMContext::MD_prof);
+ MDNode *MD = SI->getMetadata(LLVMContext::MD_prof);
bool HasWeight = MD && (MD->getNumOperands() == 2 + SI->getNumCases());
if (HasWeight)
for (unsigned MD_i = 1, MD_e = MD->getNumOperands(); MD_i < MD_e;
bool HasWeight = MD && (MD->getNumOperands() == 2 + SI->getNumCases());
if (HasWeight)
for (unsigned MD_i = 1, MD_e = MD->getNumOperands(); MD_i < MD_e;
}
static inline bool HasBranchWeights(const Instruction* I) {
}
static inline bool HasBranchWeights(const Instruction* I) {
- MDNode *ProfMD = I->getMDNode(LLVMContext::MD_prof);
+ MDNode *ProfMD = I->getMetadata(LLVMContext::MD_prof);
if (ProfMD && ProfMD->getOperand(0))
if (MDString* MDS = dyn_cast<MDString>(ProfMD->getOperand(0)))
return MDS->getString().equals("branch_weights");
if (ProfMD && ProfMD->getOperand(0))
if (MDString* MDS = dyn_cast<MDString>(ProfMD->getOperand(0)))
return MDS->getString().equals("branch_weights");
/// metadata.
static void GetBranchWeights(TerminatorInst *TI,
SmallVectorImpl<uint64_t> &Weights) {
/// metadata.
static void GetBranchWeights(TerminatorInst *TI,
SmallVectorImpl<uint64_t> &Weights) {
- MDNode *MD = TI->getMDNode(LLVMContext::MD_prof);
+ MDNode *MD = TI->getMetadata(LLVMContext::MD_prof);
assert(MD);
for (unsigned i = 1, e = MD->getNumOperands(); i < e; ++i) {
ConstantInt *CI = cast<ConstantInt>(MD->getOperand(i));
assert(MD);
for (unsigned i = 1, e = MD->getNumOperands(); i < e; ++i) {
ConstantInt *CI = cast<ConstantInt>(MD->getOperand(i));
uint64_t &ProbTrue, uint64_t &ProbFalse) {
assert(BI->isConditional() &&
"Looking for probabilities on unconditional branch?");
uint64_t &ProbTrue, uint64_t &ProbFalse) {
assert(BI->isConditional() &&
"Looking for probabilities on unconditional branch?");
- MDNode *ProfileData = BI->getMDNode(LLVMContext::MD_prof);
+ MDNode *ProfileData = BI->getMetadata(LLVMContext::MD_prof);
if (!ProfileData || ProfileData->getNumOperands() != 3) return false;
ConstantInt *CITrue = dyn_cast<ConstantInt>(ProfileData->getOperand(1));
ConstantInt *CIFalse = dyn_cast<ConstantInt>(ProfileData->getOperand(2));
if (!ProfileData || ProfileData->getNumOperands() != 3) return false;
ConstantInt *CITrue = dyn_cast<ConstantInt>(ProfileData->getOperand(1));
ConstantInt *CIFalse = dyn_cast<ConstantInt>(ProfileData->getOperand(2));
}
// Remap attached metadata.
}
// Remap attached metadata.
- SmallVector<std::pair<unsigned, Value *>, 4> MDs;
+ SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
- for (auto MI = MDs.begin(), ME = MDs.end(); MI != ME; ++MI) {
- Value *Old = MI->second;
- Value *New = MapValue(Old, VMap, Flags, TypeMapper, Materializer);
+ for (SmallVectorImpl<std::pair<unsigned, MDNode *>>::iterator
+ MI = MDs.begin(),
+ ME = MDs.end();
+ MI != ME; ++MI) {
+ MDNode *Old = MI->second;
+ MDNode *New = MapValue(Old, VMap, Flags, TypeMapper, Materializer);
if (New != Old)
I->setMetadata(MI->first, New);
}
if (New != Old)
I->setMetadata(MI->first, New);
}
/// \brief Propagate known metadata from one instruction to another.
static void propagateMetadata(Instruction *To, const Instruction *From) {
/// \brief Propagate known metadata from one instruction to another.
static void propagateMetadata(Instruction *To, const Instruction *From) {
- SmallVector<std::pair<unsigned, Value *>, 4> Metadata;
+ SmallVector<std::pair<unsigned, MDNode *>, 4> Metadata;
From->getAllMetadataOtherThanDebugLoc(Metadata);
for (auto M : Metadata) {
From->getAllMetadataOtherThanDebugLoc(Metadata);
for (auto M : Metadata) {
/// \returns \p I after propagating metadata from \p VL.
static Instruction *propagateMetadata(Instruction *I, ArrayRef<Value *> VL) {
Instruction *I0 = cast<Instruction>(VL[0]);
/// \returns \p I after propagating metadata from \p VL.
static Instruction *propagateMetadata(Instruction *I, ArrayRef<Value *> VL) {
Instruction *I0 = cast<Instruction>(VL[0]);
- SmallVector<std::pair<unsigned, Value *>, 4> Metadata;
+ SmallVector<std::pair<unsigned, MDNode *>, 4> Metadata;
I0->getAllMetadataOtherThanDebugLoc(Metadata);
for (unsigned i = 0, n = Metadata.size(); i != n; ++i) {
unsigned Kind = Metadata[i].first;
I0->getAllMetadataOtherThanDebugLoc(Metadata);
for (unsigned i = 0, n = Metadata.size(); i != n; ++i) {
unsigned Kind = Metadata[i].first;
- MDNode *MD = cast_or_null<MDNode>(Metadata[i].second);
+ MDNode *MD = Metadata[i].second;
for (int i = 1, e = VL.size(); MD && i != e; i++) {
Instruction *I = cast<Instruction>(VL[i]);
for (int i = 1, e = VL.size(); MD && i != e; i++) {
Instruction *I = cast<Instruction>(VL[i]);
- MDNode *IMD = I->getMDNode(Kind);
+ MDNode *IMD = I->getMetadata(Kind);
if (NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.sp"))
for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
std::string Name;
if (NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.sp"))
for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
std::string Name;
- DISubprogram SP(cast_or_null<MDNode>(NMD->getOperand(i)));
+ DISubprogram SP(NMD->getOperand(i));
assert((!SP || SP.isSubprogram()) &&
"A MDNode in llvm.dbg.sp should be null or a DISubprogram.");
if (!SP)
assert((!SP || SP.isSubprogram()) &&
"A MDNode in llvm.dbg.sp should be null or a DISubprogram.");
if (!SP)
projects / oota-llvm.git / commitdiff