[llvm-commits] CVS: llvm/lib/Bytecode/Reader/Reader.cpp Reader.h

[Chris Lattner]

Changes in directory llvm/lib/Bytecode/Reader:

Reader.cpp updated: 1.148 -> 1.149
Reader.h updated: 1.19 -> 1.20
---
Log message:

Remove a dead field, make the map go to integer type ID to hash better and
avoid a getType.


---
Diffs of the changes:  (+12 -17)

Index: llvm/lib/Bytecode/Reader/Reader.cpp
diff -u llvm/lib/Bytecode/Reader/Reader.cpp:1.148 llvm/lib/Bytecode/Reader/Reader.cpp:1.149
--- llvm/lib/Bytecode/Reader/Reader.cpp:1.148	Wed Dec  8 22:53:17 2004
+++ llvm/lib/Bytecode/Reader/Reader.cpp	Thu Dec  9 00:19:44 2004
@@ -35,14 +35,11 @@
 /// @brief A class for maintaining the slot number definition
 /// as a placeholder for the actual definition for forward constants defs.
 class ConstantPlaceHolder : public ConstantExpr {
-  unsigned ID;
   ConstantPlaceHolder();                       // DO NOT IMPLEMENT
   void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT
 public:
-  ConstantPlaceHolder(const Type *Ty, unsigned id) 
-    : ConstantExpr(Instruction::UserOp1, Constant::getNullValue(Ty), Ty),
-    ID(id) {}
-  unsigned getID() { return ID; }
+  ConstantPlaceHolder(const Type *Ty) 
+    : ConstantExpr(Instruction::UserOp1, Constant::getNullValue(Ty), Ty) {}
 };
 
 }
@@ -494,8 +491,7 @@
       error("Value for slot " + utostr(Slot) + 
             " is expected to be a constant!");
 
-  const Type *Ty = getType(TypeSlot);
-  std::pair<const Type*, unsigned> Key(Ty, Slot);
+  std::pair<unsigned, unsigned> Key(TypeSlot, Slot);
   ConstantRefsType::iterator I = ConstantFwdRefs.lower_bound(Key);
 
   if (I != ConstantFwdRefs.end() && I->first == Key) {
@@ -503,7 +499,7 @@
   } else {
     // Create a placeholder for the constant reference and
     // keep track of the fact that we have a forward ref to recycle it
-    Constant *C = new ConstantPlaceHolder(Ty, Slot);
+    Constant *C = new ConstantPlaceHolder(getType(TypeSlot));
     
     // Keep track of the fact that we have a forward ref to recycle it
     ConstantFwdRefs.insert(I, std::make_pair(Key, C));
@@ -1477,9 +1473,10 @@
 /// referenced constants in the ConstantFwdRefs map. It uses the 
 /// replaceAllUsesWith method of Value class to substitute the placeholder
 /// instance with the actual instance.
-void BytecodeReader::ResolveReferencesToConstant(Constant *NewV, unsigned Slot){
+void BytecodeReader::ResolveReferencesToConstant(Constant *NewV, unsigned Typ,
+                                                 unsigned Slot) {
   ConstantRefsType::iterator I =
-    ConstantFwdRefs.find(std::make_pair(NewV->getType(), Slot));
+    ConstantFwdRefs.find(std::make_pair(Typ, Slot));
   if (I == ConstantFwdRefs.end()) return;   // Never forward referenced?
 
   Value *PH = I->second;   // Get the placeholder...
@@ -1518,7 +1515,7 @@
     // Create the constant, inserting it as needed.
     Constant *C = ConstantArray::get(ATy, Elements);
     unsigned Slot = insertValue(C, Typ, Tab);
-    ResolveReferencesToConstant(C, Slot);
+    ResolveReferencesToConstant(C, Typ, Slot);
     if (Handler) Handler->handleConstantString(cast<ConstantArray>(C));
   }
 }
@@ -1564,7 +1561,7 @@
         if (&Tab != &ModuleValues && Typ < ModuleValues.size() &&
             ModuleValues[Typ])
           Slot += ModuleValues[Typ]->size();
-        ResolveReferencesToConstant(C, Slot);
+        ResolveReferencesToConstant(C, Typ, Slot);
       }
     }
   }
@@ -1572,14 +1569,12 @@
   // After we have finished parsing the constant pool, we had better not have
   // any dangling references left.
   if (!ConstantFwdRefs.empty()) {
-  typedef std::map<std::pair<const Type*,unsigned>, Constant*> ConstantRefsType;
     ConstantRefsType::const_iterator I = ConstantFwdRefs.begin();
-    const Type* missingType = I->first.first;
     Constant* missingConst = I->second;
     error(utostr(ConstantFwdRefs.size()) + 
           " unresolved constant reference exist. First one is '" + 
           missingConst->getName() + "' of type '" + 
-          missingType->getDescription() + "'.");
+          missingConst->getType()->getDescription() + "'.");
   }
 
   checkPastBlockEnd("Constant Pool");


Index: llvm/lib/Bytecode/Reader/Reader.h
diff -u llvm/lib/Bytecode/Reader/Reader.h:1.19 llvm/lib/Bytecode/Reader/Reader.h:1.20
--- llvm/lib/Bytecode/Reader/Reader.h:1.19	Mon Nov 15 15:55:06 2004
+++ llvm/lib/Bytecode/Reader/Reader.h	Thu Dec  9 00:19:44 2004
@@ -102,7 +102,7 @@
   /// This map is needed so that forward references to constants can be looked 
   /// up by Type and slot number when resolving those references.
   /// @brief A mapping of a Type/slot pair to a Constant*.
-  typedef std::map<std::pair<const Type*,unsigned>, Constant*> ConstantRefsType;
+  typedef std::map<std::pair<unsigned,unsigned>, Constant*> ConstantRefsType;
 
   /// For lazy read-in of functions, we need to save the location in the
   /// data stream where the function is located. This structure provides that
@@ -453,7 +453,7 @@
 
   /// @brief Resolve all references to the placeholder (if any) for the 
   /// given constant.
-  void ResolveReferencesToConstant(Constant *C, unsigned Slot);
+  void ResolveReferencesToConstant(Constant *C, unsigned Typ, unsigned Slot);
 
   /// @brief Release our memory.
   void freeState() {