mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-17 05:29:24 +00:00
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
This commit is contained in:
parent
99c58f4910
commit
e5828f1fa7
@ -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...
|
||||
|
@ -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() {
|
||||
|
@ -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);
|
||||
|
@ -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 = "",
|
||||
|
@ -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) {
|
||||
}
|
||||
|
||||
|
||||
|
@ -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);
|
||||
|
@ -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) {
|
||||
|
@ -99,51 +99,42 @@ Function *CallInst::getCalledFunction() {
|
||||
// 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)
|
||||
|
@ -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.
|
||||
//
|
||||
|
@ -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)
|
||||
|
Loading…
Reference in New Issue
Block a user