For PR411:

Take an incremental step towards type plane elimination. This change
separates types from values in the symbol tables by finally making use
of the TypeSymbolTable class. This yields more natural interfaces for
dealing with types and unclutters the SymbolTable class.


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

31 files changed, 241 insertions, 344 deletions

diff --git a/include/llvm/Bytecode/Format.h b/include/llvm/Bytecode/Format.h
index 562d8ff011..fc896b895d 100644
--- a/include/llvm/Bytecode/Format.h
+++ b/include/llvm/Bytecode/Format.h
@@ -35,7 +35,7 @@ public:
     ModuleBlockID          = 1,  ///< Module block that contains other blocks.
     FunctionBlockID        = 2,  ///< Function block identifier
     ConstantPoolBlockID    = 3,  ///< Constant pool identifier
-    SymbolTableBlockID     = 4,  ///< Symbol table identifier
+    ValueSymbolTableBlockID= 4,  ///< Value Symbol table identifier
     ModuleGlobalInfoBlockID= 5,  ///< Module global info identifier
     GlobalTypePlaneBlockID = 6,  ///< Global type plan identifier
     InstructionListBlockID = 7,  ///< All instructions in a function
@@ -46,8 +46,9 @@ public:
     /// instructions to be encoded more efficiently because VBR takes fewer
     /// bytes with smaller values.
     /// @brief Value Compaction Table Block
-    CompactionTableBlockID = 0x08,
+    CompactionTableBlockID = 8,
 
+    TypeSymbolTableBlockID = 9,  ///< Value Symbol table identifier
     // Not a block id, just used to count them
     NumberOfBlockIDs
   };
diff --git a/include/llvm/Function.h b/include/llvm/Function.h
index 7346c3b3e3..a31e7f4834 100644
--- a/include/llvm/Function.h
+++ b/include/llvm/Function.h
@@ -163,8 +163,8 @@ public:
 
   /// getSymbolTable() - Return the symbol table...
   ///
-  inline       SymbolTable &getSymbolTable()       { return *SymTab; }
-  inline const SymbolTable &getSymbolTable() const { return *SymTab; }
+  inline       SymbolTable &getValueSymbolTable()       { return *SymTab; }
+  inline const SymbolTable &getValueSymbolTable() const { return *SymTab; }
 
 
   //===--------------------------------------------------------------------===//
diff --git a/include/llvm/Module.h b/include/llvm/Module.h
index 42214af1ac..e5c157be95 100644
--- a/include/llvm/Module.h
+++ b/include/llvm/Module.h
@@ -25,6 +25,7 @@ class GlobalVariable;
 class GlobalValueRefMap;   // Used by ConstantVals.cpp
 class FunctionType;
 class SymbolTable;
