X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FMetadata.h;h=fd8ea0c13b2c0044d1ce5a1b49a2a7753e548fdd;hb=cd0129f5a6f0485ecac525c17a3c5dff0a19ca5f;hp=b38336b98b0157a47b5eb59d756a608fc183cda6;hpb=e4b275610a7a05b7ee4c0378a906a6330e4c4ab0;p=oota-llvm.git diff --git a/include/llvm/Metadata.h b/include/llvm/Metadata.h index b38336b98b0..fd8ea0c13b2 100644 --- a/include/llvm/Metadata.h +++ b/include/llvm/Metadata.h @@ -13,43 +13,31 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_MDNODE_H -#define LLVM_MDNODE_H +#ifndef LLVM_METADATA_H +#define LLVM_METADATA_H -#include "llvm/User.h" +#include "llvm/Value.h" #include "llvm/Type.h" -#include "llvm/OperandTraits.h" +#include "llvm/ADT/FoldingSet.h" +#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/ilist_node.h" -#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ValueHandle.h" namespace llvm { class Constant; +class Instruction; class LLVMContext; -template -struct ConstantCreator; +class MetadataContextImpl; //===----------------------------------------------------------------------===// // MetadataBase - A base class for MDNode, MDString and NamedMDNode. -class MetadataBase : public User { -private: - /// ReservedSpace - The number of operands actually allocated. NumOperands is - /// the number actually in use. - unsigned ReservedSpace; - +class MetadataBase : public Value { protected: MetadataBase(const Type *Ty, unsigned scid) - : User(Ty, scid, NULL, 0), ReservedSpace(0) {} + : Value(Ty, scid) {} - void resizeOperands(unsigned NumOps); public: - /// isNullValue - Return true if this is the value that would be returned by - /// getNullValue. This always returns false because getNullValue will never - /// produce metadata. - virtual bool isNullValue() const { - return false; - } /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const MetadataBase *) { return true; } @@ -65,32 +53,29 @@ public: /// MDString is always unnamd. class MDString : public MetadataBase { MDString(const MDString &); // DO NOT IMPLEMENT - void *operator new(size_t, unsigned); // DO NOT IMPLEMENT - unsigned getNumOperands(); // DO NOT IMPLEMENT StringRef Str; protected: - explicit MDString(LLVMContext &C, const char *begin, unsigned l) - : MetadataBase(Type::getMetadataTy(C), Value::MDStringVal), Str(begin, l) {} + explicit MDString(LLVMContext &C, StringRef S) + : MetadataBase(Type::getMetadataTy(C), Value::MDStringVal), Str(S) {} public: - // Do not allocate any space for operands. - void *operator new(size_t s) { - return User::operator new(s, 0); - } - static MDString *get(LLVMContext &Context, const StringRef &Str); + static MDString *get(LLVMContext &Context, StringRef Str); + static MDString *get(LLVMContext &Context, const char *Str); StringRef getString() const { return Str; } - unsigned length() const { return Str.size(); } + unsigned getLength() const { return (unsigned)Str.size(); } + typedef StringRef::iterator iterator; + /// begin() - Pointer to the first byte of the string. /// - const char *begin() const { return Str.begin(); } + iterator begin() const { return Str.begin(); } /// end() - Pointer to one byte past the end of the string. /// - const char *end() const { return Str.end(); } + iterator end() const { return Str.end(); } /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const MDString *) { return true; } @@ -103,62 +88,70 @@ public: /// MDNode - a tuple of other values. /// These contain a list of the values that represent the metadata. /// MDNode is always unnamed. -class MDNode : public MetadataBase { +class MDNode : public MetadataBase, public FoldingSetNode { MDNode(const MDNode &); // DO NOT IMPLEMENT - void *operator new(size_t, unsigned); // DO NOT IMPLEMENT - // getNumOperands - Make this only available for private uses. - unsigned getNumOperands() { return User::getNumOperands(); } - SmallVector Node; - friend struct ConstantCreator >; + friend class ElementVH; + // Use CallbackVH to hold MDNode elements. + struct ElementVH : public CallbackVH { + MDNode *Parent; + ElementVH() {} + ElementVH(Value *V, MDNode *P) : CallbackVH(V), Parent(P) {} + ~ElementVH() {} + + virtual void deleted() { + Parent->replaceElement(this->operator Value*(), 0); + } + + virtual void allUsesReplacedWith(Value *NV) { + Parent->replaceElement(this->operator Value*(), NV); + } + }; + + static const unsigned short FunctionLocalBit = 1; + + // Replace each instance of F from the element list of this node with T. + void replaceElement(Value *F, Value *T); + + ElementVH *Node; + unsigned NodeSize; + protected: - explicit MDNode(LLVMContext &C, Value*const* Vals, unsigned NumVals); + explicit MDNode(LLVMContext &C, Value *const *Vals, unsigned NumVals, + bool isFunctionLocal); public: - // Do not allocate any space for operands. - void *operator new(size_t s) { - return User::operator new(s, 0); - } // Constructors and destructors. - static MDNode *get(LLVMContext &Context, - Value* const* Vals, unsigned NumVals); - - /// dropAllReferences - Remove all uses and clear node vector. - void dropAllReferences(); + static MDNode *get(LLVMContext &Context, Value *const *Vals, unsigned NumVals, + bool isFunctionLocal = false); /// ~MDNode - Destroy MDNode. ~MDNode(); /// getElement - Return specified element. Value *getElement(unsigned i) const { - assert (getNumElements() > i && "Invalid element number!"); + assert(i < getNumElements() && "Invalid element number!"); return Node[i]; } /// getNumElements - Return number of MDNode elements. - unsigned getNumElements() const { - return Node.size(); - } - - // Element access - typedef SmallVectorImpl::const_iterator const_elem_iterator; - typedef SmallVectorImpl::iterator elem_iterator; - /// elem_empty - Return true if MDNode is empty. - bool elem_empty() const { return Node.empty(); } - const_elem_iterator elem_begin() const { return Node.begin(); } - const_elem_iterator elem_end() const { return Node.end(); } - elem_iterator elem_begin() { return Node.begin(); } - elem_iterator elem_end() { return Node.end(); } - - /// isNullValue - Return true if this is the value that would be returned by - /// getNullValue. This always returns false because getNullValue will never - /// produce metadata. - virtual bool isNullValue() const { - return false; - } - - virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U) { - llvm_unreachable("This should never be called because MDNodes have no ops"); - } + unsigned getNumElements() const { return NodeSize; } + + /// isFunctionLocal - Return whether MDNode is local to a function. + /// Note: MDNodes are designated as function-local when created, and keep + /// that designation even if their operands are modified to no longer + /// refer to function-local IR. + bool isFunctionLocal() const { return SubclassData & FunctionLocalBit; } + + /// getLocalFunction - Return false if MDNode's recursive function-localness + /// is invalid (local to more than one function). Return true otherwise. + /// If MDNode has one function to which it is local, set LocalFunction to that + /// function. + bool getLocalFunction(Function *LocalFunction, + SmallPtrSet *VisitedMDNodes = NULL); + + /// Profile - calculate a unique identifier for this MDNode to collapse + /// duplicates + void Profile(FoldingSetNodeID &ID) const; /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const MDNode *) { return true; } @@ -167,23 +160,6 @@ public: } }; -//===----------------------------------------------------------------------===// -/// WeakMetadataVH - a weak value handle for metadata. -class WeakMetadataVH : public WeakVH { -public: - WeakMetadataVH() : WeakVH() {} - WeakMetadataVH(MetadataBase *M) : WeakVH(M) {} - WeakMetadataVH(const WeakMetadataVH &RHS) : WeakVH(RHS) {} - - operator Value*() const { - llvm_unreachable("WeakMetadataVH only handles Metadata"); - } - - operator MetadataBase*() const { - return dyn_cast_or_null(getValPtr()); - } -}; - //===----------------------------------------------------------------------===// /// NamedMDNode - a tuple of other metadata. /// NamedMDNode is always named. All NamedMDNode element has a type of metadata. @@ -195,24 +171,17 @@ class NamedMDNode : public MetadataBase, public ilist_node { friend class LLVMContextImpl; NamedMDNode(const NamedMDNode &); // DO NOT IMPLEMENT - void *operator new(size_t, unsigned); // DO NOT IMPLEMENT - // getNumOperands - Make this only available for private uses. - unsigned getNumOperands() { return User::getNumOperands(); } Module *Parent; - SmallVector Node; - typedef SmallVectorImpl::iterator elem_iterator; + SmallVector, 4> Node; + void setParent(Module *M) { Parent = M; } protected: - explicit NamedMDNode(LLVMContext &C, const Twine &N, MetadataBase*const* Vals, + explicit NamedMDNode(LLVMContext &C, const Twine &N, MetadataBase*const *Vals, unsigned NumVals, Module *M = 0); public: - // Do not allocate any space for operands. - void *operator new(size_t s) { - return User::operator new(s, 0); - } static NamedMDNode *Create(LLVMContext &C, const Twine &N, - MetadataBase*const*MDs, + MetadataBase *const *MDs, unsigned NumMDs, Module *M = 0) { return new NamedMDNode(C, N, MDs, NumMDs, M); } @@ -232,45 +201,32 @@ public: /// getParent - Get the module that holds this named metadata collection. inline Module *getParent() { return Parent; } inline const Module *getParent() const { return Parent; } - void setParent(Module *M) { Parent = M; } /// getElement - Return specified element. MetadataBase *getElement(unsigned i) const { - assert (getNumElements() > i && "Invalid element number!"); + assert(i < getNumElements() && "Invalid element number!"); return Node[i]; } /// getNumElements - Return number of NamedMDNode elements. unsigned getNumElements() const { - return Node.size(); + return (unsigned)Node.size(); } /// addElement - Add metadata element. void addElement(MetadataBase *M) { - resizeOperands(0); - OperandList[NumOperands++] = M; - Node.push_back(WeakMetadataVH(M)); + Node.push_back(TrackingVH(M)); } - typedef SmallVectorImpl::const_iterator const_elem_iterator; + typedef SmallVectorImpl >::iterator elem_iterator; + typedef SmallVectorImpl >::const_iterator + const_elem_iterator; bool elem_empty() const { return Node.empty(); } const_elem_iterator elem_begin() const { return Node.begin(); } const_elem_iterator elem_end() const { return Node.end(); } elem_iterator elem_begin() { return Node.begin(); } elem_iterator elem_end() { return Node.end(); } - /// isNullValue - Return true if this is the value that would be returned by - /// getNullValue. This always returns false because getNullValue will never - /// produce metadata. - virtual bool isNullValue() const { - return false; - } - - virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U) { - llvm_unreachable( - "This should never be called because NamedMDNodes have no ops"); - } - /// 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) { @@ -278,6 +234,69 @@ public: } }; +//===----------------------------------------------------------------------===// +/// MetadataContext - +/// MetadataContext handles uniquing and assignment of IDs for custom metadata +/// types. Custom metadata handler names do not contain spaces. And the name +/// must start with an alphabet. The regular expression used to check name +/// is [a-zA-Z$._][a-zA-Z$._0-9]* +class MetadataContext { + // DO NOT IMPLEMENT + MetadataContext(MetadataContext&); + void operator=(MetadataContext&); + + MetadataContextImpl *const pImpl; +public: + MetadataContext(); + ~MetadataContext(); + + /// registerMDKind - Register a new metadata kind and return its ID. + /// A metadata kind can be registered only once. + unsigned registerMDKind(StringRef Name); + + /// getMDKind - Return metadata kind. If the requested metadata kind + /// is not registered then return 0. + unsigned getMDKind(StringRef Name) const; + + /// isValidName - Return true if Name is a valid custom metadata handler name. + static bool isValidName(StringRef Name); + + /// getMD - Get the metadata of given kind attached to an Instruction. + /// If the metadata is not found then return 0. + MDNode *getMD(unsigned Kind, const Instruction *Inst); + + /// getMDs - Get the metadata attached to an Instruction. + void getMDs(const Instruction *Inst, + SmallVectorImpl > > &MDs) const; + + /// addMD - Attach the metadata of given kind to an Instruction. + void addMD(unsigned Kind, MDNode *Node, Instruction *Inst); + + /// removeMD - Remove metadata of given kind attached with an instuction. + void removeMD(unsigned Kind, Instruction *Inst); + + /// removeAllMetadata - Remove all metadata attached with an instruction. + void removeAllMetadata(Instruction *Inst); + + /// copyMD - If metadata is attached with Instruction In1 then attach + /// the same metadata to In2. + void copyMD(Instruction *In1, Instruction *In2); + + /// getHandlerNames - Populate client supplied smallvector using custom + /// metadata name and ID. + void getHandlerNames(SmallVectorImpl >&) const; + + /// ValueIsDeleted - This handler is used to update metadata store + /// when a value is deleted. + void ValueIsDeleted(const Value *) {} + void ValueIsDeleted(Instruction *Inst); + void ValueIsRAUWd(Value *V1, Value *V2); + + /// ValueIsCloned - This handler is used to update metadata store + /// when In1 is cloned to create In2. + void ValueIsCloned(const Instruction *In1, Instruction *In2); +}; + } // end llvm namespace #endif