From f067d584a81ae771d301304ea885e55e2de8ee9a Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Mon, 7 Feb 2011 16:40:21 +0000 Subject: implement .ll and .bc support for nsw/nuw on shl and exact on lshr/ashr. Factor some code better. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125006 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Operator.h | 156 ++++++++++++++++-------------------------------- 1 file changed, 50 insertions(+), 106 deletions(-) (limited to 'include/llvm/Operator.h') 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(V) && classof(cast(V))) || - (isa(V) && classof(cast(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(V) && classof(cast(V))) || - (isa(V) && classof(cast(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(V) && classof(cast(V))) || - (isa(V) && classof(cast(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(V) && classof(cast(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(V) && classof(cast(V))) || - (isa(V) && classof(cast(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(V) && classof(cast(V))) || (isa(V) && classof(cast(V))); } }; + -/// UDivOperator - An Operator with opcode Instruction::UDiv. -/// -class UDivOperator : public PossiblyExactOperator { + +/// ConcreteOperator - A helper template for defining operators for individual +/// opcodes. +template +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 *) { + 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(V) && classof(cast(V))) || - (isa(V) && classof(cast(V))); + (isa(V) && classof(cast(V))); } }; + +class AddOperator + : public ConcreteOperator {}; +class SubOperator + : public ConcreteOperator {}; +class MulOperator + : public ConcreteOperator {}; +class ShlOperator + : public ConcreteOperator {}; + + +class SDivOperator + : public ConcreteOperator {}; +class UDivOperator + : public ConcreteOperator {}; +class AShrOperator + : public ConcreteOperator {}; +class LShrOperator + : public ConcreteOperator {}; + -class GEPOperator : public Operator { + +class GEPOperator + : public ConcreteOperator { 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(I)) - if (C->isNullValue()) + if (ConstantInt *C = dyn_cast(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(V) && classof(cast(V))) || - (isa(V) && classof(cast(V))); - } }; } // End llvm namespace -- cgit v1.1