Definition of the Bytecode Handler interface. Subclasses can override just

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

diff --git a/include/llvm/iOther.h b/include/llvm/iOther.h
index ba76227e4ab41111d77af06d56a2c5ea074a19aa..18779f9c328f71281d7489a511aacf4995eb4668 100644 (file)
--- a/include/llvm/iOther.h
+++ b/include/llvm/iOther.h
@@ -31,12 +31,20 @@ class CastInst : public Instruction {
     Operands.reserve(1);
     Operands.push_back(Use(CI.Operands[0], this));
   }
+  void init(Value *S) {
+    Operands.reserve(1);
+    Operands.push_back(Use(S, this));
+  }
 public:
   CastInst(Value *S, const Type *Ty, const std::string &Name = "",
            Instruction *InsertBefore = 0)
     : Instruction(Ty, Cast, Name, InsertBefore) {
-    Operands.reserve(1);
-    Operands.push_back(Use(S, this));
+    init(S);
+  }
+  CastInst(Value *S, const Type *Ty, const std::string &Name,
+           BasicBlock *InsertAtEnd)
+    : Instruction(Ty, Cast, Name, InsertAtEnd) {
+    init(S);
   }
 
   virtual Instruction *clone() const { return new CastInst(*this); }
@@ -61,15 +69,25 @@ public:
 ///
 class CallInst : public Instruction {
   CallInst(const CallInst &CI);
+  void init(Value *Func, const std::vector<Value*> &Params);
+  void init(Value *Func, Value *Actual);
+  void init(Value *Func);
+
 public:
   CallInst(Value *F, const std::vector<Value*> &Par,
            const std::string &Name = "", Instruction *InsertBefore = 0);
+  CallInst(Value *F, const std::vector<Value*> &Par,
+           const std::string &Name, BasicBlock *InsertAtEnd);
 
-  // Alternate CallInst ctors w/ no actuals & one actual, respectively.
-  CallInst(Value *F, const std::string &Name = "", 
-           Instruction *InsertBefore = 0);
+  // Alternate CallInst ctors w/ one actual & no actuals, respectively.
   CallInst(Value *F, Value *Actual, const std::string& Name = "",
            Instruction *InsertBefore = 0);
+  CallInst(Value *F, Value *Actual, const std::string& Name,
+           BasicBlock *InsertAtEnd);
+  explicit CallInst(Value *F, const std::string &Name = "", 
+                    Instruction *InsertBefore = 0);
+  explicit CallInst(Value *F, const std::string &Name, 
+                    BasicBlock *InsertAtEnd);
 
   virtual Instruction *clone() const { return new CallInst(*this); }
   bool mayWriteToMemory() const { return true; }
@@ -106,16 +124,25 @@ class ShiftInst : public Instruction {
     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 std::string &Name = "",
-            Instruction *InsertBefore = 0)
-    : Instruction(S->getType(), Opcode, Name, InsertBefore) {
+  void init(OtherOps Opcode, Value *S, Value *SA) {
     assert((Opcode == Shl || Opcode == Shr) && "ShiftInst Opcode invalid!");
     Operands.reserve(2);
     Operands.push_back(Use(S, this));
     Operands.push_back(Use(SA, this));
   }
 
+public:
+  ShiftInst(OtherOps Opcode, Value *S, Value *SA, const std::string &Name = "",
+            Instruction *InsertBefore = 0)
+    : Instruction(S->getType(), Opcode, Name, InsertBefore) {
+    init(Opcode, S, SA);
+  }
+  ShiftInst(OtherOps Opcode, Value *S, Value *SA, const std::string &Name,
+            BasicBlock *InsertAtEnd)
+    : Instruction(S->getType(), Opcode, Name, InsertAtEnd) {
+    init(Opcode, S, SA);
+  }
+
   OtherOps getOpcode() const {
     return static_cast<OtherOps>(Instruction::getOpcode());
   }
@@ -146,16 +173,25 @@ class SelectInst : public Instruction {
     Operands.push_back(Use(SI.Operands[1], this));
     Operands.push_back(Use(SI.Operands[2], this));
   }
-public:
-  SelectInst(Value *C, Value *S1, Value *S2, const std::string &Name = "",
-             Instruction *InsertBefore = 0)
-    : Instruction(S1->getType(), Instruction::Select, Name, InsertBefore) {
+  void init(Value *C, Value *S1, Value *S2) {
     Operands.reserve(3);
     Operands.push_back(Use(C, this));
     Operands.push_back(Use(S1, this));
     Operands.push_back(Use(S2, this));
   }
 
+public:
+  SelectInst(Value *C, Value *S1, Value *S2, const std::string &Name = "",
+             Instruction *InsertBefore = 0)
+    : Instruction(S1->getType(), Instruction::Select, Name, InsertBefore) {
+    init(C, S1, S2);
+  }
+  SelectInst(Value *C, Value *S1, Value *S2, const std::string &Name,
+             BasicBlock *InsertAtEnd)
+    : Instruction(S1->getType(), Instruction::Select, Name, InsertAtEnd) {
+    init(C, S1, S2);
+  }
+
   Value *getCondition() const { return Operands[0]; }
   Value *getTrueValue() const { return Operands[1]; }
   Value *getFalseValue() const { return Operands[2]; }
@@ -187,17 +223,25 @@ public:
 ///
 class VANextInst : public Instruction {
   PATypeHolder ArgTy;
+  void init(Value *List) {
+    Operands.reserve(1);
+    Operands.push_back(Use(List, this));
+  }
   VANextInst(const VANextInst &VAN)
     : Instruction(VAN.getType(), VANext), ArgTy(VAN.getArgType()) {
-    Operands.reserve(1);
-    Operands.push_back(Use(VAN.Operands[0], this));
+    init(VAN.Operands[0]);
   }
+
 public:
   VANextInst(Value *List, const Type *Ty, const std::string &Name = "",
              Instruction *InsertBefore = 0)
     : Instruction(List->getType(), VANext, Name, InsertBefore), ArgTy(Ty) {
-    Operands.reserve(1);
-    Operands.push_back(Use(List, this));
+    init(List);
+  }
+  VANextInst(Value *List, const Type *Ty, const std::string &Name,
+             BasicBlock *InsertAtEnd)
+    : Instruction(List->getType(), VANext, Name, InsertAtEnd), ArgTy(Ty) {
+    init(List);
   }
 
   const Type *getArgType() const { return ArgTy; }
@@ -223,17 +267,24 @@ public:
 /// an argument of the specified type given a va_list.
 ///
 class VAArgInst : public Instruction {
+  void init(Value* List) {
+    Operands.reserve(1);
+    Operands.push_back(Use(List, this));
+  }
   VAArgInst(const VAArgInst &VAA)
     : Instruction(VAA.getType(), VAArg) {
-    Operands.reserve(1);
-    Operands.push_back(Use(VAA.Operands[0], this));
+    init(VAA.Operands[0]);
   }
 public:
   VAArgInst(Value *List, const Type *Ty, const std::string &Name = "",
              Instruction *InsertBefore = 0)
     : Instruction(Ty, VAArg, Name, InsertBefore) {
-    Operands.reserve(1);
-    Operands.push_back(Use(List, this));
+    init(List);
+  }
+  VAArgInst(Value *List, const Type *Ty, const std::string &Name,
+            BasicBlock *InsertAtEnd)
+    : Instruction(Ty, VAArg, Name, InsertAtEnd) {
+    init(List);
   }
 
   virtual Instruction *clone() const { return new VAArgInst(*this); }