Rename ConstPoolVal -> Constant

Rename ConstPool*   -> Constant*
Rename ConstPoolVals.h -> ConstantVals.h


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1407 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 118 insertions, 118 deletions

diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp
index 7438319000..c588f72a23 100644
--- a/lib/VMCore/ConstantFold.cpp
+++ b/lib/VMCore/ConstantFold.cpp
@@ -30,67 +30,67 @@ class TemplateRules : public ConstRules {
   // Redirecting functions that cast to the appropriate types
   //===--------------------------------------------------------------------===//
 
-  virtual ConstPoolVal *op_not(const ConstPoolVal *V) const {
+  virtual Constant *op_not(const Constant *V) const {
     return SubClassName::Not((const ArgType *)V);
   }
 
   
-  virtual ConstPoolVal *add(const ConstPoolVal *V1, 
-                            const ConstPoolVal *V2) const { 
+  virtual Constant *add(const Constant *V1, 
+                        const Constant *V2) const { 
     return SubClassName::Add((const ArgType *)V1, (const ArgType *)V2);  
   }
 
-  virtual ConstPoolVal *sub(const ConstPoolVal *V1, 
-                            const ConstPoolVal *V2) const { 
+  virtual Constant *sub(const Constant *V1, 
+                        const Constant *V2) const { 
     return SubClassName::Sub((const ArgType *)V1, (const ArgType *)V2);  
   }
 
-  virtual ConstPoolVal *mul(const ConstPoolVal *V1, 
-                            const ConstPoolVal *V2) const { 
+  virtual Constant *mul(const Constant *V1, 
+                        const Constant *V2) const { 
     return SubClassName::Mul((const ArgType *)V1, (const ArgType *)V2);  
   }
 
-  virtual ConstPoolBool *lessthan(const ConstPoolVal *V1, 
-                                  const ConstPoolVal *V2) const { 
+  virtual ConstantBool *lessthan(const Constant *V1, 
+                                 const Constant *V2) const { 
     return SubClassName::LessThan((const ArgType *)V1, (const ArgType *)V2);
   }
 
   // Casting operators.  ick
-  virtual ConstPoolBool *castToBool(const ConstPoolVal *V) const {
+  virtual ConstantBool *castToBool(const Constant *V) const {
     return SubClassName::CastToBool((const ArgType*)V);
   }
-  virtual ConstPoolSInt *castToSByte(const ConstPoolVal *V) const {
+  virtual ConstantSInt *castToSByte(const Constant *V) const {
     return SubClassName::CastToSByte((const ArgType*)V);
   }
-  virtual ConstPoolUInt *castToUByte(const ConstPoolVal *V) const {
+  virtual ConstantUInt *castToUByte(const Constant *V) const {
     return SubClassName::CastToUByte((const ArgType*)V);
   }
-  virtual ConstPoolSInt *castToShort(const ConstPoolVal *V) const {
+  virtual ConstantSInt *castToShort(const Constant *V) const {
     return SubClassName::CastToShort((const ArgType*)V);
   }
-  virtual ConstPoolUInt *castToUShort(const ConstPoolVal *V) const {
+  virtual ConstantUInt *castToUShort(const Constant *V) const {
     return SubClassName::CastToUShort((const ArgType*)V);
   }
-  virtual ConstPoolSInt *castToInt(const ConstPoolVal *V) const {
+  virtual ConstantSInt *castToInt(const Constant *V) const {
     return SubClassName::CastToInt((const ArgType*)V);
   }
-  virtual ConstPoolUInt *castToUInt(const ConstPoolVal *V) const {
+  virtual ConstantUInt *castToUInt(const Constant *V) const {
     return SubClassName::CastToUInt((const ArgType*)V);
   }
-  virtual ConstPoolSInt *castToLong(const ConstPoolVal *V) const {
+  virtual ConstantSInt *castToLong(const Constant *V) const {
     return SubClassName::CastToLong((const ArgType*)V);
   }
-  virtual ConstPoolUInt *castToULong(const ConstPoolVal *V) const {
+  virtual ConstantUInt *castToULong(const Constant *V) const {
     return SubClassName::CastToULong((const ArgType*)V);
   }
-  virtual ConstPoolFP   *castToFloat(const ConstPoolVal *V) const {
+  virtual ConstantFP   *castToFloat(const Constant *V) const {
     return SubClassName::CastToFloat((const ArgType*)V);
   }
-  virtual ConstPoolFP   *castToDouble(const ConstPoolVal *V) const {
+  virtual ConstantFP   *castToDouble(const Constant *V) const {
     return SubClassName::CastToDouble((const ArgType*)V);
   }
-  virtual ConstPoolPointer *castToPointer(const ConstPoolVal *V, 
-                                          const PointerType *Ty) const {
+  virtual ConstantPointer *castToPointer(const Constant *V, 
+                                         const PointerType *Ty) const {
     return SubClassName::CastToPointer((const ArgType*)V, Ty);
   }
 
@@ -98,35 +98,35 @@ class TemplateRules : public ConstRules {
   // Default "noop" implementations
   //===--------------------------------------------------------------------===//
 
-  inline static ConstPoolVal *Not(const ArgType *V) { return 0; }
+  inline static Constant *Not(const ArgType *V) { return 0; }
 
-  inline static ConstPoolVal *Add(const ArgType *V1, const ArgType *V2) {
+  inline static Constant *Add(const ArgType *V1, const ArgType *V2) {
     return 0;
   }
-  inline static ConstPoolVal *Sub(const ArgType *V1, const ArgType *V2) {
+  inline static Constant *Sub(const ArgType *V1, const ArgType *V2) {
     return 0;
   }
-  inline static ConstPoolVal *Mul(const ArgType *V1, const ArgType *V2) {
+  inline static Constant *Mul(const ArgType *V1, const ArgType *V2) {
     return 0;
   }
-  inline static ConstPoolBool *LessThan(const ArgType *V1, const ArgType *V2) {
+  inline static ConstantBool *LessThan(const ArgType *V1, const ArgType *V2) {
     return 0;
   }
 
   // Casting operators.  ick
-  inline static ConstPoolBool *CastToBool  (const ConstPoolVal *V) { return 0; }
-  inline static ConstPoolSInt *CastToSByte (const ConstPoolVal *V) { return 0; }
-  inline static ConstPoolUInt *CastToUByte (const ConstPoolVal *V) { return 0; }
-  inline static ConstPoolSInt *CastToShort (const ConstPoolVal *V) { return 0; }
-  inline static ConstPoolUInt *CastToUShort(const ConstPoolVal *V) { return 0; }
-  inline static ConstPoolSInt *CastToInt   (const ConstPoolVal *V) { return 0; }
-  inline static ConstPoolUInt *CastToUInt  (const ConstPoolVal *V) { return 0; }
-  inline static ConstPoolSInt *CastToLong  (const ConstPoolVal *V) { return 0; }
-  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;}
+  inline static ConstantBool *CastToBool  (const Constant *V) { return 0; }
+  inline static ConstantSInt *CastToSByte (const Constant *V) { return 0; }
+  inline static ConstantUInt *CastToUByte (const Constant *V) { return 0; }
+  inline static ConstantSInt *CastToShort (const Constant *V) { return 0; }
+  inline static ConstantUInt *CastToUShort(const Constant *V) { return 0; }
+  inline static ConstantSInt *CastToInt   (const Constant *V) { return 0; }
+  inline static ConstantUInt *CastToUInt  (const Constant *V) { return 0; }
+  inline static ConstantSInt *CastToLong  (const Constant *V) { return 0; }
+  inline static ConstantUInt *CastToULong (const Constant *V) { return 0; }
+  inline static ConstantFP   *CastToFloat (const Constant *V) { return 0; }
+  inline static ConstantFP   *CastToDouble(const Constant *V) { return 0; }
+  inline static ConstantPointer *CastToPointer(const Constant *,
+                                               const PointerType *) {return 0;}
 };
 
 
@@ -137,7 +137,7 @@ class TemplateRules : public ConstRules {
 //
 // EmptyRules provides a concrete base class of ConstRules that does nothing
 //
-struct EmptyRules : public TemplateRules<ConstPoolVal, EmptyRules> {
+struct EmptyRules : public TemplateRules<Constant, EmptyRules> {
 };
 
 
@@ -148,20 +148,20 @@ struct EmptyRules : public TemplateRules<ConstPoolVal, EmptyRules> {
 //
 // BoolRules provides a concrete base class of ConstRules for the 'bool' type.
 //
-struct BoolRules : public TemplateRules<ConstPoolBool, BoolRules> {
+struct BoolRules : public TemplateRules<ConstantBool, BoolRules> {
 
-  inline static ConstPoolVal *Not(const ConstPoolBool *V) { 
-    return ConstPoolBool::get(!V->getValue());
+  inline static Constant *Not(const ConstantBool *V) { 
+    return ConstantBool::get(!V->getValue());
   }
 
-  inline static ConstPoolVal *Or(const ConstPoolBool *V1,
-				 const ConstPoolBool *V2) {
-    return ConstPoolBool::get(V1->getValue() | V2->getValue());
+  inline static Constant *Or(const ConstantBool *V1,
+                             const ConstantBool *V2) {
+    return ConstantBool::get(V1->getValue() | V2->getValue());
   }
 
-  inline static ConstPoolVal *And(const ConstPoolBool *V1, 
-                                  const ConstPoolBool *V2) {
-    return ConstPoolBool::get(V1->getValue() & V2->getValue());
+  inline static Constant *And(const ConstantBool *V1, 
+                              const ConstantBool *V2) {
+    return ConstantBool::get(V1->getValue() & V2->getValue());
   }
 };
 
@@ -172,56 +172,56 @@ struct BoolRules : public TemplateRules<ConstPoolBool, BoolRules> {
 //
 // PointerRules provides a concrete base class of ConstRules for pointer types
 //
-struct PointerRules : public TemplateRules<ConstPoolPointer, PointerRules> {
-  inline static ConstPoolBool *CastToBool  (const ConstPoolVal *V) {
-    if (V->isNullValue()) return ConstPoolBool::False;
+struct PointerRules : public TemplateRules<ConstantPointer, PointerRules> {
+  inline static ConstantBool *CastToBool  (const Constant *V) {
+    if (V->isNullValue()) return ConstantBool::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);
+  inline static ConstantSInt *CastToSByte (const Constant *V) {
+    if (V->isNullValue()) return ConstantSInt::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);
+  inline static ConstantUInt *CastToUByte (const Constant *V) {
+    if (V->isNullValue()) return ConstantUInt::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);
+  inline static ConstantSInt *CastToShort (const Constant *V) {
+    if (V->isNullValue()) return ConstantSInt::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);
+  inline static ConstantUInt *CastToUShort(const Constant *V) {
+    if (V->isNullValue()) return ConstantUInt::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);
+  inline static ConstantSInt *CastToInt   (const Constant *V) {
+    if (V->isNullValue()) return ConstantSInt::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);
+  inline static ConstantUInt *CastToUInt  (const Constant *V) {
+    if (V->isNullValue()) return ConstantUInt::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);
+  inline static ConstantSInt *CastToLong  (const Constant *V) {
+    if (V->isNullValue()) return ConstantSInt::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);
+  inline static ConstantUInt *CastToULong (const Constant *V) {
+    if (V->isNullValue()) return ConstantUInt::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);
+  inline static ConstantFP   *CastToFloat (const Constant *V) {
+    if (V->isNullValue()) return ConstantFP::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);
+  inline static ConstantFP   *CastToDouble(const Constant *V) {
+    if (V->isNullValue()) return ConstantFP::get(Type::DoubleTy, 0);
     return 0;  // Can't const prop other types of pointers
   }
 
-  inline static ConstPoolPointer *CastToPointer(const ConstPoolPointer *V,
-                                                const PointerType *PTy) {
+  inline static ConstantPointer *CastToPointer(const ConstantPointer *V,
+                                               const PointerType *PTy) {
     if (V->isNullValue())
-      return ConstPoolPointerNull::get(PTy);
+      return ConstantPointerNull::get(PTy);
     return 0;  // Can't const prop other types of pointers
   }
 };
@@ -235,66 +235,66 @@ struct PointerRules : public TemplateRules<ConstPoolPointer, PointerRules> {
 // different types.  This allows the C++ compiler to automatically generate our
 // constant handling operations in a typesafe and accurate manner.
 //
-template<class ConstPoolClass, class BuiltinType, Type **Ty>
+template<class ConstantClass, class BuiltinType, Type **Ty>
 struct DirectRules 
-  : public TemplateRules<ConstPoolClass, 
-                         DirectRules<ConstPoolClass, BuiltinType, Ty> > {
+  : public TemplateRules<ConstantClass, 
+                         DirectRules<ConstantClass, BuiltinType, Ty> > {
 
-  inline static ConstPoolVal *Not(const ConstPoolClass *V) { 
-    return ConstPoolClass::get(*Ty, !(BuiltinType)V->getValue());;
+  inline static Constant *Not(const ConstantClass *V) { 
+    return ConstantClass::get(*Ty, !(BuiltinType)V->getValue());;
   }
 
-  inline static ConstPoolVal *Add(const ConstPoolClass *V1, 
-                                  const ConstPoolClass *V2) {
+  inline static Constant *Add(const ConstantClass *V1, 
+                              const ConstantClass *V2) {
     BuiltinType Result = (BuiltinType)V1->getValue() + 
                          (BuiltinType)V2->getValue();
-    return ConstPoolClass::get(*Ty, Result);
+    return ConstantClass::get(*Ty, Result);
   }
 
-  inline static ConstPoolVal *Sub(const ConstPoolClass *V1, 
-                                  const ConstPoolClass *V2) {
+  inline static Constant *Sub(const ConstantClass *V1, 
+                              const ConstantClass *V2) {
     BuiltinType Result = (BuiltinType)V1->getValue() -
                          (BuiltinType)V2->getValue();
-    return ConstPoolClass::get(*Ty, Result);
+    return ConstantClass::get(*Ty, Result);
   }
 
-  inline static ConstPoolVal *Mul(const ConstPoolClass *V1, 
-				   const ConstPoolClass *V2) {
+  inline static Constant *Mul(const ConstantClass *V1, 
+                              const ConstantClass *V2) {
     BuiltinType Result = (BuiltinType)V1->getValue() *
                          (BuiltinType)V2->getValue();
-    return ConstPoolClass::get(*Ty, Result);
+    return ConstantClass::get(*Ty, Result);
   }
 
-  inline static ConstPoolBool *LessThan(const ConstPoolClass *V1, 
-                                        const ConstPoolClass *V2) {
+  inline static ConstantBool *LessThan(const ConstantClass *V1, 
+                                       const ConstantClass *V2) {
     bool Result = (BuiltinType)V1->getValue() < (BuiltinType)V2->getValue();
-    return ConstPoolBool::get(Result);
+    return ConstantBool::get(Result);
   } 
 
-  inline static ConstPoolPointer *CastToPointer(const ConstPoolClass *V,
-                                                const PointerType *PTy) {
+  inline static ConstantPointer *CastToPointer(const ConstantClass *V,
+                                               const PointerType *PTy) {
     if (V->isNullValue())    // Is it a FP or Integral null value?
-      return ConstPoolPointerNull::get(PTy);
+      return ConstantPointerNull::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) {    \
+  inline static CLASS *CastTo##TYPE  (const ConstantClass *V) {    \
     return CLASS::get(Type::TYPE##Ty, (CTYPE)(BuiltinType)V->getValue()); \
   }
 
-  DEF_CAST(Bool  , ConstPoolBool, bool)
-  DEF_CAST(SByte , ConstPoolSInt, signed char)
-  DEF_CAST(UByte , ConstPoolUInt, unsigned char)
-  DEF_CAST(Short , ConstPoolSInt, signed short)
-  DEF_CAST(UShort, ConstPoolUInt, unsigned short)
-  DEF_CAST(Int   , ConstPoolSInt, signed int)
-  DEF_CAST(UInt  , ConstPoolUInt, unsigned int)
-  DEF_CAST(Long  , ConstPoolSInt, int64_t)
-  DEF_CAST(ULong , ConstPoolUInt, uint64_t)
-  DEF_CAST(Float , ConstPoolFP  , float)
-  DEF_CAST(Double, ConstPoolFP  , double)
+  DEF_CAST(Bool  , ConstantBool, bool)
+  DEF_CAST(SByte , ConstantSInt, signed char)
+  DEF_CAST(UByte , ConstantUInt, unsigned char)
+  DEF_CAST(Short , ConstantSInt, signed short)
+  DEF_CAST(UShort, ConstantUInt, unsigned short)
+  DEF_CAST(Int   , ConstantSInt, signed int)
+  DEF_CAST(UInt  , ConstantUInt, unsigned int)
+  DEF_CAST(Long  , ConstantSInt, int64_t)
+  DEF_CAST(ULong , ConstantUInt, uint64_t)
+  DEF_CAST(Float , ConstantFP  , float)
+  DEF_CAST(Double, ConstantFP  , double)
 #undef DEF_CAST
 };
 
@@ -318,25 +318,25 @@ Annotation *ConstRules::find(AnnotationID AID, const Annotable *TyA, void *) {
   case Type::BoolTyID:    return new BoolRules();
   case Type::PointerTyID: return new PointerRules();
   case Type::SByteTyID:
-    return new DirectRules<ConstPoolSInt,   signed char , &Type::SByteTy>();
+    return new DirectRules<ConstantSInt,   signed char , &Type::SByteTy>();
   case Type::UByteTyID:
-    return new DirectRules<ConstPoolUInt, unsigned char , &Type::UByteTy>();
+    return new DirectRules<ConstantUInt, unsigned char , &Type::UByteTy>();
   case Type::ShortTyID:
-    return new DirectRules<ConstPoolSInt,   signed short, &Type::ShortTy>();
+    return new DirectRules<ConstantSInt,   signed short, &Type::ShortTy>();
   case Type::UShortTyID:
-    return new DirectRules<ConstPoolUInt, unsigned short, &Type::UShortTy>();
+    return new DirectRules<ConstantUInt, unsigned short, &Type::UShortTy>();
   case Type::IntTyID:
-    return new DirectRules<ConstPoolSInt,   signed int  , &Type::IntTy>();
+    return new DirectRules<ConstantSInt,   signed int  , &Type::IntTy>();
   case Type::UIntTyID:
-    return new DirectRules<ConstPoolUInt, unsigned int  , &Type::UIntTy>();
+    return new DirectRules<ConstantUInt, unsigned int  , &Type::UIntTy>();
   case Type::LongTyID:
-    return new DirectRules<ConstPoolSInt,  int64_t      , &Type::LongTy>();
+    return new DirectRules<ConstantSInt,  int64_t      , &Type::LongTy>();
   case Type::ULongTyID:
-    return new DirectRules<ConstPoolUInt, uint64_t      , &Type::ULongTy>();
+    return new DirectRules<ConstantUInt, uint64_t      , &Type::ULongTy>();
   case Type::FloatTyID:
-    return new DirectRules<ConstPoolFP  , float         , &Type::FloatTy>();
+    return new DirectRules<ConstantFP  , float         , &Type::FloatTy>();
   case Type::DoubleTyID:
-    return new DirectRules<ConstPoolFP  , double        , &Type::DoubleTy>();
+    return new DirectRules<ConstantFP  , double        , &Type::DoubleTy>();
   default:
     return new EmptyRules();
   }