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   // addIncoming - Add an incoming value to the end of the PHI list
  50   void addIncoming(Value *D, BasicBlock *BB);
  51
  52   // removeIncomingValue - Remove an incoming value.  This is useful if a
  53   // predecessor basic block is deleted.  The value removed is returned.
  54   Value *removeIncomingValue(const BasicBlock *BB);
  55 };
  56
  57
  58 //===----------------------------------------------------------------------===//
  59 //                           MethodArgument Class
  60 //===----------------------------------------------------------------------===//
  61
  62 class MethodArgument : public Value {  // Defined in the InstrType.cpp file
  63   Method *Parent;
  64
  65   friend class ValueHolder<MethodArgument,Method>;
  66   inline void setParent(Method *parent) { Parent = parent; }
  67
  68 public:
  69   MethodArgument(const Type *Ty, const string &Name = "")
  70     : Value(Ty, Value::MethodArgumentVal, Name) {
  71     Parent = 0;
  72   }
  73
  74   // Specialize setName to handle symbol table majik...
  75   virtual void setName(const string &name);
  76
  77   inline const Method *getParent() const { return Parent; }
  78   inline       Method *getParent()       { return Parent; }
  79 };
  80
  81
  82 //===----------------------------------------------------------------------===//
  83 //             Classes to function calls and method invocations
  84 //===----------------------------------------------------------------------===//
  85
  86 class CallInst : public Instruction {
  87   MethodUse M;
  88   vector<Use> Params;
  89   CallInst(const CallInst &CI);
  90 public:
  91   CallInst(Method *M, vector<Value*> &params, const string &Name = "");
  92   inline ~CallInst() { dropAllReferences(); }
  93
  94   virtual string getOpcode() const { return "call"; }
  95
  96   virtual Instruction *clone() const { return new CallInst(*this); }
  97   bool hasSideEffects() const { return true; }
  98
  99
 100   const Method *getCalledMethod() const { return M; }
 101         Method *getCalledMethod()       { return M; }
 102
 103   // Implement all of the functionality required by Instruction...
 104   //
 105   virtual void dropAllReferences();
 106   virtual const Value *getOperand(unsigned i) const {
 107     return i == 0 ? M : ((i <= Params.size()) ? Params[i-1] : 0);
 108   }
 109   inline Value *getOperand(unsigned i) {
 110     return (Value*)((const CallInst*)this)->getOperand(i);
 111   }
 112   virtual unsigned getNumOperands() const { return Params.size()+1; }
 113
 114   virtual bool setOperand(unsigned i, Value *Val);
 115 };
 116
 117 #endif