Rename ConstPoolVal -> Constant

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

llvm-svn: 1407

3 files changed, 20 insertions, 20 deletions

diff --git a/llvm/lib/Bytecode/Writer/ConstantWriter.cpp b/llvm/lib/Bytecode/Writer/ConstantWriter.cpp
index 8beb1325791..835ef9850b4 100644
--- a/llvm/lib/Bytecode/Writer/ConstantWriter.cpp
+++ b/llvm/lib/Bytecode/Writer/ConstantWriter.cpp
@@ -10,7 +10,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "WriterInternals.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 #include "llvm/SymbolTable.h"
 #include "llvm/DerivedTypes.h"
 
@@ -93,10 +93,10 @@ void BytecodeWriter::outputType(const Type *T) {
   }
 }
 
-bool BytecodeWriter::outputConstant(const ConstPoolVal *CPV) {
+bool BytecodeWriter::outputConstant(const Constant *CPV) {
   switch (CPV->getType()->getPrimitiveID()) {
   case Type::BoolTyID:    // Boolean Types
-    if (cast<const ConstPoolBool>(CPV)->getValue())
+    if (cast<const ConstantBool>(CPV)->getValue())
       output_vbr((unsigned)1, Out);
     else
       output_vbr((unsigned)0, Out);
@@ -106,22 +106,22 @@ bool BytecodeWriter::outputConstant(const ConstPoolVal *CPV) {
   case Type::UShortTyID:
   case Type::UIntTyID:
   case Type::ULongTyID:
-    output_vbr(cast<const ConstPoolUInt>(CPV)->getValue(), Out);
+    output_vbr(cast<const ConstantUInt>(CPV)->getValue(), Out);
     break;
 
   case Type::SByteTyID:   // Signed integer types...
   case Type::ShortTyID:
   case Type::IntTyID:
   case Type::LongTyID:
-    output_vbr(cast<const ConstPoolSInt>(CPV)->getValue(), Out);
+    output_vbr(cast<const ConstantSInt>(CPV)->getValue(), Out);
     break;
 
   case Type::TypeTyID:     // Serialize type type
-    assert(0 && "Types should not be in the ConstPool!");
+    assert(0 && "Types should not be in the Constant!");
     break;
 
   case Type::ArrayTyID: {
-    const ConstPoolArray *CPA = cast<const ConstPoolArray>(CPV);
+    const ConstantArray *CPA = cast<const ConstantArray>(CPV);
     unsigned size = CPA->getValues().size();
     if (!((const ArrayType *)CPA->getType())->isSized())
       output_vbr(size, Out);            // Not for sized arrays!!!
@@ -135,7 +135,7 @@ bool BytecodeWriter::outputConstant(const ConstPoolVal *CPV) {
   }
 
   case Type::StructTyID: {
-    const ConstPoolStruct *CPS = cast<const ConstPoolStruct>(CPV);
+    const ConstantStruct *CPS = cast<const ConstantStruct>(CPV);
     const vector<Use> &Vals = CPS->getValues();
 
     for (unsigned i = 0; i < Vals.size(); ++i) {
@@ -147,28 +147,28 @@ bool BytecodeWriter::outputConstant(const ConstPoolVal *CPV) {
   }
 
   case Type::PointerTyID: {
-    const ConstPoolPointer *CPP = cast<const ConstPoolPointer>(CPV);
-    if (isa<ConstPoolPointerNull>(CPP)) {
+    const ConstantPointer *CPP = cast<const ConstantPointer>(CPV);
+    if (isa<ConstantPointerNull>(CPP)) {
       output_vbr((unsigned)0, Out);
-    } else if (const ConstPoolPointerRef *CPR = 
-	                dyn_cast<ConstPoolPointerRef>(CPP)) {
+    } else if (const ConstantPointerRef *CPR = 
+	                dyn_cast<ConstantPointerRef>(CPP)) {
       output_vbr((unsigned)1, Out);
       int Slot = Table.getValSlot((Value*)CPR->getValue());
       assert(Slot != -1 && "Global used but not available!!");
       output_vbr((unsigned)Slot, Out);
     } else {
-      assert(0 && "Unknown ConstPoolPointer Subclass!");
+      assert(0 && "Unknown ConstantPointer Subclass!");
     }
     break;
   }
 
   case Type::FloatTyID: {   // Floating point types...
-    float Tmp = (float)cast<ConstPoolFP>(CPV)->getValue();
+    float Tmp = (float)cast<ConstantFP>(CPV)->getValue();
     output_data(&Tmp, &Tmp+1, Out);
     break;
   }
   case Type::DoubleTyID: {
-    double Tmp = cast<ConstPoolFP>(CPV)->getValue();
+    double Tmp = cast<ConstantFP>(CPV)->getValue();
     output_data(&Tmp, &Tmp+1, Out);
     break;
   }
diff --git a/llvm/lib/Bytecode/Writer/Writer.cpp b/llvm/lib/Bytecode/Writer/Writer.cpp
index dd46d88bc9f..3091384722b 100644
--- a/llvm/lib/Bytecode/Writer/Writer.cpp
+++ b/llvm/lib/Bytecode/Writer/Writer.cpp
@@ -27,7 +27,7 @@
 #include "llvm/GlobalVariable.h"
 #include "llvm/Method.h"
 #include "llvm/BasicBlock.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
 #include "llvm/SymbolTable.h"
 #include "llvm/DerivedTypes.h"
 #include "Support/STLExtras.h"
@@ -81,7 +81,7 @@ void BytecodeWriter::outputConstants(bool isMethod) {
 
     unsigned NC = ValNo;              // Number of constants
     for (; NC < Plane.size() && 
-	   (isa<ConstPoolVal>(Plane[NC]) || 
+	   (isa<Constant>(Plane[NC]) || 
             isa<Type>(Plane[NC])); NC++) /*empty*/;
     NC -= ValNo;                      // Convert from index into count
     if (NC == 0) continue;            // Skip empty type planes...
@@ -100,9 +100,9 @@ void BytecodeWriter::outputConstants(bool isMethod) {
 
     for (unsigned i = ValNo; i < ValNo+NC; ++i) {
       const Value *V = Plane[i];
-      if (const ConstPoolVal *CPV = dyn_cast<ConstPoolVal>(V)) {
+      if (const Constant *CPV = dyn_cast<Constant>(V)) {
 	//cerr << "Serializing value: <" << V->getType() << ">: " 
-	//     << ((const ConstPoolVal*)V)->getStrValue() << ":" 
+	//     << ((const Constant*)V)->getStrValue() << ":" 
 	//     << Out.size() << "\n";
 	outputConstant(CPV);
       } else {
diff --git a/llvm/lib/Bytecode/Writer/WriterInternals.h b/llvm/lib/Bytecode/Writer/WriterInternals.h
index ff49c1d7fbb..8a929870f40 100644
--- a/llvm/lib/Bytecode/Writer/WriterInternals.h
+++ b/llvm/lib/Bytecode/Writer/WriterInternals.h
@@ -39,7 +39,7 @@ private :
 
   void outputModuleInfoBlock(const Module *C);
   void outputSymbolTable(const SymbolTable &ST);
-  bool outputConstant(const ConstPoolVal *CPV);
+  bool outputConstant(const Constant *CPV);
   void outputType(const Type *T);
 };