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

15 files changed, 399 insertions, 400 deletions

diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp
index 9523c94..dcf8cf3 100644
--- a/lib/VMCore/AsmWriter.cpp
+++ b/lib/VMCore/AsmWriter.cpp
@@ -16,7 +16,7 @@
 #include "llvm/Method.h"
 #include "llvm/GlobalVariable.h"
 #include "llvm/BasicBlock.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 #include "llvm/iMemory.h"
 #include "llvm/iTerminators.h"
 #include "llvm/iPHINode.h"
@@ -69,7 +69,7 @@ static void WriteAsOperandInternal(ostream &Out, const Value *V, bool PrintName,
   if (PrintName && V->hasName()) {
     Out << " %" << V->getName();
   } else {
-    if (const ConstPoolVal *CPV = dyn_cast<const ConstPoolVal>(V)) {
+    if (const Constant *CPV = dyn_cast<const Constant>(V)) {
       Out << " " << CPV->getStrValue();
     } else {
       int Slot;
@@ -275,13 +275,13 @@ public:
   inline void write(const Method *M)         { printMethod(M);      }
   inline void write(const BasicBlock *BB)    { printBasicBlock(BB); }
   inline void write(const Instruction *I)    { printInstruction(I); }
-  inline void write(const ConstPoolVal *CPV) { printConstant(CPV);  }
+  inline void write(const Constant *CPV)     { printConstant(CPV);  }
   inline void write(const Type *Ty)          { printType(Ty);       }
 
 private :
   void printModule(const Module *M);
   void printSymbolTable(const SymbolTable &ST);
-  void printConstant(const ConstPoolVal *CPV);
+  void printConstant(const Constant *CPV);
   void printGlobal(const GlobalVariable *GV);
   void printMethod(const Method *M);
   void printMethodArgument(const MethodArgument *MA);
@@ -345,7 +345,7 @@ void AssemblyWriter::printSymbolTable(const SymbolTable &ST) {
     
     for (; I != End; ++I) {
       const Value *V = I->second;
-      if (const ConstPoolVal *CPV = dyn_cast<const ConstPoolVal>(V)) {
+      if (const Constant *CPV = dyn_cast<const Constant>(V)) {
 	printConstant(CPV);
       } else if (const Type *Ty = dyn_cast<const Type>(V)) {
 	Out << "\t%" << I->first << " = type " << Ty->getDescription() << endl;
@@ -357,7 +357,7 @@ void AssemblyWriter::printSymbolTable(const SymbolTable &ST) {
 
 // printConstant - Print out a constant pool entry...
 //
-void AssemblyWriter::printConstant(const ConstPoolVal *CPV) {
+void AssemblyWriter::printConstant(const Constant *CPV) {
   // Don't print out unnamed constants, they will be inlined
   if (!CPV->hasName()) return;
 
@@ -666,7 +666,7 @@ void WriteToAssembly(const BasicBlock *BB, ostream &o) {
   W.write(BB);
 }
 
-void WriteToAssembly(const ConstPoolVal *CPV, ostream &o) {
+void WriteToAssembly(const Constant *CPV, ostream &o) {
   if (CPV == 0) { o << "<null> constant pool value\n"; return; }
   o << " " << CPV->getType()->getDescription() << " " << CPV->getStrValue();
 }
@@ -701,7 +701,7 @@ CachedWriter &CachedWriter::operator<<(const Value *V) {
   switch (V->getValueType()) {
   case Value::ConstantVal:
     Out << " "; AW->write(V->getType());
-    Out << " " << cast<ConstPoolVal>(V)->getStrValue(); break;
+    Out << " " << cast<Constant>(V)->getStrValue(); break;
   case Value::MethodArgumentVal: 
     AW->write(V->getType()); Out << " " << V->getName(); break;
   case Value::TypeVal:           AW->write(cast<const Type>(V)); break;
diff --git a/lib/VMCore/BasicBlock.cpp b/lib/VMCore/BasicBlock.cpp
index 40962ef..861aea4 100644
--- a/lib/VMCore/BasicBlock.cpp
+++ b/lib/VMCore/BasicBlock.cpp
@@ -70,14 +70,14 @@ void BasicBlock::dropAllReferences() {
 	   std::mem_fun(&Instruction::dropAllReferences));
 }
 
-// hasConstantPoolReferences() - This predicate is true if there is a 
+// hasConstantReferences() - This predicate is true if there is a 
 // reference to this basic block in the constant pool for this method.  For
 // example, if a block is reached through a switch table, that table resides
 // in the constant pool, and the basic block is reference from it.
 //
-bool BasicBlock::hasConstantPoolReferences() const {
+bool BasicBlock::hasConstantReferences() const {
   for (use_const_iterator I = use_begin(), E = use_end(); I != E; ++I)
-    if (::isa<ConstPoolVal>(*I))
+    if (::isa<Constant>(*I))
       return true;
 
   return false;
diff --git a/lib/VMCore/ConstPoolVals.cpp b/lib/VMCore/ConstPoolVals.cpp
index dd30171..3814311 100644
--- a/lib/VMCore/ConstPoolVals.cpp
+++ b/lib/VMCore/ConstPoolVals.cpp
@@ -1,11 +1,11 @@
-//===-- iConstPool.cpp - Implement ConstPool instructions --------*- C++ -*--=//
+//===-- ConstantVals.cpp - Implement Constant nodes --------------*- C++ -*--=//
 //
-// This file implements the ConstPool* classes...
+// This file implements the Constant* classes...
 //
 //===----------------------------------------------------------------------===//
 
 #define __STDC_LIMIT_MACROS           // Get defs for INT64_MAX and friends...
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/SymbolTable.h"
 #include "llvm/GlobalValue.h"
@@ -15,40 +15,40 @@
 #include <algorithm>
 #include <assert.h>
 
-ConstPoolBool *ConstPoolBool::True  = new ConstPoolBool(true);
-ConstPoolBool *ConstPoolBool::False = new ConstPoolBool(false);
+ConstantBool *ConstantBool::True  = new ConstantBool(true);
+ConstantBool *ConstantBool::False = new ConstantBool(false);
 
 
 //===----------------------------------------------------------------------===//
-//                              ConstPoolVal Class
+//                              Constant Class
 //===----------------------------------------------------------------------===//
 
 // Specialize setName to take care of symbol table majik
-void ConstPoolVal::setName(const string &Name, SymbolTable *ST) {
+void Constant::setName(const string &Name, SymbolTable *ST) {
   assert(ST && "Type::setName - Must provide symbol table argument!");
 
   if (Name.size()) ST->insert(Name, this);
 }
 
 // Static constructor to create a '0' constant of arbitrary type...
-ConstPoolVal *ConstPoolVal::getNullConstant(const Type *Ty) {
+Constant *Constant::getNullConstant(const Type *Ty) {
   switch (Ty->getPrimitiveID()) {
-  case Type::BoolTyID:   return ConstPoolBool::get(false);
+  case Type::BoolTyID:   return ConstantBool::get(false);
   case Type::SByteTyID:
   case Type::ShortTyID:
   case Type::IntTyID:
-  case Type::LongTyID:   return ConstPoolSInt::get(Ty, 0);
+  case Type::LongTyID:   return ConstantSInt::get(Ty, 0);
 
   case Type::UByteTyID:
   case Type::UShortTyID:
   case Type::UIntTyID:
-  case Type::ULongTyID:  return ConstPoolUInt::get(Ty, 0);
+  case Type::ULongTyID:  return ConstantUInt::get(Ty, 0);
 
   case Type::FloatTyID:
-  case Type::DoubleTyID: return ConstPoolFP::get(Ty, 0);
+  case Type::DoubleTyID: return ConstantFP::get(Ty, 0);
 
   case Type::PointerTyID: 
-    return ConstPoolPointerNull::get(cast<PointerType>(Ty));
+    return ConstantPointerNull::get(cast<PointerType>(Ty));
   default:
     return 0;
   }
@@ -58,24 +58,24 @@ ConstPoolVal *ConstPoolVal::getNullConstant(const Type *Ty) {
 #include "llvm/Assembly/Writer.h"
 #endif
 
-void ConstPoolVal::destroyConstantImpl() {
-  // When a ConstPoolVal is destroyed, there may be lingering
+void Constant::destroyConstantImpl() {
+  // When a Constant is destroyed, there may be lingering
   // references to the constant by other constants in the constant pool.  These
   // constants are implicitly dependant on the module that is being deleted,
   // but they don't know that.  Because we only find out when the CPV is
   // deleted, we must now notify all of our users (that should only be
-  // ConstPoolVals) that they are, in fact, invalid now and should be deleted.
+  // Constants) that they are, in fact, invalid now and should be deleted.
   //
   while (!use_empty()) {
     Value *V = use_back();
 #ifndef NDEBUG      // Only in -g mode...
-    if (!isa<ConstPoolVal>(V)) {
+    if (!isa<Constant>(V)) {
       cerr << "While deleting: " << this << endl;
       cerr << "Use still stuck around after Def is destroyed: " << V << endl;
     }
 #endif
-    assert(isa<ConstPoolVal>(V) && "References remain to ConstPoolPointerRef!");
-    ConstPoolVal *CPV = cast<ConstPoolVal>(V);
+    assert(isa<Constant>(V) && "References remain to ConstantPointerRef!");
+    Constant *CPV = cast<Constant>(V);
     CPV->destroyConstant();
 
     // The constant should remove itself from our use list...
@@ -87,45 +87,43 @@ void ConstPoolVal::destroyConstantImpl() {
 }
 
 //===----------------------------------------------------------------------===//
-//                            ConstPoolXXX Classes
+//                            ConstantXXX Classes
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 //                             Normal Constructors
 
-ConstPoolBool::ConstPoolBool(bool V) : ConstPoolVal(Type::BoolTy) {
+ConstantBool::ConstantBool(bool V) : Constant(Type::BoolTy) {
   Val = V;
 }
 
-ConstPoolInt::ConstPoolInt(const Type *Ty, uint64_t V) : ConstPoolVal(Ty) {
+ConstantInt::ConstantInt(const Type *Ty, uint64_t V) : Constant(Ty) {
   Val.Unsigned = V;
 }
 
-ConstPoolSInt::ConstPoolSInt(const Type *Ty, int64_t V) : ConstPoolInt(Ty, V) {
+ConstantSInt::ConstantSInt(const Type *Ty, int64_t V) : ConstantInt(Ty, V) {
   assert(isValueValidForType(Ty, V) && "Value too large for type!");
 }
 
-ConstPoolUInt::ConstPoolUInt(const Type *Ty, uint64_t V) : ConstPoolInt(Ty, V) {
+ConstantUInt::ConstantUInt(const Type *Ty, uint64_t V) : ConstantInt(Ty, V) {
   assert(isValueValidForType(Ty, V) && "Value too large for type!");
 }
 
-ConstPoolFP::ConstPoolFP(const Type *Ty, double V) : ConstPoolVal(Ty) {
+ConstantFP::ConstantFP(const Type *Ty, double V) : Constant(Ty) {
   assert(isValueValidForType(Ty, V) && "Value too large for type!");
   Val = V;
 }
 
-ConstPoolArray::ConstPoolArray(const ArrayType *T,
-			       const vector<ConstPoolVal*> &V)
-  : ConstPoolVal(T) {
+ConstantArray::ConstantArray(const ArrayType *T,
+                             const vector<Constant*> &V) : Constant(T) {
   for (unsigned i = 0; i < V.size(); i++) {
     assert(V[i]->getType() == T->getElementType());
     Operands.push_back(Use(V[i], this));
   }
 }
 
-ConstPoolStruct::ConstPoolStruct(const StructType *T,
-				 const vector<ConstPoolVal*> &V)
-  : ConstPoolVal(T) {
+ConstantStruct::ConstantStruct(const StructType *T,
+                               const vector<Constant*> &V) : Constant(T) {
   const StructType::ElementTypes &ETypes = T->getElementTypes();
   
   for (unsigned i = 0; i < V.size(); i++) {
@@ -134,8 +132,8 @@ ConstPoolStruct::ConstPoolStruct(const StructType *T,
   }
 }
 
-ConstPoolPointerRef::ConstPoolPointerRef(GlobalValue *GV)
-  : ConstPoolPointer(GV->getType()) {
+ConstantPointerRef::ConstantPointerRef(GlobalValue *GV)
+  : ConstantPointer(GV->getType()) {
   Operands.push_back(Use(GV, this));
 }
 
@@ -144,23 +142,23 @@ ConstPoolPointerRef::ConstPoolPointerRef(GlobalValue *GV)
 //===----------------------------------------------------------------------===//
 //                          getStrValue implementations
 
-string ConstPoolBool::getStrValue() const {
+string ConstantBool::getStrValue() const {
   return Val ? "true" : "false";
 }
 
-string ConstPoolSInt::getStrValue() const {
+string ConstantSInt::getStrValue() const {
   return itostr(Val.Signed);
 }
 
-string ConstPoolUInt::getStrValue() const {
+string ConstantUInt::getStrValue() const {
   return utostr(Val.Unsigned);
 }
 
-string ConstPoolFP::getStrValue() const {
+string ConstantFP::getStrValue() const {
   return ftostr(Val);
 }
 
-string ConstPoolArray::getStrValue() const {
+string ConstantArray::getStrValue() const {
   string Result;
   
   // As a special case, print the array as a string if it is an array of
@@ -172,7 +170,7 @@ string ConstPoolArray::getStrValue() const {
   if (ETy == Type::SByteTy) {
     for (unsigned i = 0; i < Operands.size(); ++i)
       if (ETy == Type::SByteTy &&
-          cast<ConstPoolSInt>(Operands[i])->getValue() < 0) {
+          cast<ConstantSInt>(Operands[i])->getValue() < 0) {
         isString = false;
         break;
       }
@@ -182,8 +180,8 @@ string ConstPoolArray::getStrValue() const {
     Result = "c\"";
     for (unsigned i = 0; i < Operands.size(); ++i) {
       unsigned char C = (ETy == Type::SByteTy) ?
-        (unsigned char)cast<ConstPoolSInt>(Operands[i])->getValue() :
-        (unsigned char)cast<ConstPoolUInt>(Operands[i])->getValue();
+        (unsigned char)cast<ConstantSInt>(Operands[i])->getValue() :
+        (unsigned char)cast<ConstantUInt>(Operands[i])->getValue();
 
       if (isprint(C)) {
         Result += C;
@@ -199,10 +197,10 @@ string ConstPoolArray::getStrValue() const {
     Result = "[";
     if (Operands.size()) {
       Result += " " + Operands[0]->getType()->getDescription() + 
-	        " " + cast<ConstPoolVal>(Operands[0])->getStrValue();
+	        " " + cast<Constant>(Operands[0])->getStrValue();
       for (unsigned i = 1; i < Operands.size(); i++)
         Result += ", " + Operands[i]->getType()->getDescription() + 
-                  " " + cast<ConstPoolVal>(Operands[i])->getStrValue();
+                  " " + cast<Constant>(Operands[i])->getStrValue();
     }
     Result += " ]";
   }
@@ -210,24 +208,24 @@ string ConstPoolArray::getStrValue() const {
   return Result;
 }
 
-string ConstPoolStruct::getStrValue() const {
+string ConstantStruct::getStrValue() const {
   string Result = "{";
   if (Operands.size()) {
     Result += " " + Operands[0]->getType()->getDescription() + 
-	      " " + cast<ConstPoolVal>(Operands[0])->getStrValue();
+	      " " + cast<Constant>(Operands[0])->getStrValue();
     for (unsigned i = 1; i < Operands.size(); i++)
       Result += ", " + Operands[i]->getType()->getDescription() + 
-	        " " + cast<ConstPoolVal>(Operands[i])->getStrValue();
+	        " " + cast<Constant>(Operands[i])->getStrValue();
   }
 
   return Result + " }";
 }
 
-string ConstPoolPointerNull::getStrValue() const {
+string ConstantPointerNull::getStrValue() const {
   return "null";
 }
 
-string ConstPoolPointerRef::getStrValue() const {
+string ConstantPointerRef::getStrValue() const {
   const GlobalValue *V = getValue();
   if (V->hasName()) return "%" + V->getName();
 
@@ -243,26 +241,26 @@ string ConstPoolPointerRef::getStrValue() const {
 //===----------------------------------------------------------------------===//
 //                           classof implementations
 
-bool ConstPoolInt::classof(const ConstPoolVal *CPV) {
+bool ConstantInt::classof(const Constant *CPV) {
   return CPV->getType()->isIntegral();
 }
-bool ConstPoolSInt::classof(const ConstPoolVal *CPV) {
+bool ConstantSInt::classof(const Constant *CPV) {
   return CPV->getType()->isSigned();
 }
-bool ConstPoolUInt::classof(const ConstPoolVal *CPV) {
+bool ConstantUInt::classof(const Constant *CPV) {
   return CPV->getType()->isUnsigned();
 }
-bool ConstPoolFP::classof(const ConstPoolVal *CPV) {
+bool ConstantFP::classof(const Constant *CPV) {
   const Type *Ty = CPV->getType();
   return Ty == Type::FloatTy || Ty == Type::DoubleTy;
 }
-bool ConstPoolArray::classof(const ConstPoolVal *CPV) {
+bool ConstantArray::classof(const Constant *CPV) {
   return isa<ArrayType>(CPV->getType());
 }
-bool ConstPoolStruct::classof(const ConstPoolVal *CPV) {
+bool ConstantStruct::classof(const Constant *CPV) {
   return isa<StructType>(CPV->getType());
 }
-bool ConstPoolPointer::classof(const ConstPoolVal *CPV) {
+bool ConstantPointer::classof(const Constant *CPV) {
   return isa<PointerType>(CPV->getType());
 }
 
@@ -270,7 +268,7 @@ bool ConstPoolPointer::classof(const ConstPoolVal *CPV) {
 //===----------------------------------------------------------------------===//
 //                      isValueValidForType implementations
 
-bool ConstPoolSInt::isValueValidForType(const Type *Ty, int64_t Val) {
+bool ConstantSInt::isValueValidForType(const Type *Ty, int64_t Val) {
   switch (Ty->getPrimitiveID()) {
   default:
     return false;         // These can't be represented as integers!!!
@@ -289,7 +287,7 @@ bool ConstPoolSInt::isValueValidForType(const Type *Ty, int64_t Val) {
   return false;
 }
 
-bool ConstPoolUInt::isValueValidForType(const Type *Ty, uint64_t Val) {
+bool ConstantUInt::isValueValidForType(const Type *Ty, uint64_t Val) {
   switch (Ty->getPrimitiveID()) {
   default:
     return false;         // These can't be represented as integers!!!
@@ -308,7 +306,7 @@ bool ConstPoolUInt::isValueValidForType(const Type *Ty, uint64_t Val) {
   return false;
 }
 
-bool ConstPoolFP::isValueValidForType(const Type *Ty, double Val) {
+bool ConstantFP::isValueValidForType(const Type *Ty, double Val) {
   switch (Ty->getPrimitiveID()) {
   default:
     return false;         // These can't be represented as floating point!
@@ -326,28 +324,28 @@ bool ConstPoolFP::isValueValidForType(const Type *Ty, double Val) {
 //===----------------------------------------------------------------------===//
 //                      Hash Function Implementations
 #if 0
-unsigned ConstPoolSInt::hash(const Type *Ty, int64_t V) {
+unsigned ConstantSInt::hash(const Type *Ty, int64_t V) {
   return unsigned(Ty->getPrimitiveID() ^ V);
 }
 
-unsigned ConstPoolUInt::hash(const Type *Ty, uint64_t V) {
+unsigned ConstantUInt::hash(const Type *Ty, uint64_t V) {
   return unsigned(Ty->getPrimitiveID() ^ V);
 }
 
-unsigned ConstPoolFP::hash(const Type *Ty, double V) {
+unsigned ConstantFP::hash(const Type *Ty, double V) {
   return Ty->getPrimitiveID() ^ unsigned(V);
 }
 
-unsigned ConstPoolArray::hash(const ArrayType *Ty,
-			      const vector<ConstPoolVal*> &V) {
+unsigned ConstantArray::hash(const ArrayType *Ty,
+                             const vector<Constant*> &V) {
   unsigned Result = (Ty->getUniqueID() << 5) ^ (Ty->getUniqueID() * 7);
   for (unsigned i = 0; i < V.size(); ++i)
     Result ^= V[i]->getHash() << (i & 7);
   return Result;
 }
 
-unsigned ConstPoolStruct::hash(const StructType *Ty,
-			       const vector<ConstPoolVal*> &V) {
+unsigned ConstantStruct::hash(const StructType *Ty,
+                              const vector<Constant*> &V) {
   unsigned Result = (Ty->getUniqueID() << 5) ^ (Ty->getUniqueID() * 7);
   for (unsigned i = 0; i < V.size(); ++i)
     Result ^= V[i]->getHash() << (i & 7);
@@ -358,23 +356,23 @@ unsigned ConstPoolStruct::hash(const StructType *Ty,
 //===----------------------------------------------------------------------===//
 //                      Factory Function Implementation
 
-template<class ValType, class ConstPoolClass>
+template<class ValType, class ConstantClass>
 struct ValueMap {
   typedef pair<const Type*, ValType> ConstHashKey;
-  map<ConstHashKey, ConstPoolClass *> Map;
+  map<ConstHashKey, ConstantClass *> Map;
 
-  inline ConstPoolClass *get(const Type *Ty, ValType V) {
-    map<ConstHashKey,ConstPoolClass *>::iterator I =
+  inline ConstantClass *get(const Type *Ty, ValType V) {
+    map<ConstHashKey,ConstantClass *>::iterator I =
       Map.find(ConstHashKey(Ty, V));
     return (I != Map.end()) ? I->second : 0;
   }
 
-  inline void add(const Type *Ty, ValType V, ConstPoolClass *CP) {
+  inline void add(const Type *Ty, ValType V, ConstantClass *CP) {
     Map.insert(make_pair(ConstHashKey(Ty, V), CP));
   }
 
-  inline void remove(ConstPoolClass *CP) {
-    for (map<ConstHashKey,ConstPoolClass *>::iterator I = Map.begin(),
+  inline void remove(ConstantClass *CP) {
+    for (map<ConstHashKey,ConstantClass *>::iterator I = Map.begin(),
                                                       E = Map.end(); I != E;++I)
       if (I->second == CP) {
 	Map.erase(I);
@@ -383,119 +381,119 @@ struct ValueMap {
   }
 };
 
-//---- ConstPoolUInt::get() and ConstPoolSInt::get() implementations...
+//---- ConstantUInt::get() and ConstantSInt::get() implementations...
 //
-static ValueMap<uint64_t, ConstPoolInt> IntConstants;
+static ValueMap<uint64_t, ConstantInt> IntConstants;
 
-ConstPoolSInt *ConstPoolSInt::get(const Type *Ty, int64_t V) {
-  ConstPoolSInt *Result = (ConstPoolSInt*)IntConstants.get(Ty, (uint64_t)V);
+ConstantSInt *ConstantSInt::get(const Type *Ty, int64_t V) {
+  ConstantSInt *Result = (ConstantSInt*)IntConstants.get(Ty, (uint64_t)V);
   if (!Result)   // If no preexisting value, create one now...
-    IntConstants.add(Ty, V, Result = new ConstPoolSInt(Ty, V));
+    IntConstants.add(Ty, V, Result = new ConstantSInt(Ty, V));
   return Result;
 }
 
-ConstPoolUInt *ConstPoolUInt::get(const Type *Ty, uint64_t V) {
-  ConstPoolUInt *Result = (ConstPoolUInt*)IntConstants.get(Ty, V);
+ConstantUInt *ConstantUInt::get(const Type *Ty, uint64_t V) {
+  ConstantUInt *Result = (ConstantUInt*)IntConstants.get(Ty, V);
   if (!Result)   // If no preexisting value, create one now...
-    IntConstants.add(Ty, V, Result = new ConstPoolUInt(Ty, V));
+    IntConstants.add(Ty, V, Result = new ConstantUInt(Ty, V));
   return Result;
 }
 
-ConstPoolInt *ConstPoolInt::get(const Type *Ty, unsigned char V) {
+ConstantInt *ConstantInt::get(const Type *Ty, unsigned char V) {
   assert(V <= 127 && "Can only be used with very small positive constants!");
-  if (Ty->isSigned()) return ConstPoolSInt::get(Ty, V);
-  return ConstPoolUInt::get(Ty, V);
+  if (Ty->isSigned()) return ConstantSInt::get(Ty, V);
+  return ConstantUInt::get(Ty, V);
 }
 
-//---- ConstPoolFP::get() implementation...
+//---- ConstantFP::get() implementation...
 //
-static ValueMap<double, ConstPoolFP> FPConstants;
+static ValueMap<double, ConstantFP> FPConstants;
 
-ConstPoolFP *ConstPoolFP::get(const Type *Ty, double V) {
-  ConstPoolFP *Result = FPConstants.get(Ty, V);
+ConstantFP *ConstantFP::get(const Type *Ty, double V) {
+  ConstantFP *Result = FPConstants.get(Ty, V);
   if (!Result)   // If no preexisting value, create one now...
-    FPConstants.add(Ty, V, Result = new ConstPoolFP(Ty, V));
+    FPConstants.add(Ty, V, Result = new ConstantFP(Ty, V));
   return Result;
 }
 
-//---- ConstPoolArray::get() implementation...
+//---- ConstantArray::get() implementation...
 //
-static ValueMap<vector<ConstPoolVal*>, ConstPoolArray> ArrayConstants;
+static ValueMap<vector<Constant*>, ConstantArray> ArrayConstants;
 
-ConstPoolArray *ConstPoolArray::get(const ArrayType *Ty,
-				    const vector<ConstPoolVal*> &V) {
-  ConstPoolArray *Result = ArrayConstants.get(Ty, V);
+ConstantArray *ConstantArray::get(const ArrayType *Ty,
+                                  const vector<Constant*> &V) {
+  ConstantArray *Result = ArrayConstants.get(Ty, V);
   if (!Result)   // If no preexisting value, create one now...
-    ArrayConstants.add(Ty, V, Result = new ConstPoolArray(Ty, V));
+    ArrayConstants.add(Ty, V, Result = new ConstantArray(Ty, V));
   return Result;
 }
 
-// ConstPoolArray::get(const string&) - Return an array that is initialized to
+// ConstantArray::get(const string&) - Return an array that is initialized to
 // contain the specified string.  A null terminator is added to the specified
 // string so that it may be used in a natural way...
 //
-ConstPoolArray *ConstPoolArray::get(const string &Str) {
-  vector<ConstPoolVal*> ElementVals;
+ConstantArray *ConstantArray::get(const string &Str) {
+  vector<Constant*> ElementVals;
 
   for (unsigned i = 0; i < Str.length(); ++i)
-    ElementVals.push_back(ConstPoolUInt::get(Type::UByteTy, Str[i]));
+    ElementVals.push_back(ConstantUInt::get(Type::UByteTy, Str[i]));
 
   // Add a null terminator to the string...
-  ElementVals.push_back(ConstPoolUInt::get(Type::UByteTy, 0));
+  ElementVals.push_back(ConstantUInt::get(Type::UByteTy, 0));
 
   ArrayType *ATy = ArrayType::get(Type::UByteTy/*,stringConstant.length()*/);
-  return ConstPoolArray::get(ATy, ElementVals);
+  return ConstantArray::get(ATy, ElementVals);
 }
 
 
 // destroyConstant - Remove the constant from the constant table...
 //
-void ConstPoolArray::destroyConstant() {
+void ConstantArray::destroyConstant() {
   ArrayConstants.remove(this);
   destroyConstantImpl();
 }
 
-//---- ConstPoolStruct::get() implementation...
+//---- ConstantStruct::get() implementation...
 //
-static ValueMap<vector<ConstPoolVal*>, ConstPoolStruct> StructConstants;
+static ValueMap<vector<Constant*>, ConstantStruct> StructConstants;
 
-ConstPoolStruct *ConstPoolStruct::get(const StructType *Ty,
-				      const vector<ConstPoolVal*> &V) {
-  ConstPoolStruct *Result = StructConstants.get(Ty, V);
+ConstantStruct *ConstantStruct::get(const StructType *Ty,
+                                    const vector<Constant*> &V) {
+  ConstantStruct *Result = StructConstants.get(Ty, V);
   if (!Result)   // If no preexisting value, create one now...
-    StructConstants.add(Ty, V, Result = new ConstPoolStruct(Ty, V));
+    StructConstants.add(Ty, V, Result = new ConstantStruct(Ty, V));
   return Result;
 }
 
 // destroyConstant - Remove the constant from the constant table...
 //
-void ConstPoolStruct::destroyConstant() {
+void ConstantStruct::destroyConstant() {
   StructConstants.remove(this);
   destroyConstantImpl();
 }
 
-//---- ConstPoolPointerNull::get() implementation...
+//---- ConstantPointerNull::get() implementation...
 //
-static ValueMap<char, ConstPoolPointerNull> NullPtrConstants;
+static ValueMap<char, ConstantPointerNull> NullPtrConstants;
 
-ConstPoolPointerNull *ConstPoolPointerNull::get(const PointerType *Ty) {
-  ConstPoolPointerNull *Result = NullPtrConstants.get(Ty, 0);
+ConstantPointerNull *ConstantPointerNull::get(const PointerType *Ty) {
+  ConstantPointerNull *Result = NullPtrConstants.get(Ty, 0);
   if (!Result)   // If no preexisting value, create one now...
-    NullPtrConstants.add(Ty, 0, Result = new ConstPoolPointerNull(Ty));
+    NullPtrConstants.add(Ty, 0, Result = new ConstantPointerNull(Ty));
   return Result;
 }
 
-//---- ConstPoolPointerRef::get() implementation...
+//---- ConstantPointerRef::get() implementation...
 //
-ConstPoolPointerRef *ConstPoolPointerRef::get(GlobalValue *GV) {
+ConstantPointerRef *ConstantPointerRef::get(GlobalValue *GV) {
   assert(GV->getParent() && "Global Value must be attached to a module!");
 
   // The Module handles the pointer reference sharing...
-  return GV->getParent()->getConstPoolPointerRef(GV);
+  return GV->getParent()->getConstantPointerRef(GV);
 }
 
 
-void ConstPoolPointerRef::mutateReference(GlobalValue *NewGV) {
-  getValue()->getParent()->mutateConstPoolPointerRef(getValue(), NewGV);
+void ConstantPointerRef::mutateReference(GlobalValue *NewGV) {
+  getValue()->getParent()->mutateConstantPointerRef(getValue(), NewGV);
   Operands[0] = NewGV;
 }
diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp
index 7438319..c588f72 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();
   }
diff --git a/lib/VMCore/ConstantFold.h b/lib/VMCore/ConstantFold.h
index 72632ee..bd59780 100644
--- a/lib/VMCore/ConstantFold.h
+++ b/lib/VMCore/ConstantFold.h
@@ -5,10 +5,10 @@
 //
 // Unfortunately we can't overload operators on pointer types (like this:)
 //
-//      inline bool operator==(const ConstPoolVal *V1, const ConstPoolVal *V2)
+//      inline bool operator==(const Constant *V1, const Constant *V2)
 //
 // so we must make due with references, even though it leads to some butt ugly
-// looking code downstream.  *sigh*  (ex:  ConstPoolVal *Result = *V1 + *v2; )
+// looking code downstream.  *sigh*  (ex:  Constant *Result = *V1 + *v2; )
 //
 //===----------------------------------------------------------------------===//
 //
@@ -33,7 +33,7 @@
 #ifndef LLVM_OPT_CONSTANTHANDLING_H
 #define LLVM_OPT_CONSTANTHANDLING_H
 
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 #include "llvm/Instruction.h"
 #include "llvm/Type.h"
 class PointerType;
@@ -44,15 +44,15 @@ namespace opt {
 //  Implement == and != directly...
 //===----------------------------------------------------------------------===//
 
-inline ConstPoolBool *operator==(const ConstPoolVal &V1, 
-                                 const ConstPoolVal &V2) {
+inline ConstantBool *operator==(const Constant &V1, 
+                                const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
-  return ConstPoolBool::get(&V1 == &V2);
+  return ConstantBool::get(&V1 == &V2);
 }
 
-inline ConstPoolBool *operator!=(const ConstPoolVal &V1, 
-                                 const ConstPoolVal &V2) {
-  return ConstPoolBool::get(&V1 != &V2);
+inline ConstantBool *operator!=(const Constant &V1, 
+                                const Constant &V2) {
+  return ConstantBool::get(&V1 != &V2);
 }
 
 //===----------------------------------------------------------------------===//
@@ -66,35 +66,35 @@ public:
   static AnnotationID AID;    // AnnotationID for this class
 
   // Unary Operators...
-  virtual ConstPoolVal *op_not(const ConstPoolVal *V) const = 0;
+  virtual Constant *op_not(const Constant *V) const = 0;
 
   // Binary Operators...
-  virtual ConstPoolVal *add(const ConstPoolVal *V1, 
-                            const ConstPoolVal *V2) const = 0;
-  virtual ConstPoolVal *sub(const ConstPoolVal *V1, 
-                            const ConstPoolVal *V2) const = 0;
-  virtual ConstPoolVal *mul(const ConstPoolVal *V1, 
-			    const ConstPoolVal *V2) const = 0;
+  virtual Constant *add(const Constant *V1, 
+                        const Constant *V2) const = 0;
+  virtual Constant *sub(const Constant *V1, 
+                        const Constant *V2) const = 0;
+  virtual Constant *mul(const Constant *V1, 
+                        const Constant *V2) const = 0;
 
-  virtual ConstPoolBool *lessthan(const ConstPoolVal *V1, 
-                                  const ConstPoolVal *V2) const = 0;
+  virtual ConstantBool *lessthan(const Constant *V1, 
+                                 const Constant *V2) const = 0;
 
   // Casting operators.  ick
-  virtual ConstPoolBool *castToBool  (const ConstPoolVal *V) const = 0;
-  virtual ConstPoolSInt *castToSByte (const ConstPoolVal *V) const = 0;
-  virtual ConstPoolUInt *castToUByte (const ConstPoolVal *V) const = 0;
-  virtual ConstPoolSInt *castToShort (const ConstPoolVal *V) const = 0;
-  virtual ConstPoolUInt *castToUShort(const ConstPoolVal *V) const = 0;
-  virtual ConstPoolSInt *castToInt   (const ConstPoolVal *V) const = 0;
-  virtual ConstPoolUInt *castToUInt  (const ConstPoolVal *V) const = 0;
-  virtual ConstPoolSInt *castToLong  (const ConstPoolVal *V) const = 0;
-  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 {
+  virtual ConstantBool *castToBool  (const Constant *V) const = 0;
+  virtual ConstantSInt *castToSByte (const Constant *V) const = 0;
+  virtual ConstantUInt *castToUByte (const Constant *V) const = 0;
+  virtual ConstantSInt *castToShort (const Constant *V) const = 0;
+  virtual ConstantUInt *castToUShort(const Constant *V) const = 0;
+  virtual ConstantSInt *castToInt   (const Constant *V) const = 0;
+  virtual ConstantUInt *castToUInt  (const Constant *V) const = 0;
+  virtual ConstantSInt *castToLong  (const Constant *V) const = 0;
+  virtual ConstantUInt *castToULong (const Constant *V) const = 0;
+  virtual ConstantFP   *castToFloat (const Constant *V) const = 0;
+  virtual ConstantFP   *castToDouble(const Constant *V) const = 0;
+  virtual ConstantPointer *castToPointer(const Constant *V,
+                                         const PointerType *Ty) const = 0;
+
+  inline Constant *castTo(const Constant *V, const Type *Ty) const {
     switch (Ty->getPrimitiveID()) {
     case Type::BoolTyID:   return castToBool(V);
     case Type::UByteTyID:  return castToUByte(V);
@@ -116,7 +116,7 @@ public:
   // we just want to make sure to hit the cache instead of doing it indirectly,
   //  if possible...
   //
-  static inline ConstRules *get(const ConstPoolVal &V) {
+  static inline ConstRules *get(const Constant &V) {
     return (ConstRules*)V.getType()->getOrCreateAnnotation(AID);
   }
 private :
@@ -127,29 +127,29 @@ private :
 };
 
 
-inline ConstPoolVal *operator!(const ConstPoolVal &V) {
+inline Constant *operator!(const Constant &V) {
   return ConstRules::get(V)->op_not(&V);
 }
 
 
 
-inline ConstPoolVal *operator+(const ConstPoolVal &V1, const ConstPoolVal &V2) {
+inline Constant *operator+(const Constant &V1, const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
   return ConstRules::get(V1)->add(&V1, &V2);
 }
 
-inline ConstPoolVal *operator-(const ConstPoolVal &V1, const ConstPoolVal &V2) {
+inline Constant *operator-(const Constant &V1, const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
   return ConstRules::get(V1)->sub(&V1, &V2);
 }
 
-inline ConstPoolVal *operator*(const ConstPoolVal &V1, const ConstPoolVal &V2) {
+inline Constant *operator*(const Constant &V1, const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
   return ConstRules::get(V1)->mul(&V1, &V2);
 }
 
-inline ConstPoolBool *operator<(const ConstPoolVal &V1, 
-                                const ConstPoolVal &V2) {
+inline ConstantBool *operator<(const Constant &V1, 
+                               const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
   return ConstRules::get(V1)->lessthan(&V1, &V2);
 }
@@ -159,18 +159,18 @@ inline ConstPoolBool *operator<(const ConstPoolVal &V1,
 //  Implement 'derived' operators based on what we already have...
 //===----------------------------------------------------------------------===//
 
-inline ConstPoolBool *operator>(const ConstPoolVal &V1, 
-                                const ConstPoolVal &V2) {
+inline ConstantBool *operator>(const Constant &V1, 
+                               const Constant &V2) {
   return V2 < V1;
 }
 
-inline ConstPoolBool *operator>=(const ConstPoolVal &V1, 
-                                 const ConstPoolVal &V2) {
+inline ConstantBool *operator>=(const Constant &V1, 
+                                const Constant &V2) {
   return (V1 < V2)->inverted();      // !(V1 < V2)
 }
 
-inline ConstPoolBool *operator<=(const ConstPoolVal &V1, 
-                                 const ConstPoolVal &V2) {
+inline ConstantBool *operator<=(const Constant &V1, 
+                                const Constant &V2) {
   return (V1 > V2)->inverted();      // !(V1 > V2)
 }
 
@@ -179,13 +179,13 @@ inline ConstPoolBool *operator<=(const ConstPoolVal &V1,
 //  Implement higher level instruction folding type instructions
 //===----------------------------------------------------------------------===//
 
-inline ConstPoolVal *ConstantFoldCastInstruction(const ConstPoolVal *V,
-                                                 const Type *DestTy) {
+inline Constant *ConstantFoldCastInstruction(const Constant *V,
+                                             const Type *DestTy) {
   return ConstRules::get(*V)->castTo(V, DestTy);
 }
 
-inline ConstPoolVal *ConstantFoldUnaryInstruction(unsigned Opcode, 
-                                                  const ConstPoolVal *V) {
+inline Constant *ConstantFoldUnaryInstruction(unsigned Opcode, 
+                                              const Constant *V) {
   switch (Opcode) {
   case Instruction::Not:  return !*V;
     // TODO: Handle get element ptr instruction here in the future? GEP null?
@@ -193,9 +193,9 @@ inline ConstPoolVal *ConstantFoldUnaryInstruction(unsigned Opcode,
   return 0;
 }
 
-inline ConstPoolVal *ConstantFoldBinaryInstruction(unsigned Opcode,
-                                                   const ConstPoolVal *V1, 
-                                                   const ConstPoolVal *V2) {
+inline Constant *ConstantFoldBinaryInstruction(unsigned Opcode,
+                                               const Constant *V1, 
+                                               const Constant *V2) {
   switch (Opcode) {
   case Instruction::Add:     return *V1 + *V2;
   case Instruction::Sub:     return *V1 - *V2;
diff --git a/lib/VMCore/ConstantFolding.h b/lib/VMCore/ConstantFolding.h
index 72632ee..bd59780 100644
--- a/lib/VMCore/ConstantFolding.h
+++ b/lib/VMCore/ConstantFolding.h
@@ -5,10 +5,10 @@
 //
 // Unfortunately we can't overload operators on pointer types (like this:)
 //
-//      inline bool operator==(const ConstPoolVal *V1, const ConstPoolVal *V2)
+//      inline bool operator==(const Constant *V1, const Constant *V2)
 //
 // so we must make due with references, even though it leads to some butt ugly
-// looking code downstream.  *sigh*  (ex:  ConstPoolVal *Result = *V1 + *v2; )
+// looking code downstream.  *sigh*  (ex:  Constant *Result = *V1 + *v2; )
 //
 //===----------------------------------------------------------------------===//
 //
@@ -33,7 +33,7 @@
 #ifndef LLVM_OPT_CONSTANTHANDLING_H
 #define LLVM_OPT_CONSTANTHANDLING_H
 
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 #include "llvm/Instruction.h"
 #include "llvm/Type.h"
 class PointerType;
@@ -44,15 +44,15 @@ namespace opt {
 //  Implement == and != directly...
 //===----------------------------------------------------------------------===//
 
-inline ConstPoolBool *operator==(const ConstPoolVal &V1, 
-                                 const ConstPoolVal &V2) {
+inline ConstantBool *operator==(const Constant &V1, 
+                                const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
-  return ConstPoolBool::get(&V1 == &V2);
+  return ConstantBool::get(&V1 == &V2);
 }
 
-inline ConstPoolBool *operator!=(const ConstPoolVal &V1, 
-                                 const ConstPoolVal &V2) {
-  return ConstPoolBool::get(&V1 != &V2);
+inline ConstantBool *operator!=(const Constant &V1, 
+                                const Constant &V2) {
+  return ConstantBool::get(&V1 != &V2);
 }
 
 //===----------------------------------------------------------------------===//
@@ -66,35 +66,35 @@ public:
   static AnnotationID AID;    // AnnotationID for this class
 
   // Unary Operators...
-  virtual ConstPoolVal *op_not(const ConstPoolVal *V) const = 0;
+  virtual Constant *op_not(const Constant *V) const = 0;
 
   // Binary Operators...
-  virtual ConstPoolVal *add(const ConstPoolVal *V1, 
-                            const ConstPoolVal *V2) const = 0;
-  virtual ConstPoolVal *sub(const ConstPoolVal *V1, 
-                            const ConstPoolVal *V2) const = 0;
-  virtual ConstPoolVal *mul(const ConstPoolVal *V1, 
-			    const ConstPoolVal *V2) const = 0;
+  virtual Constant *add(const Constant *V1, 
+                        const Constant *V2) const = 0;
+  virtual Constant *sub(const Constant *V1, 
+                        const Constant *V2) const = 0;
+  virtual Constant *mul(const Constant *V1, 
+                        const Constant *V2) const = 0;
 
-  virtual ConstPoolBool *lessthan(const ConstPoolVal *V1, 
-                                  const ConstPoolVal *V2) const = 0;
+  virtual ConstantBool *lessthan(const Constant *V1, 
+                                 const Constant *V2) const = 0;
 
   // Casting operators.  ick
-  virtual ConstPoolBool *castToBool  (const ConstPoolVal *V) const = 0;
-  virtual ConstPoolSInt *castToSByte (const ConstPoolVal *V) const = 0;
-  virtual ConstPoolUInt *castToUByte (const ConstPoolVal *V) const = 0;
-  virtual ConstPoolSInt *castToShort (const ConstPoolVal *V) const = 0;
-  virtual ConstPoolUInt *castToUShort(const ConstPoolVal *V) const = 0;
-  virtual ConstPoolSInt *castToInt   (const ConstPoolVal *V) const = 0;
-  virtual ConstPoolUInt *castToUInt  (const ConstPoolVal *V) const = 0;
-  virtual ConstPoolSInt *castToLong  (const ConstPoolVal *V) const = 0;
-  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 {
+  virtual ConstantBool *castToBool  (const Constant *V) const = 0;
+  virtual ConstantSInt *castToSByte (const Constant *V) const = 0;
+  virtual ConstantUInt *castToUByte (const Constant *V) const = 0;
+  virtual ConstantSInt *castToShort (const Constant *V) const = 0;
+  virtual ConstantUInt *castToUShort(const Constant *V) const = 0;
+  virtual ConstantSInt *castToInt   (const Constant *V) const = 0;
+  virtual ConstantUInt *castToUInt  (const Constant *V) const = 0;
+  virtual ConstantSInt *castToLong  (const Constant *V) const = 0;
+  virtual ConstantUInt *castToULong (const Constant *V) const = 0;
+  virtual ConstantFP   *castToFloat (const Constant *V) const = 0;
+  virtual ConstantFP   *castToDouble(const Constant *V) const = 0;
+  virtual ConstantPointer *castToPointer(const Constant *V,
+                                         const PointerType *Ty) const = 0;
+
+  inline Constant *castTo(const Constant *V, const Type *Ty) const {
     switch (Ty->getPrimitiveID()) {
     case Type::BoolTyID:   return castToBool(V);
     case Type::UByteTyID:  return castToUByte(V);
@@ -116,7 +116,7 @@ public:
   // we just want to make sure to hit the cache instead of doing it indirectly,
   //  if possible...
   //
-  static inline ConstRules *get(const ConstPoolVal &V) {
+  static inline ConstRules *get(const Constant &V) {
     return (ConstRules*)V.getType()->getOrCreateAnnotation(AID);
   }
 private :
@@ -127,29 +127,29 @@ private :
 };
 
 
-inline ConstPoolVal *operator!(const ConstPoolVal &V) {
+inline Constant *operator!(const Constant &V) {
   return ConstRules::get(V)->op_not(&V);
 }
 
 
 
-inline ConstPoolVal *operator+(const ConstPoolVal &V1, const ConstPoolVal &V2) {
+inline Constant *operator+(const Constant &V1, const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
   return ConstRules::get(V1)->add(&V1, &V2);
 }
 
-inline ConstPoolVal *operator-(const ConstPoolVal &V1, const ConstPoolVal &V2) {
+inline Constant *operator-(const Constant &V1, const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
   return ConstRules::get(V1)->sub(&V1, &V2);
 }
 
-inline ConstPoolVal *operator*(const ConstPoolVal &V1, const ConstPoolVal &V2) {
+inline Constant *operator*(const Constant &V1, const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
   return ConstRules::get(V1)->mul(&V1, &V2);
 }
 
-inline ConstPoolBool *operator<(const ConstPoolVal &V1, 
-                                const ConstPoolVal &V2) {
+inline ConstantBool *operator<(const Constant &V1, 
+                               const Constant &V2) {
   assert(V1.getType() == V2.getType() && "Constant types must be identical!");
   return ConstRules::get(V1)->lessthan(&V1, &V2);
 }
@@ -159,18 +159,18 @@ inline ConstPoolBool *operator<(const ConstPoolVal &V1,
 //  Implement 'derived' operators based on what we already have...
 //===----------------------------------------------------------------------===//
 
-inline ConstPoolBool *operator>(const ConstPoolVal &V1, 
-                                const ConstPoolVal &V2) {
+inline ConstantBool *operator>(const Constant &V1, 
+                               const Constant &V2) {
   return V2 < V1;
 }
 
-inline ConstPoolBool *operator>=(const ConstPoolVal &V1, 
-                                 const ConstPoolVal &V2) {
+inline ConstantBool *operator>=(const Constant &V1, 
+                                const Constant &V2) {
   return (V1 < V2)->inverted();      // !(V1 < V2)
 }
 
-inline ConstPoolBool *operator<=(const ConstPoolVal &V1, 
-                                 const ConstPoolVal &V2) {
+inline ConstantBool *operator<=(const Constant &V1, 
+                                const Constant &V2) {
   return (V1 > V2)->inverted();      // !(V1 > V2)
 }
 
@@ -179,13 +179,13 @@ inline ConstPoolBool *operator<=(const ConstPoolVal &V1,
 //  Implement higher level instruction folding type instructions
 //===----------------------------------------------------------------------===//
 
-inline ConstPoolVal *ConstantFoldCastInstruction(const ConstPoolVal *V,
-                                                 const Type *DestTy) {
+inline Constant *ConstantFoldCastInstruction(const Constant *V,
+                                             const Type *DestTy) {
   return ConstRules::get(*V)->castTo(V, DestTy);
 }
 
-inline ConstPoolVal *ConstantFoldUnaryInstruction(unsigned Opcode, 
-                                                  const ConstPoolVal *V) {
+inline Constant *ConstantFoldUnaryInstruction(unsigned Opcode, 
+                                              const Constant *V) {
   switch (Opcode) {
   case Instruction::Not:  return !*V;
     // TODO: Handle get element ptr instruction here in the future? GEP null?
@@ -193,9 +193,9 @@ inline ConstPoolVal *ConstantFoldUnaryInstruction(unsigned Opcode,
   return 0;
 }
 
-inline ConstPoolVal *ConstantFoldBinaryInstruction(unsigned Opcode,
-                                                   const ConstPoolVal *V1, 
-                                                   const ConstPoolVal *V2) {
+inline Constant *ConstantFoldBinaryInstruction(unsigned Opcode,
+                                               const Constant *V1, 
+                                               const Constant *V2) {
   switch (Opcode) {
   case Instruction::Add:     return *V1 + *V2;
   case Instruction::Sub:     return *V1 - *V2;
diff --git a/lib/VMCore/Function.cpp b/lib/VMCore/Function.cpp
index b997f11..c3d8e87 100644
--- a/lib/VMCore/Function.cpp
+++ b/lib/VMCore/Function.cpp
@@ -85,11 +85,11 @@ void Method::dropAllReferences() {
 // GlobalVariable Implementation
 //===----------------------------------------------------------------------===//
 
-GlobalVariable::GlobalVariable(const Type *Ty, bool isConstant, bool isIntern,
-			       ConstPoolVal *Initializer = 0,
+GlobalVariable::GlobalVariable(const Type *Ty, bool constant, bool isIntern,
+			       Constant *Initializer = 0,
 			       const string &Name = "")
   : GlobalValue(PointerType::get(Ty), Value::GlobalVariableVal, isIntern, Name),
-    Constant(isConstant) {
+    isConstantGlobal(constant) {
   if (Initializer) Operands.push_back(Use((Value*)Initializer, this));
 }
 
diff --git a/lib/VMCore/Linker.cpp b/lib/VMCore/Linker.cpp
index 8be0793..8a02946 100644
--- a/lib/VMCore/Linker.cpp
+++ b/lib/VMCore/Linker.cpp
@@ -16,7 +16,7 @@
 #include "llvm/SymbolTable.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/iOther.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 
 // Error - Simple wrapper function to conditionally assign to E and return true.
 // This just makes error return conditions a little bit simpler...
@@ -90,31 +90,31 @@ static Value *RemapOperand(const Value *In, map<const Value*, Value*> &LocalMap,
   }
 
   // Check to see if it's a constant that we are interesting in transforming...
-  if (ConstPoolVal *CPV = dyn_cast<ConstPoolVal>(In)) {
+  if (Constant *CPV = dyn_cast<Constant>(In)) {
     if (!isa<DerivedType>(CPV->getType()))
       return CPV;              // Simple constants stay identical...
 
-    ConstPoolVal *Result = 0;
+    Constant *Result = 0;
 
-    if (ConstPoolArray *CPA = dyn_cast<ConstPoolArray>(CPV)) {
+    if (ConstantArray *CPA = dyn_cast<ConstantArray>(CPV)) {
       const vector<Use> &Ops = CPA->getValues();
-      vector<ConstPoolVal*> Operands(Ops.size());
+      vector<Constant*> Operands(Ops.size());
       for (unsigned i = 0; i < Ops.size(); ++i)
         Operands[i] = 
-          cast<ConstPoolVal>(RemapOperand(Ops[i], LocalMap, GlobalMap));
-      Result = ConstPoolArray::get(cast<ArrayType>(CPA->getType()), Operands);
-    } else if (ConstPoolStruct *CPS = dyn_cast<ConstPoolStruct>(CPV)) {
+          cast<Constant>(RemapOperand(Ops[i], LocalMap, GlobalMap));
+      Result = ConstantArray::get(cast<ArrayType>(CPA->getType()), Operands);
+    } else if (ConstantStruct *CPS = dyn_cast<ConstantStruct>(CPV)) {
       const vector<Use> &Ops = CPS->getValues();
-      vector<ConstPoolVal*> Operands(Ops.size());
+      vector<Constant*> Operands(Ops.size());
       for (unsigned i = 0; i < Ops.size(); ++i)
         Operands[i] = 
-          cast<ConstPoolVal>(RemapOperand(Ops[i], LocalMap, GlobalMap));
-      Result = ConstPoolStruct::get(cast<StructType>(CPS->getType()), Operands);
-    } else if (isa<ConstPoolPointerNull>(CPV)) {
+          cast<Constant>(RemapOperand(Ops[i], LocalMap, GlobalMap));
+      Result = ConstantStruct::get(cast<StructType>(CPS->getType()), Operands);
+    } else if (isa<ConstantPointerNull>(CPV)) {
       Result = CPV;
-    } else if (ConstPoolPointerRef *CPR = dyn_cast<ConstPoolPointerRef>(CPV)) {
+    } else if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(CPV)) {
       Value *V = RemapOperand(CPR->getValue(), LocalMap, GlobalMap);
-      Result = ConstPoolPointerRef::get(cast<GlobalValue>(V));
+      Result = ConstantPointerRef::get(cast<GlobalValue>(V));
     } else {
       assert(0 && "Unknown type of derived type constant value!");
     }
@@ -207,8 +207,8 @@ static bool LinkGlobalInits(Module *Dest, const Module *Src,
 
     if (SGV->hasInitializer()) {      // Only process initialized GV's
       // Figure out what the initializer looks like in the dest module...
-      ConstPoolVal *DInit =
-        cast<ConstPoolVal>(RemapOperand(SGV->getInitializer(), ValueMap));
+      Constant *DInit =
+        cast<Constant>(RemapOperand(SGV->getInitializer(), ValueMap));
 
       GlobalVariable *DGV = cast<GlobalVariable>(ValueMap[SGV]);    
       if (DGV->hasInitializer() && SGV->hasExternalLinkage() &&
diff --git a/lib/VMCore/Module.cpp b/lib/VMCore/Module.cpp
index 86b944d..a425355 100644
--- a/lib/VMCore/Module.cpp
+++ b/lib/VMCore/Module.cpp
@@ -11,7 +11,7 @@
 #include "llvm/InstrTypes.h"
 #include "llvm/ValueHolderImpl.h"
 #include "llvm/Type.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 #include "Support/STLExtras.h"
 #include <map>
 
@@ -24,7 +24,7 @@ template class ValueHolder<Method, Module, Module>;
 // Define the GlobalValueRefMap as a struct that wraps a map so that we don't
 // have Module.h depend on <map>
 //
-struct GlobalValueRefMap : public map<GlobalValue*, ConstPoolPointerRef*>{
+struct GlobalValueRefMap : public map<GlobalValue*, ConstantPointerRef*>{
 };
 
 
@@ -63,7 +63,7 @@ void Module::dropAllReferences() {
   if (GVRefMap) {
     for (GlobalValueRefMap::iterator I = GVRefMap->begin(), E = GVRefMap->end();
 	 I != E; ++I) {
-      // Delete the ConstPoolPointerRef node...
+      // Delete the ConstantPointerRef node...
       I->second->destroyConstant();
     }
 
@@ -89,24 +89,24 @@ bool Module::reduceApply(bool (*Func)(const Method*)) const {
 }
 
 // Accessor for the underlying GlobalValRefMap...
-ConstPoolPointerRef *Module::getConstPoolPointerRef(GlobalValue *V){
+ConstantPointerRef *Module::getConstantPointerRef(GlobalValue *V){
   // Create ref map lazily on demand...
   if (GVRefMap == 0) GVRefMap = new GlobalValueRefMap();
 
   GlobalValueRefMap::iterator I = GVRefMap->find(V);
   if (I != GVRefMap->end()) return I->second;
 
-  ConstPoolPointerRef *Ref = new ConstPoolPointerRef(V);
+  ConstantPointerRef *Ref = new ConstantPointerRef(V);
   GVRefMap->insert(make_pair(V, Ref));
 
   return Ref;
 }
 
-void Module::mutateConstPoolPointerRef(GlobalValue *OldGV, GlobalValue *NewGV) {
+void Module::mutateConstantPointerRef(GlobalValue *OldGV, GlobalValue *NewGV) {
   GlobalValueRefMap::iterator I = GVRefMap->find(OldGV);
   assert(I != GVRefMap->end() && 
-	 "mutateConstPoolPointerRef; OldGV not in table!");
-  ConstPoolPointerRef *Ref = I->second;
+	 "mutateConstantPointerRef; OldGV not in table!");
+  ConstantPointerRef *Ref = I->second;
 
   // Remove the old entry...
   GVRefMap->erase(I);
diff --git a/lib/VMCore/SlotCalculator.cpp b/lib/VMCore/SlotCalculator.cpp
index 6fed526..9c5d97a 100644
--- a/lib/VMCore/SlotCalculator.cpp
+++ b/lib/VMCore/SlotCalculator.cpp
@@ -15,7 +15,7 @@
 #include "llvm/GlobalVariable.h"
 #include "llvm/Module.h"
 #include "llvm/BasicBlock.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 #include "llvm/iOther.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/SymbolTable.h"
@@ -114,7 +114,7 @@ void SlotCalculator::processSymbolTableConstants(const SymbolTable *ST) {
   for (SymbolTable::const_iterator I = ST->begin(), E = ST->end(); I != E; ++I)
     for (SymbolTable::type_const_iterator TI = I->second.begin(), 
 	   TE = I->second.end(); TI != TE; ++TI)
-      if (isa<ConstPoolVal>(TI->second))
+      if (isa<Constant>(TI->second))
 	insertValue(TI->second);
 }
 
@@ -231,7 +231,7 @@ int SlotCalculator::getValSlot(const Value *D) const {
 
 
 int SlotCalculator::insertValue(const Value *D) {
-  if (isa<ConstPoolVal>(D) || isa<GlobalVariable>(D)) {
+  if (isa<Constant>(D) || isa<GlobalVariable>(D)) {
     const User *U = cast<const User>(D);
     // This makes sure that if a constant has uses (for example an array
     // of const ints), that they are inserted also.  Same for global variable
@@ -259,7 +259,7 @@ int SlotCalculator::insertVal(const Value *D, bool dontIgnore = false) {
   if (!dontIgnore)                               // Don't ignore nonignorables!
     if (D->getType() == Type::VoidTy ||          // Ignore void type nodes
 	(IgnoreNamedNodes &&                     // Ignore named and constants
-	 (D->hasName() || isa<ConstPoolVal>(D)) && !isa<Type>(D))) {
+	 (D->hasName() || isa<Constant>(D)) && !isa<Type>(D))) {
       SC_DEBUG("ignored value " << D << endl);
       return -1;                  // We do need types unconditionally though
     }
@@ -336,8 +336,8 @@ int SlotCalculator::doInsertVal(const Value *D) {
 
   SC_DEBUG("  Inserting value [" << Ty << "] = " << D << " slot=" << 
 	   DestSlot << " [");
-  // G = Global, C = ConstPoolVal, T = Type, M = Method, o = other
-  SC_DEBUG((isa<GlobalVariable>(D) ? "G" : (isa<ConstPoolVal>(D) ? "C" : 
+  // G = Global, C = Constant, T = Type, M = Method, o = other
+  SC_DEBUG((isa<GlobalVariable>(D) ? "G" : (isa<Constant>(D) ? "C" : 
            (isa<Type>(D) ? "T" : (isa<Method>(D) ? "M" : "o")))));
   SC_DEBUG("]\n");
   return (int)DestSlot;
diff --git a/lib/VMCore/SymbolTable.cpp b/lib/VMCore/SymbolTable.cpp
index c32cec9..dd6329f 100644
--- a/lib/VMCore/SymbolTable.cpp
+++ b/lib/VMCore/SymbolTable.cpp
@@ -26,14 +26,14 @@ SymbolTable::~SymbolTable() {
     }
   }
 
-  // TODO: FIXME: BIG ONE: This doesn't unreference abstract types for the planes
-  // that could still have entries!
+ // TODO: FIXME: BIG ONE: This doesn't unreference abstract types for the planes
+ // that could still have entries!
 
 #ifndef NDEBUG   // Only do this in -g mode...
   bool LeftoverValues = true;
   for (iterator i = begin(); i != end(); ++i) {
     for (type_iterator I = i->second.begin(); I != i->second.end(); ++I)
-      if (!isa<ConstPoolVal>(I->second) && !isa<Type>(I->second)) {
+      if (!isa<Constant>(I->second) && !isa<Type>(I->second)) {
 	cerr << "Value still in symbol table! Type = '"
 	     << i->first->getDescription() << "' Name = '" << I->first << "'\n";
 	LeftoverValues = false;
diff --git a/lib/VMCore/Type.cpp b/lib/VMCore/Type.cpp
index 5f39682..00e86e4 100644
--- a/lib/VMCore/Type.cpp
+++ b/lib/VMCore/Type.cpp
@@ -98,9 +98,9 @@ bool Type::isLosslesslyConvertableTo(const Type *Ty) const {
 
 
 bool StructType::indexValid(const Value *V) const {
-  if (!isa<ConstPoolVal>(V)) return false;
+  if (!isa<Constant>(V)) return false;
   if (V->getType() != Type::UByteTy) return false;
-  unsigned Idx = cast<ConstPoolUInt>(V)->getValue();
+  unsigned Idx = cast<ConstantUInt>(V)->getValue();
   return Idx < ETypes.size();
 }
 
@@ -108,9 +108,9 @@ bool StructType::indexValid(const Value *V) const {
 // element.  For a structure type, this must be a constant value...
 //
 const Type *StructType::getTypeAtIndex(const Value *V) const {
-  assert(isa<ConstPoolVal>(V) && "Structure index must be a constant!!");
+  assert(isa<Constant>(V) && "Structure index must be a constant!!");
   assert(V->getType() == Type::UByteTy && "Structure index must be ubyte!");
-  unsigned Idx = cast<ConstPoolUInt>(V)->getValue();
+  unsigned Idx = cast<ConstantUInt>(V)->getValue();
   assert(Idx < ETypes.size() && "Structure index out of range!");
   assert(indexValid(V) && "Invalid structure index!"); // Duplicate check
 
diff --git a/lib/VMCore/Value.cpp b/lib/VMCore/Value.cpp
index d40aaca..3429d7c 100644
--- a/lib/VMCore/Value.cpp
+++ b/lib/VMCore/Value.cpp
@@ -8,7 +8,6 @@
 #include "llvm/InstrTypes.h"
 #include "llvm/SymbolTable.h"
 #include "llvm/SymTabValue.h"
-#include "llvm/ConstPoolVals.h"
 #include "llvm/Type.h"
 #ifndef NDEBUG      // Only in -g mode...
 #include "llvm/Assembly/Writer.h"
diff --git a/lib/VMCore/iMemory.cpp b/lib/VMCore/iMemory.cpp
index 56223cd..a0a7b0f 100644
--- a/lib/VMCore/iMemory.cpp
+++ b/lib/VMCore/iMemory.cpp
@@ -5,7 +5,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/iMemory.h"
-#include "llvm/ConstPoolVals.h"
 
 //===----------------------------------------------------------------------===//
 //                        MemAccessInst Implementation
@@ -37,20 +36,23 @@ const Type* MemAccessInst::getIndexedType(const Type *Ptr,
   return CurIDX == Idx.size() ? Ptr : 0;
 }
 
-const vector<ConstPoolVal*> MemAccessInst::getIndicesBROKEN() const {
+
+#if 1
+#include "llvm/ConstantVals.h"
+const vector<Constant*> MemAccessInst::getIndicesBROKEN() const {
   cerr << "MemAccessInst::getIndices() does not do what you want it to.  Talk"
        << " to Chris about this.  We can phase it out after the paper.\n";
 
-  vector<ConstPoolVal*> RetVal;
+  vector<Constant*> RetVal;
 
   // THIS CODE WILL FAIL IF A NON CONSTANT INDEX IS USED AS AN ARRAY INDEX
   // THIS IS WHY YOU SHOULD NOT USE THIS FUNCTION ANY MORE!!!
   for (unsigned i = getFirstIndexOperandNumber(); i < getNumOperands(); ++i)
-    RetVal.push_back(cast<ConstPoolVal>(getOperand(i)));
+    RetVal.push_back(cast<Constant>(getOperand(i)));
 
   return RetVal;
 }
-
+#endif
 
 //===----------------------------------------------------------------------===//
 //                           LoadInst Implementation
diff --git a/lib/VMCore/iSwitch.cpp b/lib/VMCore/iSwitch.cpp
index e5e3c50..91edbc0 100644
--- a/lib/VMCore/iSwitch.cpp
+++ b/lib/VMCore/iSwitch.cpp
@@ -27,7 +27,7 @@ SwitchInst::SwitchInst(const SwitchInst &SI)
   }
 }
 
-void SwitchInst::dest_push_back(ConstPoolVal *OnVal, BasicBlock *Dest) {
+void SwitchInst::dest_push_back(Constant *OnVal, BasicBlock *Dest) {
   Operands.push_back(Use(OnVal, this));
   Operands.push_back(Use(Dest, this));
 }