RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-01-31 20:51:52 +01:00
Code Issues Projects Releases Wiki Activity

Make NamedMDNode not be a subclass of Value, and simplify the interface

Browse Source 
for creating and populating NamedMDNodes.

llvm-svn: 109061
This commit is contained in:
Dan Gohman 2010-07-21 23:38:33 +00:00
parent c8342b43c4
commit 859ffd353e
19 changed files with 97 additions and 273 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
include/llvm/Metadata.h
View File

@ -177,10 +177,11 @@ private:
//===----------------------------------------------------------------------===//
/// NamedMDNode - a tuple of MDNodes.
/// NamedMDNode is always named. All NamedMDNode operand has a type of metadata.
class NamedMDNode : public Value, public ilist_node<NamedMDNode> {
class NamedMDNode : public ilist_node<NamedMDNode> {
friend class SymbolTableListTraits<NamedMDNode, Module>;
friend struct ilist_traits<NamedMDNode>;
friend class LLVMContextImpl;
friend class Module;
NamedMDNode(const NamedMDNode &); // DO NOT IMPLEMENT
std::string Name;
@ -188,18 +189,11 @@ class NamedMDNode : public Value, public ilist_node<NamedMDNode> {
void *Operands; // SmallVector<TrackingVH<MDNode>, 4>
void setParent(Module *M) { Parent = M; }
protected:
explicit NamedMDNode(LLVMContext &C, const Twine &N, MDNode*const *Vals,
unsigned NumVals, Module *M = 0);
explicit NamedMDNode(const Twine &N);
public:
static NamedMDNode *Create(LLVMContext &C, const Twine &N,
MDNode *const *MDs,
unsigned NumMDs, Module *M = 0) {
return new NamedMDNode(C, N, MDs, NumMDs, M);
}
static NamedMDNode *Create(const NamedMDNode *NMD, Module *M = 0);
/// eraseFromParent - Drop all references and remove the node from parent
/// module.
void eraseFromParent();
@ -223,17 +217,11 @@ public:
/// addOperand - Add metadata operand.
void addOperand(MDNode *M);
/// setName - Set the name of this named metadata.
void setName(const Twine &NewName);
/// getName - Return a constant reference to this named metadata's name.
StringRef getName() const;
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const NamedMDNode *) { return true; }
static bool classof(const Value *V) {
return V->getValueID() == NamedMDNodeVal;
}
/// print - Implement operator<< on NamedMDNode.
void print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW = 0) const;
};
} // end llvm namespace

26
include/llvm/Module.h
View File

