X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FInstrTypes.h;h=fc1917b10be2b14f8a20c887af88b5b7687797ae;hb=d0713f94af4d2dbd97ab251a43e3d290a13e860e;hp=3d834e97a08fbfd36add32274c87fff319cba86a;hpb=9a49b210c1ae2c619ecd969b5ec17a68690928a9;p=oota-llvm.git diff --git a/include/llvm/InstrTypes.h b/include/llvm/InstrTypes.h index 3d834e97a08..fc1917b10be 100644 --- a/include/llvm/InstrTypes.h +++ b/include/llvm/InstrTypes.h @@ -11,33 +11,34 @@ #include "llvm/Instruction.h" -class Method; -class SymTabValue; - //===----------------------------------------------------------------------===// // TerminatorInst Class //===----------------------------------------------------------------------===// -// TerminatorInst - Subclasses of this class are all able to terminate a basic -// block. Thus, these are all the flow control type of operations. -// +/// TerminatorInst - Subclasses of this class are all able to terminate a basic +/// block. Thus, these are all the flow control type of operations. +/// class TerminatorInst : public Instruction { -public: - TerminatorInst(Instruction::TermOps iType); +protected: + TerminatorInst(Instruction::TermOps iType, Instruction *InsertBefore = 0); TerminatorInst(const Type *Ty, Instruction::TermOps iType, - const string &Name = ""); - inline ~TerminatorInst() {} + const std::string &Name = "", Instruction *InsertBefore = 0) + : Instruction(Ty, iType, Name, InsertBefore) { + } +public: - // Terminators must implement the methods required by Instruction... + /// Terminators must implement the methods required by Instruction... virtual Instruction *clone() const = 0; - virtual const char *getOpcodeName() const = 0; - // Additionally, they must provide a method to get at the successors of this - // terminator instruction. If 'idx' is out of range, a null pointer shall be - // returned. - // + /// Additionally, they must provide a method to get at the successors of this + /// terminator instruction. 'idx' may not be >= the number of successors + /// returned by getNumSuccessors()! + /// virtual const BasicBlock *getSuccessor(unsigned idx) const = 0; virtual unsigned getNumSuccessors() const = 0; + + /// Set a successor at a given index + virtual void setSuccessor(unsigned idx, BasicBlock *B) = 0; inline BasicBlock *getSuccessor(unsigned idx) { return (BasicBlock*)((const TerminatorInst *)this)->getSuccessor(idx); @@ -54,70 +55,52 @@ public: }; -//===----------------------------------------------------------------------===// -// UnaryOperator Class -//===----------------------------------------------------------------------===// - -class UnaryOperator : public Instruction { -public: - - // create() - Construct a unary instruction, given the opcode - // and its operand. - // - static UnaryOperator *create(UnaryOps Op, Value *Source); - - UnaryOperator(Value *S, UnaryOps iType, const string &Name = "") - : Instruction(S->getType(), iType, Name) { - Operands.reserve(1); - Operands.push_back(Use(S, this)); - } - - inline UnaryOps getOpcode() const { - return (UnaryOps)Instruction::getOpcode(); - } - - virtual Instruction *clone() const { - return create(getOpcode(), Operands[0]); - } - - virtual const char *getOpcodeName() const = 0; - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const UnaryOperator *) { return true; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() >= FirstUnaryOp && I->getOpcode() < NumUnaryOps; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - - - //===----------------------------------------------------------------------===// // BinaryOperator Class //===----------------------------------------------------------------------===// class BinaryOperator : public Instruction { +protected: + BinaryOperator(BinaryOps iType, Value *S1, Value *S2, const Type *Ty, + const std::string &Name, Instruction *InsertBefore); + public: - // create() - Construct a binary instruction, given the opcode - // and the two operands. - // + /// create() - Construct a binary instruction, given the opcode and the two + /// operands. Optionally (if InstBefore is specified) insert the instruction + /// into a BasicBlock right before the specified instruction. The specified + /// Instruction is allowed to be a dereferenced end iterator. + /// static BinaryOperator *create(BinaryOps Op, Value *S1, Value *S2, - const string &Name = ""); - - BinaryOperator(BinaryOps iType, Value *S1, Value *S2, - const string &Name = "") - : Instruction(S1->getType(), iType, Name) { - Operands.reserve(2); - Operands.push_back(Use(S1, this)); - Operands.push_back(Use(S2, this)); - assert(Operands[0] && Operands[1] && - Operands[0]->getType() == Operands[1]->getType()); - } - - inline BinaryOps getOpcode() const { + const std::string &Name = "", + Instruction *InsertBefore = 0); + + + /// Helper functions to construct and inspect unary operations (NEG and NOT) + /// via binary operators SUB and XOR: + /// + /// createNeg, createNot - Create the NEG and NOT + /// instructions out of SUB and XOR instructions. + /// + static BinaryOperator *createNeg(Value *Op, const std::string &Name = "", + Instruction *InsertBefore = 0); + static BinaryOperator *createNot(Value *Op, const std::string &Name = "", + Instruction *InsertBefore = 0); + + /// isNeg, isNot - Check if the given Value is a NEG or NOT instruction. + /// + static bool isNeg(const Value *V); + static bool isNot(const Value *V); + + /// getNegArgument, getNotArgument - Helper functions to extract the + /// unary argument of a NEG or NOT operation implemented via Sub or Xor. + /// + static const Value* getNegArgument(const BinaryOperator* Bop); + static Value* getNegArgument( BinaryOperator* Bop); + static const Value* getNotArgument(const BinaryOperator* Bop); + static Value* getNotArgument( BinaryOperator* Bop); + + BinaryOps getOpcode() const { return (BinaryOps)Instruction::getOpcode(); } @@ -125,15 +108,13 @@ public: return create(getOpcode(), Operands[0], Operands[1]); } - virtual const char *getOpcodeName() const = 0; - - // swapOperands - Exchange the two operands to this instruction. - // This instruction is safe to use on any binary instruction and - // does not modify the semantics of the instruction. If the - // instruction is order dependant (SetLT f.e.) the opcode is - // changed. If the instruction cannot be reversed (ie, it's a Div), - // then return true. - // + /// swapOperands - Exchange the two operands to this instruction. + /// This instruction is safe to use on any binary instruction and + /// does not modify the semantics of the instruction. If the + /// instruction is order dependant (SetLT f.e.) the opcode is + /// changed. If the instruction cannot be reversed (ie, it's a Div), + /// then return true. + /// bool swapOperands(); // Methods for support type inquiry through isa, cast, and dyn_cast: