diff --git a/llvm/lib/Transforms/ExprTypeConvert.cpp b/llvm/lib/Transforms/ExprTypeConvert.cpp
index 7efe623..57d533d 100644
--- a/llvm/lib/Transforms/ExprTypeConvert.cpp
+++ b/llvm/lib/Transforms/ExprTypeConvert.cpp
@@ -11,7 +11,7 @@
 #include "llvm/iOther.h"
 #include "llvm/iPHINode.h"
 #include "llvm/iMemory.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 #include "llvm/Optimizations/ConstantHandling.h"
 #include "llvm/Optimizations/DCE.h"
 #include "llvm/Analysis/Expressions.h"
@@ -36,7 +36,7 @@
 static bool AllIndicesZero(const MemAccessInst *MAI) {
   for (User::op_const_iterator S = MAI->idx_begin(), E = MAI->idx_end();
        S != E; ++S)
-    if (!isa<ConstPoolVal>(*S) || !cast<ConstPoolVal>(*S)->isNullValue())
+    if (!isa<Constant>(*S) || !cast<Constant>(*S)->isNullValue())
       return false;
   return true;
 }
@@ -155,7 +155,7 @@
     unsigned DataSize = TD.getTypeSize(ElType);
     
     if (OffsetAmount > DataSize) // Allocate a sized array amount...
-      Expr.Var = ConstPoolUInt::get(Type::UIntTy, OffsetAmount/DataSize);
+      Expr.Var = ConstantUInt::get(Type::UIntTy, OffsetAmount/DataSize);
   }
 #endif
 
@@ -198,7 +198,7 @@
     // const prop'd in general).  We just ask the constant propogator to see if
     // it can convert the value...
     //
-    if (ConstPoolVal *CPV = dyn_cast<ConstPoolVal>(V))
+    if (Constant *CPV = dyn_cast<Constant>(V))
       if (opt::ConstantFoldCastInstruction(CPV, Ty))
         return true;  // Don't worry about deallocating, it's a constant.
 
@@ -285,8 +285,8 @@
     const Type *BaseType = GEP->getPointerOperand()->getType();
     const Type *ElTy = 0;
 
