include/llvm/iOther.h

   1 //===-- llvm/iOther.h - "Other" instruction node definitions -----*- C++ -*--=//
   2 //
   3 // This file contains the declarations for instructions that fall into the
   4 // grandios 'other' catagory...
   5 //
   6 //===----------------------------------------------------------------------===//
   7
   8 #ifndef LLVM_IOTHER_H
   9 #define LLVM_IOTHER_H
  10
  11 #include "llvm/InstrTypes.h"
  12 #include "llvm/Method.h"
  13 #include <vector>
  14
  15 //===----------------------------------------------------------------------===//
  16 //                               PHINode Class
  17 //===----------------------------------------------------------------------===//
  18
  19 // PHINode - The PHINode class is used to represent the magical mystical PHI
  20 // node, that can not exist in nature, but can be synthesized in a computer
  21 // scientist's overactive imagination.
  22 //
  23 class PHINode : public Instruction {
  24   typedef pair<Use,BasicBlockUse> PairTy;
  25   vector<PairTy> IncomingValues;
  26
  27   PHINode(const PHINode &PN);
  28 public:
  29   PHINode(const Type *Ty, const string &Name = "");
  30   inline ~PHINode() { dropAllReferences(); }
  31
  32   virtual Instruction *clone() const { return new PHINode(*this); }
  33
  34   // Implement all of the functionality required by User...
  35   //
  36   virtual void dropAllReferences();
  37   virtual const Value *getOperand(unsigned i) const {
  38     if (i >= IncomingValues.size()*2) return 0;
  39     if (i & 1) return IncomingValues[i/2].second;
  40     else       return IncomingValues[i/2].first;
  41   }
  42   inline Value *getOperand(unsigned i) {
  43     return (Value*)((const PHINode*)this)->getOperand(i);
  44   }
  45   virtual unsigned getNumOperands() const { return IncomingValues.size()*2; }
  46   virtual bool setOperand(unsigned i, Value *Val);
  47   virtual string getOpcode() const { return "phi"; }
  48
  49   // getNumIncomingValues - Return the number of incoming edges the PHI node has
  50   inline unsigned getNumIncomingValues() const { return IncomingValues.size(); }
  51
  52   // getIncomingValue - Return incoming value #x
  53   inline Value *getIncomingValue(unsigned i) const { return IncomingValues[i].first; }
  54
  55   // getIncomingBlock - Return incoming basic block #x
  56   inline BasicBlock *getIncomingBlock(unsigned i) const { return IncomingValues[i].second; }
  57
  58   // addIncoming - Add an incoming value to the end of the PHI list
  59   void addIncoming(Value *D, BasicBlock *BB);
  60
  61   // removeIncomingValue - Remove an incoming value.  This is useful if a
  62   // predecessor basic block is deleted.  The value removed is returned.
  63   Value *removeIncomingValue(const BasicBlock *BB);
  64 };
  65
  66
  67 //===----------------------------------------------------------------------===//
  68 //                           MethodArgument Class
  69 //===----------------------------------------------------------------------===//
  70
  71 class MethodArgument : public Value {  // Defined in the InstrType.cpp file
  72   Method *Parent;
  73
  74   friend class ValueHolder<MethodArgument,Method>;
  75   inline void setParent(Method *parent) { Parent = parent; }
  76
  77 public:
  78   MethodArgument(const Type *Ty, const string &Name = "")
  79     : Value(Ty, Value::MethodArgumentVal, Name) {
  80     Parent = 0;
  81   }
  82
  83   // Specialize setName to handle symbol table majik...
  84   virtual void setName(const string &name);
  85
  86   inline const Method *getParent() const { return Parent; }
  87   inline       Method *getParent()       { return Parent; }
  88 };
  89
  90
  91 //===----------------------------------------------------------------------===//
  92 //             Classes to function calls and method invocations
  93 //===----------------------------------------------------------------------===//
  94
  95 class CallInst : public Instruction {
  96   MethodUse M;
  97   vector<Use> Params;
  98   CallInst(const CallInst &CI);
  99 public:
 100   CallInst(Method *M, vector<Value*> &params, const string &Name = "");
 101   inline ~CallInst() { dropAllReferences(); }
 102
 103   virtual string getOpcode() const { return "call"; }
 104
 105   virtual Instruction *clone() const { return new CallInst(*this); }
 106   bool hasSideEffects() const { return true; }
 107
 108
 109   const Method *getCalledMethod() const { return M; }
 110         Method *getCalledMethod()       { return M; }
 111
 112   // Implement all of the functionality required by Instruction...
 113   //
 114   virtual void dropAllReferences();
 115   virtual const Value *getOperand(unsigned i) const {
 116     return i == 0 ? M : ((i <= Params.size()) ? Params[i-1] : 0);
 117   }
 118   inline Value *getOperand(unsigned i) {
 119     return (Value*)((const CallInst*)this)->getOperand(i);
 120   }
 121   virtual unsigned getNumOperands() const { return Params.size()+1; }
 122
 123   virtual bool setOperand(unsigned i, Value *Val);
 124 };
 125
 126 #endif