@ -28,7 +28,6 @@ namespace llvm {
class FunctionType;
class GVMaterializer;
class LLVMContext;
class MDSymbolTable;
template<> struct ilist_traits<Function>
: public SymbolTableListTraits<Function, Module> {
@ -61,7 +60,7 @@ template<> struct ilist_traits<GlobalAlias>
};
template<> struct ilist_traits<NamedMDNode>
: public SymbolTableListTraits<NamedMDNode, Module> {
: public ilist_default_traits<NamedMDNode> {
// createSentinel is used to get hold of a node that marks the end of
// the list...
NamedMDNode *createSentinel() const {
@ -72,8 +71,8 @@ template<> struct ilist_traits<NamedMDNode>
NamedMDNode *provideInitialHead() const { return createSentinel(); }
NamedMDNode *ensureHead(NamedMDNode*) const { return createSentinel(); }
static void noteHead(NamedMDNode*, NamedMDNode*) {}
void addNodeToList(NamedMDNode *N);
void removeNodeFromList(NamedMDNode *N);
void addNodeToList(NamedMDNode *N) {}
void removeNodeFromList(NamedMDNode *N) {}
private:
mutable ilist_node<NamedMDNode> Sentinel;
};
@ -100,7 +99,7 @@ public:
/// The type for the list of aliases.
typedef iplist<GlobalAlias> AliasListType;
/// The type for the list of named metadata.
typedef iplist<NamedMDNode> NamedMDListType;
typedef ilist<NamedMDNode> NamedMDListType;
/// The type for the list of dependent libraries.
typedef std::vector<std::string> LibraryListType;
@ -151,7 +150,7 @@ private:
std::string ModuleID; ///< Human readable identifier for the module
std::string TargetTriple; ///< Platform target triple Module compiled on
std::string DataLayout; ///< Target data description
MDSymbolTable *NamedMDSymTab; ///< NamedMDNode names.
void *NamedMDSymTab; ///< NamedMDNode names.
friend class Constant;
@ -331,6 +330,10 @@ public:
/// NamedMDNode with the specified name is not found.
NamedMDNode *getOrInsertNamedMetadata(StringRef Name);
/// eraseNamedMetadata - Remove the given NamedMDNode from this module
/// and delete it.
void eraseNamedMetadata(NamedMDNode *NMD);
/// @}
/// @name Type Accessors
/// @{
@ -417,13 +420,6 @@ public:
static iplist<GlobalAlias> Module::*getSublistAccess(GlobalAlias*) {
return &Module::AliasList;
}
/// Get the Module's list of named metadata (constant).
const NamedMDListType &getNamedMDList() const { return NamedMDList; }
/// Get the Module's list of named metadata.
NamedMDListType &getNamedMDList() { return NamedMDList; }
static iplist<NamedMDNode> Module::*getSublistAccess(NamedMDNode *) {
return &Module::NamedMDList;
}
/// Get the symbol table of global variable and function identifiers
const ValueSymbolTable &getValueSymbolTable() const { return *ValSymTab; }
/// Get the Module's symbol table of global variable and function identifiers.
@ -432,10 +428,6 @@ public:
const TypeSymbolTable &getTypeSymbolTable() const { return *TypeSymTab; }
/// Get the Module's symbol table of types
TypeSymbolTable &getTypeSymbolTable() { return *TypeSymTab; }
/// Get the symbol table of named metadata
const MDSymbolTable &getMDSymbolTable() const { return *NamedMDSymTab; }
/// Get the Module's symbol table of named metadata
MDSymbolTable &getMDSymbolTable() { return *NamedMDSymTab; }
/// @}
/// @name Global Variable Iteration

1
include/llvm/Value.h
View File

@ -220,7 +220,6 @@ public:
ConstantPointerNullVal, // This is an instance of ConstantPointerNull
MDNodeVal, // This is an instance of MDNode
MDStringVal, // This is an instance of MDString
NamedMDNodeVal, // This is an instance of NamedMDNode
InlineAsmVal, // This is an instance of InlineAsm
PseudoSourceValueVal, // This is an instance of PseudoSourceValue
FixedStackPseudoSourceValueVal, // This is an instance of

88
include/llvm/ValueSymbolTable.h
View File

@ -128,94 +128,6 @@ private:
/// @}
};
/// This class provides a symbol table of name/NamedMDNode pairs. It is
/// essentially a StringMap wrapper.
class MDSymbolTable {
friend class SymbolTableListTraits<NamedMDNode, Module>;
/// @name Types
/// @{
private:
/// @brief A mapping of names to metadata
typedef StringMap<NamedMDNode*> MDMap;
public:
/// @brief An iterator over a ValueMap.
typedef MDMap::iterator iterator;
/// @brief A const_iterator over a ValueMap.
typedef MDMap::const_iterator const_iterator;
/// @}
/// @name Constructors
/// @{
public:
MDSymbolTable(const MDNode &); // DO NOT IMPLEMENT
void operator=(const MDSymbolTable &); // DO NOT IMPLEMENT
MDSymbolTable() : mmap(0) {}
~MDSymbolTable();
/// @}
/// @name Accessors
/// @{
public:
/// This method finds the value with the given \p Name in the
/// the symbol table.
/// @returns the NamedMDNode associated with the \p Name
/// @brief Lookup a named Value.
NamedMDNode *lookup(StringRef Name) const { return mmap.lookup(Name); }
/// @returns true iff the symbol table is empty
/// @brief Determine if the symbol table is empty
inline bool empty() const { return mmap.empty(); }
/// @brief The number of name/type pairs is returned.
inline unsigned size() const { return unsigned(mmap.size()); }
/// @}
/// @name Iteration
/// @{
public:
/// @brief Get an iterator that from the beginning of the symbol table.
inline iterator begin() { return mmap.begin(); }
/// @brief Get a const_iterator that from the beginning of the symbol table.
inline const_iterator begin() const { return mmap.begin(); }
/// @brief Get an iterator to the end of the symbol table.
inline iterator end() { return mmap.end(); }
/// @brief Get a const_iterator to the end of the symbol table.
inline const_iterator end() const { return mmap.end(); }
/// @}
/// @name Mutators
/// @{
public:
/// insert - The method inserts a new entry into the stringmap. This will
/// replace existing entry, if any.
void insert(StringRef Name, NamedMDNode *Node) {
StringMapEntry<NamedMDNode *> &Entry =
mmap.GetOrCreateValue(Name, Node);
if (Entry.getValue() != Node) {
mmap.remove(&Entry);
(void) mmap.GetOrCreateValue(Name, Node);
}
}
/// This method removes a NamedMDNode from the symbol table.
void remove(StringRef Name) { mmap.erase(Name); }
/// @}
/// @name Internal Data
/// @{
private:
MDMap mmap; ///< The map that holds the symbol table.
/// @}
};
} // End llvm namespace
#endif

10
lib/Analysis/DebugInfo.cpp
View File

@ -13,7 +13,6 @@
//===----------------------------------------------------------------------===//
#include "llvm/Analysis/DebugInfo.h"
#include "llvm/Target/TargetMachine.h" // FIXME: LAYERING VIOLATION!
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Intrinsics.h"
@ -22,6 +21,7 @@
#include "llvm/Module.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/Dwarf.h"
#include "llvm/Support/raw_ostream.h"
@ -1072,10 +1072,10 @@ DIVariable DIFactory::CreateVariable(unsigned Tag, DIDescriptor Context,
char One = '\1';
if (FName.startswith(StringRef(&One, 1)))
FName = FName.substr(1);
NamedMDNode *FnLocals = M.getNamedMetadata(Twine("llvm.dbg.lv.", FName));
if (!FnLocals)
FnLocals = NamedMDNode::Create(VMContext, Twine("llvm.dbg.lv.", FName),
NULL, 0, &M);
SmallString<32> Out;
NamedMDNode *FnLocals =
M.getOrInsertNamedMetadata(Twine("llvm.dbg.lv.", FName).toStringRef(Out));
FnLocals->addOperand(Node);
}
return DIVariable(Node);

5
lib/AsmParser/LLParser.cpp
View File

@ -543,7 +543,7 @@ bool LLParser::ParseNamedMetadata() {
ParseToken(lltok::lbrace, "Expected '{' here"))
return true;
SmallVector<MDNode *, 8> Elts;
NamedMDNode *NMD = M->getOrInsertNamedMetadata(Name);
if (Lex.getKind() != lltok::rbrace)
do {
if (ParseToken(lltok::exclaim, "Expected '!' here"))
@ -551,13 +551,12 @@ bool LLParser::ParseNamedMetadata() {
MDNode *N = 0;
if (ParseMDNodeID(N)) return true;
Elts.push_back(N);
NMD->addOperand(N);
} while (EatIfPresent(lltok::comma));
if (ParseToken(lltok::rbrace, "expected end of metadata node"))
return true;
NamedMDNode::Create(Context, Name, Elts.data(), Elts.size(), M);
return false;
}

7
lib/Bitcode/Reader/BitcodeReader.cpp
View File

@ -801,16 +801,13 @@ bool BitcodeReader::ParseMetadata() {
// Read named metadata elements.
unsigned Size = Record.size();
SmallVector<MDNode *, 8> Elts;
NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name);
for (unsigned i = 0; i != Size; ++i) {
MDNode *MD = dyn_cast<MDNode>(MDValueList.getValueFwdRef(Record[i]));
if (MD == 0)
return Error("Malformed metadata record");
Elts.push_back(MD);
NMD->addOperand(MD);
}
Value *V = NamedMDNode::Create(Context, Name.str(), Elts.data(),
Elts.size(), TheModule);
MDValueList.AssignValue(V, NextMDValueNo++);
break;
}
case bitc::METADATA_FN_NODE:

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

