Rename ConstPoolPointerReference to ConstPoolPointerRef - My fingers get tired typing that much

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

include/llvm/ConstPoolVals.h

@@ -304,20 +304,20 @@ public:
 };
 
 
-// ConstPoolPointerReference - a constant pointer value that is initialized to
+// ConstPoolPointerRef - a constant pointer value that is initialized to
 // point to a global value, which lies at a constant, fixed address.
 //
-class ConstPoolPointerReference : public ConstPoolPointer {
+class ConstPoolPointerRef : public ConstPoolPointer {
   friend class Module;   // Modules maintain these references
-  ConstPoolPointerReference(const ConstPoolPointerReference &); // DNI!
+  ConstPoolPointerRef(const ConstPoolPointerRef &); // DNI!
 
 protected:
-  ConstPoolPointerReference(GlobalValue *GV);
+  ConstPoolPointerRef(GlobalValue *GV);
-  ~ConstPoolPointerReference() {}
+  ~ConstPoolPointerRef() {}
 
   virtual void destroyConstant() { destroyConstantImpl(); }
 public:
-  static ConstPoolPointerReference *get(GlobalValue *GV);
+  static ConstPoolPointerRef *get(GlobalValue *GV);
 
   virtual string getStrValue() const;
 
@@ -329,7 +329,7 @@ public:
   }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const ConstPoolPointerReference *) { return true; }
+  static inline bool classof(const ConstPoolPointerRef *) { return true; }
   static inline bool classof(const ConstPoolPointer *CPV) {
     return CPV->getNumOperands() == 1;
   }

include/llvm/Module.h

@@ -18,7 +18,7 @@
 class Method;
 class GlobalVariable;
 class GlobalValueRefMap;   // Used by ConstPoolVals.cpp