+class TypeSymbolTable;
 
 template<> struct ilist_traits<Function>
   : public SymbolTableListTraits<Function, Module, Module> {
@@ -91,7 +92,8 @@ private:
   FunctionListType FunctionList; ///< The Functions in the module
   LibraryListType LibraryList;   ///< The Libraries needed by the module
   std::string GlobalScopeAsm;    ///< Inline Asm at global scope.
-  SymbolTable *SymTab;           ///< Symbol Table for the module
+  SymbolTable *ValSymTab;        ///< Symbol table for values
+  TypeSymbolTable *TypeSymTab;   ///< Symbol table for types
   std::string ModuleID;          ///< Human readable identifier for the module
   std::string TargetTriple;      ///< Platform target triple Module compiled on
   std::string DataLayout;        ///< Target data description
@@ -237,9 +239,13 @@ public:
   /// Get the Module's list of functions.
   FunctionListType       &getFunctionList()           { return FunctionList; }
   /// Get the symbol table of global variable and function identifiers
-  const SymbolTable      &getSymbolTable() const      { return *SymTab; }
+  const SymbolTable      &getValueSymbolTable() const { return *ValSymTab; }
   /// Get the Module's symbol table of global variable and function identifiers.
-  SymbolTable            &getSymbolTable()            { return *SymTab; }
+  SymbolTable            &getValueSymbolTable()       { return *ValSymTab; }
+  /// Get the symbol table of types
+  const TypeSymbolTable   &getTypeSymbolTable() const { return *TypeSymTab; }
+  /// Get the Module's symbol table of types
+  TypeSymbolTable         &getTypeSymbolTable()       { return *TypeSymTab; }
 
 /// @}
 /// @name Global Variable Iteration
diff --git a/include/llvm/SymbolTable.h b/include/llvm/SymbolTable.h
index 52a2c29ea7..6451f9c8e2 100644
--- a/include/llvm/SymbolTable.h
+++ b/include/llvm/SymbolTable.h
@@ -47,16 +47,6 @@ class SymbolTable : public AbstractTypeUser {
 /// @name Types
 /// @{
 public:
-
-  /// @brief A mapping of names to types.
-  typedef std::map<const std::string, const Type*> TypeMap;
-
-  /// @brief An iterator over the TypeMap.
-  typedef TypeMap::iterator type_iterator;
-
-  /// @brief A const_iterator over the TypeMap.
-  typedef TypeMap::const_iterator type_const_iterator;
-
   /// @brief A mapping of names to values.
   typedef std::map<const std::string, Value *> ValueMap;
 
@@ -96,20 +86,10 @@ public:
   /// @brief Lookup a named, typed value.
   Value *lookup(const Type *Ty, const std::string &name) const;
 
-  /// This method finds the type with the given \p name in the
-  /// type  map and returns it.
-  /// @returns null if the name is not found, otherwise the Type
-  /// associated with the \p name.
-  /// @brief Lookup a type by name.
-  Type* lookupType(const std::string& name) const;
-
   /// @returns true iff the type map and the type plane are both not
   /// empty.
   /// @brief Determine if the symbol table is empty
-  inline bool isEmpty() const { return pmap.empty() && tmap.empty(); }
-
-  /// @brief The number of name/type pairs is returned.
-  inline unsigned num_types() const { return unsigned(tmap.size()); }
+  inline bool isEmpty() const { return pmap.empty(); }
 
   /// Given a base name, return a string that is either equal to it or
   /// derived from it that does not already occur in the symbol table
@@ -178,20 +158,6 @@ public:
     return pmap.find(Typ)->second.end();
   }
 
-  /// Get an iterator to the start of the name/Type map.
-  inline type_iterator type_begin() { return tmap.begin(); }
-
-  /// @brief Get a const_iterator to the start of the name/Type map.
-  inline type_const_iterator type_begin() const { return tmap.begin(); }
-
-  /// Get an iterator to the end of the name/Type map. This serves as the
-  /// marker for end of iteration of the types.
-  inline type_iterator type_end() { return tmap.end(); }
-
-  /// Get a const-iterator to the end of the name/Type map. This serves
-  /// as the marker for end of iteration of the types.
-  inline type_const_iterator type_end() const { return tmap.end(); }
-
   /// This method returns a plane_const_iterator for iteration over
   /// the type planes starting at a specific plane, given by \p Ty.
   /// @brief Find a type plane.
@@ -219,16 +185,6 @@ public:
   /// @brief Strip the symbol table.
   bool strip();
 
-  /// Inserts a type into the symbol table with the specified name. There can be
-  /// a many-to-one mapping between names and types. This method allows a type
-  /// with an existing entry in the symbol table to get a new name.
-  /// @brief Insert a type under a new name.
-  void insert(const std::string &Name, const Type *Typ);
-
-  /// Remove a type at the specified position in the symbol table.
-  /// @returns the removed Type.
-  Type* remove(type_iterator TI);
-
 /// @}
 /// @name Mutators used by Value::setName and other LLVM internals.
 /// @{
@@ -286,15 +242,9 @@ private:
   /// @brief The mapping of types to names to values.
   PlaneMap pmap;
 
-  /// This is the type plane. It is separated from the pmap
-  /// because the elements of the map are name/Type pairs not
-  /// name/Value pairs and Type is not a Value.
-  TypeMap tmap;
-
   /// This value is used to retain the last unique value used
   /// by getUniqueName to generate unique names.
   mutable uint32_t LastUnique;
-
 /// @}
 
 };
