diff --git a/lib/Bytecode/Reader/ConstantReader.cpp b/lib/Bytecode/Reader/ConstantReader.cpp
index ec841cfbbe1..baa367d52b8 100644
--- a/lib/Bytecode/Reader/ConstantReader.cpp
+++ b/lib/Bytecode/Reader/ConstantReader.cpp
@@ -13,86 +13,158 @@
 #include "llvm/ConstPoolVals.h"
 #include "llvm/DerivedTypes.h"
 #include "ReaderInternals.h"
+#include <algorithm>
 
-bool BytecodeParser::parseTypeConstant(const uchar *&Buf, const uchar *EndBuf,
-				       ConstPoolVal *&V) {
-  const Type *Val = 0;
 
+
+const Type *BytecodeParser::parseTypeConstant(const uchar *&Buf,
+					      const uchar *EndBuf) {
   unsigned PrimType;
-  if (read_vbr(Buf, EndBuf, PrimType)) return failure(true);
+  if (read_vbr(Buf, EndBuf, PrimType)) return failure<const Type*>(0);
 
-  if ((Val = Type::getPrimitiveType((Type::PrimitiveID)PrimType))) {
-    V = new ConstPoolType(Val);    // It's just a primitive ID.
-    return false;
-  }
+  const Type *Val = 0;
+  if ((Val = Type::getPrimitiveType((Type::PrimitiveID)PrimType)))
+    return Val;
   
   switch (PrimType) {
   case Type::MethodTyID: {
     unsigned Typ;
-    if (read_vbr(Buf, EndBuf, Typ)) return failure(true);
+    if (read_vbr(Buf, EndBuf, Typ)) return failure(Val);
     const Type *RetType = getType(Typ);
-    if (RetType == 0) return failure(true);
+    if (RetType == 0) return failure(Val);
 
     unsigned NumParams;
-    if (read_vbr(Buf, EndBuf, NumParams)) return failure(true);
+    if (read_vbr(Buf, EndBuf, NumParams)) return failure(Val);
 
-    MethodType::ParamTypes Params;
+    vector<const Type*> Params;
     while (NumParams--) {
-      if (read_vbr(Buf, EndBuf, Typ)) return failure(true);
+      if (read_vbr(Buf, EndBuf, Typ)) return failure(Val);
       const Type *Ty = getType(Typ);
-      if (Ty == 0) return failure(true);
+      if (Ty == 0) return failure(Val);
       Params.push_back(Ty);
     }
 
-    Val = MethodType::getMethodType(RetType, Params);
+    Val = MethodType::get(RetType, Params);
     break;
   }
   case Type::ArrayTyID: {
     unsigned ElTyp;
-    if (read_vbr(Buf, EndBuf, ElTyp)) return failure(true);
+    if (read_vbr(Buf, EndBuf, ElTyp)) return failure(Val);
     const Type *ElementType = getType(ElTyp);
-    if (ElementType == 0) return failure(true);
+    if (ElementType == 0) return failure(Val);
 
     int NumElements;
-    if (read_vbr(Buf, EndBuf, NumElements)) return failure(true);
-    Val = ArrayType::getArrayType(ElementType, NumElements);
+    if (read_vbr(Buf, EndBuf, NumElements)) return failure(Val);
+    Val = ArrayType::get(ElementType, NumElements);
     break;
   }
   case Type::StructTyID: {
     unsigned Typ;
-    StructType::ElementTypes Elements;
+    vector<const Type*> Elements;
 
-    if (read_vbr(Buf, EndBuf, Typ)) return failure(true);
+    if (read_vbr(Buf, EndBuf, Typ)) return failure(Val);
     while (Typ) {         // List is terminated by void/0 typeid
       const Type *Ty = getType(Typ);
-      if (Ty == 0) return failure(true);
+      if (Ty == 0) return failure(Val);
       Elements.push_back(Ty);
       
-      if (read_vbr(Buf, EndBuf, Typ)) return failure(true);
+      if (read_vbr(Buf, EndBuf, Typ)) return failure(Val);
     }
 
-    Val = StructType::getStructType(Elements);
+    Val = StructType::get(Elements);
     break;
   }
   case Type::PointerTyID: {
     unsigned ElTyp;
-    if (read_vbr(Buf, EndBuf, ElTyp)) return failure(true);
+    if (read_vbr(Buf, EndBuf, ElTyp)) return failure(Val);
     const Type *ElementType = getType(ElTyp);
-    if (ElementType == 0) return failure(true);
-    Val = PointerType::getPointerType(ElementType);
+    if (ElementType == 0) return failure(Val);
+    Val = PointerType::get(ElementType);
     break;
   }
 
   default:
     cerr << __FILE__ << ":" << __LINE__ << ": Don't know how to deserialize"
 	 << " primitive Type " << PrimType << "\n";
-    return failure(true);
+    return failure(Val);
   }
 
-  V = new ConstPoolType(Val);
+  return Val;
+}
+
+// refineAbstractType - The callback method is invoked when one of the
+// elements of TypeValues becomes more concrete...
+//
+void BytecodeParser::refineAbstractType(const DerivedType *OldType, 
+					const Type *NewType) {
+  TypeValuesListTy::iterator I = find(MethodTypeValues.begin(), 
+				      MethodTypeValues.end(), OldType);
+  if (I == MethodTypeValues.end()) {
+    I = find(ModuleTypeValues.begin(), ModuleTypeValues.end(), OldType);
+    assert(I != ModuleTypeValues.end() && 
+	   "Can't refine a type I don't know about!");
+  }
+
+  *I = NewType;  // Update to point to new, more refined type.
+}
+
+
+
+// parseTypeConstants - We have to use this wierd code to handle recursive
+// types.  We know that recursive types will only reference the current slab of
+// values in the type plane, but they can forward reference types before they
+// have been read.  For example, Type #0 might be '{ Ty#1 }' and Type #1 might
+// be 'Ty#0*'.  When reading Type #0, type number one doesn't exist.  To fix
+// this ugly problem, we pesimistically insert an opaque type for each type we
+// are about to read.  This means that forward references will resolve to
+// something and when we reread the type later, we can replace the opaque type
+// with a new resolved concrete type.
+//
+bool BytecodeParser::parseTypeConstants(const uchar *&Buf, const uchar *EndBuf,
+					TypeValuesListTy &Tab,
+					unsigned NumEntries) {
+  assert(Tab.size() == 0 && "I think table should always be empty here!"
+	 "This should simplify later code");
+
+  // Record the base, starting level that we will begin with.
+  unsigned BaseLevel = Tab.size();
+
+  // Insert a bunch of opaque types to be resolved later...
+  for (unsigned i = 0; i < NumEntries; i++)
+    Tab.push_back(PATypeHandle<Type>(OpaqueType::get(), this));
+
+  // Loop through reading all of the types.  Forward types will make use of the
+  // opaque types just inserted.
+  //
+  for (unsigned i = 0; i < NumEntries; i++) {
+    const Type *NewTy = parseTypeConstant(Buf, EndBuf);
+    if (NewTy == 0) return failure(true);
+    BCR_TRACE(4, "Read Type Constant: '" << NewTy << "'\n");
+
+    // Don't insertValue the new type... instead we want to replace the opaque
+    // type with the new concrete value...
+    //
+
+    // Refine the abstract type to the new type.  This causes all uses of the
+    // abstract type to use the newty.  This also will cause the opaque type
+    // to be deleted...
+    //
+    // FIXME when types are not const
+    const_cast<DerivedType*>(Tab[i+BaseLevel]->castDerivedTypeAsserting())->refineAbstractTypeTo(NewTy);
+
+    // This should have replace the old opaque type with the new type in the
+    // value table...
+    assert(Tab[i+BaseLevel] == NewTy && "refineAbstractType didn't work!");
+  }
+
+  BCR_TRACE(5, "Resulting types:\n");
+  for (unsigned i = 0; i < NumEntries; i++) {
+    BCR_TRACE(5, Tab[i+BaseLevel]->castTypeAsserting() << "\n");
+  }
   return false;
 }
 
+
 bool BytecodeParser::parseConstPoolValue(const uchar *&Buf, 
 					 const uchar *EndBuf,
 					 const Type *Ty, ConstPoolVal *&V) {
@@ -101,7 +173,7 @@ bool BytecodeParser::parseConstPoolValue(const uchar *&Buf,
     unsigned Val;
     if (read_vbr(Buf, EndBuf, Val)) return failure(true);
     if (Val != 0 && Val != 1) return failure(true);
-    V = new ConstPoolBool(Val == 1);
+    V = ConstPoolBool::get(Val == 1);
     break;
   }
 
@@ -111,14 +183,14 @@ bool BytecodeParser::parseConstPoolValue(const uchar *&Buf,
     unsigned Val;
     if (read_vbr(Buf, EndBuf, Val)) return failure(true);
     if (!ConstPoolUInt::isValueValidForType(Ty, Val)) return failure(true);
-    V = new ConstPoolUInt(Ty, Val);
+    V = ConstPoolUInt::get(Ty, Val);
     break;
   }
 
   case Type::ULongTyID: {
     uint64_t Val;
     if (read_vbr(Buf, EndBuf, Val)) return failure(true);
-    V = new ConstPoolUInt(Ty, Val);
+    V = ConstPoolUInt::get(Ty, Val);
     break;
   }
 
@@ -128,34 +200,34 @@ bool BytecodeParser::parseConstPoolValue(const uchar *&Buf,
     int Val;
     if (read_vbr(Buf, EndBuf, Val)) return failure(true);
     if (!ConstPoolSInt::isValueValidForType(Ty, Val)) return failure(true);
-    V = new ConstPoolSInt(Ty, Val);
+    V = ConstPoolSInt::get(Ty, Val);
     break;
   }
 
   case Type::LongTyID: {
     int64_t Val;
     if (read_vbr(Buf, EndBuf, Val)) return failure(true);
-    V = new ConstPoolSInt(Ty, Val);
+    V = ConstPoolSInt::get(Ty, Val);
     break;
   }
 
   case Type::FloatTyID: {
     float F;
     if (input_data(Buf, EndBuf, &F, &F+1)) return failure(true);
-    V = new ConstPoolFP(Ty, F);
+    V = ConstPoolFP::get(Ty, F);
     break;
   }
 
   case Type::DoubleTyID: {
     double Val;
     if (input_data(Buf, EndBuf, &Val, &Val+1)) return failure(true);
-    V = new ConstPoolFP(Ty, Val);
+    V = ConstPoolFP::get(Ty, Val);
     break;
   }
 
   case Type::TypeTyID:
-    if (parseTypeConstant(Buf, EndBuf, V)) return failure(true);
-    break;
+    assert(0 && "Type constants should be handled seperately!!!");
+    abort();
 
   case Type::ArrayTyID: {
     const ArrayType *AT = (const ArrayType*)Ty;
@@ -173,7 +245,7 @@ bool BytecodeParser::parseConstPoolValue(const uchar *&Buf,
       if (!V || !V->isConstant()) return failure(true);
       Elements.push_back((ConstPoolVal*)V);
     }
-    V = new ConstPoolArray(AT, Elements);
+    V = ConstPoolArray::get(AT, Elements);
     break;
   }
 
@@ -191,7 +263,7 @@ bool BytecodeParser::parseConstPoolValue(const uchar *&Buf,
       Elements.push_back((ConstPoolVal*)V);      
     }
 
-    V = new ConstPoolStruct(ST, Elements);
+    V = ConstPoolStruct::get(ST, Elements);
     break;
   }    
 
@@ -201,12 +273,13 @@ bool BytecodeParser::parseConstPoolValue(const uchar *&Buf,
 	 << Ty->getName() << "'\n";
     return failure(true);
   }
+
   return false;
 }
 
 bool BytecodeParser::ParseConstantPool(const uchar *&Buf, const uchar *EndBuf,
-				       SymTabValue::ConstantPoolType &CP, 
-				       ValueTable &Tab) {
+				       ValueTable &Tab, 
+				       TypeValuesListTy &TypeTab) {
   while (Buf < EndBuf) {
     unsigned NumEntries, Typ;
 
@@ -214,16 +287,17 @@ bool BytecodeParser::ParseConstantPool(const uchar *&Buf, const uchar *EndBuf,
         read_vbr(Buf, EndBuf, Typ)) return failure(true);
     const Type *Ty = getType(Typ);
     if (Ty == 0) return failure(true);
+    BCR_TRACE(3, "Type: '" << Ty << "'  NumEntries: " << NumEntries << "\n");
 
-    for (unsigned i = 0; i < NumEntries; i++) {
-      ConstPoolVal *I;
-      if (parseConstPoolValue(Buf, EndBuf, Ty, I)) return failure(true);
-#if 0
-      cerr << "  Read const value: <" << I->getType()->getName() 
-	   << ">: " << I->getStrValue() << endl;
-#endif
-      insertValue(I, Tab);
-      CP.insert(I);
+    if (Typ == Type::TypeTyID) {
+      if (parseTypeConstants(Buf, EndBuf, TypeTab, NumEntries)) return true;
+    } else {
+      for (unsigned i = 0; i < NumEntries; i++) {
+	ConstPoolVal *I;
+	if (parseConstPoolValue(Buf, EndBuf, Ty, I)) return failure(true);
+	BCR_TRACE(4, "Read Constant: '" << I << "'\n");
+	insertValue(I, Tab);
+      }
     }
   }
   
diff --git a/lib/Bytecode/Reader/InstructionReader.cpp b/lib/Bytecode/Reader/InstructionReader.cpp
index 6dedc288a40..ed5a54d392e 100644
--- a/lib/Bytecode/Reader/InstructionReader.cpp
+++ b/lib/Bytecode/Reader/InstructionReader.cpp
@@ -82,7 +82,7 @@ bool BytecodeParser::ParseRawInst(const uchar *&Buf, const uchar *EndBuf,
 
 #if 0
   cerr << "NO: "  << Result.NumOperands   << " opcode: " << Result.Opcode 
-       << " Ty: " << Result.Ty->getName() << " arg1: "   << Result.Arg1 
+       << " Ty: " << Result.Ty->getDescription() << " arg1: "   << Result.Arg1 
        << " arg2: "   << Result.Arg2 << " arg3: "   << Result.Arg3 << endl;
 #endif
   return false;
diff --git a/lib/Bytecode/Reader/Reader.cpp b/lib/Bytecode/Reader/Reader.cpp
index e7e2b488c93..540768383ac 100644
--- a/lib/Bytecode/Reader/Reader.cpp
+++ b/lib/Bytecode/Reader/Reader.cpp
@@ -29,9 +29,17 @@ bool BytecodeParser::getTypeSlot(const Type *Ty, unsigned &Slot) {
   if (Ty->isPrimitiveType()) {
     Slot = Ty->getPrimitiveID();
   } else {
-    TypeMapType::iterator I = TypeMap.find(Ty);
-    if (I == TypeMap.end()) return failure(true);   // Didn't find type!
-    Slot = I->second;
+    // Check the method level types first...
+    TypeValuesListTy::iterator I = find(MethodTypeValues.begin(),
+					MethodTypeValues.end(), Ty);
+    if (I != MethodTypeValues.end()) {
+      Slot = FirstDerivedTyID+ModuleTypeValues.size()+
+             (&*I - &MethodTypeValues[0]);
+    } else {
+      I = find(ModuleTypeValues.begin(), ModuleTypeValues.end(), Ty);
+      if (I == ModuleTypeValues.end()) return true;   // Didn't find type!
+      Slot = FirstDerivedTyID + (&*I - &ModuleTypeValues[0]);
+    }
   }
   //cerr << "getTypeSlot '" << Ty->getName() << "' = " << Slot << endl;
   return false;
@@ -46,32 +54,20 @@ const Type *BytecodeParser::getType(unsigned ID) {
   const Value *D = getValue(Type::TypeTy, ID, false);
   if (D == 0) return failure<const Type*>(0);
 
-  assert(D->getType() == Type::TypeTy);
-  return ((const ConstPoolType*)D->castConstantAsserting())->getValue();
+  return D->castTypeAsserting();
 }
 
-bool BytecodeParser::insertValue(Value *Def, vector<ValueList> &ValueTab) {
+bool BytecodeParser::insertValue(Value *Val, vector<ValueList> &ValueTab) {
   unsigned type;
-  if (getTypeSlot(Def->getType(), type)) return failure(true);
+  if (getTypeSlot(Val->getType(), type)) return failure(true);
+  assert(type != Type::TypeTyID && "Types should never be insertValue'd!");
  
   if (ValueTab.size() <= type)
     ValueTab.resize(type+1, ValueList());
 
   //cerr << "insertValue Values[" << type << "][" << ValueTab[type].size() 
-  //     << "] = " << Def << endl;
-
-  if (type == Type::TypeTyID && Def->isConstant()) {
-    const Type *Ty = ((const ConstPoolType*)Def)->getValue();
-    unsigned ValueOffset = FirstDerivedTyID;
-
-    if (&ValueTab == &Values)    // Take into consideration module level types
-      ValueOffset += ModuleValues[type].size();
-
-    if (TypeMap.find(Ty) == TypeMap.end())
-      TypeMap[Ty] = ValueTab[type].size()+ValueOffset;
-  }
-
-  ValueTab[type].push_back(Def);
+  //     << "] = " << Val << endl;
+  ValueTab[type].push_back(Val);
 
   return false;
 }
@@ -83,15 +79,27 @@ Value *BytecodeParser::getValue(const Type *Ty, unsigned oNum, bool Create) {
   if (getTypeSlot(Ty, type)) return failure<Value*>(0); // TODO: true
 
   if (type == Type::TypeTyID) {  // The 'type' plane has implicit values
+    assert(Create == false);
     const Type *T = Type::getPrimitiveType((Type::PrimitiveID)Num);
     if (T) return (Value*)T;   // Asked for a primitive type...
 
     // Otherwise, derived types need offset...
     Num -= FirstDerivedTyID;
+
+    // Is it a module level type?
+    if (Num < ModuleTypeValues.size())
+      return (Value*)(const Type*)ModuleTypeValues[Num];
+
+    // Nope, is it a method level type?
+    Num -= ModuleTypeValues.size();
+    if (Num < MethodTypeValues.size())
+      return (Value*)(const Type*)MethodTypeValues[Num];
+
+    return 0;
   }
 
-  if (ModuleValues.size() > type) {
-    if (ModuleValues[type].size() > Num)
+  if (type < ModuleValues.size()) {
+    if (Num < ModuleValues[type].size())
       return ModuleValues[type][Num];
     Num -= ModuleValues[type].size();
   }
@@ -153,22 +161,25 @@ bool BytecodeParser::ParseBasicBlock(const uchar *&Buf, const uchar *EndBuf,
   BB = new BasicBlock();
 
   while (Buf < EndBuf) {
-    Instruction *Def;
-    if (ParseInstruction(Buf, EndBuf, Def)) {
+    Instruction *Inst;
+    if (ParseInstruction(Buf, EndBuf, Inst)) {
       delete BB;
       return failure(true);
     }
 
-    if (Def == 0) { delete BB; return failure(true); }
-    if (insertValue(Def, Values)) { delete BB; return failure(true); }
+    if (Inst == 0) { delete BB; return failure(true); }
+    if (insertValue(Inst, Values)) { delete BB; return failure(true); }
 
-    BB->getInstList().push_back(Def);
+    BB->getInstList().push_back(Inst);
+
+    BCR_TRACE(4, Inst);
   }
 
   return false;
 }
 
-bool BytecodeParser::ParseSymbolTable(const uchar *&Buf, const uchar *EndBuf) {
+bool BytecodeParser::ParseSymbolTable(const uchar *&Buf, const uchar *EndBuf,
+				      SymbolTable *ST) {
   while (Buf < EndBuf) {
     // Symtab block header: [num entries][type id number]
     unsigned NumEntries, Typ;
@@ -177,6 +188,9 @@ bool BytecodeParser::ParseSymbolTable(const uchar *&Buf, const uchar *EndBuf) {
     const Type *Ty = getType(Typ);
     if (Ty == 0) return failure(true);
 
+    BCR_TRACE(3, "Plane Type: '" << Ty << "' with " << NumEntries <<
+	      " entries\n");
+
     for (unsigned i = 0; i < NumEntries; ++i) {
       // Symtab entry: [def slot #][name]
       unsigned slot;
@@ -186,8 +200,14 @@ bool BytecodeParser::ParseSymbolTable(const uchar *&Buf, const uchar *EndBuf) {
 	return failure(true);
 
       Value *D = getValue(Ty, slot, false); // Find mapping...
-      if (D == 0) return failure(true);
-      D->setName(Name);
+      if (D == 0) {
+	BCR_TRACE(3, "FAILED LOOKUP: Slot #" << slot << endl);
+	return failure(true);
+      }
+      BCR_TRACE(4, "Map: '" << Name << "' to #" << slot << ":" << D;
+		if (!D->isInstruction()) cerr << endl);
+
+      D->setName(Name, ST);
     }
   }
 
@@ -207,6 +227,8 @@ bool BytecodeParser::ParseMethod(const uchar *&Buf, const uchar *EndBuf,
   MethodSignatureList.pop_front();
   Method *M = new Method(MTy);
 
+  BCR_TRACE(2, "METHOD TYPE: " << MTy << endl);
+
   const MethodType::ParamTypes &Params = MTy->getParamTypes();
   for (MethodType::ParamTypes::const_iterator It = Params.begin();
        It != Params.end(); ++It) {
@@ -222,17 +244,17 @@ bool BytecodeParser::ParseMethod(const uchar *&Buf, const uchar *EndBuf,
 
     switch (Type) {
     case BytecodeFormat::ConstantPool:
-      if (ParseConstantPool(Buf, Buf+Size, M->getConstantPool(), Values)) {
-	cerr << "Error reading constant pool!\n";
+      BCR_TRACE(2, "BLOCK BytecodeFormat::ConstantPool: {\n");
+      if (ParseConstantPool(Buf, Buf+Size, Values, MethodTypeValues)) {
 	delete M; return failure(true);
       }
       break;
 
     case BytecodeFormat::BasicBlock: {
+      BCR_TRACE(2, "BLOCK BytecodeFormat::BasicBlock: {\n");
       BasicBlock *BB;
       if (ParseBasicBlock(Buf, Buf+Size, BB) ||
 	  insertValue(BB, Values)) {
-	cerr << "Error parsing basic block!\n";
 	delete M; return failure(true);                // Parse error... :(
       }
 
@@ -241,17 +263,20 @@ bool BytecodeParser::ParseMethod(const uchar *&Buf, const uchar *EndBuf,
     }
 
     case BytecodeFormat::SymbolTable:
-      if (ParseSymbolTable(Buf, Buf+Size)) {
-	cerr << "Error reading method symbol table!\n";
+      BCR_TRACE(2, "BLOCK BytecodeFormat::SymbolTable: {\n");
+      if (ParseSymbolTable(Buf, Buf+Size, M->getSymbolTableSure())) {
 	delete M; return failure(true);
       }
       break;
 
     default:
+      BCR_TRACE(2, "BLOCK <unknown>:ignored! {\n");
       Buf += Size;
       if (OldBuf > Buf) return failure(true); // Wrap around!
       break;
     }
+    BCR_TRACE(2, "} end block\n");
+
     if (align32(Buf, EndBuf)) {
       delete M;    // Malformed bc file, read past end of block.
       return failure(true);
@@ -298,15 +323,15 @@ bool BytecodeParser::ParseModuleGlobalInfo(const uchar *&Buf, const uchar *End,
   while (MethSignature != Type::VoidTyID) { // List is terminated by Void
     const Type *Ty = getType(MethSignature);
     if (!Ty || !Ty->isMethodType()) { 
-      cerr << "Method not meth type! ";
+      cerr << "Method not meth type!  Ty = " << Ty << endl;
       if (Ty) cerr << Ty->getName(); else cerr << MethSignature; cerr << endl; 
       return failure(true); 
     }
 
-    // When the ModuleGlobalInfo section is read, we load the type of each method
-    // and the 'ModuleValues' slot that it lands in.  We then load a placeholder
-    // into its slot to reserve it.  When the method is loaded, this placeholder
-    // is replaced.
+    // When the ModuleGlobalInfo section is read, we load the type of each 
+    // method and the 'ModuleValues' slot that it lands in.  We then load a 
+    // placeholder into its slot to reserve it.  When the method is loaded, this
+    // placeholder is replaced.
 
     // Insert the placeholder...
     Value *Def = new MethPHolder(Ty, 0);
@@ -323,6 +348,7 @@ bool BytecodeParser::ParseModuleGlobalInfo(const uchar *&Buf, const uchar *End,
     //
     MethodSignatureList.push_back(make_pair((const MethodType*)Ty, SlotNo));
     if (read_vbr(Buf, End, MethSignature)) return failure(true);
+    BCR_TRACE(2, "Method of type: " << Ty << endl);
   }
 
   if (align32(Buf, End)) return failure(true);
@@ -342,33 +368,36 @@ bool BytecodeParser::ParseModule(const uchar *Buf, const uchar *EndBuf,
   if (Type != BytecodeFormat::Module || Buf+Size != EndBuf)
     return failure(true);                      // Hrm, not a class?
 
+  BCR_TRACE(0, "BLOCK BytecodeFormat::Module: {\n");
   MethodSignatureList.clear();                 // Just in case...
 
   // Read into instance variables...
   if (read_vbr(Buf, EndBuf, FirstDerivedTyID)) return failure(true);
   if (align32(Buf, EndBuf)) return failure(true);
+  BCR_TRACE(1, "FirstDerivedTyID = " << FirstDerivedTyID << "\n");
 
   C = new Module();
-
   while (Buf < EndBuf) {
     const uchar *OldBuf = Buf;
     if (readBlock(Buf, EndBuf, Type, Size)) { delete C; return failure(true); }
     switch (Type) {
-    case BytecodeFormat::ModuleGlobalInfo:
-      if (ParseModuleGlobalInfo(Buf, Buf+Size, C)) {
-	cerr << "Error reading class global info section!\n";
+    case BytecodeFormat::ConstantPool:
+      BCR_TRACE(1, "BLOCK BytecodeFormat::ConstantPool: {\n");
+      if (ParseConstantPool(Buf, Buf+Size, ModuleValues, ModuleTypeValues)) {
 	delete C; return failure(true);
       }
       break;
 
-    case BytecodeFormat::ConstantPool:
-      if (ParseConstantPool(Buf, Buf+Size, C->getConstantPool(), ModuleValues)) {
-	cerr << "Error reading class constant pool!\n";
+    case BytecodeFormat::ModuleGlobalInfo:
+      BCR_TRACE(1, "BLOCK BytecodeFormat::ModuleGlobalInfo: {\n");
+
+      if (ParseModuleGlobalInfo(Buf, Buf+Size, C)) {
 	delete C; return failure(true);
       }
       break;
 
     case BytecodeFormat::Method: {
+      BCR_TRACE(1, "BLOCK BytecodeFormat::Method: {\n");
       if (ParseMethod(Buf, Buf+Size, C)) {
 	delete C; return failure(true);               // Error parsing method
       }
@@ -376,23 +405,26 @@ bool BytecodeParser::ParseModule(const uchar *Buf, const uchar *EndBuf,
     }
 
     case BytecodeFormat::SymbolTable:
-      if (ParseSymbolTable(Buf, Buf+Size)) {
-	cerr << "Error reading class symbol table!\n";
+      BCR_TRACE(1, "BLOCK BytecodeFormat::SymbolTable: {\n");
+      if (ParseSymbolTable(Buf, Buf+Size, C->getSymbolTableSure())) {
 	delete C; return failure(true);
       }
       break;
 
     default:
-      cerr << "Unknown class block: " << Type << endl;
+      cerr << "  Unknown class block: " << Type << endl;
       Buf += Size;
       if (OldBuf > Buf) return failure(true); // Wrap around!
       break;
     }
+    BCR_TRACE(1, "} end block\n");
     if (align32(Buf, EndBuf)) { delete C; return failure(true); }
   }
 
   if (!MethodSignatureList.empty())      // Expected more methods!
     return failure(true);
+
+  BCR_TRACE(0, "} end block\n\n");
   return false;
 }
 
diff --git a/lib/Bytecode/Reader/ReaderInternals.h b/lib/Bytecode/Reader/ReaderInternals.h
index 5721c7324d9..b94b791dcea 100644
--- a/lib/Bytecode/Reader/ReaderInternals.h
+++ b/lib/Bytecode/Reader/ReaderInternals.h
@@ -14,6 +14,16 @@
 #include <map>
 #include <utility>
 
+// Enable to trace to figure out what the heck is going on when parsing fails
+#define TRACE_LEVEL 0
+
+#if TRACE_LEVEL    // ByteCodeReading_TRACEer
+#include "llvm/Assembly/Writer.h"
+#define BCR_TRACE(n, X) if (n < TRACE_LEVEL) cerr << string(n*2, ' ') << X
+#else
+#define BCR_TRACE(n, X)
+#endif
+
 class BasicBlock;
 class Method;
 class Module;
@@ -32,7 +42,7 @@ struct RawInst {       // The raw fields out of the bytecode stream...
   };
 };
 
-class BytecodeParser {
+class BytecodeParser : public AbstractTypeUser {
 public:
   BytecodeParser() {
     // Define this in case we don't see a ModuleGlobalInfo block.
@@ -43,10 +53,15 @@ public:
 private:          // All of this data is transient across calls to ParseBytecode
   typedef vector<Value *> ValueList;
   typedef vector<ValueList> ValueTable;
-  typedef map<const Type *, unsigned> TypeMapType;
   ValueTable Values, LateResolveValues;
   ValueTable ModuleValues, LateResolveModuleValues;
-  TypeMapType TypeMap;
+
+  // TypesLoaded - This vector mirrors the Values[TypeTyID] plane.  It is used
+  // to deal with forward references to types.
+  //
+  typedef vector<PATypeHandle<Type> > TypeValuesListTy;
+  TypeValuesListTy ModuleTypeValues;
+  TypeValuesListTy MethodTypeValues;
 
   // Information read from the ModuleGlobalInfo section of the file...
   unsigned FirstDerivedTyID;
@@ -61,19 +76,19 @@ private:          // All of this data is transient across calls to ParseBytecode
 private:
   bool ParseModule            (const uchar * Buf, const uchar *End, Module *&);
   bool ParseModuleGlobalInfo  (const uchar *&Buf, const uchar *End, Module *);
-  bool ParseSymbolTable       (const uchar *&Buf, const uchar *End);
-  bool ParseMethod            (const uchar *&Buf, const uchar *End, Module *);
+  bool ParseSymbolTable   (const uchar *&Buf, const uchar *End, SymbolTable *);
+  bool ParseMethod        (const uchar *&Buf, const uchar *End, Module *);
   bool ParseBasicBlock    (const uchar *&Buf, const uchar *End, BasicBlock *&);
   bool ParseInstruction   (const uchar *&Buf, const uchar *End, Instruction *&);
   bool ParseRawInst       (const uchar *&Buf, const uchar *End, RawInst &);
 
   bool ParseConstantPool(const uchar *&Buf, const uchar *EndBuf,
-			 SymTabValue::ConstantPoolType &CP, ValueTable &Tab);
-
-
+			 ValueTable &Tab, TypeValuesListTy &TypeTab);
   bool parseConstPoolValue(const uchar *&Buf, const uchar *End,
 			   const Type *Ty, ConstPoolVal *&V);
-  bool parseTypeConstant  (const uchar *&Buf, const uchar *, ConstPoolVal *&);
+  bool parseTypeConstants(const uchar *&Buf, const uchar *EndBuf,
+			  TypeValuesListTy &Tab, unsigned NumEntries);
+  const Type *parseTypeConstant(const uchar *&Buf, const uchar *EndBuf);
 
   Value      *getValue(const Type *Ty, unsigned num, bool Create = true);
   const Type *getType(unsigned ID);
@@ -82,6 +97,12 @@ private:
   bool postResolveValues(ValueTable &ValTab);
 
   bool getTypeSlot(const Type *Ty, unsigned &Slot);
+
+
+  // refineAbstractType - The callback method is invoked when one of the
+  // elements of TypeValues becomes more concrete...
+  //
+  virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
 };
 
 template<class SuperType>