include/llvm/MDNode.h

   1 //===-- llvm/Metadata.h - Constant class subclass definitions ---*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 /// @file
  11 /// This file contains the declarations for the subclasses of Constant,
  12 /// which represent the different flavors of constant values that live in LLVM.
  13 /// Note that Constants are immutable (once created they never change) and are
  14 /// fully shared by structural equivalence.  This means that two structurally
  15 /// equivalent constants will always have the same address.  Constant's are
  16 /// created on demand as needed and never deleted: thus clients don't have to
  17 /// worry about the lifetime of the objects.
  18 //
  19 //===----------------------------------------------------------------------===//
  20
  21 #ifndef LLVM_MDNODE_H
  22 #define LLVM_MDNODE_H
  23
  24 #include "llvm/Constant.h"
  25 #include "llvm/Type.h"
  26 #include "llvm/ADT/FoldingSet.h"
  27 #include "llvm/ADT/SmallVector.h"
  28 #include "llvm/Support/ErrorHandling.h"
  29 #include "llvm/Support/ValueHandle.h"
  30
  31 namespace llvm {
  32
  33 //===----------------------------------------------------------------------===//
  34 /// MDNode - a tuple of other values.
  35 /// These contain a list of the Constants that represent the metadata. The
  36 /// operand list is always empty, query the element list instead.
  37 ///
  38 /// This class will attempt to keep track of values as they are modified. When
  39 /// a value is replaced the element will be replaced with it, and when the
  40 /// value is deleted the element is set to a null pointer. In order to preserve
  41 /// structural equivalence while the elements mutate, the MDNode may call
  42 /// replaceAllUsesWith on itself. Because of this, users of MDNode must use a
  43 /// WeakVH or CallbackVH to hold the node pointer if there is a chance that one
  44 /// of the elements held by the node may change.
  45 ///
  46 class MDNode : public Constant, public FoldingSetNode {
  47   MDNode(const MDNode &);      // DO NOT IMPLEMENT
  48
  49   friend class ElementVH;
  50   struct ElementVH : public CallbackVH {
  51     MDNode *OwningNode;
  52
  53     ElementVH(Value *V, MDNode *Parent)
  54       : CallbackVH(V), OwningNode(Parent) {}
  55
  56     ~ElementVH() {}
  57
  58     /// deleted - Set this entry in the MDNode to 'null'. This will reallocate
  59     /// the MDNode.
  60     virtual void deleted() {
  61       OwningNode->replaceElement(this->operator Value*(), 0);
  62     }
  63
  64     /// allUsesReplacedWith - Modify the MDNode by replacing this entry with
  65     /// new_value. This will reallocate the MDNode.
  66     virtual void allUsesReplacedWith(Value *new_value) {
  67       OwningNode->replaceElement(this->operator Value*(), new_value);
  68     }
  69   };
  70
  71   void replaceElement(Value *From, Value *To);
  72
  73   SmallVector<ElementVH, 4> Node;
  74   typedef SmallVectorImpl<ElementVH>::iterator elem_iterator;
  75 protected:
  76   explicit MDNode(Value*const* Vals, unsigned NumVals);
  77 public:
  78   typedef SmallVectorImpl<ElementVH>::const_iterator const_elem_iterator;
  79
  80   /// get() - Static factory methods - Return objects of the specified value.
  81   ///
  82   static MDNode *get(Value*const* Vals, unsigned NumVals);
  83
  84   Value *getElement(unsigned i) const {
  85     return Node[i];
  86   }
  87
  88   unsigned getNumElements() const {
  89     return Node.size();
  90   }
  91
  92   bool elem_empty() const {
  93     return Node.empty();
  94   }
  95
  96   const_elem_iterator elem_begin() const {
  97     return Node.begin();
  98   }
  99
 100   const_elem_iterator elem_end() const {
 101     return Node.end();
 102   }
 103
 104   /// getType() specialization - Type is always MetadataTy.
 105   ///
 106   inline const Type *getType() const {
 107     return Type::MetadataTy;
 108   }
 109
 110   /// isNullValue - Return true if this is the value that would be returned by
 111   /// getNullValue.  This always returns false because getNullValue will never
 112   /// produce metadata.
 113   virtual bool isNullValue() const {
 114     return false;
 115   }
 116
 117   /// Profile - calculate a unique identifier for this MDNode to collapse
 118   /// duplicates
 119   void Profile(FoldingSetNodeID &ID) const;
 120
 121   virtual void destroyConstant();
 122   virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U) {
 123     LLVM_UNREACHABLE("This should never be called because MDNodes have no ops");
 124   }
 125
 126   /// Methods for support type inquiry through isa, cast, and dyn_cast:
 127   static inline bool classof(const MDNode *) { return true; }
 128   static bool classof(const Value *V) {
 129     return V->getValueID() == MDNodeVal;
 130   }
 131 };
 132
 133 } // end llvm namespace
 134
 135 #endif