diff --git a/include/llvm/TypeSymbolTable.h b/include/llvm/TypeSymbolTable.h
index c9f8d3107b..b95415377e 100644
--- a/include/llvm/TypeSymbolTable.h
+++ b/include/llvm/TypeSymbolTable.h
@@ -111,12 +111,12 @@ public:
   /// Remove a type at the specified position in the symbol table.
   /// @returns the removed Type.
   /// @returns the Type that was erased from the symbol table.
-  Type* erase(iterator TI);
+  Type* remove(iterator TI);
 
   /// Remove a specific Type from the symbol table. This isn't fast, linear
   /// search, O(n), algorithm.
   /// @returns true if the erase was successful (TI was found)
-  bool erase(Type* TI);
+  bool remove(Type* TI);
 
   /// Rename a type. This ain't fast, we have to linearly search for it first.
   /// @returns true if the rename was successful (type was found)
diff --git a/lib/AsmParser/llvmAsmParser.cpp.cvs b/lib/AsmParser/llvmAsmParser.cpp.cvs
index e78dc6fe12..ebbffeb7ab 100644
--- a/lib/AsmParser/llvmAsmParser.cpp.cvs
+++ b/lib/AsmParser/llvmAsmParser.cpp.cvs
@@ -639,8 +639,8 @@ static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
 
 static Value *lookupInSymbolTable(const Type *Ty, const std::string &Name) {
   SymbolTable &SymTab =
-    inFunctionScope() ? CurFun.CurrentFunction->getSymbolTable() :
-                        CurModule.CurrentModule->getSymbolTable();
+    inFunctionScope() ? CurFun.CurrentFunction->getValueSymbolTable() :
+                        CurModule.CurrentModule->getValueSymbolTable();
   return SymTab.lookup(Ty, Name);
 }
 
@@ -821,7 +821,7 @@ static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) {
   case ValID::NameVal:                  // Is it a named definition?
     Name = ID.Name;
     if (Value *N = CurFun.CurrentFunction->
-                   getSymbolTable().lookup(Type::LabelTy, Name))
+                   getValueSymbolTable().lookup(Type::LabelTy, Name))
       BB = cast<BasicBlock>(N);
     break;
   }
@@ -961,7 +961,7 @@ static void setValueName(Value *V, char *NameStr) {
     }
 
     assert(inFunctionScope() && "Must be in function scope!");
-    SymbolTable &ST = CurFun.CurrentFunction->getSymbolTable();
+    SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
     if (ST.lookup(V->getType(), Name)) {
       GenerateError("Redefinition of value '" + Name + "' of type '" +
                      V->getType()->getDescription() + "'!");
diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index 0059531518..192b560819 100644
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -311,8 +311,8 @@ static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
 
 static Value *lookupInSymbolTable(const Type *Ty, const std::string &Name) {
   SymbolTable &SymTab =
-    inFunctionScope() ? CurFun.CurrentFunction->getSymbolTable() :
-                        CurModule.CurrentModule->getSymbolTable();
+    inFunctionScope() ? CurFun.CurrentFunction->getValueSymbolTable() :
+                        CurModule.CurrentModule->getValueSymbolTable();
   return SymTab.lookup(Ty, Name);
 }
 
@@ -493,7 +493,7 @@ static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) {
   case ValID::NameVal:                  // Is it a named definition?
     Name = ID.Name;
     if (Value *N = CurFun.CurrentFunction->
-                   getSymbolTable().lookup(Type::LabelTy, Name))
+                   getValueSymbolTable().lookup(Type::LabelTy, Name))
       BB = cast<BasicBlock>(N);
     break;
   }
