RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-22 18:54:02 +01:00
Code Issues Projects Releases Wiki Activity

Revert "IR: MDNode => Value"

Browse Source 
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.

llvm-svn: 221711
This commit is contained in:
Duncan P. N. Exon Smith 2014-11-11 21:30:22 +00:00
parent 71097ab326
commit 8770505e4e
46 changed files with 173 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/llvm/IR/IRBuilder.h
View File

@ -23,12 +23,12 @@
#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 {
class MDNode;
/// \brief This provides the default implementation of the IRBuilder
/// 'InsertHelper' method that is called whenever an instruction is created by

42
include/llvm/IR/Instruction.h
View File

@ -141,41 +141,23 @@ public:
/// 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.
Value *getMetadata(StringRef Kind) const {
MDNode *getMetadata(StringRef Kind) const {
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(SmallVectorImpl<std::pair<unsigned, Value *>> &MDs) const {
getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const {
if (hasMetadata())
getAllMetadataImpl(MDs);
}
@ -183,7 +165,7 @@ public:
/// 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);
}
@ -195,9 +177,9 @@ public:
/// 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
@ -290,14 +272,12 @@ private:
}
// 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;
void
getAllMetadataImpl(SmallVectorImpl<std::pair<unsigned, Value *>> &) const;
getAllMetadataImpl(SmallVectorImpl<std::pair<unsigned, MDNode *>> &) const;
void getAllMetadataOtherThanDebugLocImpl(
SmallVectorImpl<std::pair<unsigned, Value *>> &) const;
SmallVectorImpl<std::pair<unsigned, MDNode *>> &) const;
void clearMetadataHashEntries();
public:
//===--------------------------------------------------------------------===//

17
include/llvm/IR/Metadata.h
View File

@ -237,10 +237,10 @@ private:
};
//===----------------------------------------------------------------------===//
/// \brief A tuple of metadata nodes.
/// \brief A tuple of MDNodes.
///
/// 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>;
@ -250,7 +250,7 @@ class NamedMDNode : public ilist_node<NamedMDNode> {
std::string Name;
Module *Parent;
void *Operands; // SmallVector<TrackingVH<Value>, 4>
void *Operands; // SmallVector<TrackingVH<MDNode>, 4>
void setParent(Module *M) { Parent = M; }
@ -305,12 +305,9 @@ public:
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;
void addOperand(Value *M);
void addOperand(MDNode *M);
StringRef getName() const;
void print(raw_ostream &ROS) const;
void dump() const;
@ -318,11 +315,11 @@ public:
// ---------------------------------------------------------------------------
// 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()); }
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()); }

2
lib/Analysis/BranchProbabilityInfo.cpp
View File

