From e5828f1fa7c2691f747f5060ce11b8e55cea03ab Mon Sep 17 00:00:00 2001 From: Alkis Evlogimenos Date: Wed, 26 May 2004 21:41:09 +0000 Subject: [PATCH] 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 --- include/llvm/InstrTypes.h | 8 +++-- include/llvm/Instruction.h | 4 +++ include/llvm/iMemory.h | 11 +++++++ include/llvm/iTerminators.h | 24 ++++++++++----- lib/VMCore/InstrTypes.cpp | 3 +- lib/VMCore/Instruction.cpp | 28 ++++++++++++++---- lib/VMCore/iBranch.cpp | 53 +++++++++++++++------------------ lib/VMCore/iCall.cpp | 59 ++++++++++++++++--------------------- lib/VMCore/iMemory.cpp | 31 +++++++++---------- lib/VMCore/iSwitch.cpp | 24 ++++++++------- 10 files changed, 135 insertions(+), 110 deletions(-) diff --git a/include/llvm/InstrTypes.h b/include/llvm/InstrTypes.h index 30ba130b892..df64c9bd0ee 100644 --- a/include/llvm/InstrTypes.h +++ b/include/llvm/InstrTypes.h @@ -32,9 +32,13 @@ protected: 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 fae6d2a11a4..17eec871f7e 100644 --- a/include/llvm/Instruction.h +++ b/include/llvm/Instruction.h @@ -36,11 +36,15 @@ class Instruction : public User, public Annotable { friend class SymbolTableListTraits >; 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 64a546d3aaa..a794ca54023 100644 --- a/include/llvm/iMemory.h +++ b/include/llvm/iMemory.h @@ -163,6 +163,10 @@ class LoadInst : public Instruction { 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 @@ class StoreInst : public Instruction { 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 @@ class GetElementPtrInst : public Instruction { 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 &Idx); + public: GetElementPtrInst(Value *Ptr, const std::vector &Idx, const std::string &Name = "", Instruction *InsertBefore =0); diff --git a/include/llvm/iTerminators.h b/include/llvm/iTerminators.h index f6e1c362cfd..78a1b74fd84 100644 --- a/include/llvm/iTerminators.h +++ b/include/llvm/iTerminators.h @@ -32,6 +32,14 @@ class ReturnInst : public TerminatorInst { 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 @@ public: // 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 @@ public: /// 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 @@ class SwitchInst : public TerminatorInst { // 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 @@ public: /// class InvokeInst : public TerminatorInst { InvokeInst(const InvokeInst &BI); + void init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException, + const std::vector &Params); public: InvokeInst(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException, const std::vector &Params, const std::string &Name = "", diff --git a/lib/VMCore/InstrTypes.cpp b/lib/VMCore/InstrTypes.cpp index b10f9cc31cf..aa5c3514e25 100644 --- a/lib/VMCore/InstrTypes.cpp +++ b/lib/VMCore/InstrTypes.cpp @@ -29,8 +29,7 @@ TerminatorInst::TerminatorInst(Instruction::TermOps iType, Instruction *IB) } 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 0de34b5bd54..5ddf2843540 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, } } +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 78951b2965d..a5ba36fd177 100644 --- a/lib/VMCore/iBranch.cpp +++ b/lib/VMCore/iBranch.cpp @@ -28,52 +28,45 @@ void UnwindInst::setSuccessor(unsigned idx, BasicBlock *NewSucc) { 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 37298f99fd4..edd55933014 100644 --- a/lib/VMCore/iCall.cpp +++ b/lib/VMCore/iCall.cpp @@ -99,51 +99,42 @@ Function *CallInst::getCalledFunction() { // InvokeInst Implementation //===----------------------------------------------------------------------===// -InvokeInst::InvokeInst(Value *Func, BasicBlock *IfNormal, - BasicBlock *IfException, - const std::vector ¶ms, - const std::string &Name, Instruction *InsertBefore) - : TerminatorInst(cast(cast(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 &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(cast(Func->getType())->getElementType()); + cast(cast(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 ¶ms, - const std::string &Name, BasicBlock *InsertAtEnd) - : TerminatorInst(cast(cast(Func->getType()) + const std::vector &Params, + const std::string &Name, Instruction *InsertBefore) + : TerminatorInst(cast(cast(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(cast(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 &Params, + const std::string &Name, BasicBlock *InsertAtEnd) + : TerminatorInst(cast(cast(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 da4cc7483f0..2b731b45c5a 100644 --- a/lib/VMCore/iMemory.cpp +++ b/lib/VMCore/iMemory.cpp @@ -67,16 +67,14 @@ FreeInst::FreeInst(Value *Ptr, Instruction *InsertBefore) LoadInst::LoadInst(Value *Ptr, const std::string &Name, Instruction *InsertBef) : Instruction(cast(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(Ptr->getType())->getElementType(), Load, Name, InsertBef), Volatile(isVolatile) { - Operands.reserve(1); - Operands.push_back(Use(Ptr, this)); + init(Ptr); } //===----------------------------------------------------------------------===// @@ -85,19 +83,13 @@ LoadInst::LoadInst(Value *Ptr, const std::string &Name, bool isVolatile, 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 @@ static inline const Type *checkType(const Type *Ty) { return Ty; } -GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector &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 &Idx) +{ Operands.reserve(1+Idx.size()); Operands.push_back(Use(Ptr, this)); @@ -125,6 +114,14 @@ GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector &Idx, Operands.push_back(Use(Idx[i], this)); } +GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector &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 c4cffc22d7d..d4dccde5b58 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)