[llvm] r344769 - [TI removal] Remove `TerminatorInst` from the IR type system!
Justin Bogner via llvm-commits
llvm-commits at lists.llvm.org
Mon Oct 22 12:03:53 PDT 2018
Chandler Carruth via llvm-commits <llvm-commits at lists.llvm.org> writes:
> Author: chandlerc
> Date: Thu Oct 18 17:22:37 2018
> New Revision: 344769
>
> URL: http://llvm.org/viewvc/llvm-project?rev=344769&view=rev
> Log:
> [TI removal] Remove `TerminatorInst` from the IR type system!
It's best to include instructions for updating code directly in the
commit message for this kind of change so that it's easy to find. In any
case, could you please add a note to the release notes about this being
removed and saying to replace isa<TerminatorInst>(I) with
I.isTerminator() or so?
> Modified:
> llvm/trunk/include/llvm/IR/InstrTypes.h
> llvm/trunk/include/llvm/IR/Instructions.h
> llvm/trunk/lib/IR/Instructions.cpp
>
> Modified: llvm/trunk/include/llvm/IR/InstrTypes.h
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/IR/InstrTypes.h?rev=344769&r1=344768&r2=344769&view=diff
> ==============================================================================
>
> --- llvm/trunk/include/llvm/IR/InstrTypes.h (original)
> +++ llvm/trunk/include/llvm/IR/InstrTypes.h Thu Oct 18 17:22:37 2018
> @@ -46,34 +46,6 @@
> namespace llvm {
>
> //===----------------------------------------------------------------------===//
> -// TerminatorInst Class
> -//===----------------------------------------------------------------------===//
> -
> -/// Subclasses of this class are all able to terminate a basic
> -/// block. Thus, these are all the flow control type of operations.
> -///
> -class TerminatorInst : public Instruction {
> -protected:
> - TerminatorInst(Type *Ty, Instruction::TermOps iType,
> - Use *Ops, unsigned NumOps,
> - Instruction *InsertBefore = nullptr)
> - : Instruction(Ty, iType, Ops, NumOps, InsertBefore) {}
> -
> - TerminatorInst(Type *Ty, Instruction::TermOps iType,
> - Use *Ops, unsigned NumOps, BasicBlock *InsertAtEnd)
> - : Instruction(Ty, iType, Ops, NumOps, InsertAtEnd) {}
> -
> -public:
> - // Methods for support type inquiry through isa, cast, and dyn_cast:
> - static bool classof(const Instruction *I) {
> - return I->isTerminator();
> - }
> - static bool classof(const Value *V) {
> - return isa<Instruction>(V) && classof(cast<Instruction>(V));
> - }
> -};
> -
> -//===----------------------------------------------------------------------===//
> // UnaryInstruction Class
> //===----------------------------------------------------------------------===//
>
>
> Modified: llvm/trunk/include/llvm/IR/Instructions.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/IR/Instructions.h?rev=344769&r1=344768&r2=344769&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/IR/Instructions.h (original)
> +++ llvm/trunk/include/llvm/IR/Instructions.h Thu Oct 18 17:22:37 2018
> @@ -1357,8 +1357,6 @@ class InvokeInst;
>
> template <class T> struct CallBaseParent { using type = Instruction; };
>
> -template <> struct CallBaseParent<InvokeInst> { using type = TerminatorInst; };
> -
> //===----------------------------------------------------------------------===//
> /// Base class for all callable instructions (InvokeInst and CallInst)
> /// Holds everything related to calling a function, abstracting from the base
> @@ -3265,7 +3263,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(Lan
> /// Return a value (possibly void), from a function. Execution
> /// does not continue in this function any longer.
> ///
> -class ReturnInst : public TerminatorInst {
> +class ReturnInst : public Instruction {
> ReturnInst(const ReturnInst &RI);
>
> private:
> @@ -3325,8 +3323,6 @@ public:
> }
>
> private:
> - friend TerminatorInst;
> -
> BasicBlock *getSuccessor(unsigned idx) const {
> llvm_unreachable("ReturnInst has no successors!");
> }
> @@ -3349,7 +3345,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(Ret
> //===---------------------------------------------------------------------------
> /// Conditional or Unconditional Branch instruction.
> ///
> -class BranchInst : public TerminatorInst {
> +class BranchInst : public Instruction {
> /// Ops list - Branches are strange. The operands are ordered:
> /// [Cond, FalseDest,] TrueDest. This makes some accessors faster because
> /// they don't have to check for cond/uncond branchness. These are mostly
> @@ -3493,7 +3489,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(Bra
> //===---------------------------------------------------------------------------
> /// Multiway switch
> ///
> -class SwitchInst : public TerminatorInst {
> +class SwitchInst : public Instruction {
> unsigned ReservedSpace;
>
> // Operand[0] = Value to switch on
> @@ -3576,7 +3572,7 @@ public:
> /// Returns number of current case.
> unsigned getCaseIndex() const { return Index; }
>
> - /// Returns TerminatorInst's successor index for current case successor.
> + /// Returns successor index for current case successor.
> unsigned getSuccessorIndex() const {
> assert(((unsigned)Index == DefaultPseudoIndex ||
> (unsigned)Index < SI->getNumCases()) &&
> @@ -3632,7 +3628,7 @@ public:
> CaseIteratorImpl(SwitchInstT *SI, unsigned CaseNum) : Case(SI, CaseNum) {}
>
> /// Initializes case iterator for given SwitchInst and for given
> - /// TerminatorInst's successor index.
> + /// successor index.
> static CaseIteratorImpl fromSuccessorIndex(SwitchInstT *SI,
> unsigned SuccessorIndex) {
> assert(SuccessorIndex < SI->getNumSuccessors() &&
> @@ -3850,7 +3846,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(Swi
> //===---------------------------------------------------------------------------
> /// Indirect Branch Instruction.
> ///
> -class IndirectBrInst : public TerminatorInst {
> +class IndirectBrInst : public Instruction {
> unsigned ReservedSpace;
>
> // Operand[0] = Address to jump to
> @@ -4226,7 +4222,7 @@ InvokeInst::InvokeInst(Value *Func, Basi
> //===---------------------------------------------------------------------------
> /// Resume the propagation of an exception.
> ///
> -class ResumeInst : public TerminatorInst {
> +class ResumeInst : public Instruction {
> ResumeInst(const ResumeInst &RI);
>
> explicit ResumeInst(Value *Exn, Instruction *InsertBefore=nullptr);
> @@ -4264,8 +4260,6 @@ public:
> }
>
> private:
> - friend TerminatorInst;
> -
> BasicBlock *getSuccessor(unsigned idx) const {
> llvm_unreachable("ResumeInst has no successors!");
> }
> @@ -4285,7 +4279,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(Res
> //===----------------------------------------------------------------------===//
> // CatchSwitchInst Class
> //===----------------------------------------------------------------------===//
> -class CatchSwitchInst : public TerminatorInst {
> +class CatchSwitchInst : public Instruction {
> /// The number of operands actually allocated. NumOperands is
> /// the number actually in use.
> unsigned ReservedSpace;
> @@ -4551,7 +4545,7 @@ public:
> // CatchReturnInst Class
> //===----------------------------------------------------------------------===//
>
> -class CatchReturnInst : public TerminatorInst {
> +class CatchReturnInst : public Instruction {
> CatchReturnInst(const CatchReturnInst &RI);
> CatchReturnInst(Value *CatchPad, BasicBlock *BB, Instruction *InsertBefore);
> CatchReturnInst(Value *CatchPad, BasicBlock *BB, BasicBlock *InsertAtEnd);
> @@ -4611,8 +4605,6 @@ public:
> }
>
> private:
> - friend TerminatorInst;
> -
> BasicBlock *getSuccessor(unsigned Idx) const {
> assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!");
> return getSuccessor();
> @@ -4634,7 +4626,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(Cat
> // CleanupReturnInst Class
> //===----------------------------------------------------------------------===//
>
> -class CleanupReturnInst : public TerminatorInst {
> +class CleanupReturnInst : public Instruction {
> private:
> CleanupReturnInst(const CleanupReturnInst &RI);
> CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
> @@ -4707,8 +4699,6 @@ public:
> }
>
> private:
> - friend TerminatorInst;
> -
> BasicBlock *getSuccessor(unsigned Idx) const {
> assert(Idx == 0);
> return getUnwindDest();
> @@ -4741,7 +4731,7 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(Cle
> /// presence of this instruction indicates some higher level knowledge that the
> /// end of the block cannot be reached.
> ///
> -class UnreachableInst : public TerminatorInst {
> +class UnreachableInst : public Instruction {
> protected:
> // Note: Instruction needs to be a friend here to call cloneImpl.
> friend class Instruction;
> @@ -4768,8 +4758,6 @@ public:
> }
>
> private:
> - friend TerminatorInst;
> -
> BasicBlock *getSuccessor(unsigned idx) const {
> llvm_unreachable("UnreachableInst has no successors!");
> }
>
> Modified: llvm/trunk/lib/IR/Instructions.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/IR/Instructions.cpp?rev=344769&r1=344768&r2=344769&view=diff
> ==============================================================================
> --- llvm/trunk/lib/IR/Instructions.cpp (original)
> +++ llvm/trunk/lib/IR/Instructions.cpp Thu Oct 18 17:22:37 2018
> @@ -622,55 +622,53 @@ LandingPadInst *InvokeInst::getLandingPa
> //===----------------------------------------------------------------------===//
>
> ReturnInst::ReturnInst(const ReturnInst &RI)
> - : TerminatorInst(Type::getVoidTy(RI.getContext()), Instruction::Ret,
> - OperandTraits<ReturnInst>::op_end(this) -
> - RI.getNumOperands(),
> - RI.getNumOperands()) {
> + : Instruction(Type::getVoidTy(RI.getContext()), Instruction::Ret,
> + OperandTraits<ReturnInst>::op_end(this) - RI.getNumOperands(),
> + RI.getNumOperands()) {
> if (RI.getNumOperands())
> Op<0>() = RI.Op<0>();
> SubclassOptionalData = RI.SubclassOptionalData;
> }
>
> ReturnInst::ReturnInst(LLVMContext &C, Value *retVal, Instruction *InsertBefore)
> - : TerminatorInst(Type::getVoidTy(C), Instruction::Ret,
> - OperandTraits<ReturnInst>::op_end(this) - !!retVal, !!retVal,
> - InsertBefore) {
> + : Instruction(Type::getVoidTy(C), Instruction::Ret,
> + OperandTraits<ReturnInst>::op_end(this) - !!retVal, !!retVal,
> + InsertBefore) {
> if (retVal)
> Op<0>() = retVal;
> }
>
> ReturnInst::ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd)
> - : TerminatorInst(Type::getVoidTy(C), Instruction::Ret,
> - OperandTraits<ReturnInst>::op_end(this) - !!retVal, !!retVal,
> - InsertAtEnd) {
> + : Instruction(Type::getVoidTy(C), Instruction::Ret,
> + OperandTraits<ReturnInst>::op_end(this) - !!retVal, !!retVal,
> + InsertAtEnd) {
> if (retVal)
> Op<0>() = retVal;
> }
>
> ReturnInst::ReturnInst(LLVMContext &Context, BasicBlock *InsertAtEnd)
> - : TerminatorInst(Type::getVoidTy(Context), Instruction::Ret,
> - OperandTraits<ReturnInst>::op_end(this), 0, InsertAtEnd) {
> -}
> + : Instruction(Type::getVoidTy(Context), Instruction::Ret,
> + OperandTraits<ReturnInst>::op_end(this), 0, InsertAtEnd) {}
>
> //===----------------------------------------------------------------------===//
> // ResumeInst Implementation
> //===----------------------------------------------------------------------===//
>
> ResumeInst::ResumeInst(const ResumeInst &RI)
> - : TerminatorInst(Type::getVoidTy(RI.getContext()), Instruction::Resume,
> - OperandTraits<ResumeInst>::op_begin(this), 1) {
> + : Instruction(Type::getVoidTy(RI.getContext()), Instruction::Resume,
> + OperandTraits<ResumeInst>::op_begin(this), 1) {
> Op<0>() = RI.Op<0>();
> }
>
> ResumeInst::ResumeInst(Value *Exn, Instruction *InsertBefore)
> - : TerminatorInst(Type::getVoidTy(Exn->getContext()), Instruction::Resume,
> - OperandTraits<ResumeInst>::op_begin(this), 1, InsertBefore) {
> + : Instruction(Type::getVoidTy(Exn->getContext()), Instruction::Resume,
> + OperandTraits<ResumeInst>::op_begin(this), 1, InsertBefore) {
> Op<0>() = Exn;
> }
>
> ResumeInst::ResumeInst(Value *Exn, BasicBlock *InsertAtEnd)
> - : TerminatorInst(Type::getVoidTy(Exn->getContext()), Instruction::Resume,
> - OperandTraits<ResumeInst>::op_begin(this), 1, InsertAtEnd) {
> + : Instruction(Type::getVoidTy(Exn->getContext()), Instruction::Resume,
> + OperandTraits<ResumeInst>::op_begin(this), 1, InsertAtEnd) {
> Op<0>() = Exn;
> }
>
> @@ -679,10 +677,10 @@ ResumeInst::ResumeInst(Value *Exn, Basic
> //===----------------------------------------------------------------------===//
>
> CleanupReturnInst::CleanupReturnInst(const CleanupReturnInst &CRI)
> - : TerminatorInst(CRI.getType(), Instruction::CleanupRet,
> - OperandTraits<CleanupReturnInst>::op_end(this) -
> - CRI.getNumOperands(),
> - CRI.getNumOperands()) {
> + : Instruction(CRI.getType(), Instruction::CleanupRet,
> + OperandTraits<CleanupReturnInst>::op_end(this) -
> + CRI.getNumOperands(),
> + CRI.getNumOperands()) {
> setInstructionSubclassData(CRI.getSubclassDataFromInstruction());
> Op<0>() = CRI.Op<0>();
> if (CRI.hasUnwindDest())
> @@ -700,19 +698,19 @@ void CleanupReturnInst::init(Value *Clea
>
> CleanupReturnInst::CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB,
> unsigned Values, Instruction *InsertBefore)
> - : TerminatorInst(Type::getVoidTy(CleanupPad->getContext()),
> - Instruction::CleanupRet,
> - OperandTraits<CleanupReturnInst>::op_end(this) - Values,
> - Values, InsertBefore) {
> + : Instruction(Type::getVoidTy(CleanupPad->getContext()),
> + Instruction::CleanupRet,
> + OperandTraits<CleanupReturnInst>::op_end(this) - Values,
> + Values, InsertBefore) {
> init(CleanupPad, UnwindBB);
> }
>
> CleanupReturnInst::CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB,
> unsigned Values, BasicBlock *InsertAtEnd)
> - : TerminatorInst(Type::getVoidTy(CleanupPad->getContext()),
> - Instruction::CleanupRet,
> - OperandTraits<CleanupReturnInst>::op_end(this) - Values,
> - Values, InsertAtEnd) {
> + : Instruction(Type::getVoidTy(CleanupPad->getContext()),
> + Instruction::CleanupRet,
> + OperandTraits<CleanupReturnInst>::op_end(this) - Values,
> + Values, InsertAtEnd) {
> init(CleanupPad, UnwindBB);
> }
>
> @@ -725,25 +723,25 @@ void CatchReturnInst::init(Value *CatchP
> }
>
> CatchReturnInst::CatchReturnInst(const CatchReturnInst &CRI)
> - : TerminatorInst(Type::getVoidTy(CRI.getContext()), Instruction::CatchRet,
> - OperandTraits<CatchReturnInst>::op_begin(this), 2) {
> + : Instruction(Type::getVoidTy(CRI.getContext()), Instruction::CatchRet,
> + OperandTraits<CatchReturnInst>::op_begin(this), 2) {
> Op<0>() = CRI.Op<0>();
> Op<1>() = CRI.Op<1>();
> }
>
> CatchReturnInst::CatchReturnInst(Value *CatchPad, BasicBlock *BB,
> Instruction *InsertBefore)
> - : TerminatorInst(Type::getVoidTy(BB->getContext()), Instruction::CatchRet,
> - OperandTraits<CatchReturnInst>::op_begin(this), 2,
> - InsertBefore) {
> + : Instruction(Type::getVoidTy(BB->getContext()), Instruction::CatchRet,
> + OperandTraits<CatchReturnInst>::op_begin(this), 2,
> + InsertBefore) {
> init(CatchPad, BB);
> }
>
> CatchReturnInst::CatchReturnInst(Value *CatchPad, BasicBlock *BB,
> BasicBlock *InsertAtEnd)
> - : TerminatorInst(Type::getVoidTy(BB->getContext()), Instruction::CatchRet,
> - OperandTraits<CatchReturnInst>::op_begin(this), 2,
> - InsertAtEnd) {
> + : Instruction(Type::getVoidTy(BB->getContext()), Instruction::CatchRet,
> + OperandTraits<CatchReturnInst>::op_begin(this), 2,
> + InsertAtEnd) {
> init(CatchPad, BB);
> }
>
> @@ -755,8 +753,8 @@ CatchSwitchInst::CatchSwitchInst(Value *
> unsigned NumReservedValues,
> const Twine &NameStr,
> Instruction *InsertBefore)
> - : TerminatorInst(ParentPad->getType(), Instruction::CatchSwitch, nullptr, 0,
> - InsertBefore) {
> + : Instruction(ParentPad->getType(), Instruction::CatchSwitch, nullptr, 0,
> + InsertBefore) {
> if (UnwindDest)
> ++NumReservedValues;
> init(ParentPad, UnwindDest, NumReservedValues + 1);
> @@ -766,8 +764,8 @@ CatchSwitchInst::CatchSwitchInst(Value *
> CatchSwitchInst::CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
> unsigned NumReservedValues,
> const Twine &NameStr, BasicBlock *InsertAtEnd)
> - : TerminatorInst(ParentPad->getType(), Instruction::CatchSwitch, nullptr, 0,
> - InsertAtEnd) {
> + : Instruction(ParentPad->getType(), Instruction::CatchSwitch, nullptr, 0,
> + InsertAtEnd) {
> if (UnwindDest)
> ++NumReservedValues;
> init(ParentPad, UnwindDest, NumReservedValues + 1);
> @@ -775,8 +773,8 @@ CatchSwitchInst::CatchSwitchInst(Value *
> }
>
> CatchSwitchInst::CatchSwitchInst(const CatchSwitchInst &CSI)
> - : TerminatorInst(CSI.getType(), Instruction::CatchSwitch, nullptr,
> - CSI.getNumOperands()) {
> + : Instruction(CSI.getType(), Instruction::CatchSwitch, nullptr,
> + CSI.getNumOperands()) {
> init(CSI.getParentPad(), CSI.getUnwindDest(), CSI.getNumOperands());
> setNumHungOffUseOperands(ReservedSpace);
> Use *OL = getOperandList();
> @@ -874,13 +872,11 @@ FuncletPadInst::FuncletPadInst(Instructi
>
> UnreachableInst::UnreachableInst(LLVMContext &Context,
> Instruction *InsertBefore)
> - : TerminatorInst(Type::getVoidTy(Context), Instruction::Unreachable,
> - nullptr, 0, InsertBefore) {
> -}
> + : Instruction(Type::getVoidTy(Context), Instruction::Unreachable, nullptr,
> + 0, InsertBefore) {}
> UnreachableInst::UnreachableInst(LLVMContext &Context, BasicBlock *InsertAtEnd)
> - : TerminatorInst(Type::getVoidTy(Context), Instruction::Unreachable,
> - nullptr, 0, InsertAtEnd) {
> -}
> + : Instruction(Type::getVoidTy(Context), Instruction::Unreachable, nullptr,
> + 0, InsertAtEnd) {}
>
> //===----------------------------------------------------------------------===//
> // BranchInst Implementation
> @@ -893,18 +889,18 @@ void BranchInst::AssertOK() {
> }
>
> BranchInst::BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore)
> - : TerminatorInst(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
> - OperandTraits<BranchInst>::op_end(this) - 1,
> - 1, InsertBefore) {
> + : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
> + OperandTraits<BranchInst>::op_end(this) - 1, 1,
> + InsertBefore) {
> assert(IfTrue && "Branch destination may not be null!");
> Op<-1>() = IfTrue;
> }
>
> BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
> Instruction *InsertBefore)
> - : TerminatorInst(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
> - OperandTraits<BranchInst>::op_end(this) - 3,
> - 3, InsertBefore) {
> + : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
> + OperandTraits<BranchInst>::op_end(this) - 3, 3,
> + InsertBefore) {
> Op<-1>() = IfTrue;
> Op<-2>() = IfFalse;
> Op<-3>() = Cond;
> @@ -914,18 +910,16 @@ BranchInst::BranchInst(BasicBlock *IfTru
> }
>
> BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd)
> - : TerminatorInst(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
> - OperandTraits<BranchInst>::op_end(this) - 1,
> - 1, InsertAtEnd) {
> + : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
> + OperandTraits<BranchInst>::op_end(this) - 1, 1, InsertAtEnd) {
> assert(IfTrue && "Branch destination may not be null!");
> Op<-1>() = IfTrue;
> }
>
> BranchInst::BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
> - BasicBlock *InsertAtEnd)
> - : TerminatorInst(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
> - OperandTraits<BranchInst>::op_end(this) - 3,
> - 3, InsertAtEnd) {
> + BasicBlock *InsertAtEnd)
> + : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
> + OperandTraits<BranchInst>::op_end(this) - 3, 3, InsertAtEnd) {
> Op<-1>() = IfTrue;
> Op<-2>() = IfFalse;
> Op<-3>() = Cond;
> @@ -934,10 +928,10 @@ BranchInst::BranchInst(BasicBlock *IfTru
> #endif
> }
>
> -BranchInst::BranchInst(const BranchInst &BI) :
> - TerminatorInst(Type::getVoidTy(BI.getContext()), Instruction::Br,
> - OperandTraits<BranchInst>::op_end(this) - BI.getNumOperands(),
> - BI.getNumOperands()) {
> +BranchInst::BranchInst(const BranchInst &BI)
> + : Instruction(Type::getVoidTy(BI.getContext()), Instruction::Br,
> + OperandTraits<BranchInst>::op_end(this) - BI.getNumOperands(),
> + BI.getNumOperands()) {
> Op<-1>() = BI.Op<-1>();
> if (BI.getNumOperands() != 1) {
> assert(BI.getNumOperands() == 3 && "BR can have 1 or 3 operands!");
> @@ -3567,8 +3561,8 @@ void SwitchInst::init(Value *Value, Basi
> /// constructor can also autoinsert before another instruction.
> SwitchInst::SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
> Instruction *InsertBefore)
> - : TerminatorInst(Type::getVoidTy(Value->getContext()), Instruction::Switch,
> - nullptr, 0, InsertBefore) {
> + : Instruction(Type::getVoidTy(Value->getContext()), Instruction::Switch,
> + nullptr, 0, InsertBefore) {
> init(Value, Default, 2+NumCases*2);
> }
>
> @@ -3578,13 +3572,13 @@ SwitchInst::SwitchInst(Value *Value, Bas
> /// constructor also autoinserts at the end of the specified BasicBlock.
> SwitchInst::SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
> BasicBlock *InsertAtEnd)
> - : TerminatorInst(Type::getVoidTy(Value->getContext()), Instruction::Switch,
> - nullptr, 0, InsertAtEnd) {
> + : Instruction(Type::getVoidTy(Value->getContext()), Instruction::Switch,
> + nullptr, 0, InsertAtEnd) {
> init(Value, Default, 2+NumCases*2);
> }
>
> SwitchInst::SwitchInst(const SwitchInst &SI)
> - : TerminatorInst(SI.getType(), Instruction::Switch, nullptr, 0) {
> + : Instruction(SI.getType(), Instruction::Switch, nullptr, 0) {
> init(SI.getCondition(), SI.getDefaultDest(), SI.getNumOperands());
> setNumHungOffUseOperands(SI.getNumOperands());
> Use *OL = getOperandList();
> @@ -3596,7 +3590,6 @@ SwitchInst::SwitchInst(const SwitchInst
> SubclassOptionalData = SI.SubclassOptionalData;
> }
>
> -
> /// addCase - Add an entry to the switch instruction...
> ///
> void SwitchInst::addCase(ConstantInt *OnVal, BasicBlock *Dest) {
> @@ -3675,21 +3668,21 @@ void IndirectBrInst::growOperands() {
>
> IndirectBrInst::IndirectBrInst(Value *Address, unsigned NumCases,
> Instruction *InsertBefore)
> -: TerminatorInst(Type::getVoidTy(Address->getContext()),Instruction::IndirectBr,
> - nullptr, 0, InsertBefore) {
> + : Instruction(Type::getVoidTy(Address->getContext()),
> + Instruction::IndirectBr, nullptr, 0, InsertBefore) {
> init(Address, NumCases);
> }
>
> IndirectBrInst::IndirectBrInst(Value *Address, unsigned NumCases,
> BasicBlock *InsertAtEnd)
> -: TerminatorInst(Type::getVoidTy(Address->getContext()),Instruction::IndirectBr,
> - nullptr, 0, InsertAtEnd) {
> + : Instruction(Type::getVoidTy(Address->getContext()),
> + Instruction::IndirectBr, nullptr, 0, InsertAtEnd) {
> init(Address, NumCases);
> }
>
> IndirectBrInst::IndirectBrInst(const IndirectBrInst &IBI)
> - : TerminatorInst(Type::getVoidTy(IBI.getContext()), Instruction::IndirectBr,
> - nullptr, IBI.getNumOperands()) {
> + : Instruction(Type::getVoidTy(IBI.getContext()), Instruction::IndirectBr,
> + nullptr, IBI.getNumOperands()) {
> allocHungoffUses(IBI.getNumOperands());
> Use *OL = getOperandList();
> const Use *InOL = IBI.getOperandList();
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list