@ -509,7 +509,8 @@ static void WriteMDNode(const MDNode *N,
Record.clear();
}
static void WriteModuleMetadata(const ValueEnumerator &VE,
static void WriteModuleMetadata(const Module *M,
const ValueEnumerator &VE,
BitstreamWriter &Stream) {
const ValueEnumerator::ValueList &Vals = VE.getMDValues();
bool StartedMetadataBlock = false;
@ -544,27 +545,32 @@ static void WriteModuleMetadata(const ValueEnumerator &VE,
// Emit the finished record.
Stream.EmitRecord(bitc::METADATA_STRING, Record, MDSAbbrev);
Record.clear();
} else if (const NamedMDNode *NMD = dyn_cast<NamedMDNode>(Vals[i].first)) {
if (!StartedMetadataBlock) {
Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
StartedMetadataBlock = true;
}
// Write name.
StringRef Str = NMD->getName();
for (unsigned i = 0, e = Str.size(); i != e; ++i)
Record.push_back(Str[i]);
Stream.EmitRecord(bitc::METADATA_NAME, Record, 0/*TODO*/);
Record.clear();
// Write named metadata operands.
for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
Record.push_back(VE.getValueID(NMD->getOperand(i)));
Stream.EmitRecord(bitc::METADATA_NAMED_NODE, Record, 0);
Record.clear();
}
}
// Write named metadata.
for (Module::const_named_metadata_iterator I = M->named_metadata_begin(),
E = M->named_metadata_end(); I != E; ++I) {
const NamedMDNode *NMD = I;
if (!StartedMetadataBlock) {
Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
StartedMetadataBlock = true;
}
// Write name.
StringRef Str = NMD->getName();
for (unsigned i = 0, e = Str.size(); i != e; ++i)
Record.push_back(Str[i]);
Stream.EmitRecord(bitc::METADATA_NAME, Record, 0/*TODO*/);
Record.clear();
// Write named metadata operands.
for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
Record.push_back(VE.getValueID(NMD->getOperand(i)));
Stream.EmitRecord(bitc::METADATA_NAMED_NODE, Record, 0);
Record.clear();
}
if (StartedMetadataBlock)
Stream.ExitBlock();
}
@ -1530,7 +1536,7 @@ static void WriteModule(const Module *M, BitstreamWriter &Stream) {
WriteModuleConstants(VE, Stream);
// Emit metadata.
WriteModuleMetadata(VE, Stream);
WriteModuleMetadata(M, VE, Stream);
// Emit function bodies.
for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)

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