-    while (!Indices.empty() && isa<ConstPoolUInt>(Indices.back()) &&
-           cast<ConstPoolUInt>(Indices.back())->getValue() == 0) {
+    while (!Indices.empty() && isa<ConstantUInt>(Indices.back()) &&
+           cast<ConstantUInt>(Indices.back())->getValue() == 0) {
       Indices.pop_back();
       ElTy = GetElementPtrInst::getIndexedType(BaseType, Indices,
                                                            true);
@@ -329,7 +329,7 @@
 
   Instruction *I = dyn_cast<Instruction>(V);
   if (I == 0)
-    if (ConstPoolVal *CPV = cast<ConstPoolVal>(V)) {
+    if (Constant *CPV = cast<Constant>(V)) {
       // Constants are converted by constant folding the cast that is required.
       // We assume here that all casts are implemented for constant prop.
       Value *Result = opt::ConstantFoldCastInstruction(CPV, Ty);
@@ -349,7 +349,7 @@
 
   ValueHandle IHandle(VMC, I);  // Prevent I from being removed!
   
-  ConstPoolVal *Dummy = ConstPoolVal::getNullConstant(Ty);
+  Constant *Dummy = Constant::getNullConstant(Ty);
 
   //cerr << endl << endl << "Type:\t" << Ty << "\nInst: " << I << "BB Before: " << BB << endl;
 
@@ -380,8 +380,7 @@
     LoadInst *LI = cast<LoadInst>(I);
     assert(!LI->hasIndices() || AllIndicesZero(LI));
 
-    Res = new LoadInst(ConstPoolVal::getNullConstant(PointerType::get(Ty)), 
-                       Name);
+    Res = new LoadInst(Constant::getNullConstant(PointerType::get(Ty)), Name);
     VMC.ExprMap[I] = Res;
     Res->setOperand(0, ConvertExpressionToType(LI->getPointerOperand(),
                                                PointerType::get(Ty), VMC));
@@ -433,8 +432,8 @@
     const Type *BaseType = GEP->getPointerOperand()->getType();
     const Type *PVTy = cast<PointerType>(Ty)->getValueType();
     Res = 0;
-    while (!Indices.empty() && isa<ConstPoolUInt>(Indices.back()) &&
-           cast<ConstPoolUInt>(Indices.back())->getValue() == 0) {
+    while (!Indices.empty() && isa<ConstantUInt>(Indices.back()) &&
+           cast<ConstantUInt>(Indices.back())->getValue() == 0) {
       Indices.pop_back();
       if (GetElementPtrInst::getIndexedType(BaseType, Indices, true) == PVTy) {
         if (Indices.size() == 0) {
@@ -723,8 +722,8 @@
   ValueHandle IHandle(VMC, I);
 
   const Type *NewTy = NewVal->getType();
-  ConstPoolVal *Dummy = (NewTy != Type::VoidTy) ? 
-                  ConstPoolVal::getNullConstant(NewTy) : 0;
+  Constant *Dummy = (NewTy != Type::VoidTy) ? 
+                  Constant::getNullConstant(NewTy) : 0;
 
   switch (I->getOpcode()) {
   case Instruction::Cast:
@@ -793,12 +792,12 @@
   case Instruction::Store: {
     if (I->getOperand(0) == OldVal) {  // Replace the source value
       const PointerType *NewPT = PointerType::get(NewTy);
-      Res = new StoreInst(NewVal, ConstPoolVal::getNullConstant(NewPT));
+      Res = new StoreInst(NewVal, Constant::getNullConstant(NewPT));
       VMC.ExprMap[I] = Res;
       Res->setOperand(1, ConvertExpressionToType(I->getOperand(1), NewPT, VMC));
     } else {                           // Replace the source pointer
       const Type *ValTy = cast<PointerType>(NewTy)->getValueType();
-      Res = new StoreInst(ConstPoolVal::getNullConstant(ValTy), NewVal);
+      Res = new StoreInst(Constant::getNullConstant(ValTy), NewVal);
       VMC.ExprMap[I] = Res;
       Res->setOperand(0, ConvertExpressionToType(I->getOperand(0), ValTy, VMC));
     }
diff --git a/llvm/lib/Transforms/HoistPHIConstants.cpp b/llvm/lib/Transforms/HoistPHIConstants.cpp
index fe7cabf..e28e8a2 100644
--- a/llvm/lib/Transforms/HoistPHIConstants.cpp
+++ b/llvm/lib/Transforms/HoistPHIConstants.cpp
@@ -51,32 +51,29 @@
   CachedCopyMap Cache;
   bool Changed = false;
   
-  for (Method::iterator BI = M->begin(), BE = M->end(); BI != BE; ++BI)
-    {
-      vector<PHINode*> phis;            // normalizing invalidates BB iterator
+  for (Method::iterator BI = M->begin(), BE = M->end(); BI != BE; ++BI) {
+    vector<PHINode*> phis;            // normalizing invalidates BB iterator
       
-      for (BasicBlock::iterator II = (*BI)->begin(); II != (*BI)->end(); ++II)
-        {
-          if (PHINode *PN = dyn_cast<PHINode>(*II))
-            phis.push_back(PN);
-          else
-            break;                      // All PHIs occur at top of BB!
-        }
+    for (BasicBlock::iterator II = (*BI)->begin(); II != (*BI)->end(); ++II) {
+      if (PHINode *PN = dyn_cast<PHINode>(*II))
+        phis.push_back(PN);
+      else
+        break;                      // All PHIs occur at top of BB!
+    }
       
-      for (vector<PHINode*>::iterator PI=phis.begin(); PI != phis.end(); ++PI)
-        for (unsigned i = 0; i < (*PI)->getNumIncomingValues(); ++i)
-          {
-	    Value *Op = (*PI)->getIncomingValue(i);
-
-            if (isa<ConstPoolVal>(Op)) {
-            (*PI)->setIncomingValue(i,
+    for (vector<PHINode*>::iterator PI=phis.begin(); PI != phis.end(); ++PI)
+      for (unsigned i = 0; i < (*PI)->getNumIncomingValues(); ++i) {
+        Value *Op = (*PI)->getIncomingValue(i);
+        
+        if (isa<Constant>(Op)) {
+          (*PI)->setIncomingValue(i,
                     NormalizePhiOperand((*PI),
                                         (*PI)->getIncomingValue(i),
                                         (*PI)->getIncomingBlock(i), Cache));
-            Changed = true;
-            }
-          }
-    }
+          Changed = true;
+        }
+      }
+  }
   
   return Changed;
 }
diff --git a/llvm/lib/Transforms/IPO/ConstantMerge.cpp b/llvm/lib/Transforms/IPO/ConstantMerge.cpp
index 3564a81..70e3437 100644
--- a/llvm/lib/Transforms/IPO/ConstantMerge.cpp
+++ b/llvm/lib/Transforms/IPO/ConstantMerge.cpp
@@ -23,7 +23,7 @@
 //
 static inline 
 bool mergeDuplicateConstants(Module *M, unsigned &ConstantNo,
-                             map<ConstPoolVal*, GlobalVariable*> &CMap) {
+                             map<Constant*, GlobalVariable*> &CMap) {
   Module::GlobalListType &GList = M->getGlobalList();
   if (GList.size() <= ConstantNo) return false;   // No new constants
   bool MadeChanges = false;
@@ -32,10 +32,10 @@
     GlobalVariable *GV = GList[ConstantNo];
     if (GV->isConstant()) {  // Only process constants
       assert(GV->hasInitializer() && "Globals constants must have inits!");
-      ConstPoolVal *Init = GV->getInitializer();
+      Constant *Init = GV->getInitializer();
 
       // Check to see if the initializer is already known...
-      map<ConstPoolVal*, GlobalVariable*>::iterator I = CMap.find(Init);
+      map<Constant*, GlobalVariable*>::iterator I = CMap.find(Init);
 
       if (I == CMap.end()) {    // Nope, add it to the map
         CMap.insert(make_pair(Init, GV));
@@ -59,7 +59,7 @@
 // deal with passes.
 //
 bool ConstantMerge::mergeDuplicateConstants(Module *M) {
-  map<ConstPoolVal*, GlobalVariable*> Constants;
+  map<Constant*, GlobalVariable*> Constants;
   unsigned LastConstantSeen = 0;
   return ::mergeDuplicateConstants(M, LastConstantSeen, Constants);
 }
diff --git a/llvm/lib/Transforms/IPO/DeadTypeElimination.cpp b/llvm/lib/Transforms/IPO/DeadTypeElimination.cpp
index f29ae29..8599118 100644
--- a/llvm/lib/Transforms/IPO/DeadTypeElimination.cpp
+++ b/llvm/lib/Transforms/IPO/DeadTypeElimination.cpp
@@ -458,13 +458,13 @@
   const Type *Ty = PN->getType();
 
   if (const PointerType *PT = dyn_cast<PointerType>(Ty))
-    NewVal = ConstPoolPointerNull::get(PT);
+    NewVal = ConstantPointerNull::get(PT);
   else if (Ty == Type::BoolTy)
-    NewVal = ConstPoolBool::True;
+    NewVal = ConstantBool::True;
   else if (Ty == Type::FloatTy || Ty == Type::DoubleTy)
-    NewVal = ConstPoolFP::get(Ty, 42);
+    NewVal = ConstantFP::get(Ty, 42);
   else if (Ty->isIntegral())
-    NewVal = ConstPoolInt::get(Ty, 42);
+    NewVal = ConstantInt::get(Ty, 42);
 
   assert(NewVal && "Unknown PHI node type!");
   PN->addIncoming(NewVal, BB);
diff --git a/llvm/lib/Transforms/IPO/InlineSimple.cpp b/llvm/lib/Transforms/IPO/InlineSimple.cpp
index e54e0d9..40b98bd 100644
--- a/llvm/lib/Transforms/IPO/InlineSimple.cpp
+++ b/llvm/lib/Transforms/IPO/InlineSimple.cpp
@@ -41,7 +41,7 @@
   for (unsigned op = 0, E = I->getNumOperands(); op != E; ++op) {
     const Value *Op = I->getOperand(op);
     Value *V = ValueMap[Op];
-    if (!V && (isa<GlobalValue>(Op) || isa<ConstPoolVal>(Op)))
+    if (!V && (isa<GlobalValue>(Op) || isa<Constant>(Op)))
       continue;  // Globals and constants don't get relocated
 
     if (!V) {
diff --git a/llvm/lib/Transforms/IPO/MutateStructTypes.cpp b/llvm/lib/Transforms/IPO/MutateStructTypes.cpp
index a433e26..c9f7917 100644
--- a/llvm/lib/Transforms/IPO/MutateStructTypes.cpp
+++ b/llvm/lib/Transforms/IPO/MutateStructTypes.cpp
@@ -115,7 +115,7 @@
 
   if (const StructType *OldST = dyn_cast<StructType>(OldTy)) {
     // Figure out what the current index is...
-    unsigned ElNum = cast<ConstPoolUInt>(Idx[i])->getValue();
+    unsigned ElNum = cast<ConstantUInt>(Idx[i])->getValue();
     assert(ElNum < OldST->getElementTypes().size());
 
     map<const StructType*, TransformType>::iterator I = Transforms.find(OldST);
@@ -123,7 +123,7 @@
       assert(ElNum < I->second.second.size());
       // Apply the XForm specified by Transforms map...
       unsigned NewElNum = I->second.second[ElNum];
-      Idx[i] = ConstPoolUInt::get(Type::UByteTy, NewElNum);
+      Idx[i] = ConstantUInt::get(Type::UByteTy, NewElNum);
     }
   }
 
@@ -140,12 +140,12 @@
   // Ignore null values and simple constants..
   if (V == 0) return 0;
 
-  if (ConstPoolVal *CPV = dyn_cast<ConstPoolVal>(V)) {
+  if (Constant *CPV = dyn_cast<Constant>(V)) {
     if (V->getType()->isPrimitiveType())
       return CPV;
 
-    if (isa<ConstPoolPointerNull>(CPV))
-      return ConstPoolPointerNull::get(
+    if (isa<ConstantPointerNull>(CPV))
+      return ConstantPointerNull::get(
                       cast<PointerType>(ConvertType(V->getType())));
     assert(0 && "Unable to convert constpool val of this type!");
   }
diff --git a/llvm/lib/Transforms/Instrumentation/TraceValues.cpp b/llvm/lib/Transforms/Instrumentation/TraceValues.cpp
index 07db028..b42bb7b 100644
--- a/llvm/lib/Transforms/Instrumentation/TraceValues.cpp
+++ b/llvm/lib/Transforms/Instrumentation/TraceValues.cpp
@@ -15,7 +15,7 @@
 
 #include "llvm/Transforms/Instrumentation/TraceValues.h"
 #include "llvm/GlobalVariable.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 #include "llvm/Type.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Instruction.h"
@@ -68,7 +68,7 @@
 }
 
 static inline GlobalVariable *GetStringRef(Module *M, const string &str) {
-  ConstPoolArray *Init = ConstPoolArray::get(str);
+  ConstantArray *Init = ConstantArray::get(str);
   GlobalVariable *GV = new GlobalVariable(Init->getType(), /*Const*/true,
 					  /*intern*/true, Init);
   M->getGlobalList().push_back(GV);
diff --git a/llvm/lib/Transforms/LevelRaise.cpp b/llvm/lib/Transforms/LevelRaise.cpp
index f802705..e0ca4db 100644
--- a/llvm/lib/Transforms/LevelRaise.cpp
+++ b/llvm/lib/Transforms/LevelRaise.cpp
@@ -11,7 +11,7 @@
 #include "llvm/Method.h"
 #include "llvm/iOther.h"
 #include "llvm/iMemory.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 #include "llvm/Optimizations/ConstantHandling.h"
 #include "llvm/Optimizations/DCE.h"
 #include "llvm/Optimizations/ConstantProp.h"
@@ -175,7 +175,7 @@
 #endif
           ValueMapCache ValueMap;
           Value *E = ConvertExpressionToType(Src, DestTy, ValueMap);
-          if (ConstPoolVal *CPV = dyn_cast<ConstPoolVal>(E))
+          if (Constant *CPV = dyn_cast<Constant>(E))
             CI->replaceAllUsesWith(CPV);
 
           BI = BB->begin();  // Rescan basic block.  BI might be invalidated.
@@ -242,7 +242,7 @@
             }
 
             // Insert a zero to index through this type...
-            Indices.push_back(ConstPoolUInt::get(CurCTy->getIndexType(), 0));
+            Indices.push_back(ConstantUInt::get(CurCTy->getIndexType(), 0));
 
             // Did we find what we're looking for?
             if (ElTy->isLosslesslyConvertableTo(DestPointedTy)) break;
@@ -502,8 +502,7 @@
 
   // Insert a cast!
   CastInst *TheCast = 
-    new CastInst(ConstPoolVal::getNullConstant(V->getType()), DestTy,
-                 V->getName());
+    new CastInst(Constant::getNullConstant(V->getType()), DestTy, V->getName());
   BB->getInstList().insert(InsertBefore, TheCast);
 
   cerr << "Inserting cast for " << V << endl;
diff --git a/llvm/lib/Transforms/Scalar/ConstantProp.cpp b/llvm/lib/Transforms/Scalar/ConstantProp.cpp
index bf28868..4fb3254 100644
--- a/llvm/lib/Transforms/Scalar/ConstantProp.cpp
+++ b/llvm/lib/Transforms/Scalar/ConstantProp.cpp
@@ -29,12 +29,12 @@
 #include "llvm/iTerminators.h"
 #include "llvm/iPHINode.h"
 #include "llvm/iOther.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 
 inline static bool 
 ConstantFoldUnaryInst(BasicBlock *BB, BasicBlock::iterator &II,
-                      UnaryOperator *Op, ConstPoolVal *D) {
-  ConstPoolVal *ReplaceWith = 
+                      UnaryOperator *Op, Constant *D) {
+  Constant *ReplaceWith = 
     opt::ConstantFoldUnaryInstruction(Op->getOpcode(), D);
 
   if (!ReplaceWith) return false;   // Nothing new to change...
@@ -56,8 +56,8 @@
 
 inline static bool 
 ConstantFoldCast(BasicBlock *BB, BasicBlock::iterator &II,
-                 CastInst *CI, ConstPoolVal *D) {
-  ConstPoolVal *ReplaceWith = 
+                 CastInst *CI, Constant *D) {
+  Constant *ReplaceWith = 
     opt::ConstantFoldCastInstruction(D, CI->getType());
 
   if (!ReplaceWith) return false;   // Nothing new to change...
@@ -80,8 +80,8 @@
 inline static bool 
 ConstantFoldBinaryInst(BasicBlock *BB, BasicBlock::iterator &II,
 		       BinaryOperator *Op,
-		       ConstPoolVal *D1, ConstPoolVal *D2) {
-  ConstPoolVal *ReplaceWith =
+		       Constant *D1, Constant *D2) {
+  Constant *ReplaceWith =
     opt::ConstantFoldBinaryInstruction(Op->getOpcode(), D1, D2);
   if (!ReplaceWith) return false;   // Nothing new to change...
 
@@ -111,7 +111,7 @@
     BasicBlock *Dest1 = cast<BasicBlock>(BI->getOperand(0));
     BasicBlock *Dest2 = cast<BasicBlock>(BI->getOperand(1));
 
-    if (ConstPoolBool *Cond = dyn_cast<ConstPoolBool>(BI->getCondition())) {
+    if (ConstantBool *Cond = dyn_cast<ConstantBool>(BI->getCondition())) {
       // Are we branching on constant?
       // YES.  Change to unconditional branch...
       BasicBlock *Destination = Cond->getValue() ? Dest1 : Dest2;
@@ -160,18 +160,18 @@
 						     BasicBlock::iterator &II) {
   Instruction *Inst = *II;
   if (BinaryOperator *BInst = dyn_cast<BinaryOperator>(Inst)) {
-    ConstPoolVal *D1 = dyn_cast<ConstPoolVal>(Inst->getOperand(0));
-    ConstPoolVal *D2 = dyn_cast<ConstPoolVal>(Inst->getOperand(1));
+    Constant *D1 = dyn_cast<Constant>(Inst->getOperand(0));
+    Constant *D2 = dyn_cast<Constant>(Inst->getOperand(1));
 
     if (D1 && D2)
       return ConstantFoldBinaryInst(BB, II, cast<BinaryOperator>(Inst), D1, D2);
 
   } else if (CastInst *CI = dyn_cast<CastInst>(Inst)) {
-    ConstPoolVal *D = dyn_cast<ConstPoolVal>(CI->getOperand(0));
+    Constant *D = dyn_cast<Constant>(CI->getOperand(0));
     if (D) return ConstantFoldCast(BB, II, CI, D);
                                          
   } else if (UnaryOperator *UInst = dyn_cast<UnaryOperator>(Inst)) {
-    ConstPoolVal *D = dyn_cast<ConstPoolVal>(UInst->getOperand(0));
+    Constant *D = dyn_cast<Constant>(UInst->getOperand(0));
     if (D) return ConstantFoldUnaryInst(BB, II, UInst, D);
   } else if (TerminatorInst *TInst = dyn_cast<TerminatorInst>(Inst)) {
     return opt::ConstantFoldTerminator(TInst);
diff --git a/llvm/lib/Transforms/Scalar/DCE.cpp b/llvm/lib/Transforms/Scalar/DCE.cpp
index e1bda22..6c4e3d2 100644
--- a/llvm/lib/Transforms/Scalar/DCE.cpp
+++ b/llvm/lib/Transforms/Scalar/DCE.cpp
@@ -96,7 +96,7 @@
 }
 
 static void ReplaceUsesWithConstant(Instruction *I) {
-  ConstPoolVal *CPV = ConstPoolVal::getNullConstant(I->getType());
+  Constant *CPV = Constant::getNullConstant(I->getType());
   
   // Make all users of this instruction reference the constant instead
   I->replaceAllUsesWith(CPV);
@@ -166,7 +166,7 @@
 
   // Remove basic blocks that have no predecessors... which are unreachable.
   if (BB->pred_begin() == BB->pred_end() &&
-      !BB->hasConstantPoolReferences()) {
+      !BB->hasConstantReferences()) {
     //cerr << "Removing BB: \n" << BB;
 
     // Loop through all of our successors and make sure they know that one
@@ -225,7 +225,7 @@
   // and if there is only one successor of the predecessor. 
   BasicBlock::pred_iterator PI(BB->pred_begin());
   if (PI != BB->pred_end() && *PI != BB &&    // Not empty?  Not same BB?
-      ++PI == BB->pred_end() && !BB->hasConstantPoolReferences()) {
+      ++PI == BB->pred_end() && !BB->hasConstantReferences()) {
     BasicBlock *Pred = *BB->pred_begin();
     TerminatorInst *Term = Pred->getTerminator();
     assert(Term != 0 && "malformed basic block without terminator!");
diff --git a/llvm/lib/Transforms/Scalar/InductionVars.cpp b/llvm/lib/Transforms/Scalar/InductionVars.cpp
index 7dfae48..d4b7bc5 100644
--- a/llvm/lib/Transforms/Scalar/InductionVars.cpp
+++ b/llvm/lib/Transforms/Scalar/InductionVars.cpp
@@ -20,7 +20,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Optimizations/InductionVars.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 #include "llvm/Analysis/IntervalPartition.h"
 #include "llvm/Assembly/Writer.h"
 #include "llvm/SymbolTable.h"
@@ -36,7 +36,7 @@
 // an interval invariant computation.
 //
 static bool isLoopInvariant(cfg::Interval *Int, Value *V) {
-  assert(isa<ConstPoolVal>(V) || isa<Instruction>(V) || isa<MethodArgument>(V));
+  assert(isa<Constant>(V) || isa<Instruction>(V) || isa<MethodArgument>(V));
 
   if (!isa<Instruction>(V))
     return true;  // Constants and arguments are always loop invariant
@@ -132,12 +132,12 @@
 static inline bool isSimpleInductionVar(PHINode *PN) {
   assert(PN->getNumIncomingValues() == 2 && "Must have cannonical PHI node!");
   Value *Initializer = PN->getIncomingValue(0);
-  if (!isa<ConstPoolVal>(Initializer)) return false;
+  if (!isa<Constant>(Initializer)) return false;
 
   if (Initializer->getType()->isSigned()) {  // Signed constant value...
-    if (((ConstPoolSInt*)Initializer)->getValue() != 0) return false;
+    if (((ConstantSInt*)Initializer)->getValue() != 0) return false;
   } else if (Initializer->getType()->isUnsigned()) {  // Unsigned constant value
-    if (((ConstPoolUInt*)Initializer)->getValue() != 0) return false;
+    if (((ConstantUInt*)Initializer)->getValue() != 0) return false;
   } else {
     return false;   // Not signed or unsigned?  Must be FP type or something
   }
@@ -153,12 +153,12 @@
 
   // Get the right hand side of the ADD node.  See if it is a constant 1.
   Value *StepSize = I->getOperand(1);
-  if (!isa<ConstPoolVal>(StepSize)) return false;
+  if (!isa<Constant>(StepSize)) return false;
 
   if (StepSize->getType()->isSigned()) {  // Signed constant value...
-    if (((ConstPoolSInt*)StepSize)->getValue() != 1) return false;
+    if (((ConstantSInt*)StepSize)->getValue() != 1) return false;
   } else if (StepSize->getType()->isUnsigned()) {  // Unsigned constant value
-    if (((ConstPoolUInt*)StepSize)->getValue() != 1) return false;
+    if (((ConstantUInt*)StepSize)->getValue() != 1) return false;
   } else {
     return false;   // Not signed or unsigned?  Must be FP type or something
   }
@@ -189,8 +189,8 @@
 
   // Create the neccesary instructions...
   PHINode        *PN      = new PHINode(Type::UIntTy, PHIName);
-  ConstPoolVal   *One     = ConstPoolUInt::get(Type::UIntTy, 1);
-  ConstPoolVal   *Zero    = ConstPoolUInt::get(Type::UIntTy, 0);
+  Constant       *One     = ConstantUInt::get(Type::UIntTy, 1);
+  Constant       *Zero    = ConstantUInt::get(Type::UIntTy, 0);
   BinaryOperator *AddNode = BinaryOperator::create(Instruction::Add, 
 						   PN, One, AddName);
 
diff --git a/llvm/lib/Transforms/Scalar/LowerAllocations.cpp b/llvm/lib/Transforms/Scalar/LowerAllocations.cpp
index 2385fee..ceb45f5 100644
--- a/llvm/lib/Transforms/Scalar/LowerAllocations.cpp
+++ b/llvm/lib/Transforms/Scalar/LowerAllocations.cpp
@@ -13,7 +13,7 @@
 #include "llvm/iMemory.h"
 #include "llvm/iOther.h"
 #include "llvm/SymbolTable.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 
 // doPassInitialization - For the lower allocations pass, this ensures that a
 // module contains a declaration for a malloc and a free function.
@@ -80,7 +80,7 @@
         unsigned Size = DataLayout.getTypeSize(AllocTy);
 
         // malloc(type) becomes sbyte *malloc(constint)
-        Value *MallocArg = ConstPoolUInt::get(Type::UIntTy, Size);
+        Value *MallocArg = ConstantUInt::get(Type::UIntTy, Size);
         if (MI->getNumOperands() && Size == 1) {
           MallocArg = MI->getOperand(0);         // Operand * 1 = Operand
         } else if (MI->getNumOperands()) {
diff --git a/llvm/lib/Transforms/Scalar/SCCP.cpp b/llvm/lib/Transforms/Scalar/SCCP.cpp
index 3c699c1..26a52d6 100644
--- a/llvm/lib/Transforms/Scalar/SCCP.cpp
+++ b/llvm/lib/Transforms/Scalar/SCCP.cpp
@@ -19,7 +19,7 @@
 #include "llvm/Optimizations/ConstantHandling.h"
 #include "llvm/Method.h"
 #include "llvm/BasicBlock.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 #include "llvm/InstrTypes.h"
 #include "llvm/iPHINode.h"
 #include "llvm/iMemory.h"
@@ -38,28 +38,28 @@
 //
 class InstVal {
   enum { 
-    Undefined,           // This instruction has no known value
-    Constant,            // This instruction has a constant value
+    undefined,           // This instruction has no known value
+    constant,            // This instruction has a constant value
     // Range,            // This instruction is known to fall within a range
-    Overdefined          // This instruction has an unknown value
-  } LatticeValue;    // The current lattice position
-  ConstPoolVal *ConstantVal;     // If Constant value, the current value
+    overdefined          // This instruction has an unknown value
+  } LatticeValue;        // The current lattice position
+  Constant *ConstantVal; // If Constant value, the current value
 public:
-  inline InstVal() : LatticeValue(Undefined), ConstantVal(0) {}
+  inline InstVal() : LatticeValue(undefined), ConstantVal(0) {}
 
   // markOverdefined - Return true if this is a new status to be in...
   inline bool markOverdefined() {
-    if (LatticeValue != Overdefined) {
-      LatticeValue = Overdefined;
+    if (LatticeValue != overdefined) {
+      LatticeValue = overdefined;
       return true;
     }
     return false;
   }
 
   // markConstant - Return true if this is a new status for us...
-  inline bool markConstant(ConstPoolVal *V) {
-    if (LatticeValue != Constant) {
-      LatticeValue = Constant;
+  inline bool markConstant(Constant *V) {
+    if (LatticeValue != constant) {
+      LatticeValue = constant;
       ConstantVal = V;
       return true;
     } else {
@@ -68,11 +68,11 @@
     return false;
   }
 
-  inline bool isUndefined()   const { return LatticeValue == Undefined; }
-  inline bool isConstant()    const { return LatticeValue == Constant; }
-  inline bool isOverdefined() const { return LatticeValue == Overdefined; }
+  inline bool isUndefined()   const { return LatticeValue == undefined; }
+  inline bool isConstant()    const { return LatticeValue == constant; }
+  inline bool isOverdefined() const { return LatticeValue == overdefined; }
 
-  inline ConstPoolVal *getConstant() const { return ConstantVal; }
+  inline Constant *getConstant() const { return ConstantVal; }
 };
 
 
@@ -113,7 +113,7 @@
   // is not already a constant, add it to the instruction work list so that 
   // the users of the instruction are updated later.
   //
-  inline bool markConstant(Instruction *I, ConstPoolVal *V) {
+  inline bool markConstant(Instruction *I, Constant *V) {
     //cerr << "markConstant: " << V << " = " << I;
     if (ValueState[I].markConstant(V)) {
       InstWorkList.push_back(I);
@@ -147,7 +147,7 @@
     map<Value*, InstVal>::iterator I = ValueState.find(V);
     if (I != ValueState.end()) return I->second;  // Common case, in the map
       
-    if (ConstPoolVal *CPV = dyn_cast<ConstPoolVal>(V)) {//Constants are constant
+    if (Constant *CPV = dyn_cast<Constant>(V)) {  // Constants are constant
       ValueState[CPV].markConstant(CPV);
     } else if (isa<MethodArgument>(V)) {          // MethodArgs are overdefined
       ValueState[V].markOverdefined();
@@ -246,7 +246,7 @@
     Instruction *Inst = *II;
     InstVal &IV = ValueState[Inst];
     if (IV.isConstant()) {
-      ConstPoolVal *Const = IV.getConstant();
+      Constant *Const = IV.getConstant();
       // cerr << "Constant: " << Inst << "  is: " << Const;
 
       // Replaces all of the uses of a variable with uses of the constant.
@@ -393,7 +393,7 @@
       markExecutable(BI->getSuccessor(1));
     } else if (BCValue.isConstant()) {
       // Constant condition variables mean the branch can only go a single way.
-      ConstPoolBool *CPB = cast<ConstPoolBool>(BCValue.getConstant());
+      ConstantBool *CPB = cast<ConstantBool>(BCValue.getConstant());
       if (CPB->getValue())       // If the branch condition is TRUE...
         markExecutable(BI->getSuccessor(0));
       else                       // Else if the br cond is FALSE...
@@ -409,7 +409,7 @@
       for(unsigned i = 0; BasicBlock *Succ = SI->getSuccessor(i); ++i)
         markExecutable(Succ);
     } else if (SCValue.isConstant()) {
-      ConstPoolVal *CPV = SCValue.getConstant();
+      Constant *CPV = SCValue.getConstant();
       // Make sure to skip the "default value" which isn't a value
       for (unsigned i = 1, E = SI->getNumSuccessors(); i != E; ++i) {
         if (SI->getSuccessorValue(i) == CPV) {// Found the right branch...
@@ -443,7 +443,7 @@
     if (VState.isOverdefined()) {        // Inherit overdefinedness of operand
       markOverdefined(I);
     } else if (VState.isConstant()) {    // Propogate constant value
-      ConstPoolVal *Result = isa<CastInst>(I)
+      Constant *Result = isa<CastInst>(I)
         ? opt::ConstantFoldCastInstruction(VState.getConstant(), I->getType())
         : opt::ConstantFoldUnaryInstruction(I->getOpcode(),
                                             VState.getConstant());
@@ -470,7 +470,7 @@
     if (V1State.isOverdefined() || V2State.isOverdefined()) {
       markOverdefined(I);
     } else if (V1State.isConstant() && V2State.isConstant()) {
-      ConstPoolVal *Result =
+      Constant *Result =
         opt::ConstantFoldBinaryInstruction(I->getOpcode(),
                                              V1State.getConstant(),
                                              V2State.getConstant());
diff --git a/llvm/lib/Transforms/Scalar/SymbolStripping.cpp b/llvm/lib/Transforms/Scalar/SymbolStripping.cpp
index 06cf025..bb4f01c 100644
--- a/llvm/lib/Transforms/Scalar/SymbolStripping.cpp
+++ b/llvm/lib/Transforms/Scalar/SymbolStripping.cpp
@@ -29,7 +29,7 @@
     SymbolTable::type_iterator B;
     while ((B = Plane.begin()) != Plane.end()) {   // Found nonempty type plane!
       Value *V = B->second;
-      if (isa<ConstPoolVal>(V) || isa<Type>(V))
+      if (isa<Constant>(V) || isa<Type>(V))
 	SymTab->type_remove(B);
       else 
 	V->setName("", SymTab);   // Set name to "", removing from symbol table!
diff --git a/llvm/lib/Transforms/TransformInternals.cpp b/llvm/lib/Transforms/TransformInternals.cpp
index dbe5ea9..5fdffda 100644
--- a/llvm/lib/Transforms/TransformInternals.cpp
+++ b/llvm/lib/Transforms/TransformInternals.cpp
@@ -8,7 +8,7 @@
 #include "TransformInternals.h"
 #include "llvm/Method.h"
 #include "llvm/Type.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 #include "llvm/Analysis/Expressions.h"
 #include "llvm/iOther.h"
 
@@ -96,7 +96,7 @@
            (i == SL->MemberOffsets.size()-1 || Offset <SL->MemberOffsets[i+1]));
     
     // Make sure to save the current index...
-    Offsets.push_back(ConstPoolUInt::get(Type::UByteTy, i));
+    Offsets.push_back(ConstantUInt::get(Type::UByteTy, i));
     ThisOffset = SL->MemberOffsets[i];
     NextType = STy->getElementTypes()[i];
   } else {
@@ -106,7 +106,7 @@
 
     NextType = ATy->getElementType();
     unsigned ChildSize = TD.getTypeSize(NextType);
-    Offsets.push_back(ConstPoolUInt::get(Type::UIntTy, Offset/ChildSize));
+    Offsets.push_back(ConstantUInt::get(Type::UIntTy, Offset/ChildSize));
     ThisOffset = (Offset/ChildSize)*ChildSize;
   }
 
@@ -183,7 +183,7 @@
       if (Offset >= ElSize) {
         // Calculate the index that we are entering into the array cell with
         unsigned Index = Offset/ElSize;
-        Indices.push_back(ConstPoolUInt::get(Type::UIntTy, Index));
+        Indices.push_back(ConstantUInt::get(Type::UIntTy, Index));
         Offset -= Index*ElSize;               // Consume part of the offset
 
       } else if (Scale && Scale != 1) {
@@ -204,7 +204,7 @@
         // Must be indexing a small amount into the first cell of the array
         // Just index into element zero of the array here.
         //
-        Indices.push_back(ConstPoolUInt::get(Type::UIntTy, 0));
+        Indices.push_back(ConstantUInt::get(Type::UIntTy, 0));
       }
       NextTy = ElTy;
     }
diff --git a/llvm/lib/Transforms/TransformInternals.h b/llvm/lib/Transforms/TransformInternals.h
index 8edeffc..d3ef47a 100644
--- a/llvm/lib/Transforms/TransformInternals.h
+++ b/llvm/lib/Transforms/TransformInternals.h
@@ -12,7 +12,7 @@
 #include "llvm/Instruction.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/DerivedTypes.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 #include <map>
 #include <set>
 
@@ -24,10 +24,10 @@
 //
 extern const TargetData TD;
 
-static int getConstantValue(const ConstPoolInt *CPI) {
-  if (const ConstPoolSInt *CSI = dyn_cast<ConstPoolSInt>(CPI))
+static int getConstantValue(const ConstantInt *CPI) {
+  if (const ConstantSInt *CSI = dyn_cast<ConstantSInt>(CPI))
     return CSI->getValue();
-  return cast<ConstPoolUInt>(CPI)->getValue();
+  return cast<ConstantUInt>(CPI)->getValue();
 }
 
 
diff --git a/llvm/lib/Transforms/Utils/Linker.cpp b/llvm/lib/Transforms/Utils/Linker.cpp
index 8be0793..8a02946 100644
--- a/llvm/lib/Transforms/Utils/Linker.cpp
+++ b/llvm/lib/Transforms/Utils/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 @@
   }
 
   // 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 @@
 
     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() &&