diff options
Diffstat (limited to 'include/llvm/Operator.h')
-rw-r--r-- | include/llvm/Operator.h | 156 |
1 files changed, 50 insertions, 106 deletions
diff --git a/include/llvm/Operator.h b/include/llvm/Operator.h index eaa28ad..ff2a0ad 100644 --- a/include/llvm/Operator.h +++ b/include/llvm/Operator.h @@ -106,66 +106,14 @@ public: static inline bool classof(const Instruction *I) { return I->getOpcode() == Instruction::Add || I->getOpcode() == Instruction::Sub || - I->getOpcode() == Instruction::Mul; + I->getOpcode() == Instruction::Mul || + I->getOpcode() == Instruction::Shl; } static inline bool classof(const ConstantExpr *CE) { return CE->getOpcode() == Instruction::Add || CE->getOpcode() == Instruction::Sub || - CE->getOpcode() == Instruction::Mul; - } - static inline bool classof(const Value *V) { - return (isa<Instruction>(V) && classof(cast<Instruction>(V))) || - (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V))); - } -}; - -/// AddOperator - Utility class for integer addition operators. -/// -class AddOperator : public OverflowingBinaryOperator { - ~AddOperator(); // do not implement -public: - static inline bool classof(const AddOperator *) { return true; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == Instruction::Add; - } - static inline bool classof(const ConstantExpr *CE) { - return CE->getOpcode() == Instruction::Add; - } - static inline bool classof(const Value *V) { - return (isa<Instruction>(V) && classof(cast<Instruction>(V))) || - (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V))); - } -}; - -/// SubOperator - Utility class for integer subtraction operators. -/// -class SubOperator : public OverflowingBinaryOperator { - ~SubOperator(); // do not implement -public: - static inline bool classof(const SubOperator *) { return true; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == Instruction::Sub; - } - static inline bool classof(const ConstantExpr *CE) { - return CE->getOpcode() == Instruction::Sub; - } - static inline bool classof(const Value *V) { - return (isa<Instruction>(V) && classof(cast<Instruction>(V))) || - (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V))); - } -}; - -/// MulOperator - Utility class for integer multiplication operators. -/// -class MulOperator : public OverflowingBinaryOperator { - ~MulOperator(); // do not implement -public: - static inline bool classof(const MulOperator *) { return true; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == Instruction::Mul; - } - static inline bool classof(const ConstantExpr *CE) { - return CE->getOpcode() == Instruction::Mul; + CE->getOpcode() == Instruction::Mul || + CE->getOpcode() == Instruction::Shl; } static inline bool classof(const Value *V) { return (isa<Instruction>(V) && classof(cast<Instruction>(V))) || @@ -196,63 +144,74 @@ public: return SubclassOptionalData & IsExact; } - static inline bool classof(const ConstantExpr *CE) { - return CE->getOpcode() == Instruction::SDiv || - CE->getOpcode() == Instruction::UDiv; + static bool isPossiblyExactOpcode(unsigned OpC) { + return OpC == Instruction::SDiv || + OpC == Instruction::UDiv || + OpC == Instruction::AShr || + OpC == Instruction::LShr; } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == Instruction::SDiv || - I->getOpcode() == Instruction::UDiv; - } - static inline bool classof(const Value *V) { - return (isa<Instruction>(V) && classof(cast<Instruction>(V))) || - (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V))); - } -}; - -/// SDivOperator - An Operator with opcode Instruction::SDiv. -/// -class SDivOperator : public PossiblyExactOperator { -public: - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const SDivOperator *) { return true; } static inline bool classof(const ConstantExpr *CE) { - return CE->getOpcode() == Instruction::SDiv; + return isPossiblyExactOpcode(CE->getOpcode()); } static inline bool classof(const Instruction *I) { - return I->getOpcode() == Instruction::SDiv; + return isPossiblyExactOpcode(I->getOpcode()); } static inline bool classof(const Value *V) { return (isa<Instruction>(V) && classof(cast<Instruction>(V))) || (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V))); } }; + -/// UDivOperator - An Operator with opcode Instruction::UDiv. -/// -class UDivOperator : public PossiblyExactOperator { + +/// ConcreteOperator - A helper template for defining operators for individual +/// opcodes. +template<typename SuperClass, unsigned Opc> +class ConcreteOperator : public SuperClass { + ~ConcreteOperator(); // DO NOT IMPLEMENT public: - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const UDivOperator *) { return true; } - static inline bool classof(const ConstantExpr *CE) { - return CE->getOpcode() == Instruction::UDiv; + static inline bool classof(const ConcreteOperator<SuperClass, Opc> *) { + return true; } static inline bool classof(const Instruction *I) { - return I->getOpcode() == Instruction::UDiv; + return I->getOpcode() == Opc; + } + static inline bool classof(const ConstantExpr *CE) { + return CE->getOpcode() == Opc; } static inline bool classof(const Value *V) { return (isa<Instruction>(V) && classof(cast<Instruction>(V))) || - (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V))); + (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V))); } }; + +class AddOperator + : public ConcreteOperator<OverflowingBinaryOperator, Instruction::Add> {}; +class SubOperator + : public ConcreteOperator<OverflowingBinaryOperator, Instruction::Sub> {}; +class MulOperator + : public ConcreteOperator<OverflowingBinaryOperator, Instruction::Mul> {}; +class ShlOperator + : public ConcreteOperator<OverflowingBinaryOperator, Instruction::Shl> {}; + + +class SDivOperator + : public ConcreteOperator<PossiblyExactOperator, Instruction::SDiv> {}; +class UDivOperator + : public ConcreteOperator<PossiblyExactOperator, Instruction::UDiv> {}; +class AShrOperator + : public ConcreteOperator<PossiblyExactOperator, Instruction::AShr> {}; +class LShrOperator + : public ConcreteOperator<PossiblyExactOperator, Instruction::LShr> {}; + -class GEPOperator : public Operator { + +class GEPOperator + : public ConcreteOperator<Operator, Instruction::GetElementPtr> { enum { IsInBounds = (1 << 0) }; - ~GEPOperator(); // do not implement - friend class GetElementPtrInst; friend class ConstantExpr; void setIsInBounds(bool B) { @@ -301,8 +260,8 @@ public: /// value, just potentially different types. bool hasAllZeroIndices() const { for (const_op_iterator I = idx_begin(), E = idx_end(); I != E; ++I) { - if (Constant *C = dyn_cast<Constant>(I)) - if (C->isNullValue()) + if (ConstantInt *C = dyn_cast<ConstantInt>(I)) + if (C->isZero()) continue; return false; } @@ -319,21 +278,6 @@ public: } return true; } - - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const GEPOperator *) { return true; } - static inline bool classof(const GetElementPtrInst *) { return true; } - static inline bool classof(const ConstantExpr *CE) { - return CE->getOpcode() == Instruction::GetElementPtr; - } - static inline bool classof(const Instruction *I) { - return I->getOpcode() == Instruction::GetElementPtr; - } - static inline bool classof(const Value *V) { - return (isa<Instruction>(V) && classof(cast<Instruction>(V))) || - (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V))); - } }; } // End llvm namespace |