@ -180,7 +180,7 @@ bool BranchProbabilityInfo::calcMetadataWeights(BasicBlock *BB) {
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;

6
lib/Analysis/LoopInfo.cpp
View File

@ -235,7 +235,7 @@ bool Loop::isSafeToClone() const {
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.
@ -247,7 +247,7 @@ MDNode *Loop::getLoopID() const {
// 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);
break;
}
}
@ -309,7 +309,7 @@ bool Loop::isAnnotatedParallel() const {
// 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;

2
lib/Analysis/ScalarEvolution.cpp
View File

@ -3668,7 +3668,7 @@ ScalarEvolution::GetMinTrailingZeros(const SCEV *S) {
/// 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);

12
lib/Analysis/ScopedNoAliasAA.cpp
View File

@ -213,12 +213,12 @@ ScopedNoAliasAA::getModRefInfo(ImmutableCallSite CS, const Location &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(
CS.getInstruction()->getMDNode(LLVMContext::MD_alias_scope),
CS.getInstruction()->getMetadata(LLVMContext::MD_alias_scope),
Loc.AATags.NoAlias))
return NoModRef;
@ -231,13 +231,13 @@ ScopedNoAliasAA::getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2) {
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(
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);

22
lib/Analysis/TypeBasedAliasAnalysis.cpp
View File

@ -493,7 +493,7 @@ TypeBasedAliasAnalysis::getModRefBehavior(ImmutableCallSite CS) {
// 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;
@ -514,7 +514,8 @@ TypeBasedAliasAnalysis::getModRefInfo(ImmutableCallSite CS,
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;
@ -527,9 +528,10 @@ TypeBasedAliasAnalysis::getModRefInfo(ImmutableCallSite CS1,
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))
if (const MDNode *M2 =
CS2.getInstruction()->getMDNode(LLVMContext::MD_tbaa))
CS2.getInstruction()->getMetadata(LLVMContext::MD_tbaa))
if (!Aliases(M1, M2))
return NoModRef;
@ -613,20 +615,20 @@ MDNode *MDNode::getMostGenericTBAA(MDNode *A, MDNode *B) {
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));
else
N.TBAA = getMDNode(LLVMContext::MD_tbaa);
N.TBAA = getMetadata(LLVMContext::MD_tbaa);
if (Merge)
N.Scope =
MDNode::intersect(N.Scope, getMDNode(LLVMContext::MD_alias_scope));
MDNode::intersect(N.Scope, getMetadata(LLVMContext::MD_alias_scope));
else
N.Scope = getMDNode(LLVMContext::MD_alias_scope);
N.Scope = getMetadata(LLVMContext::MD_alias_scope);
if (Merge)
N.NoAlias =
MDNode::intersect(N.NoAlias, getMDNode(LLVMContext::MD_noalias));
MDNode::intersect(N.NoAlias, getMetadata(LLVMContext::MD_noalias));
else
N.NoAlias = getMDNode(LLVMContext::MD_noalias);
N.NoAlias = getMetadata(LLVMContext::MD_noalias);
}

6
lib/Analysis/ValueTracking.cpp
View File

@ -862,7 +862,7 @@ void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne,
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: {
@ -1258,7 +1258,7 @@ void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne,
}
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
@ -1533,7 +1533,7 @@ bool isKnownNonZero(Value *V, const DataLayout *TD, unsigned Depth,
}
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())) {

2
lib/Bitcode/Writer/BitcodeWriter.cpp
View File

@ -848,7 +848,7 @@ static void WriteMetadataAttachment(const Function &F,
// 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();

8
lib/Bitcode/Writer/ValueEnumerator.cpp
View File

@ -321,7 +321,7 @@ ValueEnumerator::ValueEnumerator(const Module *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) {
@ -347,7 +347,7 @@ ValueEnumerator::ValueEnumerator(const Module *M) {
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;
@ -741,10 +741,10 @@ void ValueEnumerator::incorporateFunction(const Function &F) {
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) {
auto *N = cast<MDNode>(MDs[i].second);
MDNode *N = MDs[i].second;
if (N->isFunctionLocal() && N->getFunction())
FnLocalMDVector.push_back(N);
}

2
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
View File

@ -1399,7 +1399,7 @@ void AsmPrinter::EmitModuleIdents(Module &M) {
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));

8
lib/CodeGen/AsmPrinter/DwarfDebug.cpp
View File

@ -450,8 +450,8 @@ void DwarfDebug::beginModule() {
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)
@ -526,8 +526,8 @@ void DwarfDebug::collectDeadVariables() {
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));

6
lib/CodeGen/SelectionDAG/FastISel.cpp
View File

@ -2122,9 +2122,9 @@ FastISel::createMachineMemOperandFor(const Instruction *I) const {
} else
return nullptr;
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);

10
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
View File

@ -3480,13 +3480,13 @@ void SelectionDAGBuilder::visitLoad(const LoadInst &I) {
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);
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;
@ -3584,7 +3584,7 @@ void SelectionDAGBuilder::visitStore(const StoreInst &I) {
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;
@ -6479,7 +6479,7 @@ void SelectionDAGBuilder::visitInlineAsm(ImmutableCallSite CS) {
// 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

27
lib/IR/AsmWriter.cpp
View File

@ -545,7 +545,7 @@ public:
/// 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
@ -585,7 +585,7 @@ private:
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);
@ -718,7 +718,7 @@ void SlotTracker::processFunction() {
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(),
@ -755,7 +755,7 @@ void SlotTracker::processFunction() {
// 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);
MDForInst.clear();
}
}
@ -786,13 +786,13 @@ int SlotTracker::getGlobalSlot(const GlobalValue *V) {
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
mdn_iterator MI = mdnMap.find(cast<MDNode>(MD));
mdn_iterator MI = mdnMap.find(N);
return MI == mdnMap.end() ? -1 : (int)MI->second;
}
@ -846,10 +846,9 @@ void SlotTracker::CreateFunctionSlot(const Value *V) {
DestSlot << " [o]\n");
}
/// 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.
@ -2316,7 +2315,7 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
}
// 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;
@ -2329,8 +2328,8 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
Out << ", !<unknown kind #" << Kind << ">";
}
Out << ' ';
WriteAsOperandInternal(Out, cast<MDNode>(InstMD[i].second), &TypePrinter,
&Machine, TheModule);
WriteAsOperandInternal(Out, InstMD[i].second, &TypePrinter, &Machine,
TheModule);
}
}
printInfoComment(I);

