Refactor common initialization code in private init() functions.
This is a first step in supplying append to basic block constructors
for all instruction types.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@13793 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/include/llvm/InstrTypes.h b/include/llvm/InstrTypes.h
index 30ba130..df64c9b 100644
--- a/include/llvm/InstrTypes.h
+++ b/include/llvm/InstrTypes.h
@@ -32,9 +32,13 @@
TerminatorInst(Instruction::TermOps iType, Instruction *InsertBefore = 0);
TerminatorInst(const Type *Ty, Instruction::TermOps iType,
const std::string &Name = "", Instruction *InsertBefore = 0)
- : Instruction(Ty, iType, Name, InsertBefore) {
- }
+ : Instruction(Ty, iType, Name, InsertBefore) {}
+
TerminatorInst(Instruction::TermOps iType, BasicBlock *InsertAtEnd);
+ TerminatorInst(const Type *Ty, Instruction::TermOps iType,
+ const std::string &Name, BasicBlock *InsertAtEnd)
+ : Instruction(Ty, iType, Name, InsertAtEnd) {}
+
public:
/// Terminators must implement the methods required by Instruction...
diff --git a/include/llvm/Instruction.h b/include/llvm/Instruction.h
index fae6d2a..17eec87 100644
--- a/include/llvm/Instruction.h
+++ b/include/llvm/Instruction.h
@@ -36,11 +36,15 @@
friend class SymbolTableListTraits<Instruction, BasicBlock, Function,
ilist_traits<Instruction> >;
void setParent(BasicBlock *P);
+ void init();
+
protected:
unsigned iType; // InstructionType: The opcode of the instruction
Instruction(const Type *Ty, unsigned iType, const std::string &Name = "",
Instruction *InsertBefore = 0);
+ Instruction(const Type *Ty, unsigned iType, const std::string &Name,
+ BasicBlock *InsertAtEnd);
public:
~Instruction() {
diff --git a/include/llvm/iMemory.h b/include/llvm/iMemory.h
index 64a546d..a794ca5 100644
--- a/include/llvm/iMemory.h
+++ b/include/llvm/iMemory.h
@@ -163,6 +163,10 @@
Operands.push_back(Use(LI.Operands[0], this));
}
bool Volatile; // True if this is a volatile load
+ void init(Value *Ptr) {
+ Operands.reserve(1);
+ Operands.push_back(Use(Ptr, this));
+ }
public:
LoadInst(Value *Ptr, const std::string &Name, Instruction *InsertBefore);
LoadInst(Value *Ptr, const std::string &Name = "", bool isVolatile = false,
@@ -210,6 +214,11 @@
Operands.push_back(Use(SI.Operands[1], this));
}
bool Volatile; // True if this is a volatile store
+ void init(Value *Val, Value *Ptr) {
+ Operands.reserve(2);
+ Operands.push_back(Use(Val, this));
+ Operands.push_back(Use(Ptr, this));
+ }
public:
StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
StoreInst(Value *Val, Value *Ptr, bool isVolatile = false,
@@ -258,6 +267,8 @@
for (unsigned i = 0, E = EPI.Operands.size(); i != E; ++i)
Operands.push_back(Use(EPI.Operands[i], this));
}
+ void init(Value *Ptr, const std::vector<Value*> &Idx);
+
public:
GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
const std::string &Name = "", Instruction *InsertBefore =0);
diff --git a/include/llvm/iTerminators.h b/include/llvm/iTerminators.h
index f6e1c36..78a1b74 100644
--- a/include/llvm/iTerminators.h
+++ b/include/llvm/iTerminators.h
@@ -32,6 +32,14 @@
Operands.push_back(Use(RI.Operands[0], this));
}
}
+
+ void init(Value *RetVal) {
+ if (RetVal) {
+ Operands.reserve(1);
+ Operands.push_back(Use(RetVal, this));
+ }
+ }
+
public:
// ReturnInst constructors:
// ReturnInst() - 'ret void' instruction
@@ -42,17 +50,11 @@
// 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) {
- Operands.reserve(1);
- Operands.push_back(Use(RetVal, this));
- }
+ init(RetVal);
}
ReturnInst(Value *RetVal, BasicBlock *InsertAtEnd)
: TerminatorInst(Instruction::Ret, InsertAtEnd) {
- if (RetVal) {
- Operands.reserve(1);
- Operands.push_back(Use(RetVal, this));
- }
+ init(RetVal);
}
virtual Instruction *clone() const { return new ReturnInst(*this); }
@@ -87,6 +89,8 @@
///
class BranchInst : public TerminatorInst {
BranchInst(const BranchInst &BI);
+ void init(BasicBlock *IfTrue);
+ void init(BasicBlock *True, BasicBlock *False, Value *Cond);
public:
// BranchInst constructors (where {B, T, F} are blocks, and C is a condition):
// BranchInst(BB *B) - 'br B'
@@ -161,6 +165,8 @@
// Operand[2n ] = Value to match
// Operand[2n+1] = BasicBlock to go to on match
SwitchInst(const SwitchInst &RI);
+ void init(Value *Value, BasicBlock *Default);
+
public:
SwitchInst(Value *Value, BasicBlock *Default, Instruction *InsertBefore = 0);
SwitchInst(Value *Value, BasicBlock *Default, BasicBlock *InsertAtEnd);
@@ -259,6 +265,8 @@
///
class InvokeInst : public TerminatorInst {
InvokeInst(const InvokeInst &BI);
+ void init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
+ const std::vector<Value*> &Params);
public:
InvokeInst(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
const std::vector<Value*> &Params, const std::string &Name = "",
diff --git a/lib/VMCore/InstrTypes.cpp b/lib/VMCore/InstrTypes.cpp
index b10f9cc..aa5c351 100644
--- a/lib/VMCore/InstrTypes.cpp
+++ b/lib/VMCore/InstrTypes.cpp
@@ -29,8 +29,7 @@
}
TerminatorInst::TerminatorInst(Instruction::TermOps iType, BasicBlock *IAE)
- : Instruction(Type::VoidTy, iType) {
- if (IAE) IAE->getInstList().push_back(this);
+ : Instruction(Type::VoidTy, iType, "", IAE) {
}
diff --git a/lib/VMCore/Instruction.cpp b/lib/VMCore/Instruction.cpp
index 0de34b5..5ddf284 100644
--- a/lib/VMCore/Instruction.cpp
+++ b/lib/VMCore/Instruction.cpp
@@ -17,14 +17,18 @@
#include "Support/LeakDetector.h"
using namespace llvm;
-Instruction::Instruction(const Type *ty, unsigned it, const std::string &Name,
- Instruction *InsertBefore)
- : User(ty, Value::InstructionVal, Name) {
- Parent = 0;
- iType = it;
-
+void Instruction::init()
+{
// Make sure that we get added to a basicblock
LeakDetector::addGarbageObject(this);
+}
+
+Instruction::Instruction(const Type *ty, unsigned it, const std::string &Name,
+ Instruction *InsertBefore)
+ : User(ty, Value::InstructionVal, Name),
+ Parent(0),
+ iType(it) {
+ init();
// If requested, insert this instruction into a basic block...
if (InsertBefore) {
@@ -34,6 +38,18 @@
}
}
+Instruction::Instruction(const Type *ty, unsigned it, const std::string &Name,
+ BasicBlock *InsertAtEnd)
+ : User(ty, Value::InstructionVal, Name),
+ Parent(0),
+ iType(it) {
+ init();
+
+ // append this instruction into the basic block
+ assert(InsertAtEnd && "Basic block to append to may not be NULL!");
+ InsertAtEnd->getInstList().push_back(this);
+}
+
void Instruction::setParent(BasicBlock *P) {
if (getParent()) {
if (!P) LeakDetector::addGarbageObject(this);
diff --git a/lib/VMCore/iBranch.cpp b/lib/VMCore/iBranch.cpp
index 78951b2..a5ba36f 100644
--- a/lib/VMCore/iBranch.cpp
+++ b/lib/VMCore/iBranch.cpp
@@ -28,52 +28,45 @@
assert(0 && "UnwindInst has no successors!");
}
+void BranchInst::init(BasicBlock *IfTrue)
+{
+ assert(IfTrue != 0 && "Branch destination may not be null!");
+ Operands.reserve(1);
+ Operands.push_back(Use(IfTrue, this));
+}
+
+void BranchInst::init(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond)
+{
+ assert(IfTrue && IfFalse && Cond &&
+ "Branch destinations and condition may not be null!");
+ assert(Cond && Cond->getType() == Type::BoolTy &&
+ "May only branch on boolean predicates!");
+ Operands.reserve(3);
+ Operands.push_back(Use(IfTrue, this));
+ Operands.push_back(Use(IfFalse, this));
+ Operands.push_back(Use(Cond, this));
+}
+
BranchInst::BranchInst(BasicBlock *True, BasicBlock *False, Value *Cond,
Instruction *InsertBefore)
: TerminatorInst(Instruction::Br, InsertBefore) {
- assert(True != 0 && "True branch destination may not be null!!!");
- Operands.reserve(False ? 3 : 1);
- Operands.push_back(Use(True, this));
- if (False) {
- Operands.push_back(Use(False, this));
- Operands.push_back(Use(Cond, this));
- }
-
- assert(!!False == !!Cond &&
- "Either both cond and false or neither can be specified!");
- assert((Cond == 0 || Cond->getType() == Type::BoolTy) &&
- "May only branch on boolean predicates!!!!");
+ init(True, False, Cond);
}
BranchInst::BranchInst(BasicBlock *True, BasicBlock *False, Value *Cond,
BasicBlock *InsertAtEnd)
: TerminatorInst(Instruction::Br, InsertAtEnd) {
- assert(True != 0 && "True branch destination may not be null!!!");
- Operands.reserve(False ? 3 : 1);
- Operands.push_back(Use(True, this));
- if (False) {
- Operands.push_back(Use(False, this));
- Operands.push_back(Use(Cond, this));
- }
-
- assert(!!False == !!Cond &&
- "Either both cond and false or neither can be specified!");
- assert((Cond == 0 || Cond->getType() == Type::BoolTy) &&
- "May only branch on boolean predicates!!!!");
+ init(True, False, Cond);
}
BranchInst::BranchInst(BasicBlock *True, Instruction *InsertBefore)
: TerminatorInst(Instruction::Br, InsertBefore) {
- assert(True != 0 && "True branch destination may not be null!!!");
- Operands.reserve(1);
- Operands.push_back(Use(True, this));
+ init(True);
}
BranchInst::BranchInst(BasicBlock *True, BasicBlock *InsertAtEnd)
: TerminatorInst(Instruction::Br, InsertAtEnd) {
- assert(True != 0 && "True branch destination may not be null!!!");
- Operands.reserve(1);
- Operands.push_back(Use(True, this));
+ init(True);
}
BranchInst::BranchInst(const BranchInst &BI) : TerminatorInst(Instruction::Br) {
diff --git a/lib/VMCore/iCall.cpp b/lib/VMCore/iCall.cpp
index 37298f9..edd5593 100644
--- a/lib/VMCore/iCall.cpp
+++ b/lib/VMCore/iCall.cpp
@@ -99,51 +99,42 @@
// InvokeInst Implementation
//===----------------------------------------------------------------------===//
-InvokeInst::InvokeInst(Value *Func, BasicBlock *IfNormal,
- BasicBlock *IfException,
- const std::vector<Value*> ¶ms,
- const std::string &Name, Instruction *InsertBefore)
- : TerminatorInst(cast<FunctionType>(cast<PointerType>(Func->getType())
- ->getElementType())->getReturnType(),
- Instruction::Invoke, Name, InsertBefore) {
- Operands.reserve(3+params.size());
- Operands.push_back(Use(Func, this));
+void InvokeInst::init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
+ const std::vector<Value*> &Params)
+{
+ Operands.reserve(3+Params.size());
+ Operands.push_back(Use(Fn, this));
Operands.push_back(Use((Value*)IfNormal, this));
Operands.push_back(Use((Value*)IfException, this));
const FunctionType *MTy =
- cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType());
+ cast<FunctionType>(cast<PointerType>(Fn->getType())->getElementType());
- assert((params.size() == MTy->getNumParams()) ||
- (MTy->isVarArg() && params.size() > MTy->getNumParams()) &&
+ assert((Params.size() == MTy->getNumParams()) ||
+ (MTy->isVarArg() && Params.size() > MTy->getNumParams()) &&
"Calling a function with bad signature");
- for (unsigned i = 0; i < params.size(); i++)
- Operands.push_back(Use(params[i], this));
+ for (unsigned i = 0; i < Params.size(); i++)
+ Operands.push_back(Use(Params[i], this));
}
-InvokeInst::InvokeInst(Value *Func, BasicBlock *IfNormal,
+InvokeInst::InvokeInst(Value *Fn, BasicBlock *IfNormal,
BasicBlock *IfException,
- const std::vector<Value*> ¶ms,
- const std::string &Name, BasicBlock *InsertAtEnd)
- : TerminatorInst(cast<FunctionType>(cast<PointerType>(Func->getType())
+ const std::vector<Value*> &Params,
+ const std::string &Name, Instruction *InsertBefore)
+ : TerminatorInst(cast<FunctionType>(cast<PointerType>(Fn->getType())
->getElementType())->getReturnType(),
- Instruction::Invoke, Name) {
- Operands.reserve(3+params.size());
- Operands.push_back(Use(Func, this));
- Operands.push_back(Use((Value*)IfNormal, this));
- Operands.push_back(Use((Value*)IfException, this));
- const FunctionType *MTy =
- cast<FunctionType>(cast<PointerType>(Func->getType())->getElementType());
-
- assert((params.size() == MTy->getNumParams()) ||
- (MTy->isVarArg() && params.size() > MTy->getNumParams()) &&
- "Calling a function with bad signature");
-
- for (unsigned i = 0; i < params.size(); i++)
- Operands.push_back(Use(params[i], this));
+ Instruction::Invoke, Name, InsertBefore) {
+ init(Fn, IfNormal, IfException, Params);
+}
- if (InsertAtEnd)
- InsertAtEnd->getInstList().push_back(this);
+InvokeInst::InvokeInst(Value *Fn, BasicBlock *IfNormal,
+ BasicBlock *IfException,
+ const std::vector<Value*> &Params,
+ const std::string &Name, BasicBlock *InsertAtEnd)
+ : TerminatorInst(cast<FunctionType>(cast<PointerType>(Fn->getType())
+ ->getElementType())->getReturnType(),
+ Instruction::Invoke, Name, InsertAtEnd) {
+ init(Fn, IfNormal, IfException, Params);
}
InvokeInst::InvokeInst(const InvokeInst &CI)
diff --git a/lib/VMCore/iMemory.cpp b/lib/VMCore/iMemory.cpp
index da4cc74..2b731b4 100644
--- a/lib/VMCore/iMemory.cpp
+++ b/lib/VMCore/iMemory.cpp
@@ -67,16 +67,14 @@
LoadInst::LoadInst(Value *Ptr, const std::string &Name, Instruction *InsertBef)
: Instruction(cast<PointerType>(Ptr->getType())->getElementType(),
Load, Name, InsertBef), Volatile(false) {
- Operands.reserve(1);
- Operands.push_back(Use(Ptr, this));
+ init(Ptr);
}
LoadInst::LoadInst(Value *Ptr, const std::string &Name, bool isVolatile,
Instruction *InsertBef)
: Instruction(cast<PointerType>(Ptr->getType())->getElementType(),
Load, Name, InsertBef), Volatile(isVolatile) {
- Operands.reserve(1);
- Operands.push_back(Use(Ptr, this));
+ init(Ptr);
}
//===----------------------------------------------------------------------===//
@@ -85,19 +83,13 @@
StoreInst::StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore)
: Instruction(Type::VoidTy, Store, "", InsertBefore), Volatile(false) {
-
- Operands.reserve(2);
- Operands.push_back(Use(Val, this));
- Operands.push_back(Use(Ptr, this));
+ init(Val, Ptr);
}
StoreInst::StoreInst(Value *Val, Value *Ptr, bool isVolatile,
Instruction *InsertBefore)
: Instruction(Type::VoidTy, Store, "", InsertBefore), Volatile(isVolatile) {
-
- Operands.reserve(2);
- Operands.push_back(Use(Val, this));
- Operands.push_back(Use(Ptr, this));
+ init(Val, Ptr);
}
@@ -113,11 +105,8 @@
return Ty;
}
-GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
- const std::string &Name, Instruction *InBe)
- : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),
- Idx, true))),
- GetElementPtr, Name, InBe) {
+void GetElementPtrInst::init(Value *Ptr, const std::vector<Value*> &Idx)
+{
Operands.reserve(1+Idx.size());
Operands.push_back(Use(Ptr, this));
@@ -125,6 +114,14 @@
Operands.push_back(Use(Idx[i], this));
}
+GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
+ const std::string &Name, Instruction *InBe)
+ : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),
+ Idx, true))),
+ GetElementPtr, Name, InBe) {
+ init(Ptr, Idx);
+}
+
// getIndexedType - Returns the type of the element that would be loaded with
// a load instruction with the specified parameters.
//
diff --git a/lib/VMCore/iSwitch.cpp b/lib/VMCore/iSwitch.cpp
index c4cffc2..d4dccde 100644
--- a/lib/VMCore/iSwitch.cpp
+++ b/lib/VMCore/iSwitch.cpp
@@ -15,20 +15,22 @@
#include "llvm/BasicBlock.h"
using namespace llvm;
-SwitchInst::SwitchInst(Value *V, BasicBlock *DefaultDest,
- Instruction *InsertBefore)
- : TerminatorInst(Instruction::Switch, InsertBefore) {
- assert(V && DefaultDest);
- Operands.push_back(Use(V, this));
- Operands.push_back(Use(DefaultDest, this));
+void SwitchInst::init(Value *Value, BasicBlock *Default)
+{
+ assert(Value && Default);
+ Operands.push_back(Use(Value, this));
+ Operands.push_back(Use(Default, this));
}
-SwitchInst::SwitchInst(Value *V, BasicBlock *DefaultDest,
- BasicBlock *InsertAtEnd)
+SwitchInst::SwitchInst(Value *V, BasicBlock *D,
+ Instruction *InsertBefore)
+ : TerminatorInst(Instruction::Switch, InsertBefore) {
+ init(V, D);
+}
+
+SwitchInst::SwitchInst(Value *V, BasicBlock *D, BasicBlock *InsertAtEnd)
: TerminatorInst(Instruction::Switch, InsertAtEnd) {
- assert(V && DefaultDest);
- Operands.push_back(Use(V, this));
- Operands.push_back(Use(DefaultDest, this));
+ init(V, D);
}
SwitchInst::SwitchInst(const SwitchInst &SI)