include/llvm/User.h

   1 //===-- llvm/User.h - User class definition ---------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This class defines the interface that one who 'use's a Value must implement.
  11 // Each instance of the Value class keeps track of what User's have handles
  12 // to it.
  13 //
  14 //  * Instructions are the largest class of User's.
  15 //  * Constants may be users of other constants (think arrays and stuff)
  16 //
  17 //===----------------------------------------------------------------------===//
  18
  19 #ifndef LLVM_USER_H
  20 #define LLVM_USER_H
  21
  22 #include "llvm/Value.h"
  23 #include <vector>
  24
  25 class User : public Value {
  26   User(const User &);             // Do not implement
  27 protected:
  28   std::vector<Use> Operands;
  29 public:
  30   User(const Type *Ty, ValueTy vty, const std::string &name = "");
  31
  32   inline Value *getOperand(unsigned i) {
  33     assert(i < Operands.size() && "getOperand() out of range!");
  34     return Operands[i];
  35   }
  36   inline const Value *getOperand(unsigned i) const {
  37     assert(i < Operands.size() && "getOperand() const out of range!");
  38     return Operands[i];
  39   }
  40   inline void setOperand(unsigned i, Value *Val) {
  41     assert(i < Operands.size() && "setOperand() out of range!");
  42     Operands[i] = Val;
  43   }
  44   inline unsigned getNumOperands() const { return Operands.size(); }
  45
  46   // ---------------------------------------------------------------------------
  47   // Operand Iterator interface...
  48   //
  49   typedef std::vector<Use>::iterator       op_iterator;
  50   typedef std::vector<Use>::const_iterator const_op_iterator;
  51
  52   void op_reserve(unsigned NumElements) { Operands.reserve(NumElements); }
  53
  54   inline op_iterator       op_begin()       { return Operands.begin(); }
  55   inline const_op_iterator op_begin() const { return Operands.begin(); }
  56   inline op_iterator       op_end()         { return Operands.end(); }
  57   inline const_op_iterator op_end()   const { return Operands.end(); }
  58
  59   /// op_erase - This method is used to remove one of the arguments from the
  60   /// operands list.  Only use this if you know what you are doing.
  61   ///
  62   op_iterator op_erase(op_iterator I) { return Operands.erase(I); }
  63   op_iterator op_erase(op_iterator I, op_iterator E) {
  64     return Operands.erase(I, E);
  65   }
  66
  67   // dropAllReferences() - This function is in charge of "letting go" of all
  68   // objects that this User refers to.  This allows one to
  69   // 'delete' a whole class at a time, even though there may be circular
  70   // references... first all references are dropped, and all use counts go to
  71   // zero.  Then everything is delete'd for real.  Note that no operations are
  72   // valid on an object that has "dropped all references", except operator
  73   // delete.
  74   //
  75   inline void dropAllReferences() {
  76     Operands.clear();
  77   }
  78
  79   /// replaceUsesOfWith - Replaces all references to the "From" definition with
  80   /// references to the "To" definition.
  81   ///
  82   void replaceUsesOfWith(Value *From, Value *To);
  83
  84   // Methods for support type inquiry through isa, cast, and dyn_cast:
  85   static inline bool classof(const User *) { return true; }
  86   static inline bool classof(const Value *V) {
  87     return V->getValueType() == Value::GlobalVariableVal ||
  88            V->getValueType() == Value::ConstantVal ||
  89            V->getValueType() == Value::InstructionVal;
  90   }
  91 };
  92
  93 template<> struct simplify_type<User::op_iterator> {
  94   typedef Value* SimpleType;
  95
  96   static SimpleType getSimplifiedValue(const User::op_iterator &Val) {
  97     return (SimpleType)Val->get();
  98   }
  99 };
 100 template<> struct simplify_type<const User::op_iterator>
 101   : public simplify_type<User::op_iterator> {};
 102
 103 template<> struct simplify_type<User::const_op_iterator> {
 104   typedef Value* SimpleType;
 105
 106   static SimpleType getSimplifiedValue(const User::const_op_iterator &Val) {
 107     return (SimpleType)Val->get();
 108   }
 109 };
 110 template<> struct simplify_type<const User::const_op_iterator>
 111   : public simplify_type<User::const_op_iterator> {};
 112
 113 #endif