-class ConstPoolPointerReference;
+class ConstPoolPointerRef;
 
 class Module : public Value, public SymTabValue {
 public:
@@ -44,10 +44,10 @@ private:
   GlobalValueRefMap *GVRefMap;
 
   // Accessor for the underlying GlobalValRefMap... only through the
-  // ConstPoolPointerReference class...
+  // ConstPoolPointerRef class...
-  friend class ConstPoolPointerReference;
+  friend class ConstPoolPointerRef;
-  void mutateConstPoolPointerReference(GlobalValue *OldGV, GlobalValue *NewGV);
+  void mutateConstPoolPointerRef(GlobalValue *OldGV, GlobalValue *NewGV);
-  ConstPoolPointerReference *getConstPoolPointerReference(GlobalValue *GV);
+  ConstPoolPointerRef *getConstPoolPointerRef(GlobalValue *GV);
 
 public:
   Module();

lib/AsmParser/llvmAsmParser.y

@@ -61,7 +61,7 @@ static struct PerModuleInfo {
   // GlobalRefs - This maintains a mapping between <Type, ValID>'s and forward
   // references to global values.  Global values may be referenced before they
   // are defined, and if so, the temporary object that they represent is held
-  // here.  This is used for forward references of ConstPoolPointerReferences.
+  // here.  This is used for forward references of ConstPoolPointerRefs.
   //
   typedef map<pair<const PointerType *, ValID>, GlobalVariable*> GlobalRefsType;
   GlobalRefsType GlobalRefs;
@@ -102,11 +102,11 @@ static struct PerModuleInfo {
       I->first.second.destroy();  // Free string memory if neccesary
       
       // Loop over all of the uses of the GlobalValue.  The only thing they are
-      // allowed to be at this point is ConstPoolPointerReference's.
+      // allowed to be at this point is ConstPoolPointerRef's.
       assert(OldGV->use_size() == 1 && "Only one reference should exist!");
       while (!OldGV->use_empty()) {
-	User *U = OldGV->use_back();  // Must be a ConstPoolPointerReference...
+	User *U = OldGV->use_back();  // Must be a ConstPoolPointerRef...
-	ConstPoolPointerReference *CPPR = cast<ConstPoolPointerReference>(U);
+	ConstPoolPointerRef *CPPR = cast<ConstPoolPointerRef>(U);
 	assert(CPPR->getValue() == OldGV && "Something isn't happy");
 	
 	// Change the const pool reference to point to the real global variable
@@ -987,7 +987,7 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
     }
 
     GlobalValue *GV = cast<GlobalValue>(V);
-    $$ = ConstPoolPointerReference::get(GV);
+    $$ = ConstPoolPointerRef::get(GV);
     delete $1;            // Free the type handle
   }
 

lib/Bytecode/Reader/ConstantReader.cpp

@@ -277,7 +277,7 @@ bool BytecodeParser::parseConstPoolValue(const uchar *&Buf,
       V = ConstPoolPointerNull::get(PT);
       break;
 
-    case 1: {  // ConstPoolPointerReference value...
+    case 1: {  // ConstPoolPointerRef value...
       unsigned Slot;
       if (read_vbr(Buf, EndBuf, Slot)) return failure(true);
       BCR_TRACE(4, "CPPR: Type: '" << Ty << "'  slot: " << Slot << "\n");
@@ -308,7 +308,7 @@ bool BytecodeParser::parseConstPoolValue(const uchar *&Buf,
 	}
       }
       
-      V = ConstPoolPointerReference::get(GV);
+      V = ConstPoolPointerRef::get(GV);
       break;
     }
     default:

lib/Bytecode/Reader/Reader.cpp

@@ -217,7 +217,7 @@ bool BytecodeParser::ParseSymbolTable(const uchar *&Buf, const uchar *EndBuf,
 }
 
 // DeclareNewGlobalValue - Patch up forward references to global values in the
-// form of ConstPoolPointerReferences.
+// form of ConstPoolPointerRef.
 //
 void BytecodeParser::DeclareNewGlobalValue(GlobalValue *GV, unsigned Slot) {
   // Check to see if there is a forward reference to this global variable...
@@ -229,11 +229,11 @@ void BytecodeParser::DeclareNewGlobalValue(GlobalValue *GV, unsigned Slot) {
     BCR_TRACE(3, "Mutating CPPR Forward Ref!\n");
       
     // Loop over all of the uses of the GlobalValue.  The only thing they are
-    // allowed to be at this point is ConstPoolPointerReference's.
+    // allowed to be at this point is ConstPoolPointerRef's.
     assert(OldGV->use_size() == 1 && "Only one reference should exist!");
     while (!OldGV->use_empty()) {
-      User *U = OldGV->use_back();  // Must be a ConstPoolPointerReference...
+      User *U = OldGV->use_back();  // Must be a ConstPoolPointerRef...
-      ConstPoolPointerReference *CPPR = cast<ConstPoolPointerReference>(U);
+      ConstPoolPointerRef *CPPR = cast<ConstPoolPointerRef>(U);
       assert(CPPR->getValue() == OldGV && "Something isn't happy");
       
       BCR_TRACE(4, "Mutating Forward Ref!\n");

lib/Bytecode/Reader/ReaderInternals.h

@@ -112,7 +112,7 @@ private:
   bool getTypeSlot(const Type *Ty, unsigned &Slot);
 
   // DeclareNewGlobalValue - Patch up forward references to global values in the
-  // form of ConstPoolPointerReferences.
+  // form of ConstPoolPointerRefs.
   //
   void DeclareNewGlobalValue(GlobalValue *GV, unsigned Slot);
 

lib/Bytecode/Writer/ConstantWriter.cpp

@@ -145,8 +145,8 @@ bool BytecodeWriter::outputConstant(const ConstPoolVal *CPV) {
     const ConstPoolPointer *CPP = cast<const ConstPoolPointer>(CPV);
     if (isa<ConstPoolPointerNull>(CPP)) {
       output_vbr((unsigned)0, Out);
-    } else if (const ConstPoolPointerReference *CPR = 
+    } else if (const ConstPoolPointerRef *CPR = 
-	                dyn_cast<ConstPoolPointerReference>(CPP)) {
+	                dyn_cast<ConstPoolPointerRef>(CPP)) {
       output_vbr((unsigned)1, Out);
       int Slot = Table.getValSlot((Value*)CPR->getValue());
       assert(Slot != -1 && "Global used but not available!!");

lib/Linker/LinkModules.cpp

@@ -64,10 +64,9 @@ static Value *RemapOperand(const Value *In, map<const Value*, Value*> &LocalMap,
       Result = ConstPoolStruct::get(cast<StructType>(CPS->getType()), Operands);
     } else if (isa<ConstPoolPointerNull>(CPV)) {
       Result = CPV;
-    } else if (ConstPoolPointerReference *CPR = 
+    } else if (ConstPoolPointerRef *CPR = dyn_cast<ConstPoolPointerRef>(CPV)) {
-               dyn_cast<ConstPoolPointerReference>(CPV)) {
       Value *V = RemapOperand(CPR->getValue(), LocalMap, GlobalMap);
-      Result = ConstPoolPointerReference::get(cast<GlobalValue>(V));
+      Result = ConstPoolPointerRef::get(cast<GlobalValue>(V));
     } else {
       assert(0 && "Unknown type of derived type constant value!");
     }

lib/Transforms/Instrumentation/TraceValues.cpp

@@ -41,10 +41,10 @@ const char* const PRINTF = "printf";
 
 #undef USE_PTRREF
 #ifdef USE_PTRREF
-static inline ConstPoolPointerReference*
+static inline ConstPoolPointerRef*
 GetStringRef(Module* module, const char* str)
 {
-  static hash_map<string, ConstPoolPointerReference*> stringRefCache;
+  static hash_map<string, ConstPoolPointerRef*> stringRefCache;
   static Module* lastModule = NULL;
   
   if (lastModule != module)
@@ -53,14 +53,14 @@ GetStringRef(Module* module, const char* str)
       lastModule = module;
     }
   
-  ConstPoolPointerReference* result = stringRefCache[str];
+  ConstPoolPointerRef* result = stringRefCache[str];
   if (result == NULL)
     {
       ConstPoolArray* charArray = ConstPoolArray::get(str);
       GlobalVariable* stringVar =
         new GlobalVariable(charArray->getType(),/*isConst*/true,charArray,str);
       module->getGlobalList().push_back(stringVar);
-      result = ConstPoolPointerReference::get(stringVar);
+      result = ConstPoolPointerRef::get(stringVar);
       assert(result && "Failed to create reference to string constant");
       stringRefCache[str] = result;
     }
@@ -89,7 +89,7 @@ GetStringRef(Module* module, const char* str)
         new GlobalVariable(charArray->getType(),/*isConst*/true,charArray);
       module->getGlobalList().push_back(stringVar);
       result = stringVar;
-      // result = ConstPoolPointerReference::get(stringVar);
+      // result = ConstPoolPointerRef::get(stringVar);
       assert(result && "Failed to create reference to string constant");
       stringRefCache[str] = result;
     }

lib/Transforms/Utils/Linker.cpp

@@ -64,10 +64,9 @@ static Value *RemapOperand(const Value *In, map<const Value*, Value*> &LocalMap,
       Result = ConstPoolStruct::get(cast<StructType>(CPS->getType()), Operands);
     } else if (isa<ConstPoolPointerNull>(CPV)) {
       Result = CPV;
-    } else if (ConstPoolPointerReference *CPR = 
+    } else if (ConstPoolPointerRef *CPR = dyn_cast<ConstPoolPointerRef>(CPV)) {
-               dyn_cast<ConstPoolPointerReference>(CPV)) {
       Value *V = RemapOperand(CPR->getValue(), LocalMap, GlobalMap);
-      Result = ConstPoolPointerReference::get(cast<GlobalValue>(V));
+      Result = ConstPoolPointerRef::get(cast<GlobalValue>(V));
     } else {
       assert(0 && "Unknown type of derived type constant value!");
     }

lib/VMCore/ConstPoolVals.cpp

@@ -134,7 +134,7 @@ ConstPoolStruct::ConstPoolStruct(const StructType *T,
   }
 }
 
-ConstPoolPointerReference::ConstPoolPointerReference(GlobalValue *GV)
+ConstPoolPointerRef::ConstPoolPointerRef(GlobalValue *GV)
   : ConstPoolPointer(GV->getType()) {
   Operands.push_back(Use(GV, this));
 }
@@ -224,7 +224,7 @@ string ConstPoolPointerNull::getStrValue() const {
   return "null";
 }
 
-string ConstPoolPointerReference::getStrValue() const {
+string ConstPoolPointerRef::getStrValue() const {
   const GlobalValue *V = getValue();
   if (V->hasName()) return "%" + V->getName();
 
@@ -482,17 +482,17 @@ ConstPoolPointerNull *ConstPoolPointerNull::get(const PointerType *Ty) {
   return Result;
 }
 
-//---- ConstPoolPointerReference::get() implementation...
+//---- ConstPoolPointerRef::get() implementation...
 //
-ConstPoolPointerReference *ConstPoolPointerReference::get(GlobalValue *GV) {
+ConstPoolPointerRef *ConstPoolPointerRef::get(GlobalValue *GV) {
   assert(GV->getParent() && "Global Value must be attached to a module!");
 
   // The Module handles the pointer reference sharing...
-  return GV->getParent()->getConstPoolPointerReference(GV);
+  return GV->getParent()->getConstPoolPointerRef(GV);
 }
 
 
-void ConstPoolPointerReference::mutateReference(GlobalValue *NewGV) {
+void ConstPoolPointerRef::mutateReference(GlobalValue *NewGV) {
-  getValue()->getParent()->mutateConstPoolPointerReference(getValue(), NewGV);
+  getValue()->getParent()->mutateConstPoolPointerRef(getValue(), NewGV);
   Operands[0] = NewGV;
 }

lib/VMCore/Linker.cpp

@@ -64,10 +64,9 @@ static Value *RemapOperand(const Value *In, map<const Value*, Value*> &LocalMap,
       Result = ConstPoolStruct::get(cast<StructType>(CPS->getType()), Operands);
     } else if (isa<ConstPoolPointerNull>(CPV)) {
       Result = CPV;
-    } else if (ConstPoolPointerReference *CPR = 
+    } else if (ConstPoolPointerRef *CPR = dyn_cast<ConstPoolPointerRef>(CPV)) {
-               dyn_cast<ConstPoolPointerReference>(CPV)) {
       Value *V = RemapOperand(CPR->getValue(), LocalMap, GlobalMap);
-      Result = ConstPoolPointerReference::get(cast<GlobalValue>(V));
+      Result = ConstPoolPointerRef::get(cast<GlobalValue>(V));
     } else {
       assert(0 && "Unknown type of derived type constant value!");
     }

lib/VMCore/Module.cpp

@@ -23,7 +23,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*, ConstPoolPointerReference*>{
+struct GlobalValueRefMap : public map<GlobalValue*, ConstPoolPointerRef*>{
 };
 
 
@@ -62,7 +62,7 @@ void Module::dropAllReferences() {
   if (GVRefMap) {
     for (GlobalValueRefMap::iterator I = GVRefMap->begin(), E = GVRefMap->end();
 	 I != E; ++I) {
-      // Delete the ConstPoolPointerReference node...
+      // Delete the ConstPoolPointerRef node...
       I->second->destroyConstant();
     }
 
@@ -88,25 +88,24 @@ bool Module::reduceApply(bool (*Func)(const Method*)) const {
 }
 
 // Accessor for the underlying GlobalValRefMap...
-ConstPoolPointerReference *Module::getConstPoolPointerReference(GlobalValue *V){
+ConstPoolPointerRef *Module::getConstPoolPointerRef(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;
 
-  ConstPoolPointerReference *Ref = new ConstPoolPointerReference(V);
+  ConstPoolPointerRef *Ref = new ConstPoolPointerRef(V);
   GVRefMap->insert(make_pair(V, Ref));
 
   return Ref;
 }
 
-void Module::mutateConstPoolPointerReference(GlobalValue *OldGV, 
+void Module::mutateConstPoolPointerRef(GlobalValue *OldGV, GlobalValue *NewGV) {
-					     GlobalValue *NewGV) {
   GlobalValueRefMap::iterator I = GVRefMap->find(OldGV);
   assert(I != GVRefMap->end() && 
-	 "mutateConstPoolPointerReference; OldGV not in table!");
+	 "mutateConstPoolPointerRef; OldGV not in table!");
-  ConstPoolPointerReference *Ref = I->second;
+  ConstPoolPointerRef *Ref = I->second;
 
   // Remove the old entry...
   GVRefMap->erase(I);