From 0dc396909e01c5fb27e2a5a192131a5d79c3f0e9 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Mon, 17 Nov 2003 19:05:17 +0000 Subject: Constant folding shalt not be built on annotations git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10052 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/VMCore/ConstantFold.h | 47 ++++++++++++++++++----------------------------- 1 file changed, 18 insertions(+), 29 deletions(-) (limited to 'lib/VMCore/ConstantFold.h') diff --git a/lib/VMCore/ConstantFold.h b/lib/VMCore/ConstantFold.h index b392ad1..d733ac8 100644 --- a/lib/VMCore/ConstantFold.h +++ b/lib/VMCore/ConstantFold.h @@ -64,11 +64,8 @@ inline ConstantBool *operator!=(const Constant &V1, const Constant &V2) { // Implement all other operators indirectly through TypeRules system //===----------------------------------------------------------------------===// -class ConstRules : public Annotation { -protected: - inline ConstRules() : Annotation(AID) {} // Can only be subclassed... -public: - static AnnotationID AID; // AnnotationID for this class +struct ConstRules { + ConstRules() {} // Binary Operators... virtual Constant *add(const Constant *V1, const Constant *V2) const = 0; @@ -119,19 +116,11 @@ public: } } - // ConstRules::get - A type will cache its own type rules if one is needed... - // we just want to make sure to hit the cache instead of doing it indirectly, - // if possible... + // ConstRules::get - Return an instance of ConstRules for the specified + // constant operands. // - static inline ConstRules *get(const Constant &V1, const Constant &V2) { - if (isa(V1) || isa(V2)) - return getConstantExprRules(); - return static_cast(V1.getType()->getOrCreateAnnotation(AID)); - } + static ConstRules &get(const Constant &V1, const Constant &V2); private: - static ConstRules *getConstantExprRules(); - static Annotation *find(AnnotationID AID, const Annotable *Ty, void *); - ConstRules(const ConstRules &); // Do not implement ConstRules &operator=(const ConstRules &); // Do not implement }; @@ -139,71 +128,71 @@ private: // Unary operators... inline Constant *operator~(const Constant &V) { assert(V.getType()->isIntegral() && "Cannot invert non-integral constant!"); - return ConstRules::get(V, V)->op_xor(&V, + return ConstRules::get(V, V).op_xor(&V, ConstantInt::getAllOnesValue(V.getType())); } inline Constant *operator-(const Constant &V) { - return ConstRules::get(V, V)->sub(Constant::getNullValue(V.getType()), &V); + return ConstRules::get(V, V).sub(Constant::getNullValue(V.getType()), &V); } // Standard binary operators... inline Constant *operator+(const Constant &V1, const Constant &V2) { assert(V1.getType() == V2.getType() && "Constant types must be identical!"); - return ConstRules::get(V1, V2)->add(&V1, &V2); + return ConstRules::get(V1, V2).add(&V1, &V2); } inline Constant *operator-(const Constant &V1, const Constant &V2) { assert(V1.getType() == V2.getType() && "Constant types must be identical!"); - return ConstRules::get(V1, V2)->sub(&V1, &V2); + return ConstRules::get(V1, V2).sub(&V1, &V2); } inline Constant *operator*(const Constant &V1, const Constant &V2) { assert(V1.getType() == V2.getType() && "Constant types must be identical!"); - return ConstRules::get(V1, V2)->mul(&V1, &V2); + return ConstRules::get(V1, V2).mul(&V1, &V2); } inline Constant *operator/(const Constant &V1, const Constant &V2) { assert(V1.getType() == V2.getType() && "Constant types must be identical!"); - return ConstRules::get(V1, V2)->div(&V1, &V2); + return ConstRules::get(V1, V2).div(&V1, &V2); } inline Constant *operator%(const Constant &V1, const Constant &V2) { assert(V1.getType() == V2.getType() && "Constant types must be identical!"); - return ConstRules::get(V1, V2)->rem(&V1, &V2); + return ConstRules::get(V1, V2).rem(&V1, &V2); } // Logical Operators... inline Constant *operator&(const Constant &V1, const Constant &V2) { assert(V1.getType() == V2.getType() && "Constant types must be identical!"); - return ConstRules::get(V1, V2)->op_and(&V1, &V2); + return ConstRules::get(V1, V2).op_and(&V1, &V2); } inline Constant *operator|(const Constant &V1, const Constant &V2) { assert(V1.getType() == V2.getType() && "Constant types must be identical!"); - return ConstRules::get(V1, V2)->op_or(&V1, &V2); + return ConstRules::get(V1, V2).op_or(&V1, &V2); } inline Constant *operator^(const Constant &V1, const Constant &V2) { assert(V1.getType() == V2.getType() && "Constant types must be identical!"); - return ConstRules::get(V1, V2)->op_xor(&V1, &V2); + return ConstRules::get(V1, V2).op_xor(&V1, &V2); } // Shift Instructions... inline Constant *operator<<(const Constant &V1, const Constant &V2) { assert(V1.getType()->isInteger() && V2.getType() == Type::UByteTy); - return ConstRules::get(V1, V2)->shl(&V1, &V2); + return ConstRules::get(V1, V2).shl(&V1, &V2); } inline Constant *operator>>(const Constant &V1, const Constant &V2) { assert(V1.getType()->isInteger() && V2.getType() == Type::UByteTy); - return ConstRules::get(V1, V2)->shr(&V1, &V2); + return ConstRules::get(V1, V2).shr(&V1, &V2); } inline ConstantBool *operator<(const Constant &V1, const Constant &V2) { assert(V1.getType() == V2.getType() && "Constant types must be identical!"); - return ConstRules::get(V1, V2)->lessthan(&V1, &V2); + return ConstRules::get(V1, V2).lessthan(&V1, &V2); } -- cgit v1.1