From 225e8dd2f512e3e6840ba7cb1570fdc4d56a853f Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Tue, 27 Sep 2005 06:08:32 +0000 Subject: [PATCH] Split SimpleConstantVal up into its components, so each Constant subclass gets a different enum value. This allows 'classof' for these to be really simple, not needing to call getType() anymore. This speeds up isa/dyncast/etc for constants, and also makes them smaller. For example, the text section of a release build of InstCombine.cpp shrinks from 230037 bytes to 216363 bytes, a 6% reduction. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23466 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Constant.h | 8 ++------ include/llvm/Constants.h | 38 ++++++++++++++++---------------------- include/llvm/Value.h | 21 ++++++++++++++------- 3 files changed, 32 insertions(+), 35 deletions(-) diff --git a/include/llvm/Constant.h b/include/llvm/Constant.h index b8ec03b3ec4..b82a259849a 100644 --- a/include/llvm/Constant.h +++ b/include/llvm/Constant.h @@ -61,12 +61,8 @@ public: static inline bool classof(const Constant *) { return true; } static inline bool classof(const GlobalValue *) { return true; } static inline bool classof(const Value *V) { - return V->getValueType() == Value::SimpleConstantVal || - V->getValueType() == Value::ConstantExprVal || - V->getValueType() == Value::ConstantAggregateZeroVal || - V->getValueType() == Value::FunctionVal || - V->getValueType() == Value::GlobalVariableVal || - V->getValueType() == Value::UndefValueVal; + return V->getValueType() >= ConstantFirstVal && + V->getValueType() <= ConstantLastVal; } /// replaceUsesOfWithOnConstant - This method is a special form of diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h index 4b5d883bbfa..0b3784f0d6d 100644 --- a/include/llvm/Constants.h +++ b/include/llvm/Constants.h @@ -47,7 +47,7 @@ protected: int64_t Signed; uint64_t Unsigned; } Val; - ConstantIntegral(const Type *Ty, uint64_t V); + ConstantIntegral(const Type *Ty, ValueTy VT, uint64_t V); public: /// getRawValue - return the underlying value of this constant as a 64-bit @@ -98,8 +98,9 @@ public: /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantIntegral *) { return true; } static bool classof(const Value *V) { - return V->getValueType() == SimpleConstantVal && - V->getType()->isIntegral(); + return V->getValueType() == ConstantBoolVal || + V->getValueType() == ConstantSIntVal || + V->getValueType() == ConstantUIntVal; } }; @@ -134,7 +135,7 @@ public: /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantBool *) { return true; } static bool classof(const Value *V) { - return (V == True) | (V == False); + return V->getValueType() == ConstantBoolVal; } }; @@ -146,7 +147,7 @@ public: class ConstantInt : public ConstantIntegral { protected: ConstantInt(const ConstantInt &); // DO NOT IMPLEMENT - ConstantInt(const Type *Ty, uint64_t V); + ConstantInt(const Type *Ty, ValueTy VT, uint64_t V); public: /// equalsInt - Provide a helper method that can be used to determine if the /// constant contained within is equal to a constant. This only works for @@ -173,8 +174,8 @@ public: /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantInt *) { return true; } static bool classof(const Value *V) { - return V->getValueType() == SimpleConstantVal && - V->getType()->isInteger(); + return V->getValueType() == ConstantSIntVal || + V->getValueType() == ConstantUIntVal; } }; @@ -227,8 +228,7 @@ public: /// static inline bool classof(const ConstantSInt *) { return true; } static bool classof(const Value *V) { - return V->getValueType() == SimpleConstantVal && - V->getType()->isSigned(); + return V->getValueType() == ConstantSIntVal; } }; @@ -263,8 +263,7 @@ public: /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantUInt *) { return true; } static bool classof(const Value *V) { - return V->getValueType() == SimpleConstantVal && - V->getType()->isUnsigned(); + return V->getValueType() == ConstantUIntVal; } }; @@ -301,8 +300,7 @@ public: /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantFP *) { return true; } static bool classof(const Value *V) { - return V->getValueType() == SimpleConstantVal && - V->getType()->isFloatingPoint(); + return V->getValueType() == ConstantFPVal; } }; @@ -380,8 +378,7 @@ public: /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantArray *) { return true; } static bool classof(const Value *V) { - return V->getValueType() == SimpleConstantVal && - V->getType()->getTypeID() == Type::ArrayTyID; + return V->getValueType() == ConstantArrayVal; } }; @@ -422,8 +419,7 @@ public: /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantStruct *) { return true; } static bool classof(const Value *V) { - return V->getValueType() == SimpleConstantVal && - V->getType()->getTypeID() == Type::StructTyID; + return V->getValueType() == ConstantStructVal; } }; @@ -461,8 +457,7 @@ public: /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantPacked *) { return true; } static bool classof(const Value *V) { - return V->getValueType() == SimpleConstantVal && - V->getType()->getTypeID() == Type::PackedTyID; + return V->getValueType() == ConstantPackedVal; } }; @@ -475,7 +470,7 @@ class ConstantPointerNull : public Constant { protected: ConstantPointerNull(const PointerType *T) : Constant(reinterpret_cast(T), - Value::SimpleConstantVal, 0, 0) {} + Value::ConstantPointerNullVal, 0, 0) {} public: @@ -498,8 +493,7 @@ public: /// Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstantPointerNull *) { return true; } static bool classof(const Value *V) { - return V->getValueType() == SimpleConstantVal && - isa(V->getType()); + return V->getValueType() == ConstantPointerNullVal; } }; diff --git a/include/llvm/Value.h b/include/llvm/Value.h index 91c8cbc0689..f71491d36ea 100644 --- a/include/llvm/Value.h +++ b/include/llvm/Value.h @@ -146,8 +146,19 @@ public: UndefValueVal, // This is an instance of UndefValue ConstantExprVal, // This is an instance of ConstantExpr ConstantAggregateZeroVal, // This is an instance of ConstantAggregateNull - SimpleConstantVal, // This is some other type of Constant + ConstantBoolVal, // This is an instance of ConstantBool + ConstantSIntVal, // This is an instance of ConstantSInt + ConstantUIntVal, // This is an instance of ConstantUInt + ConstantFPVal, // This is an instance of ConstantFP + ConstantArrayVal, // This is an instance of ConstantArray + ConstantStructVal, // This is an instance of ConstantStruct + ConstantPackedVal, // This is an instance of ConstantPacked + ConstantPointerNullVal, // This is an instance of ConstantPointerNull InstructionVal, // This is an instance of Instruction + + // Markers: + ConstantFirstVal = FunctionVal, + ConstantLastVal = ConstantPointerNullVal, }; unsigned getValueType() const { return SubclassID; @@ -194,12 +205,8 @@ void Use::set(Value *V) { // the subtype header files to test to see if the value is a subclass... // template <> inline bool isa_impl(const Value &Val) { - return Val.getValueType() == Value::SimpleConstantVal || - Val.getValueType() == Value::FunctionVal || - Val.getValueType() == Value::GlobalVariableVal || - Val.getValueType() == Value::ConstantExprVal || - Val.getValueType() == Value::ConstantAggregateZeroVal || - Val.getValueType() == Value::UndefValueVal; + return Val.getValueType() >= Value::ConstantFirstVal && + Val.getValueType() <= Value::ConstantLastVal; } template <> inline bool isa_impl(const Value &Val) { return Val.getValueType() == Value::ArgumentVal; -- 2.34.1