diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h index c004347fbd8..259959ddc65 100644 --- a/include/llvm/Instructions.h +++ b/include/llvm/Instructions.h @@ -16,10 +16,1181 @@ #ifndef LLVM_INSTRUCTIONS_H #define LLVM_INSTRUCTIONS_H -#include "llvm/iTerminators.h" // Terminator instructions -#include "llvm/iPHINode.h" // The PHI node instruction -#include "llvm/iOperators.h" // Binary operator instructions -#include "llvm/iMemory.h" // Memory related instructions -#include "llvm/iOther.h" // Everything else +#include "llvm/Instruction.h" +#include "llvm/InstrTypes.h" + +namespace llvm { + +struct BasicBlock; +class PointerType; + +//===----------------------------------------------------------------------===// +// AllocationInst Class +//===----------------------------------------------------------------------===// + +/// AllocationInst - This class is the common base class of MallocInst and +/// AllocaInst. +/// +class AllocationInst : public Instruction { +protected: + void init(const Type *Ty, Value *ArraySize, unsigned iTy); + AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, + const std::string &Name = "", Instruction *InsertBefore = 0); + AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, + const std::string &Name, BasicBlock *InsertAtEnd); + +public: + + /// isArrayAllocation - Return true if there is an allocation size parameter + /// to the allocation instruction that is not 1. + /// + bool isArrayAllocation() const; + + /// getArraySize - Get the number of element allocated, for a simple + /// allocation of a single element, this will return a constant 1 value. + /// + inline const Value *getArraySize() const { return Operands[0]; } + inline Value *getArraySize() { return Operands[0]; } + + /// getType - Overload to return most specific pointer type + /// + inline const PointerType *getType() const { + return reinterpret_cast(Instruction::getType()); + } + + /// getAllocatedType - Return the type that is being allocated by the + /// instruction. + /// + const Type *getAllocatedType() const; + + virtual Instruction *clone() const = 0; + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const AllocationInst *) { return true; } + static inline bool classof(const Instruction *I) { + return I->getOpcode() == Instruction::Alloca || + I->getOpcode() == Instruction::Malloc; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + + +//===----------------------------------------------------------------------===// +// MallocInst Class +//===----------------------------------------------------------------------===// + +/// MallocInst - an instruction to allocated memory on the heap +/// +class MallocInst : public AllocationInst { + MallocInst(const MallocInst &MI); +public: + explicit MallocInst(const Type *Ty, Value *ArraySize = 0, + const std::string &Name = "", + Instruction *InsertBefore = 0) + : AllocationInst(Ty, ArraySize, Malloc, Name, InsertBefore) {} + MallocInst(const Type *Ty, Value *ArraySize, const std::string &Name, + BasicBlock *InsertAtEnd) + : AllocationInst(Ty, ArraySize, Malloc, Name, InsertAtEnd) {} + + virtual Instruction *clone() const { + return new MallocInst(*this); + } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const MallocInst *) { return true; } + static inline bool classof(const Instruction *I) { + return (I->getOpcode() == Instruction::Malloc); + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + + +//===----------------------------------------------------------------------===// +// AllocaInst Class +//===----------------------------------------------------------------------===// + +/// AllocaInst - an instruction to allocate memory on the stack +/// +class AllocaInst : public AllocationInst { + AllocaInst(const AllocaInst &); +public: + explicit AllocaInst(const Type *Ty, Value *ArraySize = 0, + const std::string &Name = "", + Instruction *InsertBefore = 0) + : AllocationInst(Ty, ArraySize, Alloca, Name, InsertBefore) {} + AllocaInst(const Type *Ty, Value *ArraySize, const std::string &Name, + BasicBlock *InsertAtEnd) + : AllocationInst(Ty, ArraySize, Alloca, Name, InsertAtEnd) {} + + virtual Instruction *clone() const { + return new AllocaInst(*this); + } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const AllocaInst *) { return true; } + static inline bool classof(const Instruction *I) { + return (I->getOpcode() == Instruction::Alloca); + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + + +//===----------------------------------------------------------------------===// +// FreeInst Class +//===----------------------------------------------------------------------===// + +/// FreeInst - an instruction to deallocate memory +/// +class FreeInst : public Instruction { + void init(Value *Ptr); + +public: + explicit FreeInst(Value *Ptr, Instruction *InsertBefore = 0); + FreeInst(Value *Ptr, BasicBlock *InsertAfter); + + virtual Instruction *clone() const { return new FreeInst(Operands[0]); } + + virtual bool mayWriteToMemory() const { return true; } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const FreeInst *) { return true; } + static inline bool classof(const Instruction *I) { + return (I->getOpcode() == Instruction::Free); + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + + +//===----------------------------------------------------------------------===// +// LoadInst Class +//===----------------------------------------------------------------------===// + +/// LoadInst - an instruction for reading from memory +/// +class LoadInst : public Instruction { + LoadInst(const LoadInst &LI) : Instruction(LI.getType(), Load) { + Volatile = LI.isVolatile(); + init(LI.Operands[0]); + } + bool Volatile; // True if this is a volatile load + void init(Value *Ptr); +public: + LoadInst(Value *Ptr, const std::string &Name, Instruction *InsertBefore); + LoadInst(Value *Ptr, const std::string &Name, BasicBlock *InsertAtEnd); + LoadInst(Value *Ptr, const std::string &Name = "", bool isVolatile = false, + Instruction *InsertBefore = 0); + LoadInst(Value *Ptr, const std::string &Name, bool isVolatile, + BasicBlock *InsertAtEnd); + + /// isVolatile - Return true if this is a load from a volatile memory + /// location. + /// + bool isVolatile() const { return Volatile; } + + /// setVolatile - Specify whether this is a volatile load or not. + /// + void setVolatile(bool V) { Volatile = V; } + + virtual Instruction *clone() const { return new LoadInst(*this); } + + virtual bool mayWriteToMemory() const { return isVolatile(); } + + Value *getPointerOperand() { return getOperand(0); } + const Value *getPointerOperand() const { return getOperand(0); } + static unsigned getPointerOperandIndex() { return 0U; } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const LoadInst *) { return true; } + static inline bool classof(const Instruction *I) { + return I->getOpcode() == Instruction::Load; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + + +//===----------------------------------------------------------------------===// +// StoreInst Class +//===----------------------------------------------------------------------===// + +/// StoreInst - an instruction for storing to memory +/// +class StoreInst : public Instruction { + StoreInst(const StoreInst &SI) : Instruction(SI.getType(), Store) { + Volatile = SI.isVolatile(); + init(SI.Operands[0], SI.Operands[1]); + } + bool Volatile; // True if this is a volatile store + void init(Value *Val, Value *Ptr); +public: + StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore); + StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd); + StoreInst(Value *Val, Value *Ptr, bool isVolatile = false, + Instruction *InsertBefore = 0); + StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd); + + + /// isVolatile - Return true if this is a load from a volatile memory + /// location. + /// + bool isVolatile() const { return Volatile; } + + /// setVolatile - Specify whether this is a volatile load or not. + /// + void setVolatile(bool V) { Volatile = V; } + + virtual Instruction *clone() const { return new StoreInst(*this); } + + virtual bool mayWriteToMemory() const { return true; } + + Value *getPointerOperand() { return getOperand(1); } + const Value *getPointerOperand() const { return getOperand(1); } + static unsigned getPointerOperandIndex() { return 1U; } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const StoreInst *) { return true; } + static inline bool classof(const Instruction *I) { + return I->getOpcode() == Instruction::Store; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + + +//===----------------------------------------------------------------------===// +// GetElementPtrInst Class +//===----------------------------------------------------------------------===// + +/// GetElementPtrInst - an instruction for type-safe pointer arithmetic to +/// access elements of arrays and structs +/// +class GetElementPtrInst : public Instruction { + GetElementPtrInst(const GetElementPtrInst &EPI) + : Instruction((static_cast(&EPI)->getType()), + GetElementPtr) { + Operands.reserve(EPI.Operands.size()); + 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); + void init(Value *Ptr, Value *Idx0, Value *Idx1); +public: + /// Constructors - Create a getelementptr instruction with a base pointer an + /// list of indices. The first ctor can optionally insert before an existing + /// instruction, the second appends the new instruction to the specified + /// BasicBlock. + GetElementPtrInst(Value *Ptr, const std::vector &Idx, + const std::string &Name = "", Instruction *InsertBefore =0); + GetElementPtrInst(Value *Ptr, const std::vector &Idx, + const std::string &Name, BasicBlock *InsertAtEnd); + + /// Constructors - These two constructors are convenience methods because two + /// index getelementptr instructions are so common. + GetElementPtrInst(Value *Ptr, Value *Idx0, Value *Idx1, + const std::string &Name = "", Instruction *InsertBefore =0); + GetElementPtrInst(Value *Ptr, Value *Idx0, Value *Idx1, + const std::string &Name, BasicBlock *InsertAtEnd); + + virtual Instruction *clone() const { return new GetElementPtrInst(*this); } + + // getType - Overload to return most specific pointer type... + inline const PointerType *getType() const { + return reinterpret_cast(Instruction::getType()); + } + + /// getIndexedType - Returns the type of the element that would be loaded with + /// a load instruction with the specified parameters. + /// + /// A null type is returned if the indices are invalid for the specified + /// pointer type. + /// + static const Type *getIndexedType(const Type *Ptr, + const std::vector &Indices, + bool AllowStructLeaf = false); + static const Type *getIndexedType(const Type *Ptr, Value *Idx0, Value *Idx1, + bool AllowStructLeaf = false); + + inline op_iterator idx_begin() { return op_begin()+1; } + inline const_op_iterator idx_begin() const { return op_begin()+1; } + inline op_iterator idx_end() { return op_end(); } + inline const_op_iterator idx_end() const { return op_end(); } + + Value *getPointerOperand() { + return getOperand(0); + } + const Value *getPointerOperand() const { + return getOperand(0); + } + static unsigned getPointerOperandIndex() { + return 0U; // get index for modifying correct operand + } + + inline unsigned getNumIndices() const { // Note: always non-negative + return getNumOperands() - 1; + } + + inline bool hasIndices() const { + return getNumOperands() > 1; + } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const GetElementPtrInst *) { return true; } + static inline bool classof(const Instruction *I) { + return (I->getOpcode() == Instruction::GetElementPtr); + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + +//===----------------------------------------------------------------------===// +// SetCondInst Class +//===----------------------------------------------------------------------===// + +/// SetCondInst class - Represent a setCC operator, where CC is eq, ne, lt, gt, +/// le, or ge. +/// +class SetCondInst : public BinaryOperator { + BinaryOps OpType; +public: + SetCondInst(BinaryOps Opcode, Value *LHS, Value *RHS, + const std::string &Name = "", Instruction *InsertBefore = 0); + SetCondInst(BinaryOps Opcode, Value *LHS, Value *RHS, + const std::string &Name, BasicBlock *InsertAtEnd); + + /// getInverseCondition - Return the inverse of the current condition opcode. + /// For example seteq -> setne, setgt -> setle, setlt -> setge, etc... + /// + BinaryOps getInverseCondition() const { + return getInverseCondition(getOpcode()); + } + + /// getInverseCondition - Static version that you can use without an + /// instruction available. + /// + static BinaryOps getInverseCondition(BinaryOps Opcode); + + /// getSwappedCondition - Return the condition opcode that would be the result + /// of exchanging the two operands of the setcc instruction without changing + /// the result produced. Thus, seteq->seteq, setle->setge, setlt->setgt, etc. + /// + BinaryOps getSwappedCondition() const { + return getSwappedCondition(getOpcode()); + } + + /// getSwappedCondition - Static version that you can use without an + /// instruction available. + /// + static BinaryOps getSwappedCondition(BinaryOps Opcode); + + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const SetCondInst *) { return true; } + static inline bool classof(const Instruction *I) { + return I->getOpcode() == SetEQ || I->getOpcode() == SetNE || + I->getOpcode() == SetLE || I->getOpcode() == SetGE || + I->getOpcode() == SetLT || I->getOpcode() == SetGT; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + +//===----------------------------------------------------------------------===// +// CastInst Class +//===----------------------------------------------------------------------===// + +/// CastInst - This class represents a cast from Operand[0] to the type of +/// the instruction (i->getType()). +/// +class CastInst : public Instruction { + CastInst(const CastInst &CI) : Instruction(CI.getType(), Cast) { + Operands.reserve(1); + Operands.push_back(Use(CI.Operands[0], this)); + } + void init(Value *S) { + Operands.reserve(1); + Operands.push_back(Use(S, this)); + } +public: + CastInst(Value *S, const Type *Ty, const std::string &Name = "", + Instruction *InsertBefore = 0) + : Instruction(Ty, Cast, Name, InsertBefore) { + init(S); + } + CastInst(Value *S, const Type *Ty, const std::string &Name, + BasicBlock *InsertAtEnd) + : Instruction(Ty, Cast, Name, InsertAtEnd) { + init(S); + } + + virtual Instruction *clone() const { return new CastInst(*this); } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const CastInst *) { return true; } + static inline bool classof(const Instruction *I) { + return I->getOpcode() == Cast; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + + +//===----------------------------------------------------------------------===// +// CallInst Class +//===----------------------------------------------------------------------===// + +/// CallInst - This class represents a function call, abstracting a target +/// machine's calling convention. +/// +class CallInst : public Instruction { + CallInst(const CallInst &CI); + void init(Value *Func, const std::vector &Params); + void init(Value *Func, Value *Actual1, Value *Actual2); + void init(Value *Func, Value *Actual); + void init(Value *Func); + +public: + CallInst(Value *F, const std::vector &Par, + const std::string &Name = "", Instruction *InsertBefore = 0); + CallInst(Value *F, const std::vector &Par, + const std::string &Name, BasicBlock *InsertAtEnd); + + // Alternate CallInst ctors w/ two actuals, w/ one actual and no + // actuals, respectively. + CallInst(Value *F, Value *Actual1, Value *Actual2, + const std::string& Name = "", Instruction *InsertBefore = 0); + CallInst(Value *F, Value *Actual1, Value *Actual2, + const std::string& Name, BasicBlock *InsertAtEnd); + CallInst(Value *F, Value *Actual, const std::string& Name = "", + Instruction *InsertBefore = 0); + CallInst(Value *F, Value *Actual, const std::string& Name, + BasicBlock *InsertAtEnd); + explicit CallInst(Value *F, const std::string &Name = "", + Instruction *InsertBefore = 0); + explicit CallInst(Value *F, const std::string &Name, + BasicBlock *InsertAtEnd); + + virtual Instruction *clone() const { return new CallInst(*this); } + bool mayWriteToMemory() const { return true; } + + // FIXME: These methods should be inline once we eliminate + // ConstantPointerRefs! + const Function *getCalledFunction() const; + Function *getCalledFunction(); + + // getCalledValue - Get a pointer to a method that is invoked by this inst. + inline const Value *getCalledValue() const { return Operands[0]; } + inline Value *getCalledValue() { return Operands[0]; } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const CallInst *) { return true; } + static inline bool classof(const Instruction *I) { + return I->getOpcode() == Instruction::Call; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + + +//===----------------------------------------------------------------------===// +// ShiftInst Class +//===----------------------------------------------------------------------===// + +/// ShiftInst - This class represents left and right shift instructions. +/// +class ShiftInst : public Instruction { + ShiftInst(const ShiftInst &SI) : Instruction(SI.getType(), SI.getOpcode()) { + Operands.reserve(2); + Operands.push_back(Use(SI.Operands[0], this)); + Operands.push_back(Use(SI.Operands[1], this)); + } + void init(OtherOps Opcode, Value *S, Value *SA) { + assert((Opcode == Shl || Opcode == Shr) && "ShiftInst Opcode invalid!"); + Operands.reserve(2); + Operands.push_back(Use(S, this)); + Operands.push_back(Use(SA, this)); + } + +public: + ShiftInst(OtherOps Opcode, Value *S, Value *SA, const std::string &Name = "", + Instruction *InsertBefore = 0) + : Instruction(S->getType(), Opcode, Name, InsertBefore) { + init(Opcode, S, SA); + } + ShiftInst(OtherOps Opcode, Value *S, Value *SA, const std::string &Name, + BasicBlock *InsertAtEnd) + : Instruction(S->getType(), Opcode, Name, InsertAtEnd) { + init(Opcode, S, SA); + } + + OtherOps getOpcode() const { + return static_cast(Instruction::getOpcode()); + } + + virtual Instruction *clone() const { return new ShiftInst(*this); } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const ShiftInst *) { return true; } + static inline bool classof(const Instruction *I) { + return (I->getOpcode() == Instruction::Shr) | + (I->getOpcode() == Instruction::Shl); + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + +//===----------------------------------------------------------------------===// +// SelectInst Class +//===----------------------------------------------------------------------===// + +/// SelectInst - This class represents the LLVM 'select' instruction. +/// +class SelectInst : public Instruction { + SelectInst(const SelectInst &SI) : Instruction(SI.getType(), SI.getOpcode()) { + Operands.reserve(3); + Operands.push_back(Use(SI.Operands[0], this)); + Operands.push_back(Use(SI.Operands[1], this)); + Operands.push_back(Use(SI.Operands[2], this)); + } + void init(Value *C, Value *S1, Value *S2) { + Operands.reserve(3); + Operands.push_back(Use(C, this)); + Operands.push_back(Use(S1, this)); + Operands.push_back(Use(S2, this)); + } + +public: + SelectInst(Value *C, Value *S1, Value *S2, const std::string &Name = "", + Instruction *InsertBefore = 0) + : Instruction(S1->getType(), Instruction::Select, Name, InsertBefore) { + init(C, S1, S2); + } + SelectInst(Value *C, Value *S1, Value *S2, const std::string &Name, + BasicBlock *InsertAtEnd) + : Instruction(S1->getType(), Instruction::Select, Name, InsertAtEnd) { + init(C, S1, S2); + } + + Value *getCondition() const { return Operands[0]; } + Value *getTrueValue() const { return Operands[1]; } + Value *getFalseValue() const { return Operands[2]; } + + OtherOps getOpcode() const { + return static_cast(Instruction::getOpcode()); + } + + virtual Instruction *clone() const { return new SelectInst(*this); } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const SelectInst *) { return true; } + static inline bool classof(const Instruction *I) { + return I->getOpcode() == Instruction::Select; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + + +//===----------------------------------------------------------------------===// +// VANextInst Class +//===----------------------------------------------------------------------===// + +/// VANextInst - This class represents the va_next llvm instruction, which +/// advances a vararg list passed an argument of the specified type, returning +/// the resultant list. +/// +class VANextInst : public Instruction { + PATypeHolder ArgTy; + void init(Value *List) { + Operands.reserve(1); + Operands.push_back(Use(List, this)); + } + VANextInst(const VANextInst &VAN) + : Instruction(VAN.getType(), VANext), ArgTy(VAN.getArgType()) { + init(VAN.Operands[0]); + } + +public: + VANextInst(Value *List, const Type *Ty, const std::string &Name = "", + Instruction *InsertBefore = 0) + : Instruction(List->getType(), VANext, Name, InsertBefore), ArgTy(Ty) { + init(List); + } + VANextInst(Value *List, const Type *Ty, const std::string &Name, + BasicBlock *InsertAtEnd) + : Instruction(List->getType(), VANext, Name, InsertAtEnd), ArgTy(Ty) { + init(List); + } + + const Type *getArgType() const { return ArgTy; } + + virtual Instruction *clone() const { return new VANextInst(*this); } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const VANextInst *) { return true; } + static inline bool classof(const Instruction *I) { + return I->getOpcode() == VANext; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + + +//===----------------------------------------------------------------------===// +// VAArgInst Class +//===----------------------------------------------------------------------===// + +/// VAArgInst - This class represents the va_arg llvm instruction, which returns +/// an argument of the specified type given a va_list. +/// +class VAArgInst : public Instruction { + void init(Value* List) { + Operands.reserve(1); + Operands.push_back(Use(List, this)); + } + VAArgInst(const VAArgInst &VAA) + : Instruction(VAA.getType(), VAArg) { + init(VAA.Operands[0]); + } +public: + VAArgInst(Value *List, const Type *Ty, const std::string &Name = "", + Instruction *InsertBefore = 0) + : Instruction(Ty, VAArg, Name, InsertBefore) { + init(List); + } + VAArgInst(Value *List, const Type *Ty, const std::string &Name, + BasicBlock *InsertAtEnd) + : Instruction(Ty, VAArg, Name, InsertAtEnd) { + init(List); + } + + virtual Instruction *clone() const { return new VAArgInst(*this); } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const VAArgInst *) { return true; } + static inline bool classof(const Instruction *I) { + return I->getOpcode() == VAArg; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + +//===----------------------------------------------------------------------===// +// PHINode Class +//===----------------------------------------------------------------------===// + +// PHINode - The PHINode class is used to represent the magical mystical PHI +// node, that can not exist in nature, but can be synthesized in a computer +// scientist's overactive imagination. +// +class PHINode : public Instruction { + PHINode(const PHINode &PN); +public: + PHINode(const Type *Ty, const std::string &Name = "", + Instruction *InsertBefore = 0) + : Instruction(Ty, Instruction::PHI, Name, InsertBefore) { + } + + PHINode(const Type *Ty, const std::string &Name, BasicBlock *InsertAtEnd) + : Instruction(Ty, Instruction::PHI, Name, InsertAtEnd) { + } + + virtual Instruction *clone() const { return new PHINode(*this); } + + /// getNumIncomingValues - Return the number of incoming edges + /// + unsigned getNumIncomingValues() const { return Operands.size()/2; } + + /// getIncomingValue - Return incoming value #x + /// + Value *getIncomingValue(unsigned i) const { + assert(i*2 < Operands.size() && "Invalid value number!"); + return Operands[i*2]; + } + void setIncomingValue(unsigned i, Value *V) { + assert(i*2 < Operands.size() && "Invalid value number!"); + Operands[i*2] = V; + } + inline unsigned getOperandNumForIncomingValue(unsigned i) { + return i*2; + } + + /// getIncomingBlock - Return incoming basic block #x + /// + BasicBlock *getIncomingBlock(unsigned i) const { + assert(i*2+1 < Operands.size() && "Invalid value number!"); + return reinterpret_cast(Operands[i*2+1].get()); + } + void setIncomingBlock(unsigned i, BasicBlock *BB) { + assert(i*2+1 < Operands.size() && "Invalid value number!"); + Operands[i*2+1] = reinterpret_cast(BB); + } + unsigned getOperandNumForIncomingBlock(unsigned i) { + return i*2+1; + } + + /// addIncoming - Add an incoming value to the end of the PHI list + /// + void addIncoming(Value *V, BasicBlock *BB) { + assert(getType() == V->getType() && + "All operands to PHI node must be the same type as the PHI node!"); + Operands.push_back(Use(V, this)); + Operands.push_back(Use(reinterpret_cast(BB), this)); + } + + /// removeIncomingValue - Remove an incoming value. This is useful if a + /// predecessor basic block is deleted. The value removed is returned. + /// + /// If the last incoming value for a PHI node is removed (and DeletePHIIfEmpty + /// is true), the PHI node is destroyed and any uses of it are replaced with + /// dummy values. The only time there should be zero incoming values to a PHI + /// node is when the block is dead, so this strategy is sound. + /// + Value *removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty = true); + + Value *removeIncomingValue(const BasicBlock *BB, bool DeletePHIIfEmpty =true){ + int Idx = getBasicBlockIndex(BB); + assert(Idx >= 0 && "Invalid basic block argument to remove!"); + return removeIncomingValue(Idx, DeletePHIIfEmpty); + } + + /// getBasicBlockIndex - Return the first index of the specified basic + /// block in the value list for this PHI. Returns -1 if no instance. + /// + int getBasicBlockIndex(const BasicBlock *BB) const { + for (unsigned i = 0; i < Operands.size()/2; ++i) + if (getIncomingBlock(i) == BB) return i; + return -1; + } + + Value *getIncomingValueForBlock(const BasicBlock *BB) const { + return getIncomingValue(getBasicBlockIndex(BB)); + } + + /// Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const PHINode *) { return true; } + static inline bool classof(const Instruction *I) { + return I->getOpcode() == Instruction::PHI; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + +//===----------------------------------------------------------------------===// +// ReturnInst Class +//===----------------------------------------------------------------------===// + +//===--------------------------------------------------------------------------- +/// ReturnInst - Return a value (possibly void), from a function. Execution +/// does not continue in this function any longer. +/// +class ReturnInst : public TerminatorInst { + ReturnInst(const ReturnInst &RI) : TerminatorInst(Instruction::Ret) { + if (RI.Operands.size()) { + assert(RI.Operands.size() == 1 && "Return insn can only have 1 operand!"); + Operands.reserve(1); + Operands.push_back(Use(RI.Operands[0], this)); + } + } + + void init(Value *RetVal) { + if (RetVal) { + assert(!isa(RetVal) && + "Cannot return basic block. Probably using the incorrect ctor"); + Operands.reserve(1); + Operands.push_back(Use(RetVal, this)); + } + } + +public: + // ReturnInst constructors: + // ReturnInst() - 'ret void' instruction + // ReturnInst(Value* X) - 'ret X' instruction + // ReturnInst( null, Inst *) - 'ret void' instruction, insert before I + // ReturnInst(Value* X, Inst *I) - 'ret X' instruction, insert before I + // ReturnInst( null, BB *B) - 'ret void' instruction, insert @ end of BB + // ReturnInst(Value* X, BB *B) - 'ret X' instruction, insert @ end of BB + ReturnInst(Value *RetVal = 0, Instruction *InsertBefore = 0) + : TerminatorInst(Instruction::Ret, InsertBefore) { + init(RetVal); + } + ReturnInst(Value *RetVal, BasicBlock *InsertAtEnd) + : TerminatorInst(Instruction::Ret, InsertAtEnd) { + init(RetVal); + } + ReturnInst(BasicBlock *InsertAtEnd) + : TerminatorInst(Instruction::Ret, InsertAtEnd) { + } + + virtual Instruction *clone() const { return new ReturnInst(*this); } + + inline const Value *getReturnValue() const { + return Operands.size() ? Operands[0].get() : 0; + } + inline Value *getReturnValue() { + return Operands.size() ? Operands[0].get() : 0; + } + + virtual const BasicBlock *getSuccessor(unsigned idx) const { + assert(0 && "ReturnInst has no successors!"); + abort(); + return 0; + } + virtual void setSuccessor(unsigned idx, BasicBlock *NewSucc); + virtual unsigned getNumSuccessors() const { return 0; } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const ReturnInst *) { return true; } + static inline bool classof(const Instruction *I) { + return (I->getOpcode() == Instruction::Ret); + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + +//===----------------------------------------------------------------------===// +// BranchInst Class +//===----------------------------------------------------------------------===// + +//===--------------------------------------------------------------------------- +/// BranchInst - Conditional or Unconditional Branch instruction. +/// +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' + // BranchInst(BB* T, BB *F, Value *C) - 'br C, T, F' + // BranchInst(BB* B, Inst *I) - 'br B' insert before I + // BranchInst(BB* T, BB *F, Value *C, Inst *I) - 'br C, T, F', insert before I + // BranchInst(BB* B, BB *I) - 'br B' insert at end + // BranchInst(BB* T, BB *F, Value *C, BB *I) - 'br C, T, F', insert at end + BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore = 0) + : TerminatorInst(Instruction::Br, InsertBefore) { + init(IfTrue); + } + BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond, + Instruction *InsertBefore = 0) + : TerminatorInst(Instruction::Br, InsertBefore) { + init(IfTrue, IfFalse, Cond); + } + + BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd) + : TerminatorInst(Instruction::Br, InsertAtEnd) { + init(IfTrue); + } + + BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond, + BasicBlock *InsertAtEnd) + : TerminatorInst(Instruction::Br, InsertAtEnd) { + init(IfTrue, IfFalse, Cond); + } + + virtual Instruction *clone() const { return new BranchInst(*this); } + + inline bool isUnconditional() const { return Operands.size() == 1; } + inline bool isConditional() const { return Operands.size() == 3; } + + inline Value *getCondition() const { + assert(isConditional() && "Cannot get condition of an uncond branch!"); + return Operands[2].get(); + } + + void setCondition(Value *V) { + assert(isConditional() && "Cannot set condition of unconditional branch!"); + setOperand(2, V); + } + + // setUnconditionalDest - Change the current branch to an unconditional branch + // targeting the specified block. + // + void setUnconditionalDest(BasicBlock *Dest) { + if (isConditional()) Operands.erase(Operands.begin()+1, Operands.end()); + Operands[0] = reinterpret_cast(Dest); + } + + virtual const BasicBlock *getSuccessor(unsigned i) const { + assert(i < getNumSuccessors() && "Successor # out of range for Branch!"); + return (i == 0) ? cast(Operands[0].get()) : + cast(Operands[1].get()); + } + inline BasicBlock *getSuccessor(unsigned idx) { + const BranchInst *BI = this; + return const_cast(BI->getSuccessor(idx)); + } + + virtual void setSuccessor(unsigned idx, BasicBlock *NewSucc) { + assert(idx < getNumSuccessors() && "Successor # out of range for Branch!"); + Operands[idx] = reinterpret_cast(NewSucc); + } + + virtual unsigned getNumSuccessors() const { return 1+isConditional(); } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const BranchInst *) { return true; } + static inline bool classof(const Instruction *I) { + return (I->getOpcode() == Instruction::Br); + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + +//===----------------------------------------------------------------------===// +// SwitchInst Class +//===----------------------------------------------------------------------===// + +//===--------------------------------------------------------------------------- +/// SwitchInst - Multiway switch +/// +class SwitchInst : public TerminatorInst { + // Operand[0] = Value to switch on + // Operand[1] = Default basic block destination + // 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) + : TerminatorInst(Instruction::Switch, InsertBefore) { + init(Value, Default); + } + SwitchInst(Value *Value, BasicBlock *Default, BasicBlock *InsertAtEnd) + : TerminatorInst(Instruction::Switch, InsertAtEnd) { + init(Value, Default); + } + + virtual Instruction *clone() const { return new SwitchInst(*this); } + + // Accessor Methods for Switch stmt + // + inline const Value *getCondition() const { return Operands[0]; } + inline Value *getCondition() { return Operands[0]; } + inline const BasicBlock *getDefaultDest() const { + return cast(Operands[1].get()); + } + inline BasicBlock *getDefaultDest() { + return cast(Operands[1].get()); + } + + /// getNumCases - return the number of 'cases' in this switch instruction. + /// Note that case #0 is always the default case. + unsigned getNumCases() const { + return Operands.size()/2; + } + + /// getCaseValue - Return the specified case value. Note that case #0, the + /// default destination, does not have a case value. + Constant *getCaseValue(unsigned i) { + assert(i && i < getNumCases() && "Illegal case value to get!"); + return getSuccessorValue(i); + } + + /// getCaseValue - Return the specified case value. Note that case #0, the + /// default destination, does not have a case value. + const Constant *getCaseValue(unsigned i) const { + assert(i && i < getNumCases() && "Illegal case value to get!"); + return getSuccessorValue(i); + } + + /// findCaseValue - Search all of the case values for the specified constant. + /// If it is explicitly handled, return the case number of it, otherwise + /// return 0 to indicate that it is handled by the default handler. + unsigned findCaseValue(const Constant *C) const { + for (unsigned i = 1, e = getNumCases(); i != e; ++i) + if (getCaseValue(i) == C) + return i; + return 0; + } + + /// addCase - Add an entry to the switch instruction... + /// + void addCase(Constant *OnVal, BasicBlock *Dest); + + /// removeCase - This method removes the specified successor from the switch + /// instruction. Note that this cannot be used to remove the default + /// destination (successor #0). + /// + void removeCase(unsigned idx); + + virtual const BasicBlock *getSuccessor(unsigned idx) const { + assert(idx < getNumSuccessors() &&"Successor idx out of range for switch!"); + return cast(Operands[idx*2+1].get()); + } + inline BasicBlock *getSuccessor(unsigned idx) { + assert(idx < getNumSuccessors() &&"Successor idx out of range for switch!"); + return cast(Operands[idx*2+1].get()); + } + + virtual void setSuccessor(unsigned idx, BasicBlock *NewSucc) { + assert(idx < getNumSuccessors() && "Successor # out of range for switch!"); + Operands[idx*2+1] = reinterpret_cast(NewSucc); + } + + // getSuccessorValue - Return the value associated with the specified + // successor. + inline const Constant *getSuccessorValue(unsigned idx) const { + assert(idx < getNumSuccessors() && "Successor # out of range!"); + return cast(Operands[idx*2].get()); + } + inline Constant *getSuccessorValue(unsigned idx) { + assert(idx < getNumSuccessors() && "Successor # out of range!"); + return cast(Operands[idx*2].get()); + } + virtual unsigned getNumSuccessors() const { return Operands.size()/2; } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const SwitchInst *) { return true; } + static inline bool classof(const Instruction *I) { + return (I->getOpcode() == Instruction::Switch); + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + +//===----------------------------------------------------------------------===// +// InvokeInst Class +//===----------------------------------------------------------------------===// + +//===--------------------------------------------------------------------------- +/// InvokeInst - Invoke instruction +/// +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 = "", + Instruction *InsertBefore = 0); + InvokeInst(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException, + const std::vector &Params, const std::string &Name, + BasicBlock *InsertAtEnd); + + virtual Instruction *clone() const { return new InvokeInst(*this); } + + bool mayWriteToMemory() const { return true; } + + /// getCalledFunction - Return the function called, or null if this is an + /// indirect function invocation... + /// + /// FIXME: These should be inlined once we get rid of ConstantPointerRefs! + /// + const Function *getCalledFunction() const; + Function *getCalledFunction(); + + // getCalledValue - Get a pointer to a function that is invoked by this inst. + inline const Value *getCalledValue() const { return Operands[0]; } + inline Value *getCalledValue() { return Operands[0]; } + + // get*Dest - Return the destination basic blocks... + inline const BasicBlock *getNormalDest() const { + return cast(Operands[1].get()); + } + inline BasicBlock *getNormalDest() { + return cast(Operands[1].get()); + } + inline const BasicBlock *getUnwindDest() const { + return cast(Operands[2].get()); + } + inline BasicBlock *getUnwindDest() { + return cast(Operands[2].get()); + } + + inline void setNormalDest(BasicBlock *B){ + Operands[1] = reinterpret_cast(B); + } + + inline void setUnwindDest(BasicBlock *B){ + Operands[2] = reinterpret_cast(B); + } + + virtual const BasicBlock *getSuccessor(unsigned i) const { + assert(i < 2 && "Successor # out of range for invoke!"); + return i == 0 ? getNormalDest() : getUnwindDest(); + } + inline BasicBlock *getSuccessor(unsigned i) { + assert(i < 2 && "Successor # out of range for invoke!"); + return i == 0 ? getNormalDest() : getUnwindDest(); + } + + virtual void setSuccessor(unsigned idx, BasicBlock *NewSucc) { + assert(idx < 2 && "Successor # out of range for invoke!"); + Operands[idx+1] = reinterpret_cast(NewSucc); + } + + virtual unsigned getNumSuccessors() const { return 2; } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const InvokeInst *) { return true; } + static inline bool classof(const Instruction *I) { + return (I->getOpcode() == Instruction::Invoke); + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + + +//===----------------------------------------------------------------------===// +// UnwindInst Class +//===----------------------------------------------------------------------===// + +//===--------------------------------------------------------------------------- +/// UnwindInst - Immediately exit the current function, unwinding the stack +/// until an invoke instruction is found. +/// +struct UnwindInst : public TerminatorInst { + UnwindInst(Instruction *InsertBefore = 0) + : TerminatorInst(Instruction::Unwind, InsertBefore) { + } + UnwindInst(BasicBlock *InsertAtEnd) + : TerminatorInst(Instruction::Unwind, InsertAtEnd) { + } + + virtual Instruction *clone() const { return new UnwindInst(); } + + virtual const BasicBlock *getSuccessor(unsigned idx) const { + assert(0 && "UnwindInst has no successors!"); + abort(); + return 0; + } + virtual void setSuccessor(unsigned idx, BasicBlock *NewSucc); + virtual unsigned getNumSuccessors() const { return 0; } + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const UnwindInst *) { return true; } + static inline bool classof(const Instruction *I) { + return I->getOpcode() == Instruction::Unwind; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } +}; + +} // End llvm namespace #endif diff --git a/include/llvm/iMemory.h b/include/llvm/iMemory.h deleted file mode 100644 index dcc647f7cd4..00000000000 --- a/include/llvm/iMemory.h +++ /dev/null @@ -1,355 +0,0 @@ -//===-- llvm/iMemory.h - Memory Operator node definitions -------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file contains the declarations of all of the memory related operators. -// This includes: malloc, free, alloca, load, store, and getelementptr -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_IMEMORY_H -#define LLVM_IMEMORY_H - -#include "llvm/Instruction.h" - -namespace llvm { - -class PointerType; - -//===----------------------------------------------------------------------===// -// AllocationInst Class -//===----------------------------------------------------------------------===// - -/// AllocationInst - This class is the common base class of MallocInst and -/// AllocaInst. -/// -class AllocationInst : public Instruction { -protected: - void init(const Type *Ty, Value *ArraySize, unsigned iTy); - AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, - const std::string &Name = "", Instruction *InsertBefore = 0); - AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, - const std::string &Name, BasicBlock *InsertAtEnd); - -public: - - /// isArrayAllocation - Return true if there is an allocation size parameter - /// to the allocation instruction that is not 1. - /// - bool isArrayAllocation() const; - - /// getArraySize - Get the number of element allocated, for a simple - /// allocation of a single element, this will return a constant 1 value. - /// - inline const Value *getArraySize() const { return Operands[0]; } - inline Value *getArraySize() { return Operands[0]; } - - /// getType - Overload to return most specific pointer type - /// - inline const PointerType *getType() const { - return reinterpret_cast(Instruction::getType()); - } - - /// getAllocatedType - Return the type that is being allocated by the - /// instruction. - /// - const Type *getAllocatedType() const; - - virtual Instruction *clone() const = 0; - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const AllocationInst *) { return true; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == Instruction::Alloca || - I->getOpcode() == Instruction::Malloc; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - - -//===----------------------------------------------------------------------===// -// MallocInst Class -//===----------------------------------------------------------------------===// - -/// MallocInst - an instruction to allocated memory on the heap -/// -class MallocInst : public AllocationInst { - MallocInst(const MallocInst &MI); -public: - explicit MallocInst(const Type *Ty, Value *ArraySize = 0, - const std::string &Name = "", - Instruction *InsertBefore = 0) - : AllocationInst(Ty, ArraySize, Malloc, Name, InsertBefore) {} - MallocInst(const Type *Ty, Value *ArraySize, const std::string &Name, - BasicBlock *InsertAtEnd) - : AllocationInst(Ty, ArraySize, Malloc, Name, InsertAtEnd) {} - - virtual Instruction *clone() const { - return new MallocInst(*this); - } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const MallocInst *) { return true; } - static inline bool classof(const Instruction *I) { - return (I->getOpcode() == Instruction::Malloc); - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - - -//===----------------------------------------------------------------------===// -// AllocaInst Class -//===----------------------------------------------------------------------===// - -/// AllocaInst - an instruction to allocate memory on the stack -/// -class AllocaInst : public AllocationInst { - AllocaInst(const AllocaInst &); -public: - explicit AllocaInst(const Type *Ty, Value *ArraySize = 0, - const std::string &Name = "", - Instruction *InsertBefore = 0) - : AllocationInst(Ty, ArraySize, Alloca, Name, InsertBefore) {} - AllocaInst(const Type *Ty, Value *ArraySize, const std::string &Name, - BasicBlock *InsertAtEnd) - : AllocationInst(Ty, ArraySize, Alloca, Name, InsertAtEnd) {} - - virtual Instruction *clone() const { - return new AllocaInst(*this); - } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const AllocaInst *) { return true; } - static inline bool classof(const Instruction *I) { - return (I->getOpcode() == Instruction::Alloca); - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - - -//===----------------------------------------------------------------------===// -// FreeInst Class -//===----------------------------------------------------------------------===// - -/// FreeInst - an instruction to deallocate memory -/// -class FreeInst : public Instruction { - void init(Value *Ptr); - -public: - explicit FreeInst(Value *Ptr, Instruction *InsertBefore = 0); - FreeInst(Value *Ptr, BasicBlock *InsertAfter); - - virtual Instruction *clone() const { return new FreeInst(Operands[0]); } - - virtual bool mayWriteToMemory() const { return true; } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const FreeInst *) { return true; } - static inline bool classof(const Instruction *I) { - return (I->getOpcode() == Instruction::Free); - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - - -//===----------------------------------------------------------------------===// -// LoadInst Class -//===----------------------------------------------------------------------===// - -/// LoadInst - an instruction for reading from memory -/// -class LoadInst : public Instruction { - LoadInst(const LoadInst &LI) : Instruction(LI.getType(), Load) { - Volatile = LI.isVolatile(); - init(LI.Operands[0]); - } - bool Volatile; // True if this is a volatile load - void init(Value *Ptr); -public: - LoadInst(Value *Ptr, const std::string &Name, Instruction *InsertBefore); - LoadInst(Value *Ptr, const std::string &Name, BasicBlock *InsertAtEnd); - LoadInst(Value *Ptr, const std::string &Name = "", bool isVolatile = false, - Instruction *InsertBefore = 0); - LoadInst(Value *Ptr, const std::string &Name, bool isVolatile, - BasicBlock *InsertAtEnd); - - /// isVolatile - Return true if this is a load from a volatile memory - /// location. - /// - bool isVolatile() const { return Volatile; } - - /// setVolatile - Specify whether this is a volatile load or not. - /// - void setVolatile(bool V) { Volatile = V; } - - virtual Instruction *clone() const { return new LoadInst(*this); } - - virtual bool mayWriteToMemory() const { return isVolatile(); } - - Value *getPointerOperand() { return getOperand(0); } - const Value *getPointerOperand() const { return getOperand(0); } - static unsigned getPointerOperandIndex() { return 0U; } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const LoadInst *) { return true; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == Instruction::Load; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - - -//===----------------------------------------------------------------------===// -// StoreInst Class -//===----------------------------------------------------------------------===// - -/// StoreInst - an instruction for storing to memory -/// -class StoreInst : public Instruction { - StoreInst(const StoreInst &SI) : Instruction(SI.getType(), Store) { - Volatile = SI.isVolatile(); - init(SI.Operands[0], SI.Operands[1]); - } - bool Volatile; // True if this is a volatile store - void init(Value *Val, Value *Ptr); -public: - StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore); - StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd); - StoreInst(Value *Val, Value *Ptr, bool isVolatile = false, - Instruction *InsertBefore = 0); - StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd); - - - /// isVolatile - Return true if this is a load from a volatile memory - /// location. - /// - bool isVolatile() const { return Volatile; } - - /// setVolatile - Specify whether this is a volatile load or not. - /// - void setVolatile(bool V) { Volatile = V; } - - virtual Instruction *clone() const { return new StoreInst(*this); } - - virtual bool mayWriteToMemory() const { return true; } - - Value *getPointerOperand() { return getOperand(1); } - const Value *getPointerOperand() const { return getOperand(1); } - static unsigned getPointerOperandIndex() { return 1U; } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const StoreInst *) { return true; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == Instruction::Store; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - - -//===----------------------------------------------------------------------===// -// GetElementPtrInst Class -//===----------------------------------------------------------------------===// - -/// GetElementPtrInst - an instruction for type-safe pointer arithmetic to -/// access elements of arrays and structs -/// -class GetElementPtrInst : public Instruction { - GetElementPtrInst(const GetElementPtrInst &EPI) - : Instruction((static_cast(&EPI)->getType()), - GetElementPtr) { - Operands.reserve(EPI.Operands.size()); - 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); - void init(Value *Ptr, Value *Idx0, Value *Idx1); -public: - /// Constructors - Create a getelementptr instruction with a base pointer an - /// list of indices. The first ctor can optionally insert before an existing - /// instruction, the second appends the new instruction to the specified - /// BasicBlock. - GetElementPtrInst(Value *Ptr, const std::vector &Idx, - const std::string &Name = "", Instruction *InsertBefore =0); - GetElementPtrInst(Value *Ptr, const std::vector &Idx, - const std::string &Name, BasicBlock *InsertAtEnd); - - /// Constructors - These two constructors are convenience methods because two - /// index getelementptr instructions are so common. - GetElementPtrInst(Value *Ptr, Value *Idx0, Value *Idx1, - const std::string &Name = "", Instruction *InsertBefore =0); - GetElementPtrInst(Value *Ptr, Value *Idx0, Value *Idx1, - const std::string &Name, BasicBlock *InsertAtEnd); - - virtual Instruction *clone() const { return new GetElementPtrInst(*this); } - - // getType - Overload to return most specific pointer type... - inline const PointerType *getType() const { - return reinterpret_cast(Instruction::getType()); - } - - /// getIndexedType - Returns the type of the element that would be loaded with - /// a load instruction with the specified parameters. - /// - /// A null type is returned if the indices are invalid for the specified - /// pointer type. - /// - static const Type *getIndexedType(const Type *Ptr, - const std::vector &Indices, - bool AllowStructLeaf = false); - static const Type *getIndexedType(const Type *Ptr, Value *Idx0, Value *Idx1, - bool AllowStructLeaf = false); - - inline op_iterator idx_begin() { return op_begin()+1; } - inline const_op_iterator idx_begin() const { return op_begin()+1; } - inline op_iterator idx_end() { return op_end(); } - inline const_op_iterator idx_end() const { return op_end(); } - - Value *getPointerOperand() { - return getOperand(0); - } - const Value *getPointerOperand() const { - return getOperand(0); - } - static unsigned getPointerOperandIndex() { - return 0U; // get index for modifying correct operand - } - - inline unsigned getNumIndices() const { // Note: always non-negative - return getNumOperands() - 1; - } - - inline bool hasIndices() const { - return getNumOperands() > 1; - } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const GetElementPtrInst *) { return true; } - static inline bool classof(const Instruction *I) { - return (I->getOpcode() == Instruction::GetElementPtr); - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - -} // End llvm namespace - -#endif // LLVM_IMEMORY_H diff --git a/include/llvm/iOperators.h b/include/llvm/iOperators.h deleted file mode 100644 index e384e051d8e..00000000000 --- a/include/llvm/iOperators.h +++ /dev/null @@ -1,72 +0,0 @@ -//===-- llvm/iOperators.h - Binary Operator node definitions ----*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file contains the declarations of the Binary Operator classes. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_IOPERATORS_H -#define LLVM_IOPERATORS_H - -#include "llvm/InstrTypes.h" - -namespace llvm { - -/// SetCondInst class - Represent a setCC operator, where CC is eq, ne, lt, gt, -/// le, or ge. -/// -class SetCondInst : public BinaryOperator { - BinaryOps OpType; -public: - SetCondInst(BinaryOps Opcode, Value *LHS, Value *RHS, - const std::string &Name = "", Instruction *InsertBefore = 0); - SetCondInst(BinaryOps Opcode, Value *LHS, Value *RHS, - const std::string &Name, BasicBlock *InsertAtEnd); - - /// getInverseCondition - Return the inverse of the current condition opcode. - /// For example seteq -> setne, setgt -> setle, setlt -> setge, etc... - /// - BinaryOps getInverseCondition() const { - return getInverseCondition(getOpcode()); - } - - /// getInverseCondition - Static version that you can use without an - /// instruction available. - /// - static BinaryOps getInverseCondition(BinaryOps Opcode); - - /// getSwappedCondition - Return the condition opcode that would be the result - /// of exchanging the two operands of the setcc instruction without changing - /// the result produced. Thus, seteq->seteq, setle->setge, setlt->setgt, etc. - /// - BinaryOps getSwappedCondition() const { - return getSwappedCondition(getOpcode()); - } - - /// getSwappedCondition - Static version that you can use without an - /// instruction available. - /// - static BinaryOps getSwappedCondition(BinaryOps Opcode); - - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const SetCondInst *) { return true; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == SetEQ || I->getOpcode() == SetNE || - I->getOpcode() == SetLE || I->getOpcode() == SetGE || - I->getOpcode() == SetLT || I->getOpcode() == SetGT; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - -} // End llvm namespace - -#endif diff --git a/include/llvm/iOther.h b/include/llvm/iOther.h deleted file mode 100644 index 4e7ef5c1e79..00000000000 --- a/include/llvm/iOther.h +++ /dev/null @@ -1,310 +0,0 @@ -//===-- llvm/iOther.h - "Other" instruction node definitions ----*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file contains the declarations for instructions that fall into the -// grandiose 'other' catagory... -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_IOTHER_H -#define LLVM_IOTHER_H - -#include "llvm/InstrTypes.h" - -namespace llvm { - -//===----------------------------------------------------------------------===// -// CastInst Class -//===----------------------------------------------------------------------===// - -/// CastInst - This class represents a cast from Operand[0] to the type of -/// the instruction (i->getType()). -/// -class CastInst : public Instruction { - CastInst(const CastInst &CI) : Instruction(CI.getType(), Cast) { - Operands.reserve(1); - Operands.push_back(Use(CI.Operands[0], this)); - } - void init(Value *S) { - Operands.reserve(1); - Operands.push_back(Use(S, this)); - } -public: - CastInst(Value *S, const Type *Ty, const std::string &Name = "", - Instruction *InsertBefore = 0) - : Instruction(Ty, Cast, Name, InsertBefore) { - init(S); - } - CastInst(Value *S, const Type *Ty, const std::string &Name, - BasicBlock *InsertAtEnd) - : Instruction(Ty, Cast, Name, InsertAtEnd) { - init(S); - } - - virtual Instruction *clone() const { return new CastInst(*this); } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const CastInst *) { return true; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == Cast; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - - -//===----------------------------------------------------------------------===// -// CallInst Class -//===----------------------------------------------------------------------===// - -/// CallInst - This class represents a function call, abstracting a target -/// machine's calling convention. -/// -class CallInst : public Instruction { - CallInst(const CallInst &CI); - void init(Value *Func, const std::vector &Params); - void init(Value *Func, Value *Actual1, Value *Actual2); - void init(Value *Func, Value *Actual); - void init(Value *Func); - -public: - CallInst(Value *F, const std::vector &Par, - const std::string &Name = "", Instruction *InsertBefore = 0); - CallInst(Value *F, const std::vector &Par, - const std::string &Name, BasicBlock *InsertAtEnd); - - // Alternate CallInst ctors w/ two actuals, w/ one actual and no - // actuals, respectively. - CallInst(Value *F, Value *Actual1, Value *Actual2, - const std::string& Name = "", Instruction *InsertBefore = 0); - CallInst(Value *F, Value *Actual1, Value *Actual2, - const std::string& Name, BasicBlock *InsertAtEnd); - CallInst(Value *F, Value *Actual, const std::string& Name = "", - Instruction *InsertBefore = 0); - CallInst(Value *F, Value *Actual, const std::string& Name, - BasicBlock *InsertAtEnd); - explicit CallInst(Value *F, const std::string &Name = "", - Instruction *InsertBefore = 0); - explicit CallInst(Value *F, const std::string &Name, - BasicBlock *InsertAtEnd); - - virtual Instruction *clone() const { return new CallInst(*this); } - bool mayWriteToMemory() const { return true; } - - // FIXME: These methods should be inline once we eliminate - // ConstantPointerRefs! - const Function *getCalledFunction() const; - Function *getCalledFunction(); - - // getCalledValue - Get a pointer to a method that is invoked by this inst. - inline const Value *getCalledValue() const { return Operands[0]; } - inline Value *getCalledValue() { return Operands[0]; } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const CallInst *) { return true; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == Instruction::Call; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - - -//===----------------------------------------------------------------------===// -// ShiftInst Class -//===----------------------------------------------------------------------===// - -/// ShiftInst - This class represents left and right shift instructions. -/// -class ShiftInst : public Instruction { - ShiftInst(const ShiftInst &SI) : Instruction(SI.getType(), SI.getOpcode()) { - Operands.reserve(2); - Operands.push_back(Use(SI.Operands[0], this)); - Operands.push_back(Use(SI.Operands[1], this)); - } - void init(OtherOps Opcode, Value *S, Value *SA) { - assert((Opcode == Shl || Opcode == Shr) && "ShiftInst Opcode invalid!"); - Operands.reserve(2); - Operands.push_back(Use(S, this)); - Operands.push_back(Use(SA, this)); - } - -public: - ShiftInst(OtherOps Opcode, Value *S, Value *SA, const std::string &Name = "", - Instruction *InsertBefore = 0) - : Instruction(S->getType(), Opcode, Name, InsertBefore) { - init(Opcode, S, SA); - } - ShiftInst(OtherOps Opcode, Value *S, Value *SA, const std::string &Name, - BasicBlock *InsertAtEnd) - : Instruction(S->getType(), Opcode, Name, InsertAtEnd) { - init(Opcode, S, SA); - } - - OtherOps getOpcode() const { - return static_cast(Instruction::getOpcode()); - } - - virtual Instruction *clone() const { return new ShiftInst(*this); } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const ShiftInst *) { return true; } - static inline bool classof(const Instruction *I) { - return (I->getOpcode() == Instruction::Shr) | - (I->getOpcode() == Instruction::Shl); - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - -//===----------------------------------------------------------------------===// -// SelectInst Class -//===----------------------------------------------------------------------===// - -/// SelectInst - This class represents the LLVM 'select' instruction. -/// -class SelectInst : public Instruction { - SelectInst(const SelectInst &SI) : Instruction(SI.getType(), SI.getOpcode()) { - Operands.reserve(3); - Operands.push_back(Use(SI.Operands[0], this)); - Operands.push_back(Use(SI.Operands[1], this)); - Operands.push_back(Use(SI.Operands[2], this)); - } - void init(Value *C, Value *S1, Value *S2) { - Operands.reserve(3); - Operands.push_back(Use(C, this)); - Operands.push_back(Use(S1, this)); - Operands.push_back(Use(S2, this)); - } - -public: - SelectInst(Value *C, Value *S1, Value *S2, const std::string &Name = "", - Instruction *InsertBefore = 0) - : Instruction(S1->getType(), Instruction::Select, Name, InsertBefore) { - init(C, S1, S2); - } - SelectInst(Value *C, Value *S1, Value *S2, const std::string &Name, - BasicBlock *InsertAtEnd) - : Instruction(S1->getType(), Instruction::Select, Name, InsertAtEnd) { - init(C, S1, S2); - } - - Value *getCondition() const { return Operands[0]; } - Value *getTrueValue() const { return Operands[1]; } - Value *getFalseValue() const { return Operands[2]; } - - OtherOps getOpcode() const { - return static_cast(Instruction::getOpcode()); - } - - virtual Instruction *clone() const { return new SelectInst(*this); } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const SelectInst *) { return true; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == Instruction::Select; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - - -//===----------------------------------------------------------------------===// -// VANextInst Class -//===----------------------------------------------------------------------===// - -/// VANextInst - This class represents the va_next llvm instruction, which -/// advances a vararg list passed an argument of the specified type, returning -/// the resultant list. -/// -class VANextInst : public Instruction { - PATypeHolder ArgTy; - void init(Value *List) { - Operands.reserve(1); - Operands.push_back(Use(List, this)); - } - VANextInst(const VANextInst &VAN) - : Instruction(VAN.getType(), VANext), ArgTy(VAN.getArgType()) { - init(VAN.Operands[0]); - } - -public: - VANextInst(Value *List, const Type *Ty, const std::string &Name = "", - Instruction *InsertBefore = 0) - : Instruction(List->getType(), VANext, Name, InsertBefore), ArgTy(Ty) { - init(List); - } - VANextInst(Value *List, const Type *Ty, const std::string &Name, - BasicBlock *InsertAtEnd) - : Instruction(List->getType(), VANext, Name, InsertAtEnd), ArgTy(Ty) { - init(List); - } - - const Type *getArgType() const { return ArgTy; } - - virtual Instruction *clone() const { return new VANextInst(*this); } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const VANextInst *) { return true; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == VANext; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - - -//===----------------------------------------------------------------------===// -// VAArgInst Class -//===----------------------------------------------------------------------===// - -/// VAArgInst - This class represents the va_arg llvm instruction, which returns -/// an argument of the specified type given a va_list. -/// -class VAArgInst : public Instruction { - void init(Value* List) { - Operands.reserve(1); - Operands.push_back(Use(List, this)); - } - VAArgInst(const VAArgInst &VAA) - : Instruction(VAA.getType(), VAArg) { - init(VAA.Operands[0]); - } -public: - VAArgInst(Value *List, const Type *Ty, const std::string &Name = "", - Instruction *InsertBefore = 0) - : Instruction(Ty, VAArg, Name, InsertBefore) { - init(List); - } - VAArgInst(Value *List, const Type *Ty, const std::string &Name, - BasicBlock *InsertAtEnd) - : Instruction(Ty, VAArg, Name, InsertAtEnd) { - init(List); - } - - virtual Instruction *clone() const { return new VAArgInst(*this); } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const VAArgInst *) { return true; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == VAArg; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - -} // End llvm namespace - -#endif diff --git a/include/llvm/iPHINode.h b/include/llvm/iPHINode.h deleted file mode 100644 index bd52993c1f0..00000000000 --- a/include/llvm/iPHINode.h +++ /dev/null @@ -1,127 +0,0 @@ -//===-- llvm/iPHINode.h - PHI instruction definition ------------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file defines the PHINode class. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_IPHINODE_H -#define LLVM_IPHINODE_H - -#include "llvm/Instruction.h" - -namespace llvm { - -struct BasicBlock; - -//===----------------------------------------------------------------------===// -// PHINode Class -//===----------------------------------------------------------------------===// - -// PHINode - The PHINode class is used to represent the magical mystical PHI -// node, that can not exist in nature, but can be synthesized in a computer -// scientist's overactive imagination. -// -class PHINode : public Instruction { - PHINode(const PHINode &PN); -public: - PHINode(const Type *Ty, const std::string &Name = "", - Instruction *InsertBefore = 0) - : Instruction(Ty, Instruction::PHI, Name, InsertBefore) { - } - - PHINode(const Type *Ty, const std::string &Name, BasicBlock *InsertAtEnd) - : Instruction(Ty, Instruction::PHI, Name, InsertAtEnd) { - } - - virtual Instruction *clone() const { return new PHINode(*this); } - - /// getNumIncomingValues - Return the number of incoming edges - /// - unsigned getNumIncomingValues() const { return Operands.size()/2; } - - /// getIncomingValue - Return incoming value #x - /// - Value *getIncomingValue(unsigned i) const { - assert(i*2 < Operands.size() && "Invalid value number!"); - return Operands[i*2]; - } - void setIncomingValue(unsigned i, Value *V) { - assert(i*2 < Operands.size() && "Invalid value number!"); - Operands[i*2] = V; - } - inline unsigned getOperandNumForIncomingValue(unsigned i) { - return i*2; - } - - /// getIncomingBlock - Return incoming basic block #x - /// - BasicBlock *getIncomingBlock(unsigned i) const { - assert(i*2+1 < Operands.size() && "Invalid value number!"); - return reinterpret_cast(Operands[i*2+1].get()); - } - void setIncomingBlock(unsigned i, BasicBlock *BB) { - assert(i*2+1 < Operands.size() && "Invalid value number!"); - Operands[i*2+1] = reinterpret_cast(BB); - } - unsigned getOperandNumForIncomingBlock(unsigned i) { - return i*2+1; - } - - /// addIncoming - Add an incoming value to the end of the PHI list - /// - void addIncoming(Value *V, BasicBlock *BB) { - assert(getType() == V->getType() && - "All operands to PHI node must be the same type as the PHI node!"); - Operands.push_back(Use(V, this)); - Operands.push_back(Use(reinterpret_cast(BB), this)); - } - - /// removeIncomingValue - Remove an incoming value. This is useful if a - /// predecessor basic block is deleted. The value removed is returned. - /// - /// If the last incoming value for a PHI node is removed (and DeletePHIIfEmpty - /// is true), the PHI node is destroyed and any uses of it are replaced with - /// dummy values. The only time there should be zero incoming values to a PHI - /// node is when the block is dead, so this strategy is sound. - /// - Value *removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty = true); - - Value *removeIncomingValue(const BasicBlock *BB, bool DeletePHIIfEmpty =true){ - int Idx = getBasicBlockIndex(BB); - assert(Idx >= 0 && "Invalid basic block argument to remove!"); - return removeIncomingValue(Idx, DeletePHIIfEmpty); - } - - /// getBasicBlockIndex - Return the first index of the specified basic - /// block in the value list for this PHI. Returns -1 if no instance. - /// - int getBasicBlockIndex(const BasicBlock *BB) const { - for (unsigned i = 0; i < Operands.size()/2; ++i) - if (getIncomingBlock(i) == BB) return i; - return -1; - } - - Value *getIncomingValueForBlock(const BasicBlock *BB) const { - return getIncomingValue(getBasicBlockIndex(BB)); - } - - /// Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const PHINode *) { return true; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == Instruction::PHI; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - -} // End llvm namespace - -#endif diff --git a/include/llvm/iTerminators.h b/include/llvm/iTerminators.h deleted file mode 100644 index 0d1e62aa4b7..00000000000 --- a/include/llvm/iTerminators.h +++ /dev/null @@ -1,403 +0,0 @@ -//===-- llvm/iTerminators.h - Termintator instruction nodes -----*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file contains the declarations for all the subclasses of the Instruction -// class which represent "terminator" instructions. Terminator instructions are -// the only instructions allowed and required to terminate a BasicBlock. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_ITERMINATORS_H -#define LLVM_ITERMINATORS_H - -#include "llvm/InstrTypes.h" - -namespace llvm { - -//===--------------------------------------------------------------------------- -/// ReturnInst - Return a value (possibly void), from a function. Execution -/// does not continue in this function any longer. -/// -class ReturnInst : public TerminatorInst { - ReturnInst(const ReturnInst &RI) : TerminatorInst(Instruction::Ret) { - if (RI.Operands.size()) { - assert(RI.Operands.size() == 1 && "Return insn can only have 1 operand!"); - Operands.reserve(1); - Operands.push_back(Use(RI.Operands[0], this)); - } - } - - void init(Value *RetVal) { - if (RetVal) { - assert(!isa(RetVal) && - "Cannot return basic block. Probably using the incorrect ctor"); - Operands.reserve(1); - Operands.push_back(Use(RetVal, this)); - } - } - -public: - // ReturnInst constructors: - // ReturnInst() - 'ret void' instruction - // ReturnInst(Value* X) - 'ret X' instruction - // ReturnInst( null, Inst *) - 'ret void' instruction, insert before I - // ReturnInst(Value* X, Inst *I) - 'ret X' instruction, insert before I - // ReturnInst( null, BB *B) - 'ret void' instruction, insert @ end of BB - // ReturnInst(Value* X, BB *B) - 'ret X' instruction, insert @ end of BB - ReturnInst(Value *RetVal = 0, Instruction *InsertBefore = 0) - : TerminatorInst(Instruction::Ret, InsertBefore) { - init(RetVal); - } - ReturnInst(Value *RetVal, BasicBlock *InsertAtEnd) - : TerminatorInst(Instruction::Ret, InsertAtEnd) { - init(RetVal); - } - ReturnInst(BasicBlock *InsertAtEnd) - : TerminatorInst(Instruction::Ret, InsertAtEnd) { - } - - virtual Instruction *clone() const { return new ReturnInst(*this); } - - inline const Value *getReturnValue() const { - return Operands.size() ? Operands[0].get() : 0; - } - inline Value *getReturnValue() { - return Operands.size() ? Operands[0].get() : 0; - } - - virtual const BasicBlock *getSuccessor(unsigned idx) const { - assert(0 && "ReturnInst has no successors!"); - abort(); - return 0; - } - virtual void setSuccessor(unsigned idx, BasicBlock *NewSucc); - virtual unsigned getNumSuccessors() const { return 0; } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const ReturnInst *) { return true; } - static inline bool classof(const Instruction *I) { - return (I->getOpcode() == Instruction::Ret); - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - -//===--------------------------------------------------------------------------- -/// BranchInst - Conditional or Unconditional Branch instruction. -/// -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' - // BranchInst(BB* T, BB *F, Value *C) - 'br C, T, F' - // BranchInst(BB* B, Inst *I) - 'br B' insert before I - // BranchInst(BB* T, BB *F, Value *C, Inst *I) - 'br C, T, F', insert before I - // BranchInst(BB* B, BB *I) - 'br B' insert at end - // BranchInst(BB* T, BB *F, Value *C, BB *I) - 'br C, T, F', insert at end - BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore = 0) - : TerminatorInst(Instruction::Br, InsertBefore) { - init(IfTrue); - } - BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond, - Instruction *InsertBefore = 0) - : TerminatorInst(Instruction::Br, InsertBefore) { - init(IfTrue, IfFalse, Cond); - } - - BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd) - : TerminatorInst(Instruction::Br, InsertAtEnd) { - init(IfTrue); - } - - BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond, - BasicBlock *InsertAtEnd) - : TerminatorInst(Instruction::Br, InsertAtEnd) { - init(IfTrue, IfFalse, Cond); - } - - virtual Instruction *clone() const { return new BranchInst(*this); } - - inline bool isUnconditional() const { return Operands.size() == 1; } - inline bool isConditional() const { return Operands.size() == 3; } - - inline Value *getCondition() const { - assert(isConditional() && "Cannot get condition of an uncond branch!"); - return Operands[2].get(); - } - - void setCondition(Value *V) { - assert(isConditional() && "Cannot set condition of unconditional branch!"); - setOperand(2, V); - } - - // setUnconditionalDest - Change the current branch to an unconditional branch - // targeting the specified block. - // - void setUnconditionalDest(BasicBlock *Dest) { - if (isConditional()) Operands.erase(Operands.begin()+1, Operands.end()); - Operands[0] = reinterpret_cast(Dest); - } - - virtual const BasicBlock *getSuccessor(unsigned i) const { - assert(i < getNumSuccessors() && "Successor # out of range for Branch!"); - return (i == 0) ? cast(Operands[0].get()) : - cast(Operands[1].get()); - } - inline BasicBlock *getSuccessor(unsigned idx) { - const BranchInst *BI = this; - return const_cast(BI->getSuccessor(idx)); - } - - virtual void setSuccessor(unsigned idx, BasicBlock *NewSucc) { - assert(idx < getNumSuccessors() && "Successor # out of range for Branch!"); - Operands[idx] = reinterpret_cast(NewSucc); - } - - virtual unsigned getNumSuccessors() const { return 1+isConditional(); } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const BranchInst *) { return true; } - static inline bool classof(const Instruction *I) { - return (I->getOpcode() == Instruction::Br); - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - - -//===--------------------------------------------------------------------------- -/// SwitchInst - Multiway switch -/// -class SwitchInst : public TerminatorInst { - // Operand[0] = Value to switch on - // Operand[1] = Default basic block destination - // 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) - : TerminatorInst(Instruction::Switch, InsertBefore) { - init(Value, Default); - } - SwitchInst(Value *Value, BasicBlock *Default, BasicBlock *InsertAtEnd) - : TerminatorInst(Instruction::Switch, InsertAtEnd) { - init(Value, Default); - } - - virtual Instruction *clone() const { return new SwitchInst(*this); } - - // Accessor Methods for Switch stmt - // - inline const Value *getCondition() const { return Operands[0]; } - inline Value *getCondition() { return Operands[0]; } - inline const BasicBlock *getDefaultDest() const { - return cast(Operands[1].get()); - } - inline BasicBlock *getDefaultDest() { - return cast(Operands[1].get()); - } - - /// getNumCases - return the number of 'cases' in this switch instruction. - /// Note that case #0 is always the default case. - unsigned getNumCases() const { - return Operands.size()/2; - } - - /// getCaseValue - Return the specified case value. Note that case #0, the - /// default destination, does not have a case value. - Constant *getCaseValue(unsigned i) { - assert(i && i < getNumCases() && "Illegal case value to get!"); - return getSuccessorValue(i); - } - - /// getCaseValue - Return the specified case value. Note that case #0, the - /// default destination, does not have a case value. - const Constant *getCaseValue(unsigned i) const { - assert(i && i < getNumCases() && "Illegal case value to get!"); - return getSuccessorValue(i); - } - - /// findCaseValue - Search all of the case values for the specified constant. - /// If it is explicitly handled, return the case number of it, otherwise - /// return 0 to indicate that it is handled by the default handler. - unsigned findCaseValue(const Constant *C) const { - for (unsigned i = 1, e = getNumCases(); i != e; ++i) - if (getCaseValue(i) == C) - return i; - return 0; - } - - /// addCase - Add an entry to the switch instruction... - /// - void addCase(Constant *OnVal, BasicBlock *Dest); - - /// removeCase - This method removes the specified successor from the switch - /// instruction. Note that this cannot be used to remove the default - /// destination (successor #0). - /// - void removeCase(unsigned idx); - - virtual const BasicBlock *getSuccessor(unsigned idx) const { - assert(idx < getNumSuccessors() &&"Successor idx out of range for switch!"); - return cast(Operands[idx*2+1].get()); - } - inline BasicBlock *getSuccessor(unsigned idx) { - assert(idx < getNumSuccessors() &&"Successor idx out of range for switch!"); - return cast(Operands[idx*2+1].get()); - } - - virtual void setSuccessor(unsigned idx, BasicBlock *NewSucc) { - assert(idx < getNumSuccessors() && "Successor # out of range for switch!"); - Operands[idx*2+1] = reinterpret_cast(NewSucc); - } - - // getSuccessorValue - Return the value associated with the specified - // successor. - inline const Constant *getSuccessorValue(unsigned idx) const { - assert(idx < getNumSuccessors() && "Successor # out of range!"); - return cast(Operands[idx*2].get()); - } - inline Constant *getSuccessorValue(unsigned idx) { - assert(idx < getNumSuccessors() && "Successor # out of range!"); - return cast(Operands[idx*2].get()); - } - virtual unsigned getNumSuccessors() const { return Operands.size()/2; } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const SwitchInst *) { return true; } - static inline bool classof(const Instruction *I) { - return (I->getOpcode() == Instruction::Switch); - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - -//===--------------------------------------------------------------------------- -/// InvokeInst - Invoke instruction -/// -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 = "", - Instruction *InsertBefore = 0); - InvokeInst(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException, - const std::vector &Params, const std::string &Name, - BasicBlock *InsertAtEnd); - - virtual Instruction *clone() const { return new InvokeInst(*this); } - - bool mayWriteToMemory() const { return true; } - - /// getCalledFunction - Return the function called, or null if this is an - /// indirect function invocation... - /// - /// FIXME: These should be inlined once we get rid of ConstantPointerRefs! - /// - const Function *getCalledFunction() const; - Function *getCalledFunction(); - - // getCalledValue - Get a pointer to a function that is invoked by this inst. - inline const Value *getCalledValue() const { return Operands[0]; } - inline Value *getCalledValue() { return Operands[0]; } - - // get*Dest - Return the destination basic blocks... - inline const BasicBlock *getNormalDest() const { - return cast(Operands[1].get()); - } - inline BasicBlock *getNormalDest() { - return cast(Operands[1].get()); - } - inline const BasicBlock *getUnwindDest() const { - return cast(Operands[2].get()); - } - inline BasicBlock *getUnwindDest() { - return cast(Operands[2].get()); - } - - inline void setNormalDest(BasicBlock *B){ - Operands[1] = reinterpret_cast(B); - } - - inline void setUnwindDest(BasicBlock *B){ - Operands[2] = reinterpret_cast(B); - } - - virtual const BasicBlock *getSuccessor(unsigned i) const { - assert(i < 2 && "Successor # out of range for invoke!"); - return i == 0 ? getNormalDest() : getUnwindDest(); - } - inline BasicBlock *getSuccessor(unsigned i) { - assert(i < 2 && "Successor # out of range for invoke!"); - return i == 0 ? getNormalDest() : getUnwindDest(); - } - - virtual void setSuccessor(unsigned idx, BasicBlock *NewSucc) { - assert(idx < 2 && "Successor # out of range for invoke!"); - Operands[idx+1] = reinterpret_cast(NewSucc); - } - - virtual unsigned getNumSuccessors() const { return 2; } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const InvokeInst *) { return true; } - static inline bool classof(const Instruction *I) { - return (I->getOpcode() == Instruction::Invoke); - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - - -//===--------------------------------------------------------------------------- -/// UnwindInst - Immediately exit the current function, unwinding the stack -/// until an invoke instruction is found. -/// -struct UnwindInst : public TerminatorInst { - UnwindInst(Instruction *InsertBefore = 0) - : TerminatorInst(Instruction::Unwind, InsertBefore) { - } - UnwindInst(BasicBlock *InsertAtEnd) - : TerminatorInst(Instruction::Unwind, InsertAtEnd) { - } - - virtual Instruction *clone() const { return new UnwindInst(); } - - virtual const BasicBlock *getSuccessor(unsigned idx) const { - assert(0 && "UnwindInst has no successors!"); - abort(); - return 0; - } - virtual void setSuccessor(unsigned idx, BasicBlock *NewSucc); - virtual unsigned getNumSuccessors() const { return 0; } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const UnwindInst *) { return true; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == Instruction::Unwind; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - -} // End llvm namespace - -#endif diff --git a/lib/Analysis/BasicAliasAnalysis.cpp b/lib/Analysis/BasicAliasAnalysis.cpp index 9145322894f..76c3a35c410 100644 --- a/lib/Analysis/BasicAliasAnalysis.cpp +++ b/lib/Analysis/BasicAliasAnalysis.cpp @@ -18,8 +18,7 @@ #include "llvm/DerivedTypes.h" #include "llvm/Function.h" #include "llvm/GlobalVariable.h" -#include "llvm/iOther.h" -#include "llvm/iMemory.h" +#include "llvm/Instructions.h" #include "llvm/Pass.h" #include "llvm/Target/TargetData.h" #include "llvm/Support/GetElementPtrTypeIterator.h" diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h index c8d5d13c37b..71876a55b46 100644 --- a/lib/AsmParser/ParserInternals.h +++ b/lib/AsmParser/ParserInternals.h @@ -16,9 +16,9 @@ #define PARSER_INTERNALS_H #include "llvm/Constants.h" -#include "llvm/iOther.h" -#include "llvm/Function.h" #include "llvm/DerivedTypes.h" +#include "llvm/Function.h" +#include "llvm/Instructions.h" #include "llvm/Assembly/Parser.h" #include "Support/StringExtras.h" diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y index 8387fea6e51..efa34f6d74b 100644 --- a/lib/AsmParser/llvmAsmParser.y +++ b/lib/AsmParser/llvmAsmParser.y @@ -13,12 +13,9 @@ %{ #include "ParserInternals.h" -#include "llvm/SymbolTable.h" +#include "llvm/Instructions.h" #include "llvm/Module.h" -#include "llvm/iTerminators.h" -#include "llvm/iMemory.h" -#include "llvm/iOperators.h" -#include "llvm/iPHINode.h" +#include "llvm/SymbolTable.h" #include "llvm/Support/GetElementPtrTypeIterator.h" #include "Support/STLExtras.h" #include diff --git a/lib/Bytecode/Writer/SlotCalculator.cpp b/lib/Bytecode/Writer/SlotCalculator.cpp index f298cd95d5c..75fb4185f7f 100644 --- a/lib/Bytecode/Writer/SlotCalculator.cpp +++ b/lib/Bytecode/Writer/SlotCalculator.cpp @@ -17,8 +17,8 @@ #include "SlotCalculator.h" #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" -#include "llvm/iOther.h" #include "llvm/Function.h" +#include "llvm/Instructions.h" #include "llvm/Module.h" #include "llvm/SymbolTable.h" #include "llvm/Type.h" diff --git a/lib/Transforms/ExprTypeConvert.cpp b/lib/Transforms/ExprTypeConvert.cpp index 1669f0371e1..0f80c2f8bb2 100644 --- a/lib/Transforms/ExprTypeConvert.cpp +++ b/lib/Transforms/ExprTypeConvert.cpp @@ -15,9 +15,7 @@ #include "TransformInternals.h" #include "llvm/Constants.h" -#include "llvm/iOther.h" -#include "llvm/iPHINode.h" -#include "llvm/iMemory.h" +#include "llvm/Instructions.h" #include "llvm/Analysis/Expressions.h" #include "Support/STLExtras.h" #include "Support/Debug.h" diff --git a/lib/Transforms/LevelRaise.cpp b/lib/Transforms/LevelRaise.cpp index 24beee5a8be..881cfd9789d 100644 --- a/lib/Transforms/LevelRaise.cpp +++ b/lib/Transforms/LevelRaise.cpp @@ -16,8 +16,7 @@ #include "llvm/Transforms/Scalar.h" #include "llvm/Transforms/Utils/Local.h" #include "TransformInternals.h" -#include "llvm/iOther.h" -#include "llvm/iMemory.h" +#include "llvm/Instructions.h" #include "llvm/Pass.h" #include "llvm/Transforms/Utils/BasicBlockUtils.h" #include "Support/CommandLine.h" diff --git a/lib/Transforms/TransformInternals.cpp b/lib/Transforms/TransformInternals.cpp index 971a58dfa00..3f7d8dbbfa2 100644 --- a/lib/Transforms/TransformInternals.cpp +++ b/lib/Transforms/TransformInternals.cpp @@ -16,7 +16,7 @@ #include "llvm/Type.h" #include "llvm/Analysis/Expressions.h" #include "llvm/Function.h" -#include "llvm/iOther.h" +#include "llvm/Instructions.h" using namespace llvm; static const Type *getStructOffsetStep(const StructType *STy, uint64_t &Offset, diff --git a/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp b/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp index 89710edaf56..5c87a5b1596 100644 --- a/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp +++ b/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp @@ -18,8 +18,7 @@ #include "llvm/Transforms/Scalar.h" #include "llvm/BasicBlock.h" #include "llvm/Function.h" -#include "llvm/iTerminators.h" -#include "llvm/iPHINode.h" +#include "llvm/Instructions.h" #include "llvm/Type.h" using namespace llvm; diff --git a/lib/VMCore/iBranch.cpp b/lib/VMCore/iBranch.cpp index e0bdcf7d18a..b2e0f29a967 100644 --- a/lib/VMCore/iBranch.cpp +++ b/lib/VMCore/iBranch.cpp @@ -12,7 +12,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/iTerminators.h" +#include "llvm/Instructions.h" #include "llvm/BasicBlock.h" #include "llvm/Type.h" using namespace llvm; diff --git a/lib/VMCore/iCall.cpp b/lib/VMCore/iCall.cpp index b6393148764..12dc9cb776e 100644 --- a/lib/VMCore/iCall.cpp +++ b/lib/VMCore/iCall.cpp @@ -11,8 +11,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/iOther.h" -#include "llvm/iTerminators.h" +#include "llvm/Instructions.h" #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" #include "llvm/Function.h" diff --git a/lib/VMCore/iMemory.cpp b/lib/VMCore/iMemory.cpp index 3fd02829e04..0cee6ac16f4 100644 --- a/lib/VMCore/iMemory.cpp +++ b/lib/VMCore/iMemory.cpp @@ -11,7 +11,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/iMemory.h" +#include "llvm/Instructions.h" #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" using namespace llvm; diff --git a/lib/VMCore/iOperators.cpp b/lib/VMCore/iOperators.cpp index c33d7973914..66653684627 100644 --- a/lib/VMCore/iOperators.cpp +++ b/lib/VMCore/iOperators.cpp @@ -11,7 +11,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/iOperators.h" +#include "llvm/Instructions.h" #include "llvm/Type.h" #include "llvm/Constants.h" #include "llvm/BasicBlock.h" diff --git a/lib/VMCore/iSwitch.cpp b/lib/VMCore/iSwitch.cpp index b78cfbbdc3d..1998b7fde5d 100644 --- a/lib/VMCore/iSwitch.cpp +++ b/lib/VMCore/iSwitch.cpp @@ -11,7 +11,7 @@ // //===----------------------------------------------------------------------===// -#include "llvm/iTerminators.h" +#include "llvm/Instructions.h" #include "llvm/BasicBlock.h" using namespace llvm;