2
lib/IR/AutoUpgrade.cpp
View File

@ -571,7 +571,7 @@ void llvm::UpgradeCallsToIntrinsic(Function* F) {
}
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)

4
lib/IR/Core.cpp
View File

@ -561,7 +561,7 @@ LLVMValueRef LLVMGetMetadata(LLVMValueRef Inst, unsigned KindID) {
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 ................................................--*/
@ -720,7 +720,7 @@ void LLVMAddNamedMetadataOperand(LLVMModuleRef M, const char* name,
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);
}

8
lib/IR/DebugInfo.cpp
View File

@ -949,7 +949,7 @@ DITypeIdentifierMap
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())
@ -997,7 +997,7 @@ void DebugInfoFinder::processModule(const Module &M) {
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) {
@ -1542,8 +1542,8 @@ llvm::makeSubprogramMap(const Module &M) {
if (!CU_Nodes)
return R;
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));

2
lib/IR/DiagnosticInfo.cpp
View File

@ -96,7 +96,7 @@ DiagnosticInfoInlineAsm::DiagnosticInfoInlineAsm(const Instruction &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();

2
lib/IR/Instruction.cpp
View File

@ -548,7 +548,7 @@ Instruction *Instruction::clone() const {
// 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);

5
lib/IR/Instructions.cpp
View File

@ -791,7 +791,7 @@ void BranchInst::swapSuccessors() {
// 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;
@ -2072,7 +2072,8 @@ void BinaryOperator::andIRFlags(const Value *V) {
/// 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));

46
lib/IR/Metadata.cpp
View File

@ -555,13 +555,13 @@ MDNode *MDNode::getMostGenericRange(MDNode *A, MDNode *B) {
// 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),
Operands(new SmallVector<TrackingVH<Value>, 4>()) {}
Operands(new SmallVector<TrackingVH<MDNode>, 4>()) {}
NamedMDNode::~NamedMDNode() {
dropAllReferences();
@ -572,16 +572,15 @@ unsigned NamedMDNode::getNumOperands() const {
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];
}
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!");
getNMDOps(Operands).push_back(TrackingVH<Value>(M));
getNMDOps(Operands).push_back(TrackingVH<MDNode>(M));
}
void NamedMDNode::eraseFromParent() {
@ -600,23 +599,16 @@ StringRef NamedMDNode::getName() const {
// 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));
}
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());
@ -663,12 +655,10 @@ void Instruction::dropUnknownMetadata(ArrayRef<unsigned> KnownIDs) {
/// 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) {
@ -729,7 +719,7 @@ void Instruction::setAAMetadata(const AAMDNodes &N) {
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());
@ -746,7 +736,7 @@ Value *Instruction::getMetadataImpl(unsigned KindID) const {
}
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.
@ -771,7 +761,7 @@ void Instruction::getAllMetadataImpl(
}
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) &&

3
lib/IR/Module.cpp
View File

@ -276,8 +276,7 @@ getModuleFlagsMetadata(SmallVectorImpl<ModuleFlagEntry> &Flags) const {
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) &&

6
lib/IR/TypeFinder.cpp
View File

@ -40,7 +40,7 @@ void TypeFinder::run(const Module &M, bool onlyNamed) {
}
// 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());
@ -71,7 +71,7 @@ void TypeFinder::run(const Module &M, bool onlyNamed) {
// 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);
MDForInst.clear();
}
@ -81,7 +81,7 @@ void TypeFinder::run(const Module &M, bool onlyNamed) {
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));
}
}

12
lib/IR/Verifier.cpp
View File

@ -555,7 +555,7 @@ void Verifier::visitGlobalAlias(const GlobalAlias &GA) {
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);
if (!MD)
continue;
@ -624,7 +624,7 @@ void Verifier::visitModuleIdents(const Module &M) {
// 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)),
@ -642,7 +642,7 @@ void Verifier::visitModuleFlags(const Module &M) {
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.
@ -2267,7 +2267,7 @@ void Verifier::visitInstruction(Instruction &I) {
}
}
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);
@ -2281,7 +2281,7 @@ void Verifier::visitInstruction(Instruction &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());
@ -2587,7 +2587,7 @@ void DebugInfoVerifier::verifyDebugInfo() {
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);

4
lib/Linker/LinkModules.cpp
View File

@ -1287,7 +1287,7 @@ bool ModuleLinker::linkModuleFlagsMetadata() {
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));
@ -1302,7 +1302,7 @@ bool ModuleLinker::linkModuleFlagsMetadata() {
// 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);

2
lib/Target/NVPTX/NVPTXGenericToNVVM.cpp
View File

@ -371,7 +371,7 @@ void GenericToNVVM::remapNamedMDNode(Module *M, NamedMDNode *N) {
// 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);

4
lib/Target/NVPTX/NVPTXUtilities.cpp
View File

@ -73,7 +73,7 @@ static void cacheAnnotationFromMD(const Module *m, const GlobalValue *gv) {
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
@ -319,7 +319,7 @@ bool llvm::getAlign(const Function &F, 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))) {

3
lib/Target/R600/SITypeRewriter.cpp
View File

@ -87,8 +87,7 @@ void SITypeRewriter::visitLoadInst(LoadInst &I) {
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);

2
lib/Transforms/InstCombine/InstCombineCalls.cpp
View File

@ -117,7 +117,7 @@ Instruction *InstCombiner::SimplifyMemTransfer(MemIntrinsic *MI) {
// 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)) &&

4
lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
View File

@ -304,7 +304,7 @@ Instruction *InstCombiner::visitAllocaInst(AllocaInst &AI) {
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(
@ -312,7 +312,7 @@ static LoadInst *combineLoadToNewType(InstCombiner &IC, LoadInst &LI, Type *NewT
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

4
lib/Transforms/Instrumentation/AddressSanitizer.cpp
View File

@ -256,9 +256,7 @@ class GlobalsMetadata {
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);

2
lib/Transforms/Instrumentation/DebugIR.cpp
View File

@ -474,7 +474,7 @@ bool getSourceInfoFromDI(const Module &M, std::string &Directory,
if (!CUNode || CUNode->getNumOperands() == 0)
return false;
DICompileUnit CU(cast<MDNode>(CUNode->getOperand(0)));
DICompileUnit CU(CUNode->getOperand(0));
if (!CU.Verify())
return false;

8
lib/Transforms/Instrumentation/GCOVProfiling.cpp
View File

@ -417,7 +417,7 @@ namespace {
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));
@ -479,7 +479,7 @@ void GCOVProfiler::emitProfileNotes() {
// 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;
@ -566,7 +566,7 @@ bool GCOVProfiler::emitProfileArcs() {
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) {
@ -847,7 +847,7 @@ Function *GCOVProfiler::insertCounterWriteout(
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,

2
lib/Transforms/Instrumentation/ThreadSanitizer.cpp
View File

@ -231,7 +231,7 @@ bool ThreadSanitizer::doInitialization(Module &M) {
}
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;
}

2
lib/Transforms/ObjCARC/ObjCARCContract.cpp
View File

@ -305,7 +305,7 @@ bool ObjCARCContract::doInitialization(Module &M) {
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;

6
lib/Transforms/ObjCARC/ObjCARCOpts.cpp
View File

@ -825,7 +825,7 @@ static MDString *AppendMDNodeToSourcePtr(unsigned NodeId,
// 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.
@ -1736,7 +1736,7 @@ ObjCARCOpt::VisitInstructionBottomUp(Instruction *Inst,
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);
@ -2017,7 +2017,7 @@ ObjCARCOpt::VisitInstructionTopDown(Instruction *Inst,
Sequence OldSeq = S.GetSeq();
MDNode *ReleaseMetadata = Inst->getMDNode(ImpreciseReleaseMDKind);
MDNode *ReleaseMetadata = Inst->getMetadata(ImpreciseReleaseMDKind);
switch (OldSeq) {
case S_Retain:

7
lib/Transforms/Scalar/Scalarizer.cpp
View File

@ -327,11 +327,14 @@ bool Scalarizer::canTransferMetadata(unsigned Tag) {
// 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])) {
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());

21
lib/Transforms/Utils/InlineFunction.cpp
View File

@ -297,9 +297,9 @@ static void CloneAliasScopeMetadata(CallSite CS, ValueToValueMapTy &VMap) {
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))
MD.insert(M);
if (const MDNode *M = J->getMDNode(LLVMContext::MD_noalias))
if (const MDNode *M = J->getMetadata(LLVMContext::MD_noalias))
MD.insert(M);
}
@ -359,31 +359,32 @@ static void CloneAliasScopeMetadata(CallSite CS, ValueToValueMapTy &VMap) {
if (!NI)
continue;
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 =
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 =
CS.getInstruction()->getMDNode(LLVMContext::MD_alias_scope))
CS.getInstruction()->getMetadata(LLVMContext::MD_alias_scope))
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.
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()) {
if (MDNode *M = CS.getInstruction()->getMDNode(LLVMContext::MD_noalias))
if (MDNode *M = CS.getInstruction()->getMetadata(LLVMContext::MD_noalias))
NI->setMetadata(LLVMContext::MD_noalias, M);
}
}
@ -589,7 +590,7 @@ static void AddAliasScopeMetadata(CallSite CS, ValueToValueMapTy &VMap,
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.
@ -615,7 +616,7 @@ static void AddAliasScopeMetadata(CallSite CS, ValueToValueMapTy &VMap,
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)));
}
}

10
lib/Transforms/Utils/Local.cpp
View File

@ -128,7 +128,7 @@ bool llvm::ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions,
// 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.
@ -206,7 +206,7 @@ bool llvm::ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions,
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));
@ -1308,13 +1308,13 @@ bool llvm::removeUnreachableBlocks(Function &F) {
}
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;
MDNode *JMD = J->getMDNode(Kind);
MDNode *KMD = cast<MDNode>(Metadata[i].second);
MDNode *JMD = J->getMetadata(Kind);
MDNode *KMD = Metadata[i].second;
switch (Kind) {
default:

8
lib/Transforms/Utils/SimplifyCFG.cpp
View File

@ -643,7 +643,7 @@ SimplifyEqualityComparisonWithOnlyPredecessor(TerminatorInst *TI,
// 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;
@ -738,7 +738,7 @@ static int ConstantIntSortPredicate(ConstantInt *const *P1,
}
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");
@ -751,7 +751,7 @@ static inline bool HasBranchWeights(const Instruction* I) {
/// 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));
@ -1970,7 +1970,7 @@ static bool ExtractBranchMetadata(BranchInst *BI,
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));

11
lib/Transforms/Utils/ValueMapper.cpp
View File

@ -208,11 +208,14 @@ void llvm::RemapInstruction(Instruction *I, ValueToValueMapTy &VMap,
}
// Remap attached metadata.
SmallVector<std::pair<unsigned, Value *>, 4> MDs;
SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
I->getAllMetadata(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);
}

2
lib/Transforms/Vectorize/LoopVectorize.cpp
View File

@ -531,7 +531,7 @@ static std::string getDebugLocString(const Loop *L) {
/// \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) {

6
lib/Transforms/Vectorize/SLPVectorizer.cpp
View File

@ -188,16 +188,16 @@ static void propagateIRFlags(Value *I, ArrayRef<Value *> VL) {
/// \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;
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]);
MDNode *IMD = I->getMDNode(Kind);
MDNode *IMD = I->getMetadata(Kind);
switch (Kind) {
default:

2
tools/opt/BreakpointPrinter.cpp
View File

@ -55,7 +55,7 @@ struct BreakpointPrinter : public ModulePass {
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)