@ -75,7 +75,7 @@ ValueEnumerator::ValueEnumerator(const Module *M) {
// Insert constants and metadata that are named at module level into the slot
// pool so that the module symbol table can refer to them...
EnumerateValueSymbolTable(M->getValueSymbolTable());
EnumerateMDSymbolTable(M->getMDSymbolTable());
EnumerateNamedMetadata(M);
SmallVector<std::pair<unsigned, MDNode*>, 8> MDs;
@ -207,31 +207,18 @@ void ValueEnumerator::EnumerateValueSymbolTable(const ValueSymbolTable &VST) {
EnumerateValue(VI->getValue());
}
/// EnumerateMDSymbolTable - Insert all of the values in the specified metadata
/// table.
void ValueEnumerator::EnumerateMDSymbolTable(const MDSymbolTable &MST) {
for (MDSymbolTable::const_iterator MI = MST.begin(), ME = MST.end();
MI != ME; ++MI)
EnumerateValue(MI->getValue());
/// EnumerateNamedMetadata - Insert all of the values referenced by
/// named metadata in the specified module.
void ValueEnumerator::EnumerateNamedMetadata(const Module *M) {
for (Module::const_named_metadata_iterator I = M->named_metadata_begin(),
E = M->named_metadata_end(); I != E; ++I)
EnumerateNamedMDNode(I);
}
void ValueEnumerator::EnumerateNamedMDNode(const NamedMDNode *MD) {
// Check to see if it's already in!
unsigned &MDValueID = MDValueMap[MD];
if (MDValueID) {
// Increment use count.
MDValues[MDValueID-1].second++;
return;
}
// Enumerate the type of this value.
EnumerateType(MD->getType());
for (unsigned i = 0, e = MD->getNumOperands(); i != e; ++i)
if (MDNode *E = MD->getOperand(i))
EnumerateValue(E);
MDValues.push_back(std::make_pair(MD, 1U));
MDValueMap[MD] = Values.size();
}
void ValueEnumerator::EnumerateMetadata(const Value *MD) {
@ -272,8 +259,6 @@ void ValueEnumerator::EnumerateValue(const Value *V) {
assert(!V->getType()->isVoidTy() && "Can't insert void values!");
if (isa<MDNode>(V) || isa<MDString>(V))
return EnumerateMetadata(V);
else if (const NamedMDNode *NMD = dyn_cast<NamedMDNode>(V))
return EnumerateNamedMDNode(NMD);
// Check to see if it's already in!
unsigned &ValueID = ValueMap[V];

2
lib/Bitcode/Writer/ValueEnumerator.h
View File

@ -141,7 +141,7 @@ private:
void EnumerateTypeSymbolTable(const TypeSymbolTable &ST);
void EnumerateValueSymbolTable(const ValueSymbolTable &ST);
void EnumerateMDSymbolTable(const MDSymbolTable &ST);
void EnumerateNamedMetadata(const Module *M);
};
} // End llvm namespace

12
lib/Linker/LinkModules.cpp
View File

@ -545,14 +545,10 @@ static void LinkNamedMDNodes(Module *Dest, Module *Src) {
for (Module::const_named_metadata_iterator I = Src->named_metadata_begin(),
E = Src->named_metadata_end(); I != E; ++I) {
const NamedMDNode *SrcNMD = I;
NamedMDNode *DestNMD = Dest->getNamedMetadata(SrcNMD->getName());
if (!DestNMD)
NamedMDNode::Create(SrcNMD, Dest);
else {
// Add Src elements into Dest node.
for (unsigned i = 0, e = SrcNMD->getNumOperands(); i != e; ++i)
DestNMD->addOperand(SrcNMD->getOperand(i));
}
NamedMDNode *DestNMD = Dest->getOrInsertNamedMetadata(SrcNMD->getName());
// Add Src elements into Dest node.
for (unsigned i = 0, e = SrcNMD->getNumOperands(); i != e; ++i)
DestNMD->addOperand(SrcNMD->getOperand(i));
}
}

6
lib/Transforms/Utils/CloneModule.cpp
View File

@ -127,11 +127,9 @@ Module *llvm::CloneModule(const Module *M,
for (Module::const_named_metadata_iterator I = M->named_metadata_begin(),
E = M->named_metadata_end(); I != E; ++I) {
const NamedMDNode &NMD = *I;
SmallVector<MDNode*, 4> MDs;
NamedMDNode *NewNMD = New->getOrInsertNamedMetadata(NMD.getName());
for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i)
MDs.push_back(cast<MDNode>(MapValue(NMD.getOperand(i), VMap)));
NamedMDNode::Create(New->getContext(), NMD.getName(),
MDs.data(), MDs.size(), New);
NewNMD->addOperand(cast<MDNode>(MapValue(NMD.getOperand(i), VMap)));
}
// Update metadata attach with instructions.

13
lib/VMCore/AsmWriter.cpp
View File

@ -63,8 +63,6 @@ static const Module *getModuleFromVal(const Value *V) {
if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
return GV->getParent();
if (const NamedMDNode *NMD = dyn_cast<NamedMDNode>(V))
return NMD->getParent();
return 0;
}
@ -2111,6 +2109,13 @@ void Module::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW) const {
W.printModule(this);
}
void NamedMDNode::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW) const {
SlotTracker SlotTable(getParent());
formatted_raw_ostream OS(ROS);
AssemblyWriter W(OS, SlotTable, getParent(), AAW);
W.printNamedMDNode(this);
}
void Type::print(raw_ostream &OS) const {
if (this == 0) {
OS << "<null Type>";
@ -2148,10 +2153,6 @@ void Value::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW) const {
SlotTracker SlotTable(F);
AssemblyWriter W(OS, SlotTable, F ? F->getParent() : 0, AAW);
W.printMDNodeBody(N);
} else if (const NamedMDNode *N = dyn_cast<NamedMDNode>(this)) {
SlotTracker SlotTable(N->getParent());
AssemblyWriter W(OS, SlotTable, N->getParent(), AAW);
W.printNamedMDNode(N);
} else if (const Constant *C = dyn_cast<Constant>(this)) {
TypePrinting TypePrinter;
TypePrinter.print(C->getType(), OS);

61
lib/VMCore/Metadata.cpp
View File

@ -330,50 +330,13 @@ void MDNode::replaceOperand(MDNodeOperand *Op, Value *To) {
// NamedMDNode implementation.
//
// SymbolTableListTraits specialization for MDSymbolTable.
void ilist_traits<NamedMDNode>::addNodeToList(NamedMDNode *N) {
assert(N->getParent() == 0 && "Value already in a container!!");
Module *Owner = getListOwner();
N->setParent(Owner);
MDSymbolTable &ST = Owner->getMDSymbolTable();
ST.insert(N->getName(), N);
}
void ilist_traits<NamedMDNode>::removeNodeFromList(NamedMDNode *N) {
N->setParent(0);
Module *Owner = getListOwner();
MDSymbolTable &ST = Owner->getMDSymbolTable();
ST.remove(N->getName());
}
static SmallVector<TrackingVH<MDNode>, 4> &getNMDOps(void *Operands) {
return *(SmallVector<TrackingVH<MDNode>, 4>*)Operands;
}
NamedMDNode::NamedMDNode(LLVMContext &C, const Twine &N,
MDNode *const *MDs,
unsigned NumMDs, Module *ParentModule)
: Value(Type::getMetadataTy(C), Value::NamedMDNodeVal), Parent(0) {
setName(N);
Operands = new SmallVector<TrackingVH<MDNode>, 4>();
SmallVector<TrackingVH<MDNode>, 4> &Node = getNMDOps(Operands);
for (unsigned i = 0; i != NumMDs; ++i)
Node.push_back(TrackingVH<MDNode>(MDs[i]));
if (ParentModule)
ParentModule->getNamedMDList().push_back(this);
}
NamedMDNode *NamedMDNode::Create(const NamedMDNode *NMD, Module *M) {
assert(NMD && "Invalid source NamedMDNode!");
SmallVector<MDNode *, 4> Elems;
Elems.reserve(NMD->getNumOperands());
for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
Elems.push_back(NMD->getOperand(i));
return new NamedMDNode(NMD->getContext(), NMD->getName().data(),
Elems.data(), Elems.size(), M);
NamedMDNode::NamedMDNode(const Twine &N)
: Name(N.str()), Parent(0),
Operands(new SmallVector<TrackingVH<MDNode>, 4>()) {
}
NamedMDNode::~NamedMDNode() {
@ -400,7 +363,7 @@ void NamedMDNode::addOperand(MDNode *M) {
/// eraseFromParent - Drop all references and remove the node from parent
/// module.
void NamedMDNode::eraseFromParent() {
getParent()->getNamedMDList().erase(this);
getParent()->eraseNamedMetadata(this);
}
/// dropAllReferences - Remove all uses and clear node vector.
@ -408,22 +371,6 @@ void NamedMDNode::dropAllReferences() {
getNMDOps(Operands).clear();
}
/// setName - Set the name of this named metadata.
void NamedMDNode::setName(const Twine &NewName) {
assert (!NewName.isTriviallyEmpty() && "Invalid named metadata name!");
SmallString<256> NameData;
StringRef NameRef = NewName.toStringRef(NameData);
// Name isn't changing?
if (getName() == NameRef)
return;
Name = NameRef.str();
if (Parent)
Parent->getMDSymbolTable().insert(NameRef, this);
}
/// getName - Return a constant reference to this named metadata's name.
StringRef NamedMDNode::getName() const {
return StringRef(Name);

21
lib/VMCore/Module.cpp
View File

@ -61,7 +61,7 @@ Module::Module(StringRef MID, LLVMContext& C)
: Context(C), Materializer(NULL), ModuleID(MID), DataLayout("") {
ValSymTab = new ValueSymbolTable();
TypeSymTab = new TypeSymbolTable();
NamedMDSymTab = new MDSymbolTable();
NamedMDSymTab = new StringMap<NamedMDNode *>();
}
Module::~Module() {
@ -73,7 +73,7 @@ Module::~Module() {
NamedMDList.clear();
delete ValSymTab;
delete TypeSymTab;
delete NamedMDSymTab;
delete static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab);
}
/// Target endian information...
@ -316,19 +316,28 @@ GlobalAlias *Module::getNamedAlias(StringRef Name) const {
NamedMDNode *Module::getNamedMetadata(const Twine &Name) const {
SmallString<256> NameData;
StringRef NameRef = Name.toStringRef(NameData);
return NamedMDSymTab->lookup(NameRef);
return static_cast<StringMap<NamedMDNode*> *>(NamedMDSymTab)->lookup(NameRef);
}
/// getOrInsertNamedMetadata - Return the first named MDNode in the module
/// with the specified name. This method returns a new NamedMDNode if a
/// NamedMDNode with the specified name is not found.
NamedMDNode *Module::getOrInsertNamedMetadata(StringRef Name) {
NamedMDNode *NMD = NamedMDSymTab->lookup(Name);
if (!NMD)
NMD = NamedMDNode::Create(getContext(), Name, NULL, 0, this);
NamedMDNode *&NMD =
(*static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab))[Name];
if (!NMD) {
NMD = new NamedMDNode(Name);
NMD->setParent(this);
NamedMDList.push_back(NMD);
}
return NMD;
}
void Module::eraseNamedMetadata(NamedMDNode *NMD) {
static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab)->erase(NMD->getName());
NamedMDList.erase(NMD);
}
//===----------------------------------------------------------------------===//
// Methods for easy access to the types in the module.
//

4
lib/VMCore/Value.cpp
View File

@ -139,10 +139,6 @@ static bool getSymTab(Value *V, ValueSymbolTable *&ST) {
} else if (Argument *A = dyn_cast<Argument>(V)) {
if (Function *P = A->getParent())
ST = &P->getValueSymbolTable();
} else if (NamedMDNode *N = dyn_cast<NamedMDNode>(V)) {
if (Module *P = N->getParent()) {
ST = &P->getValueSymbolTable();
}
} else if (isa<MDString>(V))
return true;
else {

2
lib/VMCore/ValueSymbolTable.cpp
View File

@ -115,5 +115,3 @@ void ValueSymbolTable::dump() const {
//DEBUG(dbgs() << "\n");
}
}
MDSymbolTable::~MDSymbolTable() { }

4
lib/VMCore/Verifier.cpp
View File

@ -504,8 +504,8 @@ void Verifier::visitNamedMDNode(NamedMDNode &NMD) {
if (!MD)
continue;
Assert2(!MD->isFunctionLocal(),
"Named metadata operand cannot be function local!", &NMD, MD);
Assert1(!MD->isFunctionLocal(),
"Named metadata operand cannot be function local!", MD);
visitMDNode(*MD, 0);
}
}

7
unittests/VMCore/MetadataTest.cpp
View File

@ -130,11 +130,12 @@ TEST(NamedMDNodeTest, Search) {
MDNode *n = MDNode::get(Context, &V, 1);
MDNode *n2 = MDNode::get(Context, &V2, 1);
MDNode *Nodes[2] = { n, n2 };
Module M("MyModule", Context);
const char *Name = "llvm.NMD1";
NamedMDNode *NMD = NamedMDNode::Create(Context, Name, &Nodes[0], 2, &M);
NamedMDNode *NMD = M.getOrInsertNamedMetadata(Name);
NMD->addOperand(n);
NMD->addOperand(n2);
std::string Str;
raw_string_ostream oss(Str);
NMD->print(oss);