From 76ac1a45b40a96d1e583e2576c04d19b7d23a99e Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Thu, 1 Nov 2001 05:55:13 +0000 Subject: [PATCH] Implement constant propogation of null pointer values. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1078 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/ConstantHandling.h | 4 ++ lib/VMCore/ConstantFold.cpp | 77 ++++++++++++++++++++++++++++++++- lib/VMCore/ConstantFold.h | 4 ++ lib/VMCore/ConstantFolding.h | 4 ++ 4 files changed, 88 insertions(+), 1 deletion(-) diff --git a/include/llvm/ConstantHandling.h b/include/llvm/ConstantHandling.h index d3af1bda464..9e9e760ea1f 100644 --- a/include/llvm/ConstantHandling.h +++ b/include/llvm/ConstantHandling.h @@ -36,6 +36,7 @@ #include "llvm/ConstPoolVals.h" #include "llvm/Instruction.h" #include "llvm/Type.h" +class PointerType; namespace opt { @@ -90,6 +91,8 @@ public: virtual ConstPoolUInt *castToULong (const ConstPoolVal *V) const = 0; virtual ConstPoolFP *castToFloat (const ConstPoolVal *V) const = 0; virtual ConstPoolFP *castToDouble(const ConstPoolVal *V) const = 0; + virtual ConstPoolPointer *castToPointer(const ConstPoolVal *V, + const PointerType *Ty) const = 0; inline ConstPoolVal *castTo(const ConstPoolVal *V, const Type *Ty) const { switch (Ty->getPrimitiveID()) { @@ -104,6 +107,7 @@ public: case Type::LongTyID: return castToLong(V); case Type::FloatTyID: return castToFloat(V); case Type::DoubleTyID: return castToDouble(V); + case Type::PointerTyID:return castToPointer(V, (PointerType*)Ty); default: return 0; } } diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp index 67a598cf232..74383190001 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -89,6 +89,10 @@ class TemplateRules : public ConstRules { virtual ConstPoolFP *castToDouble(const ConstPoolVal *V) const { return SubClassName::CastToDouble((const ArgType*)V); } + virtual ConstPoolPointer *castToPointer(const ConstPoolVal *V, + const PointerType *Ty) const { + return SubClassName::CastToPointer((const ArgType*)V, Ty); + } //===--------------------------------------------------------------------===// // Default "noop" implementations @@ -121,6 +125,8 @@ class TemplateRules : public ConstRules { inline static ConstPoolUInt *CastToULong (const ConstPoolVal *V) { return 0; } inline static ConstPoolFP *CastToFloat (const ConstPoolVal *V) { return 0; } inline static ConstPoolFP *CastToDouble(const ConstPoolVal *V) { return 0; } + inline static ConstPoolPointer *CastToPointer(const ConstPoolVal *, + const PointerType *) {return 0;} }; @@ -160,6 +166,67 @@ struct BoolRules : public TemplateRules { }; +//===----------------------------------------------------------------------===// +// PointerRules Class +//===----------------------------------------------------------------------===// +// +// PointerRules provides a concrete base class of ConstRules for pointer types +// +struct PointerRules : public TemplateRules { + inline static ConstPoolBool *CastToBool (const ConstPoolVal *V) { + if (V->isNullValue()) return ConstPoolBool::False; + return 0; // Can't const prop other types of pointers + } + inline static ConstPoolSInt *CastToSByte (const ConstPoolVal *V) { + if (V->isNullValue()) return ConstPoolSInt::get(Type::SByteTy, 0); + return 0; // Can't const prop other types of pointers + } + inline static ConstPoolUInt *CastToUByte (const ConstPoolVal *V) { + if (V->isNullValue()) return ConstPoolUInt::get(Type::UByteTy, 0); + return 0; // Can't const prop other types of pointers + } + inline static ConstPoolSInt *CastToShort (const ConstPoolVal *V) { + if (V->isNullValue()) return ConstPoolSInt::get(Type::ShortTy, 0); + return 0; // Can't const prop other types of pointers + } + inline static ConstPoolUInt *CastToUShort(const ConstPoolVal *V) { + if (V->isNullValue()) return ConstPoolUInt::get(Type::UShortTy, 0); + return 0; // Can't const prop other types of pointers + } + inline static ConstPoolSInt *CastToInt (const ConstPoolVal *V) { + if (V->isNullValue()) return ConstPoolSInt::get(Type::IntTy, 0); + return 0; // Can't const prop other types of pointers + } + inline static ConstPoolUInt *CastToUInt (const ConstPoolVal *V) { + if (V->isNullValue()) return ConstPoolUInt::get(Type::UIntTy, 0); + return 0; // Can't const prop other types of pointers + } + inline static ConstPoolSInt *CastToLong (const ConstPoolVal *V) { + if (V->isNullValue()) return ConstPoolSInt::get(Type::LongTy, 0); + return 0; // Can't const prop other types of pointers + } + inline static ConstPoolUInt *CastToULong (const ConstPoolVal *V) { + if (V->isNullValue()) return ConstPoolUInt::get(Type::ULongTy, 0); + return 0; // Can't const prop other types of pointers + } + inline static ConstPoolFP *CastToFloat (const ConstPoolVal *V) { + if (V->isNullValue()) return ConstPoolFP::get(Type::FloatTy, 0); + return 0; // Can't const prop other types of pointers + } + inline static ConstPoolFP *CastToDouble(const ConstPoolVal *V) { + if (V->isNullValue()) return ConstPoolFP::get(Type::DoubleTy, 0); + return 0; // Can't const prop other types of pointers + } + + inline static ConstPoolPointer *CastToPointer(const ConstPoolPointer *V, + const PointerType *PTy) { + if (V->isNullValue()) + return ConstPoolPointerNull::get(PTy); + return 0; // Can't const prop other types of pointers + } +}; + + //===----------------------------------------------------------------------===// // DirectRules Class //===----------------------------------------------------------------------===// @@ -204,6 +271,13 @@ struct DirectRules return ConstPoolBool::get(Result); } + inline static ConstPoolPointer *CastToPointer(const ConstPoolClass *V, + const PointerType *PTy) { + if (V->isNullValue()) // Is it a FP or Integral null value? + return ConstPoolPointerNull::get(PTy); + return 0; // Can't const prop other types of pointers + } + // Casting operators. ick #define DEF_CAST(TYPE, CLASS, CTYPE) \ inline static CLASS *CastTo##TYPE (const ConstPoolClass *V) { \ @@ -241,7 +315,8 @@ Annotation *ConstRules::find(AnnotationID AID, const Annotable *TyA, void *) { const Type *Ty = cast((const Value*)TyA); switch (Ty->getPrimitiveID()) { - case Type::BoolTyID: return new BoolRules(); + case Type::BoolTyID: return new BoolRules(); + case Type::PointerTyID: return new PointerRules(); case Type::SByteTyID: return new DirectRules(); case Type::UByteTyID: diff --git a/lib/VMCore/ConstantFold.h b/lib/VMCore/ConstantFold.h index d3af1bda464..9e9e760ea1f 100644 --- a/lib/VMCore/ConstantFold.h +++ b/lib/VMCore/ConstantFold.h @@ -36,6 +36,7 @@ #include "llvm/ConstPoolVals.h" #include "llvm/Instruction.h" #include "llvm/Type.h" +class PointerType; namespace opt { @@ -90,6 +91,8 @@ public: virtual ConstPoolUInt *castToULong (const ConstPoolVal *V) const = 0; virtual ConstPoolFP *castToFloat (const ConstPoolVal *V) const = 0; virtual ConstPoolFP *castToDouble(const ConstPoolVal *V) const = 0; + virtual ConstPoolPointer *castToPointer(const ConstPoolVal *V, + const PointerType *Ty) const = 0; inline ConstPoolVal *castTo(const ConstPoolVal *V, const Type *Ty) const { switch (Ty->getPrimitiveID()) { @@ -104,6 +107,7 @@ public: case Type::LongTyID: return castToLong(V); case Type::FloatTyID: return castToFloat(V); case Type::DoubleTyID: return castToDouble(V); + case Type::PointerTyID:return castToPointer(V, (PointerType*)Ty); default: return 0; } } diff --git a/lib/VMCore/ConstantFolding.h b/lib/VMCore/ConstantFolding.h index d3af1bda464..9e9e760ea1f 100644 --- a/lib/VMCore/ConstantFolding.h +++ b/lib/VMCore/ConstantFolding.h @@ -36,6 +36,7 @@ #include "llvm/ConstPoolVals.h" #include "llvm/Instruction.h" #include "llvm/Type.h" +class PointerType; namespace opt { @@ -90,6 +91,8 @@ public: virtual ConstPoolUInt *castToULong (const ConstPoolVal *V) const = 0; virtual ConstPoolFP *castToFloat (const ConstPoolVal *V) const = 0; virtual ConstPoolFP *castToDouble(const ConstPoolVal *V) const = 0; + virtual ConstPoolPointer *castToPointer(const ConstPoolVal *V, + const PointerType *Ty) const = 0; inline ConstPoolVal *castTo(const ConstPoolVal *V, const Type *Ty) const { switch (Ty->getPrimitiveID()) { @@ -104,6 +107,7 @@ public: case Type::LongTyID: return castToLong(V); case Type::FloatTyID: return castToFloat(V); case Type::DoubleTyID: return castToDouble(V); + case Type::PointerTyID:return castToPointer(V, (PointerType*)Ty); default: return 0; } }