Make getGlobalTableValue not use getTypeSlot, this speeds up the bc reader

by 5% on eon

llvm-svn: 15452

lib/Bytecode/Reader/Analyzer.cpp

@@ -218,14 +218,10 @@ public:
               << " is " << Ty->getDescription() << "\n"; 
   }
 
-  virtual void handleCompactionTableValue( 
+  virtual void handleCompactionTableValue(unsigned i, unsigned TypSlot,
-    unsigned i, 
+                                          unsigned ValSlot) { 
-    unsigned TypSlot,
-    unsigned ValSlot, 
-    const Type* Ty ) { 
     dump << "          Value: " << i << " TypSlot: " << TypSlot 
-         << " ValSlot:" << ValSlot << " is " << Ty->getDescription() 
+         << " ValSlot:" << ValSlot << "\n";
-         << "\n";
   }
 
   virtual void handleCompactionTableEnd() { 

lib/Bytecode/Reader/Reader.cpp

@@ -439,18 +439,26 @@ Value * BytecodeReader::getValue(unsigned type, unsigned oNum, bool Create) {
 /// This is just like getValue, but when a compaction table is in use, it 
 /// is ignored.  Also, no forward references or other fancy features are 
 /// supported.
-Value* BytecodeReader::getGlobalTableValue(const Type *Ty, unsigned SlotNo) {
+Value* BytecodeReader::getGlobalTableValue(unsigned TyID, unsigned SlotNo) {
-  // FIXME: getTypeSlot is inefficient!
-  unsigned TyID = getGlobalTableTypeSlot(Ty);
-  
-  if (TyID != Type::LabelTyID) {
   if (SlotNo == 0)
-      return Constant::getNullValue(Ty);
+    return Constant::getNullValue(getType(TyID));
-    --SlotNo;
+
+  if (!CompactionTypes.empty() && TyID >= Type::FirstDerivedTyID) {
+    TyID -= Type::FirstDerivedTyID;
+    if (TyID >= CompactionTypes.size())
+      error("Type ID out of range for compaction table!");
+    TyID = CompactionTypes[TyID].second;
   }
 
+  --SlotNo;
+
   if (TyID >= ModuleValues.size() || ModuleValues[TyID] == 0 ||
       SlotNo >= ModuleValues[TyID]->size()) {
+    if (TyID >= ModuleValues.size() || ModuleValues[TyID] == 0)
+      error("Corrupt compaction table entry!"
+            + utostr(TyID) + ", " + utostr(SlotNo) + ": " 
+            + utostr(ModuleValues.size()));
+    else 
       error("Corrupt compaction table entry!"
             + utostr(TyID) + ", " + utostr(SlotNo) + ": " 
             + utostr(ModuleValues.size()) + ", "
@@ -1096,30 +1104,27 @@ void BytecodeReader::ParseCompactionTable() {
     if (isTypeType) {
       ParseCompactionTypes(NumEntries);
     } else {
-      // Make sure we have enough room  for the plane 
+      // Make sure we have enough room for the plane.
       if (Ty >= CompactionValues.size())
         CompactionValues.resize(Ty+1);
 
-      // Make sure the plane is empty or we have some kind of error
+      // Make sure the plane is empty or we have some kind of error.
       if (!CompactionValues[Ty].empty())
         error("Compaction table plane contains multiple entries!");
 
-      // Notify handler about the plane
+      // Notify handler about the plane.
       if (Handler) Handler->handleCompactionTablePlane(Ty, NumEntries);
 
-      // Convert the type slot to a type
+      // Push the implicit zero.
-      const Type *Typ = getType(Ty);
+      CompactionValues[Ty].push_back(Constant::getNullValue(getType(Ty)));
-
-      // Push the implicit zero
-      CompactionValues[Ty].push_back(Constant::getNullValue(Typ));
 
       // Read in each of the entries, put them in the compaction table
       // and notify the handler that we have a new compaction table value.
       for (unsigned i = 0; i != NumEntries; ++i) {
         unsigned ValSlot = read_vbr_uint();
-        Value *V = getGlobalTableValue(Typ, ValSlot);
+        Value *V = getGlobalTableValue(Ty, ValSlot);
         CompactionValues[Ty].push_back(V);
-        if (Handler) Handler->handleCompactionTableValue(i, Ty, ValSlot, Typ);
+        if (Handler) Handler->handleCompactionTableValue(i, Ty, ValSlot);
       }
     }
   }

lib/Bytecode/Reader/Reader.h

@@ -395,8 +395,9 @@ private:
   /// @brief Get a value from its typeid and slot number
   Value* getValue(unsigned TypeID, unsigned num, bool Create = true);
 
-  /// @brief Get a value from its type and slot number, ignoring compaction tables.
+  /// @brief Get a value from its type and slot number, ignoring compaction
-  Value *getGlobalTableValue(const Type *Ty, unsigned SlotNo);
+  /// tables.
+  Value *getGlobalTableValue(unsigned TyID, unsigned SlotNo);
 
   /// @brief Get a basic block for current function
   BasicBlock *getBasicBlock(unsigned ID);