@@ -633,7 +633,7 @@ static void setValueName(Value *V, char *NameStr) {
     }
 
     assert(inFunctionScope() && "Must be in function scope!");
-    SymbolTable &ST = CurFun.CurrentFunction->getSymbolTable();
+    SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
     if (ST.lookup(V->getType(), Name)) {
       GenerateError("Redefinition of value '" + Name + "' of type '" +
                      V->getType()->getDescription() + "'!");
diff --git a/lib/AsmParser/llvmAsmParser.y.cvs b/lib/AsmParser/llvmAsmParser.y.cvs
index 0059531518..192b560819 100644
--- a/lib/AsmParser/llvmAsmParser.y.cvs
+++ b/lib/AsmParser/llvmAsmParser.y.cvs
@@ -311,8 +311,8 @@ static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
 
 static Value *lookupInSymbolTable(const Type *Ty, const std::string &Name) {
   SymbolTable &SymTab =
-    inFunctionScope() ? CurFun.CurrentFunction->getSymbolTable() :
-                        CurModule.CurrentModule->getSymbolTable();
+    inFunctionScope() ? CurFun.CurrentFunction->getValueSymbolTable() :
+                        CurModule.CurrentModule->getValueSymbolTable();
   return SymTab.lookup(Ty, Name);
 }
 
@@ -493,7 +493,7 @@ static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) {
   case ValID::NameVal:                  // Is it a named definition?
     Name = ID.Name;
     if (Value *N = CurFun.CurrentFunction->
-                   getSymbolTable().lookup(Type::LabelTy, Name))
+                   getValueSymbolTable().lookup(Type::LabelTy, Name))
       BB = cast<BasicBlock>(N);
     break;
   }
@@ -633,7 +633,7 @@ static void setValueName(Value *V, char *NameStr) {
     }
 
     assert(inFunctionScope() && "Must be in function scope!");
