maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Refactor common initialization code in private init() functions. 

This is a first step in supplying append to basic block constructors
for all instruction types.

llvm-svn: 13793
This commit is contained in:
Alkis Evlogimenos 2004-05-26 21:41:09 +00:00
parent 9e84b503f0
commit 9f0fdf7482
10 changed files with 135 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
llvm/include/llvm/InstrTypes.h
View File

@ -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...

4
llvm/include/llvm/Instruction.h
View File

@ -36,11 +36,15 @@ class Instruction : public User, public Annotable {
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() {

11
llvm/include/llvm/iMemory.h
View File

@ -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<Value*> &Idx);
public:
GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
const std::string &Name = "", Instruction *InsertBefore =0);

24
llvm/include/llvm/iTerminators.h
View File

@ -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<Value*> &Params);
public:
InvokeInst(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
const std::vector<Value*> &Params, const std::string &Name = "",

3
llvm/lib/VMCore/InstrTypes.cpp
View File

@ -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) {
}

28
llvm/lib/VMCore/Instruction.cpp
View File

@ -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);

53
llvm/lib/VMCore/iBranch.cpp
View File

@ -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) {

59
llvm/lib/VMCore/iCall.cpp
View File

@ -99,51 +99,42 @@ Function *CallInst::getCalledFunction() {
// InvokeInst Implementation
//===----------------------------------------------------------------------===//
InvokeInst::InvokeInst(Value *Func, BasicBlock *IfNormal,
BasicBlock *IfException,
const std::vector<Value*> &params,
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*> &params,
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)

31
llvm/lib/VMCore/iMemory.cpp
View File

@ -67,16 +67,14 @@ FreeInst::FreeInst(Value *Ptr, Instruction *InsertBefore)
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 @@ 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<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 @@ GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
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.
//

24
llvm/lib/VMCore/iSwitch.cpp
View File

@ -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)