Add support for indirect calls

[oota-llvm.git] / include / llvm / iOther.h

diff --git a/include/llvm/iOther.h b/include/llvm/iOther.h
index 5dc736510d5615fb116dbe16f2fa00cab32830a7..52d75629e7cb92a220cadd8894f7cbac185feeae 100644 (file)
--- a/include/llvm/iOther.h
+++ b/include/llvm/iOther.h
@@ -10,7 +10,6 @@
 
 #include "llvm/InstrTypes.h"
 #include "llvm/Method.h"
-#include <vector>
 
 //===----------------------------------------------------------------------===//
 //                               PHINode Class
@@ -38,13 +37,16 @@ public:
   inline Value *getIncomingValue(unsigned i) {
     return Operands[i*2];
   }
+  inline void setIncomingValue(unsigned i, Value *V) {
+    Operands[i*2] = V;
+  }
 
   // getIncomingBlock - Return incoming basic block #x
   inline const BasicBlock *getIncomingBlock(unsigned i) const { 
-    return Operands[i*2+1]->castBasicBlockAsserting();
+    return cast<const BasicBlock>(Operands[i*2+1]);
   }
   inline BasicBlock *getIncomingBlock(unsigned i) { 
-    return Operands[i*2+1]->castBasicBlockAsserting();
+    return cast<BasicBlock>(Operands[i*2+1]);
   }
 
   // addIncoming - Add an incoming value to the end of the PHI list
@@ -53,6 +55,16 @@ public:
   // removeIncomingValue - Remove an incoming value.  This is useful if a
   // predecessor basic block is deleted.  The value removed is returned.
   Value *removeIncomingValue(const BasicBlock *BB);
+
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const PHINode *) { return true; }
+  static inline bool classof(const Instruction *I) {
+    return I->getOpcode() == Instruction::PHINode; 
+  }
+  static inline bool classof(const Value *V) {
+    return isa<Instruction>(V) && classof(cast<Instruction>(V));
+  }
 };
 
 
@@ -66,7 +78,7 @@ public:
 class CastInst : public Instruction {
   CastInst(const CastInst &CI) : Instruction(CI.getType(), Cast) {
     Operands.reserve(1);
-    Operands.push_back(Use(Operands[0], this));
+    Operands.push_back(Use(CI.Operands[0], this));
   }
 public:
   CastInst(Value *S, const Type *Ty, const string &Name = "")
@@ -77,6 +89,15 @@ public:
 
   virtual Instruction *clone() const { return new CastInst(*this); }
   virtual const char *getOpcodeName() const { return "cast"; }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const CastInst *) { return true; }
+  static inline bool classof(const Instruction *I) {
+    return I->getOpcode() == Cast;
+  }
+  static inline bool classof(const Value *V) {
+    return isa<Instruction>(V) && classof(cast<Instruction>(V));
+  }
 };
 
 
@@ -97,10 +118,16 @@ public:
   }
 
   // Specialize setName to handle symbol table majik...
-  virtual void setName(const string &name);
+  virtual void setName(const string &name, SymbolTable *ST = 0);
 
   inline const Method *getParent() const { return Parent; }
   inline       Method *getParent()       { return Parent; }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const MethodArgument *) { return true; }
+  static inline bool classof(const Value *V) {
+    return V->getValueType() == MethodArgumentVal;
+  }
 };
 
 
@@ -111,19 +138,31 @@ public:
 class CallInst : public Instruction {
   CallInst(const CallInst &CI);
 public:
-  CallInst(Method *M, const vector<Value*> &params, const string &Name = "");
+  CallInst(Value *Meth, const vector<Value*> &params, const string &Name = "");
 
   virtual const char *getOpcodeName() const { return "call"; }
 
   virtual Instruction *clone() const { return new CallInst(*this); }
   bool hasSideEffects() const { return true; }
 
-
   const Method *getCalledMethod() const {
-    return Operands[0]->castMethodAsserting(); 
+    return dyn_cast<Method>(Operands[0]);
   }
   Method *getCalledMethod() {
-    return Operands[0]->castMethodAsserting(); 
+    return dyn_cast<Method>(Operands[0]); 
+  }
+
+  // getCalledValue - Get a pointer to a method that is invoked by this inst.
+  inline const Value *getCalledValue() const { return Operands[0]; }
+  inline       Value *getCalledValue()       { return Operands[0]; }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const CallInst *) { return true; }
+  static inline bool classof(const Instruction *I) {
+    return I->getOpcode() == Instruction::Call; 
+  }
+  static inline bool classof(const Value *V) {
+    return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
 
@@ -135,10 +174,10 @@ public:
 // ShiftInst - This class represents left and right shift instructions.
 //
 class ShiftInst : public Instruction {
-  ShiftInst(const ShiftInst &CI) : Instruction(CI.getType(), CI.getOpcode()) {
+  ShiftInst(const ShiftInst &SI) : Instruction(SI.getType(), SI.getOpcode()) {
     Operands.reserve(2);
-    Operands.push_back(Use(Operands[0], this));
-    Operands.push_back(Use(Operands[1], this));
+    Operands.push_back(Use(SI.Operands[0], this));
+    Operands.push_back(Use(SI.Operands[1], this));
   }
 public:
   ShiftInst(OtherOps Opcode, Value *S, Value *SA, const string &Name = "")
@@ -153,6 +192,16 @@ public:
   virtual const char *getOpcodeName() const {
     return getOpcode() == Shl ? "shl" : "shr"; 
   }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const ShiftInst *) { return true; }
+  static inline bool classof(const Instruction *I) {
+    return (I->getOpcode() == Instruction::Shr) | 
+           (I->getOpcode() == Instruction::Shl);
+  }
+  static inline bool classof(const Value *V) {
+    return isa<Instruction>(V) && classof(cast<Instruction>(V));
+  }
 };
 
 #endif