* Add new constructors to allow insertion of terminator instructions at the

  end of basic blocks.
* Document some confusing constructor combinations
* Move a ReturnInst method out-of-line, so that the vtable and type info don't
  need to be emitted to every translation unit that uses the class.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10106 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/InstrTypes.h b/include/llvm/InstrTypes.h
index 70cb742d96da78115dfdc0d4e4456ed7cdea5510..30ba130b892f68490fa820a263c2fe12c52509d0 100644 (file)
--- a/include/llvm/InstrTypes.h
+++ b/include/llvm/InstrTypes.h
@@ -34,6 +34,7 @@ protected:
                  const std::string &Name = "", Instruction *InsertBefore = 0)
     : Instruction(Ty, iType, Name, InsertBefore) {
   }
+  TerminatorInst(Instruction::TermOps iType, BasicBlock *InsertAtEnd);
 public:
 
   /// Terminators must implement the methods required by Instruction...

diff --git a/include/llvm/iTerminators.h b/include/llvm/iTerminators.h
index a27ffdf81da5a0c373d36f34c429fafc2e298cd7..7cf14ac11500aefba185739cf97d7e5fd9576042 100644 (file)
--- a/include/llvm/iTerminators.h
+++ b/include/llvm/iTerminators.h
@@ -33,6 +33,13 @@ class ReturnInst : public TerminatorInst {
     }
   }
 public:
+  // ReturnInst constructors:
+  // ReturnInst()                  - 'ret void' instruction
+  // ReturnInst(Value* X)          - 'ret X'    instruction
+  // ReturnInst(    null, Inst *)  - 'ret void' instruction, insert before I
+  // ReturnInst(Value* X, Inst *I) - 'ret X'    instruction, insert before I
+  // ReturnInst(    null, BB *B)   - 'ret void' instruction, insert @ end of BB
+  // ReturnInst(Value* X, BB *B)   - 'ret X'    instruction, insert @ end of BB
   ReturnInst(Value *RetVal = 0, Instruction *InsertBefore = 0)
     : TerminatorInst(Instruction::Ret, InsertBefore) {
     if (RetVal) {
@@ -40,6 +47,13 @@ public:
       Operands.push_back(Use(RetVal, this));
     }
   }
+  ReturnInst(Value *RetVal, BasicBlock *InsertAtEnd)
+    : TerminatorInst(Instruction::Ret, InsertAtEnd) {
+    if (RetVal) {
+      Operands.reserve(1);
+      Operands.push_back(Use(RetVal, this));
+    }
+  }
 
   virtual Instruction *clone() const { return new ReturnInst(*this); }
 
@@ -55,9 +69,7 @@ public:
     abort();
     return 0;
   }
-  virtual void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
-    assert(0 && "ReturnInst has no successors!");
-  }
+  virtual void setSuccessor(unsigned idx, BasicBlock *NewSucc);
   virtual unsigned getNumSuccessors() const { return 0; }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -76,10 +88,19 @@ public:
 class BranchInst : public TerminatorInst {
   BranchInst(const BranchInst &BI);
 public:
-  // If cond = null, then is an unconditional br...
-  BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *cond = 0,
-             Instruction *InsertBefore = 0);
+  // BranchInst constructors (where {B, T, F} are blocks, and C is a condition):
+  // BranchInst(BB *B)                           - 'br B'
+  // BranchInst(BB* T, BB *F, Value *C)          - 'br C, T, F'
+  // BranchInst(BB* B, Inst *I)                  - 'br B'        insert before I
+  // BranchInst(BB* T, BB *F, Value *C, Inst *I) - 'br C, T, F', insert before I
+  // BranchInst(BB* B, BB *I)                    - 'br B'        insert at end
+  // BranchInst(BB* T, BB *F, Value *C, BB *I)   - 'br C, T, F', insert at end
   BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore = 0);
+  BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *cond,
+             Instruction *InsertBefore = 0);
+  BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd);
+  BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *cond,
+             BasicBlock *InsertAtEnd);
 
   virtual Instruction *clone() const { return new BranchInst(*this); }
 
@@ -142,6 +163,7 @@ class SwitchInst : public TerminatorInst {
   SwitchInst(const SwitchInst &RI);
 public:
   SwitchInst(Value *Value, BasicBlock *Default, Instruction *InsertBefore = 0);
+  SwitchInst(Value *Value, BasicBlock *Default, BasicBlock  *InsertAtEnd);
 
   virtual Instruction *clone() const { return new SwitchInst(*this); }
 
@@ -212,6 +234,9 @@ public:
   InvokeInst(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
             const std::vector<Value*> &Params, const std::string &Name = "",
              Instruction *InsertBefore = 0);
+  InvokeInst(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
+            const std::vector<Value*> &Params, const std::string &Name,
+             BasicBlock *InsertAtEnd);
 
   virtual Instruction *clone() const { return new InvokeInst(*this); }