-    SymbolTable &ST = CurFun.CurrentFunction->getSymbolTable();
+    SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
     if (ST.lookup(V->getType(), Name)) {
       GenerateError("Redefinition of value '" + Name + "' of type '" +
                      V->getType()->getDescription() + "'!");
diff --git a/lib/Bytecode/Reader/Analyzer.cpp b/lib/Bytecode/Reader/Analyzer.cpp
index 078360249c..899a534272 100644
--- a/lib/Bytecode/Reader/Analyzer.cpp
+++ b/lib/Bytecode/Reader/Analyzer.cpp
@@ -96,11 +96,12 @@ public:
     bca.BlockSizes[BytecodeFormat::ModuleBlockID] = theSize;
     bca.BlockSizes[BytecodeFormat::FunctionBlockID] = 0;
     bca.BlockSizes[BytecodeFormat::ConstantPoolBlockID] = 0;
-    bca.BlockSizes[BytecodeFormat::SymbolTableBlockID] = 0;
+    bca.BlockSizes[BytecodeFormat::ValueSymbolTableBlockID] = 0;
     bca.BlockSizes[BytecodeFormat::ModuleGlobalInfoBlockID] = 0;
     bca.BlockSizes[BytecodeFormat::GlobalTypePlaneBlockID] = 0;
     bca.BlockSizes[BytecodeFormat::InstructionListBlockID] = 0;
     bca.BlockSizes[BytecodeFormat::CompactionTableBlockID] = 0;
+    bca.BlockSizes[BytecodeFormat::TypeSymbolTableBlockID] = 0;
   }
 
   virtual void handleFinish() {
@@ -636,8 +637,11 @@ void PrintBytecodeAnalysis(BytecodeAnalysis& bca, std::ostream& Out )
   print(Out, "Compaction Table Bytes",
         double(bca.BlockSizes[BytecodeFormat::CompactionTableBlockID]),
         double(bca.byteSize));
-  print(Out, "Symbol Table Bytes",
-        double(bca.BlockSizes[BytecodeFormat::SymbolTableBlockID]),
+  print(Out, "Value Symbol Table Bytes",
+        double(bca.BlockSizes[BytecodeFormat::ValueSymbolTableBlockID]),
+        double(bca.byteSize));
+  print(Out, "Type Symbol Table Bytes",
+        double(bca.BlockSizes[BytecodeFormat::TypeSymbolTableBlockID]),
         double(bca.byteSize));
   print(Out, "Alignment Bytes",
         double(bca.numAlignment), double(bca.byteSize));
diff --git a/lib/Bytecode/Reader/Reader.cpp b/lib/Bytecode/Reader/Reader.cpp
index afff24adb6..b1e4bf639c 100644
--- a/lib/Bytecode/Reader/Reader.cpp
+++ b/lib/Bytecode/Reader/Reader.cpp
@@ -24,6 +24,7 @@
 #include "llvm/InlineAsm.h"
 #include "llvm/Instructions.h"
 #include "llvm/SymbolTable.h"
+#include "llvm/TypeSymbolTable.h"
 #include "llvm/Bytecode/Format.h"
 #include "llvm/Config/alloca.h"
 #include "llvm/Support/GetElementPtrTypeIterator.h"
@@ -1023,13 +1024,27 @@ unsigned BytecodeReader::ParseInstructionList(Function* F) {
   return BlockNo;
 }
 
-/// Parse a symbol table. This works for both module level and function
+/// Parse a type symbol table.
+void BytecodeReader::ParseTypeSymbolTable(TypeSymbolTable *TST) {
+  // Type Symtab block header: [num entries]
+  unsigned NumEntries = read_vbr_uint();
+  for (unsigned i = 0; i < NumEntries; ++i) {
+    // Symtab entry: [type slot #][name]
+    unsigned slot = read_vbr_uint();
+    std::string Name = read_str();
+    const Type* T = getType(slot);
+    TST->insert(Name, T);
+  }
+}
+
+/// Parse a value symbol table. This works for both module level and function
 /// level symbol tables.  For function level symbol tables, the CurrentFunction
 /// parameter must be non-zero and the ST parameter must correspond to
 /// CurrentFunction's symbol table. For Module level symbol tables, the
 /// CurrentFunction argument must be zero.
-void BytecodeReader::ParseSymbolTable(Function *CurrentFunction,
-                                      SymbolTable *ST) {
+void BytecodeReader::ParseValueSymbolTable(Function *CurrentFunction,
+                                           SymbolTable *ST) {
+                                      
   if (Handler) Handler->handleSymbolTableBegin(CurrentFunction,ST);
 
   // Allow efficient basic block lookup by number.
@@ -1039,16 +1054,6 @@ void BytecodeReader::ParseSymbolTable(Function *CurrentFunction,
            E = CurrentFunction->end(); I != E; ++I)
       BBMap.push_back(I);
 
-  // Symtab block header: [num entries]
-  unsigned NumEntries = read_vbr_uint();
-  for (unsigned i = 0; i < NumEntries; ++i) {
-    // Symtab entry: [def slot #][name]
-    unsigned slot = read_vbr_uint();
-    std::string Name = read_str();
-    const Type* T = getType(slot);
-    ST->insert(Name, T);
-  }
-
   while (moreInBlock()) {
     // Symtab block header: [num entries][type id number]
     unsigned NumEntries = read_vbr_uint();
@@ -1683,8 +1688,12 @@ void BytecodeReader::ParseFunctionBody(Function* F) {
       break;
     }
 
-    case BytecodeFormat::SymbolTableBlockID:
-      ParseSymbolTable(F, &F->getSymbolTable());
+    case BytecodeFormat::ValueSymbolTableBlockID:
+      ParseValueSymbolTable(F, &F->getValueSymbolTable());
+      break;
+
+    case BytecodeFormat::TypeSymbolTableBlockID:
+      error("Functions don't have type symbol tables");
       break;
 
     default:
@@ -2084,8 +2093,12 @@ void BytecodeReader::ParseModule() {
       ParseFunctionLazily();
       break;
 
-    case BytecodeFormat::SymbolTableBlockID:
-      ParseSymbolTable(0, &TheModule->getSymbolTable());
+    case BytecodeFormat::ValueSymbolTableBlockID:
+      ParseValueSymbolTable(0, &TheModule->getValueSymbolTable());
+      break;
+
+    case BytecodeFormat::TypeSymbolTableBlockID:
+      ParseTypeSymbolTable(&TheModule->getTypeSymbolTable());
       break;
 
     default:
diff --git a/lib/Bytecode/Reader/Reader.h b/lib/Bytecode/Reader/Reader.h
index 1d2fe32af6..677c39f99f 100644
--- a/lib/Bytecode/Reader/Reader.h
+++ b/lib/Bytecode/Reader/Reader.h
@@ -29,6 +29,7 @@
 namespace llvm {
 
 class BytecodeHandler; ///< Forward declare the handler interface
+class TypeSymbolTable; ///< Forward declare
 
 /// This class defines the interface for parsing a buffer of bytecode. The
 /// parser itself takes no action except to call the various functions of
@@ -199,8 +200,11 @@ protected:
   /// @brief Parse the ModuleGlobalInfo block
   void ParseModuleGlobalInfo();
 
-  /// @brief Parse a symbol table
-  void ParseSymbolTable( Function* Func, SymbolTable *ST);
+  /// @brief Parse a value symbol table
+  void ParseTypeSymbolTable(TypeSymbolTable *ST);
+
+  /// @brief Parse a value symbol table
+  void ParseValueSymbolTable(Function* Func, SymbolTable *ST);
 
   /// @brief Parse functions lazily.
   void ParseFunctionLazily();
diff --git a/lib/Bytecode/Writer/SlotCalculator.cpp b/lib/Bytecode/Writer/SlotCalculator.cpp
index cf770c4bbc..fdf7174b85 100644
--- a/lib/Bytecode/Writer/SlotCalculator.cpp
+++ b/lib/Bytecode/Writer/SlotCalculator.cpp
@@ -22,6 +22,7 @@
 #include "llvm/Instructions.h"
 #include "llvm/Module.h"
 #include "llvm/SymbolTable.h"
+#include "llvm/TypeSymbolTable.h"
 #include "llvm/Type.h"
 #include "llvm/Analysis/ConstantsScanner.h"
 #include "llvm/ADT/PostOrderIterator.h"
@@ -189,13 +190,14 @@ void SlotCalculator::processModule() {
       }
       getOrCreateSlot(I->getType());
     }
-    processSymbolTableConstants(&F->getSymbolTable());
+    processSymbolTableConstants(&F->getValueSymbolTable());
   }
 
   // Insert constants that are named at module level into the slot pool so that
   // the module symbol table can refer to them...
   SC_DEBUG("Inserting SymbolTable values:\n");
-  processSymbolTable(&TheModule->getSymbolTable());
+  processTypeSymbolTable(&TheModule->getTypeSymbolTable());
+  processValueSymbolTable(&TheModule->getValueSymbolTable());
 
   // Now that we have collected together all of the information relevant to the
   // module, compactify the type table if it is particularly big and outputting
@@ -233,16 +235,18 @@ void SlotCalculator::processModule() {
   SC_DEBUG("end processModule!\n");
 }
 
+// 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(); 
+       TI != TE; ++TI )
+    getOrCreateSlot(TI->second);
+}
+
 // processSymbolTable - Insert all of the values in the specified symbol table
 // into the values table...
 //
-void SlotCalculator::processSymbolTable(const SymbolTable *ST) {
-  // Do the types first.
-  for (SymbolTable::type_const_iterator TI = ST->type_begin(),
-       TE = ST->type_end(); TI != TE; ++TI )
-    getOrCreateSlot(TI->second);
-
-  // Now do the values.
+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(),
@@ -251,11 +255,6 @@ void SlotCalculator::processSymbolTable(const SymbolTable *ST) {
 }
 
 void SlotCalculator::processSymbolTableConstants(const SymbolTable *ST) {
-  // Do the types first
-  for (SymbolTable::type_const_iterator TI = ST->type_begin(),
-       TE = ST->type_end(); TI != TE; ++TI )
-    getOrCreateSlot(TI->second);
-
   // Now do the constant values in all planes
   for (SymbolTable::plane_const_iterator PI = ST->plane_begin(),
        PE = ST->plane_end(); PI != PE; ++PI)
@@ -306,7 +305,7 @@ void SlotCalculator::incorporateFunction(const Function *F) {
     // symbol table references to constants not in the output.  Scan for these
     // constants now.
     //
-    processSymbolTableConstants(&F->getSymbolTable());
+    processSymbolTableConstants(&F->getValueSymbolTable());
   }
 
   SC_DEBUG("Inserting Instructions:\n");
@@ -468,13 +467,8 @@ void SlotCalculator::buildCompactionTable(const Function *F) {
         getOrCreateCompactionTableSlot(I->getOperand(op));
   }
 
-  // Do the types in the symbol table
-  const SymbolTable &ST = F->getSymbolTable();
-  for (SymbolTable::type_const_iterator TI = ST.type_begin(),
-       TE = ST.type_end(); TI != TE; ++TI)
-    getOrCreateCompactionTableSlot(TI->second);
-
   // Now do the constants and global values
+  const SymbolTable &ST = F->getValueSymbolTable();
   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(),
diff --git a/lib/Bytecode/Writer/SlotCalculator.h b/lib/Bytecode/Writer/SlotCalculator.h
index e88a88f726..405c0edbd3 100644
--- a/lib/Bytecode/Writer/SlotCalculator.h
+++ b/lib/Bytecode/Writer/SlotCalculator.h
@@ -30,6 +30,7 @@ class Type;
 class Module;
 class Function;
 class SymbolTable;
+class TypeSymbolTable;
 class ConstantArray;
 
 class SlotCalculator {
@@ -168,7 +169,8 @@ private:
   // processSymbolTable - Insert all of the values in the specified symbol table
   // into the values table...
   //
-  void processSymbolTable(const SymbolTable *ST);
+  void processTypeSymbolTable(const TypeSymbolTable *ST);
+  void processValueSymbolTable(const SymbolTable *ST);
   void processSymbolTableConstants(const SymbolTable *ST);
 
   void buildCompactionTable(const Function *F);
diff --git a/lib/Bytecode/Writer/Writer.cpp b/lib/Bytecode/Writer/Writer.cpp
index 58cc13a141..37e4abfae2 100644
--- a/lib/Bytecode/Writer/Writer.cpp
+++ b/lib/Bytecode/Writer/Writer.cpp
@@ -27,6 +27,7 @@
 #include "llvm/Instructions.h"
 #include "llvm/Module.h"
 #include "llvm/SymbolTable.h"
+#include "llvm/TypeSymbolTable.h"
 #include "llvm/Support/GetElementPtrTypeIterator.h"
 #include "llvm/Support/Compressor.h"
 #include "llvm/Support/MathExtras.h"
@@ -837,8 +838,11 @@ BytecodeWriter::BytecodeWriter(std::vector<unsigned char> &o, const Module *M)
   for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
     outputFunction(I);
 
-  // If needed, output the symbol table for the module...
-  outputSymbolTable(M->getSymbolTable());
+  // Output the symbole table for types
+  outputTypeSymbolTable(M->getTypeSymbolTable());
+
+  // Output the symbol table for values
+  outputValueSymbolTable(M->getValueSymbolTable());
 }
 
 void BytecodeWriter::outputTypes(unsigned TypeNum) {
@@ -1112,7 +1116,7 @@ void BytecodeWriter::outputFunction(const Function *F) {
   outputInstructions(F);
 
   // If needed, output the symbol table for the function...
-  outputSymbolTable(F->getSymbolTable());
+  outputValueSymbolTable(F->getValueSymbolTable());
 
   Table.purgeFunction();
 }
@@ -1187,24 +1191,33 @@ void BytecodeWriter::outputCompactionTable() {
   }
 }
 
-void BytecodeWriter::outputSymbolTable(const SymbolTable &MST) {
-  // Do not output the Bytecode block for an empty symbol table, it just wastes
+void BytecodeWriter::outputTypeSymbolTable(const TypeSymbolTable &TST) {
+  // Do not output the block for an empty symbol table, it just wastes
   // space!
-  if (MST.isEmpty()) return;
+  if (TST.empty()) return;
 
-  BytecodeBlock SymTabBlock(BytecodeFormat::SymbolTableBlockID, *this,
+  // Create a header for the symbol table
+  BytecodeBlock SymTabBlock(BytecodeFormat::TypeSymbolTableBlockID, *this,
                             true/*ElideIfEmpty*/);
-
   // Write the number of types
-  output_vbr(MST.num_types());
+  output_vbr(TST.size());
 
   // Write each of the types
-  for (SymbolTable::type_const_iterator TI = MST.type_begin(),
-       TE = MST.type_end(); TI != TE; ++TI) {
+  for (TypeSymbolTable::const_iterator TI = TST.begin(), TE = TST.end(); 
+       TI != TE; ++TI) {
     // Symtab entry:[def slot #][name]
     output_typeid((unsigned)Table.getSlot(TI->second));
     output(TI->first);
   }
+}
+
+void BytecodeWriter::outputValueSymbolTable(const SymbolTable &MST) {
+  // Do not output the Bytecode block for an empty symbol table, it just wastes
+  // space!
+  if (MST.isEmpty()) 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(),
diff --git a/lib/Bytecode/Writer/WriterInternals.h b/lib/Bytecode/Writer/WriterInternals.h
index f8c276e858..c518c01b94 100644
--- a/lib/Bytecode/Writer/WriterInternals.h
+++ b/lib/Bytecode/Writer/WriterInternals.h
@@ -25,6 +25,7 @@
 
 namespace llvm {
   class InlineAsm;
+  class TypeSymbolTable;
 
 class BytecodeWriter {
   std::vector<unsigned char> &Out;
@@ -64,7 +65,8 @@ private:
                                        unsigned Type) ;
 
   void outputModuleInfoBlock(const Module *C);
-  void outputSymbolTable(const SymbolTable &ST);
+  void outputTypeSymbolTable(const TypeSymbolTable &TST);
+  void outputValueSymbolTable(const SymbolTable &ST);
   void outputTypes(unsigned StartNo);
   void outputConstantsInPlane(const std::vector<const Value*> &Plane,
                               unsigned StartNo);
diff --git a/lib/Linker/LinkModules.cpp b/lib/Linker/LinkModules.cpp
index 9346c11824..4e298898b1 100644
--- a/lib/Linker/LinkModules.cpp
+++ b/lib/Linker/LinkModules.cpp
@@ -21,6 +21,7 @@
 #include "llvm/DerivedTypes.h"
 #include "llvm/Module.h"
 #include "llvm/SymbolTable.h"
+#include "llvm/TypeSymbolTable.h"
 #include "llvm/Instructions.h"
 #include "llvm/Assembly/Writer.h"
 #include "llvm/Support/Streams.h"
@@ -61,7 +62,7 @@ static std::string ToStr(const Type *Ty, const Module *M) {
 //  false - No errors.
 //
 static bool ResolveTypes(const Type *DestTy, const Type *SrcTy,
-                         SymbolTable *DestST, const std::string &Name) {
+                         TypeSymbolTable *DestST, const std::string &Name) {
   if (DestTy == SrcTy) return false;       // If already equal, noop
 
   // Does the type already exist in the module?
@@ -93,7 +94,8