aboutsummaryrefslogtreecommitdiffstats
path: root/lib/VMCore
diff options
context:
space:
mode:
authorChris Lattner <sabre@nondot.org>2003-11-17 19:05:17 +0000
committerChris Lattner <sabre@nondot.org>2003-11-17 19:05:17 +0000
commit0dc396909e01c5fb27e2a5a192131a5d79c3f0e9 (patch)
tree197671f8d402f27a7cd8dbaad0571c9d01ef6aff /lib/VMCore
parent02071d08c1003efce3f32975c6f4a1cf101829cc (diff)
downloadexternal_llvm-0dc396909e01c5fb27e2a5a192131a5d79c3f0e9.zip
external_llvm-0dc396909e01c5fb27e2a5a192131a5d79c3f0e9.tar.gz
external_llvm-0dc396909e01c5fb27e2a5a192131a5d79c3f0e9.tar.bz2
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
Diffstat (limited to 'lib/VMCore')
-rw-r--r--lib/VMCore/ConstantFold.cpp111
-rw-r--r--lib/VMCore/ConstantFold.h47
-rw-r--r--lib/VMCore/ConstantFolding.h47
3 files changed, 85 insertions, 120 deletions
diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp
index 7fb7a05..aca7df2 100644
--- a/lib/VMCore/ConstantFold.cpp
+++ b/lib/VMCore/ConstantFold.cpp
@@ -16,16 +16,12 @@
#include "llvm/InstrTypes.h"
#include "llvm/DerivedTypes.h"
#include <cmath>
-
-namespace llvm {
-
-AnnotationID ConstRules::AID(AnnotationManager::getID("opt::ConstRules",
- &ConstRules::find));
+using namespace llvm;
// ConstantFoldInstruction - Attempt to constant fold the specified instruction.
// If successful, the constant result is returned, if not, null is returned.
//
-Constant *ConstantFoldInstruction(Instruction *I) {
+Constant *llvm::ConstantFoldInstruction(Instruction *I) {
if (PHINode *PN = dyn_cast<PHINode>(I)) {
if (PN->getNumIncomingValues() == 0)
return Constant::getNullValue(PN->getType());
@@ -85,7 +81,8 @@ static unsigned getSize(const Type *Ty) {
return S ? S : 8; // Treat pointers at 8 bytes
}
-Constant *ConstantFoldCastInstruction(const Constant *V, const Type *DestTy) {
+Constant *llvm::ConstantFoldCastInstruction(const Constant *V,
+ const Type *DestTy) {
if (V->getType() == DestTy) return (Constant*)V;
if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
@@ -117,11 +114,12 @@ Constant *ConstantFoldCastInstruction(const Constant *V, const Type *DestTy) {
return ConstantExpr::getCast(CE->getOperand(0), DestTy);
}
- return ConstRules::get(*V, *V)->castTo(V, DestTy);
+ return ConstRules::get(*V, *V).castTo(V, DestTy);
}
-Constant *ConstantFoldBinaryInstruction(unsigned Opcode, const Constant *V1,
- const Constant *V2) {
+Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode,
+ const Constant *V1,
+ const Constant *V2) {
switch (Opcode) {
case Instruction::Add: return *V1 + *V2;
case Instruction::Sub: return *V1 - *V2;
@@ -142,8 +140,9 @@ Constant *ConstantFoldBinaryInstruction(unsigned Opcode, const Constant *V1,
return 0;
}
-Constant *ConstantFoldShiftInstruction(unsigned Opcode, const Constant *V1,
- const Constant *V2) {
+Constant *llvm::ConstantFoldShiftInstruction(unsigned Opcode,
+ const Constant *V1,
+ const Constant *V2) {
switch (Opcode) {
case Instruction::Shl: return *V1 << *V2;
case Instruction::Shr: return *V1 >> *V2;
@@ -151,8 +150,8 @@ Constant *ConstantFoldShiftInstruction(unsigned Opcode, const Constant *V1,
}
}
-Constant *ConstantFoldGetElementPtr(const Constant *C,
- const std::vector<Constant*> &IdxList) {
+Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
+ const std::vector<Constant*> &IdxList) {
if (IdxList.size() == 0 ||
(IdxList.size() == 1 && IdxList[0]->isNullValue()))
return const_cast<Constant*>(C);
@@ -592,53 +591,41 @@ struct DirectFPRules
}
};
-//===----------------------------------------------------------------------===//
-// DirectRules Subclasses
-//===----------------------------------------------------------------------===//
-//
-// Given the DirectRules class we can now implement lots of types with little
-// code. Thank goodness C++ compilers are great at stomping out layers of
-// templates... can you imagine having to do this all by hand? (/me is lazy :)
-//
-
-// ConstRules::find - Return the constant rules that take care of the specified
-// type.
-//
-Annotation *ConstRules::find(AnnotationID AID, const Annotable *TyA, void *) {
- assert(AID == ConstRules::AID && "Bad annotation for factory!");
- const Type *Ty = cast<Type>((const Value*)TyA);
-
- switch (Ty->getPrimitiveID()) {
- case Type::BoolTyID: return new BoolRules();
- case Type::PointerTyID: return new PointerRules();
- case Type::SByteTyID:
- return new DirectIntRules<ConstantSInt, signed char , &Type::SByteTy>();
- case Type::UByteTyID:
- return new DirectIntRules<ConstantUInt, unsigned char , &Type::UByteTy>();
- case Type::ShortTyID:
- return new DirectIntRules<ConstantSInt, signed short, &Type::ShortTy>();
- case Type::UShortTyID:
- return new DirectIntRules<ConstantUInt, unsigned short, &Type::UShortTy>();
- case Type::IntTyID:
- return new DirectIntRules<ConstantSInt, signed int , &Type::IntTy>();
- case Type::UIntTyID:
- return new DirectIntRules<ConstantUInt, unsigned int , &Type::UIntTy>();
- case Type::LongTyID:
- return new DirectIntRules<ConstantSInt, int64_t , &Type::LongTy>();
- case Type::ULongTyID:
- return new DirectIntRules<ConstantUInt, uint64_t , &Type::ULongTy>();
- case Type::FloatTyID:
- return new DirectFPRules<ConstantFP , float , &Type::FloatTy>();
- case Type::DoubleTyID:
- return new DirectFPRules<ConstantFP , double , &Type::DoubleTy>();
- default:
- return new EmptyRules();
+ConstRules &ConstRules::get(const Constant &V1, const Constant &V2) {
+ static EmptyRules EmptyR;
+ static BoolRules BoolR;
+ static PointerRules PointerR;
+ static DirectIntRules<ConstantSInt, signed char , &Type::SByteTy> SByteR;
+ static DirectIntRules<ConstantUInt, unsigned char , &Type::UByteTy> UByteR;
+ static DirectIntRules<ConstantSInt, signed short, &Type::ShortTy> ShortR;
+ static DirectIntRules<ConstantUInt, unsigned short, &Type::UShortTy> UShortR;
+ static DirectIntRules<ConstantSInt, signed int , &Type::IntTy> IntR;
+ static DirectIntRules<ConstantUInt, unsigned int , &Type::UIntTy> UIntR;
+ static DirectIntRules<ConstantSInt, int64_t , &Type::LongTy> LongR;
+ static DirectIntRules<ConstantUInt, uint64_t , &Type::ULongTy> ULongR;
+ static DirectFPRules <ConstantFP , float , &Type::FloatTy> FloatR;
+ static DirectFPRules <ConstantFP , double , &Type::DoubleTy> DoubleR;
+
+ if (isa<ConstantExpr>(V1) || isa<ConstantExpr>(V2))
+ return EmptyR;
+
+ // FIXME: This assert doesn't work because shifts pass both operands in to
+ // check for constant exprs. :(
+ //assert(V1.getType() == V2.getType() &&"Nonequal types to constant folder?");
+
+ switch (V1.getType()->getPrimitiveID()) {
+ default: assert(0 && "Unknown value type for constant folding!");
+ case Type::BoolTyID: return BoolR;
+ case Type::PointerTyID: return PointerR;
+ case Type::SByteTyID: return SByteR;
+ case Type::UByteTyID: return UByteR;
+ case Type::ShortTyID: return ShortR;
+ case Type::UShortTyID: return UShortR;
+ case Type::IntTyID: return IntR;
+ case Type::UIntTyID: return UIntR;
+ case Type::LongTyID: return LongR;
+ case Type::ULongTyID: return ULongR;
+ case Type::FloatTyID: return FloatR;
+ case Type::DoubleTyID: return DoubleR;
}
}
-
-ConstRules *ConstRules::getConstantExprRules() {
- static EmptyRules CERules;
- return &CERules;
-}
-
-} // End llvm namespace
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<ConstantExpr>(V1) || isa<ConstantExpr>(V2))
- return getConstantExprRules();
- return static_cast<ConstRules*>(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);
}
diff --git a/lib/VMCore/ConstantFolding.h b/lib/VMCore/ConstantFolding.h
index b392ad1..d733ac8 100644
--- a/lib/VMCore/ConstantFolding.h
+++ b/lib/VMCore/ConstantFolding.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<ConstantExpr>(V1) || isa<ConstantExpr>(V2))
- return getConstantExprRules();
- return static_cast<ConstRules*>(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);
}