4 files changed, 35 insertions, 28 deletions

diff --git a/lib/Bytecode/Writer/SlotCalculator.cpp b/lib/Bytecode/Writer/SlotCalculator.cpp
index 9115ddb..197f206 100644
--- a/lib/Bytecode/Writer/SlotCalculator.cpp
+++ b/lib/Bytecode/Writer/SlotCalculator.cpp
@@ -21,9 +21,9 @@
 #include "llvm/InlineAsm.h"
 #include "llvm/Instructions.h"
 #include "llvm/Module.h"
-#include "llvm/SymbolTable.h"
 #include "llvm/TypeSymbolTable.h"
 #include "llvm/Type.h"
+#include "llvm/ValueSymbolTable.h"
 #include "llvm/Analysis/ConstantsScanner.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/STLExtras.h"
@@ -218,8 +218,8 @@ void SlotCalculator::processModule() {
 
 // processTypeSymbolTable - Insert all of the type sin the specified symbol
 // table.
-void SlotCalculator::processTypeSymbolTable(const TypeSymbolTable *ST) {
-  for (TypeSymbolTable::const_iterator TI = ST->begin(), TE = ST->end(); 
+void SlotCalculator::processTypeSymbolTable(const TypeSymbolTable *TST) {
+  for (TypeSymbolTable::const_iterator TI = TST->begin(), TE = TST->end(); 
        TI != TE; ++TI )
     getOrCreateSlot(TI->second);
 }
@@ -227,23 +227,18 @@ void SlotCalculator::processTypeSymbolTable(const TypeSymbolTable *ST) {
 // processSymbolTable - Insert all of the values in the specified symbol table
 // into the values table...
 //
-void SlotCalculator::processValueSymbolTable(const SymbolTable *ST) {
-  for (SymbolTable::plane_const_iterator PI = ST->plane_begin(),
-       PE = ST->plane_end(); PI != PE; ++PI)
-    for (SymbolTable::value_const_iterator VI = PI->second.begin(),
-           VE = PI->second.end(); VI != VE; ++VI)
-      getOrCreateSlot(VI->second);
+void SlotCalculator::processValueSymbolTable(const ValueSymbolTable *VST) {
+  for (ValueSymbolTable::const_iterator VI = VST->begin(), VE = VST->end(); 
+       VI != VE; ++VI)
+    getOrCreateSlot(VI->second);
 }
 
-void SlotCalculator::processSymbolTableConstants(const SymbolTable *ST) {
+void SlotCalculator::processSymbolTableConstants(const ValueSymbolTable *VST) {
   // Now do the constant values in all planes
-  for (SymbolTable::plane_const_iterator PI = ST->plane_begin(),
-       PE = ST->plane_end(); PI != PE; ++PI)
-    for (SymbolTable::value_const_iterator VI = PI->second.begin(),
-           VE = PI->second.end(); VI != VE; ++VI)
-      if (isa<Constant>(VI->second) &&
-          !isa<GlobalValue>(VI->second))
-        getOrCreateSlot(VI->second);
+  for (ValueSymbolTable::const_iterator VI = VST->begin(), VE = VST->end(); 
+       VI != VE; ++VI)
+    if (isa<Constant>(VI->second) && !isa<GlobalValue>(VI->second))
+      getOrCreateSlot(VI->second);
 }
 
 
diff --git a/lib/Bytecode/Writer/SlotCalculator.h b/lib/Bytecode/Writer/SlotCalculator.h
index 8200992..6cddb30 100644
--- a/lib/Bytecode/Writer/SlotCalculator.h
+++ b/lib/Bytecode/Writer/SlotCalculator.h
@@ -31,6 +31,7 @@ class Module;
 class Function;
 class SymbolTable;
 class TypeSymbolTable;
+class ValueSymbolTable;
 class ConstantArray;
 
 class SlotCalculator {
@@ -130,8 +131,8 @@ private:
   // into the values table...
   //
   void processTypeSymbolTable(const TypeSymbolTable *ST);
-  void processValueSymbolTable(const SymbolTable *ST);
-  void processSymbolTableConstants(const SymbolTable *ST);
+  void processValueSymbolTable(const ValueSymbolTable *ST);
+  void processSymbolTableConstants(const ValueSymbolTable *ST);
 
   // insertPrimitives - helper for constructors to insert primitive types.
   void insertPrimitives();
diff --git a/lib/Bytecode/Writer/Writer.cpp b/lib/Bytecode/Writer/Writer.cpp
index 0d4ccbd..a2e8fe5 100644
--- a/lib/Bytecode/Writer/Writer.cpp
+++ b/lib/Bytecode/Writer/Writer.cpp
@@ -26,8 +26,8 @@
 #include "llvm/InlineAsm.h"
 #include "llvm/Instructions.h"
 #include "llvm/Module.h"
-#include "llvm/SymbolTable.h"
 #include "llvm/TypeSymbolTable.h"
+#include "llvm/ValueSymbolTable.h"
 #include "llvm/Support/GetElementPtrTypeIterator.h"
 #include "llvm/Support/Compressor.h"
 #include "llvm/Support/MathExtras.h"
@@ -1144,21 +1144,31 @@ void BytecodeWriter::outputTypeSymbolTable(const TypeSymbolTable &TST) {
   }
 }
 
-void BytecodeWriter::outputValueSymbolTable(const SymbolTable &MST) {
+void BytecodeWriter::outputValueSymbolTable(const ValueSymbolTable &VST) {
   // Do not output the Bytecode block for an empty symbol table, it just wastes
   // space!
-  if (MST.isEmpty()) return;
+  if (VST.empty()) return;
 
   BytecodeBlock SymTabBlock(BytecodeFormat::ValueSymbolTableBlockID, *this,
                             true/*ElideIfEmpty*/);
 
-  // Now do each of the type planes in order.
-  for (SymbolTable::plane_const_iterator PI = MST.plane_begin(),
-       PE = MST.plane_end(); PI != PE;  ++PI) {
-    SymbolTable::value_const_iterator I = MST.value_begin(PI->first);
-    SymbolTable::value_const_iterator End = MST.value_end(PI->first);
+  // Organize the symbol table by type
+  typedef std::pair<std::string, const Value*> PlaneMapEntry;
+  typedef std::vector<PlaneMapEntry> PlaneMapVector;
+  typedef std::map<const Type*, PlaneMapVector > PlaneMap;
+  PlaneMap Planes;
+  for (ValueSymbolTable::const_iterator SI = VST.begin(), SE = VST.end();
+       SI != SE; ++SI) 
+    Planes[SI->second->getType()].push_back(
+        std::make_pair(SI->first,SI->second));
+
+  for (PlaneMap::const_iterator PI = Planes.begin(), PE = Planes.end();
+       PI != PE; ++PI) {
     int Slot;
 
+    PlaneMapVector::const_iterator I = PI->second.begin(); 
+    PlaneMapVector::const_iterator End = PI->second.end(); 
+
     if (I == End) continue;  // Don't mess with an absent type...
 
     // Write the number of values in this plane
diff --git a/lib/Bytecode/Writer/WriterInternals.h b/lib/Bytecode/Writer/WriterInternals.h
index c518c01..f3c59f3 100644
--- a/lib/Bytecode/Writer/WriterInternals.h
+++ b/lib/Bytecode/Writer/WriterInternals.h
@@ -26,6 +26,7 @@
 namespace llvm {
   class InlineAsm;
   class TypeSymbolTable;
+  class ValueSymbolTable;
 
 class BytecodeWriter {
   std::vector<unsigned char> &Out;
@@ -66,7 +67,7 @@ private:
 
   void outputModuleInfoBlock(const Module *C);
   void outputTypeSymbolTable(const TypeSymbolTable &TST);
-  void outputValueSymbolTable(const SymbolTable &ST);
+  void outputValueSymbolTable(const ValueSymbolTable &ST);
   void outputTypes(unsigned StartNo);
   void outputConstantsInPlane(const std::vector<const Value*> &Plane,
                               unsigned StartNo);