X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FAsmWriter.cpp;h=b109cb006eb6cfc9453b4d251a42514d9b0a3a10;hb=5527c0b6d1bda2c63212f91837792663469fd764;hp=570d5b3d4f30454eff3a7f3d87674b92b12487ca;hpb=d1cd3285601d4accf370779ac520c1e494a08b87;p=oota-llvm.git

diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp
index 570d5b3d4f3..b109cb006eb 100644
--- a/lib/VMCore/AsmWriter.cpp
+++ b/lib/VMCore/AsmWriter.cpp
@@ -21,10 +21,7 @@
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Instruction.h"
-#include "llvm/iMemory.h"
-#include "llvm/iTerminators.h"
-#include "llvm/iPHINode.h"
-#include "llvm/iOther.h"
+#include "llvm/Instructions.h"
 #include "llvm/Module.h"
 #include "llvm/SymbolTable.h"
 #include "llvm/Assembly/Writer.h"
@@ -34,7 +31,7 @@
 #include <algorithm>
 using namespace llvm;
 
-namespace {
+namespace llvm {
 
 /// This class provides computation of slot numbers for LLVM Assembly writing.
 /// @brief LLVM Assembly Writing Slot Computation.
@@ -46,16 +43,24 @@ public:
 
   /// @brief A mapping of Values to slot numbers
   typedef std::map<const Value*, unsigned> ValueMap;
+  typedef std::map<const Type*, unsigned> TypeMap;
 
   /// @brief A plane with next slot number and ValueMap
-  struct Plane { 
+  struct ValuePlane { 
     unsigned next_slot;        ///< The next slot number to use
     ValueMap map;              ///< The map of Value* -> unsigned
-    Plane() { next_slot = 0; } ///< Make sure we start at 0
+    ValuePlane() { next_slot = 0; } ///< Make sure we start at 0
+  };
+
+  struct TypePlane {
+    unsigned next_slot;
+    TypeMap map;
+    TypePlane() { next_slot = 0; }
+    void clear() { map.clear(); next_slot = 0; }
   };
 
   /// @brief The map of planes by Type
-  typedef std::map<const Type*, Plane> TypedPlanes;
+  typedef std::map<const Type*, ValuePlane> TypedPlanes;
 
 /// @}
 /// @name Constructors
@@ -75,9 +80,11 @@ public:
   /// plane.  Its an error to ask for something not in the SlotMachine.
   /// Its an error to ask for a Type*
   int getSlot(const Value *V);
+  int getSlot(const Type*Ty);
 
   /// Determine if a Value has a slot or not
   bool hasSlot(const Value* V);
+  bool hasSlot(const Type* Ty);
 
 /// @}
 /// @name Mutators
@@ -85,7 +92,10 @@ public:
 public:
   /// If you'd like to deal with a function instead of just a module, use 
   /// this method to get its data into the SlotMachine.
-  void incorporateFunction(const Function *F) { TheFunction = F; }
+  void incorporateFunction(const Function *F) { 
+    TheFunction = F;  
+    FunctionProcessed = false;
+  }
 
   /// After calling incorporateFunction, use this method to remove the 
   /// most recently incorporated function from the SlotMachine. This 
@@ -103,11 +113,13 @@ private:
   /// been inserted already, they get inserted, otherwise they are ignored.
   /// Either way, the slot number for the Value* is returned.
   unsigned createSlot(const Value *V);
+  unsigned createSlot(const Type* Ty);
 
   /// Insert a value into the value table. Return the slot number
   /// that it now occupies.  BadThings(TM) will happen if you insert a
   /// Value that's already been inserted. 
   unsigned insertValue( const Value *V );
+  unsigned insertValue( const Type* Ty);
 
   /// Add all of the module level global variables (and their initializers)
   /// and function declarations, but not the contents of those functions.
@@ -129,18 +141,21 @@ public:
 
   /// @brief The function for which we are holding slot numbers
   const Function* TheFunction;
+  bool FunctionProcessed;
 
   /// @brief The TypePlanes map for the module level data
   TypedPlanes mMap;
+  TypePlane mTypes;
 
   /// @brief The TypePlanes map for the function level data
   TypedPlanes fMap;
+  TypePlane fTypes;
 
 /// @}
 
 };
 
-}
+}  // end namespace llvm
 
 static RegisterPass<PrintModulePass>
 X("printm", "Print module to stderr",PassInfo::Analysis|PassInfo::Optimization);
@@ -152,6 +167,11 @@ static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
                                  std::map<const Type *, std::string> &TypeTable,
                                    SlotMachine *Machine);
 
+static void WriteAsOperandInternal(std::ostream &Out, const Type *T, 
+                                   bool PrintName,
+                                 std::map<const Type *, std::string> &TypeTable,
+                                   SlotMachine *Machine);
+
 static const Module *getModuleFromVal(const Value *V) {
   if (const Argument *MA = dyn_cast<Argument>(V))
     return MA->getParent() ? MA->getParent()->getParent() : 0;
@@ -166,7 +186,6 @@ static const Module *getModuleFromVal(const Value *V) {
 }
 
 static SlotMachine *createSlotMachine(const Value *V) {
-  assert(!isa<Type>(V) && "Can't create an SC for a type!");
   if (const Argument *FA = dyn_cast<Argument>(V)) {
     return new SlotMachine(FA->getParent());
   } else if (const Instruction *I = dyn_cast<Instruction>(V)) {
@@ -262,7 +281,7 @@ static void calcTypeName(const Type *Ty,
 
   TypeStack.push_back(Ty);    // Recursive case: Add us to the stack..
   
-  switch (Ty->getPrimitiveID()) {
+  switch (Ty->getTypeID()) {
   case Type::FunctionTyID: {
     const FunctionType *FTy = cast<FunctionType>(Ty);
     calcTypeName(FTy->getReturnType(), TypeStack, TypeNames, Result);
@@ -304,6 +323,13 @@ static void calcTypeName(const Type *Ty,
     Result += "]";
     break;
   }
+  case Type::PackedTyID: {
+    const PackedType *PTy = cast<PackedType>(Ty);
+    Result += "<" + utostr(PTy->getNumElements()) + " x ";
+    calcTypeName(PTy->getElementType(), TypeStack, TypeNames, Result);
+    Result += ">";
+    break;
+  }
   case Type::OpaqueTyID:
     Result += "opaque";
     break;
@@ -363,6 +389,7 @@ std::ostream &llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty,
   }
 }
 
+/// @brief Internal constant writer. 
 static void WriteConstantInt(std::ostream &Out, const Constant *CV, 
                              bool PrintName,
                              std::map<const Type *, std::string> &TypeTable,
@@ -472,12 +499,25 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV,
     }
 
     Out << " }";
+  } else if (const ConstantPacked *CP = dyn_cast<ConstantPacked>(CV)) {
+      const Type *ETy = CP->getType()->getElementType();
+      assert(CP->getNumOperands() > 0 && 
+             "Number of operands for a PackedConst must be > 0");
+      Out << '<';
+      Out << ' ';
+      printTypeInt(Out, ETy, TypeTable);
+      WriteAsOperandInternal(Out, CP->getOperand(0),
+                             PrintName, TypeTable, Machine);
+      for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) {
+          Out << ", ";
+          printTypeInt(Out, ETy, TypeTable);
+          WriteAsOperandInternal(Out, CP->getOperand(i), PrintName,
+                                 TypeTable, Machine);
+      }
+      Out << " >";
   } else if (isa<ConstantPointerNull>(CV)) {
     Out << "null";
 
-  } else if (const ConstantPointerRef *PR = dyn_cast<ConstantPointerRef>(CV)) {
-    WriteAsOperandInternal(Out, PR->getValue(), true, TypeTable, Machine);
-
   } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
     Out << CE->getOpcodeName() << " (";
     
@@ -509,21 +549,17 @@ static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
                                   std::map<const Type*, std::string> &TypeTable,
                                    SlotMachine *Machine) {
   Out << ' ';
-  if (PrintName && V->hasName()) {
+  if ((PrintName || isa<GlobalValue>(V)) && V->hasName())
     Out << getLLVMName(V->getName());
-  } else {
-    if (const Constant *CV = dyn_cast<Constant>(V)) {
+  else {
+    const Constant *CV = dyn_cast<Constant>(V);
+    if (CV && !isa<GlobalValue>(CV))
       WriteConstantInt(Out, CV, PrintName, TypeTable, Machine);
-    } else {
+    else {
       int Slot;
       if (Machine) {
         Slot = Machine->getSlot(V);
       } else {
-        if (const Type *Ty = dyn_cast<Type>(V)) {
-          Out << Ty->getDescription();
-          return;
-        }
-
         Machine = createSlotMachine(V);
         if (Machine == 0) 
           Slot = Machine->getSlot(V);
@@ -539,7 +575,6 @@ static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
   }
 }
 
-
 /// WriteAsOperand - Write the name of the specified value out to the specified
 /// ostream.  This can be useful when you just want to print int %reg126, not
 /// the whole instruction that generated it.
@@ -556,17 +591,56 @@ std::ostream &llvm::WriteAsOperand(std::ostream &Out, const Value *V,
   if (PrintType)
     printTypeInt(Out, V->getType(), TypeNames);
   
-  if (const Type *Ty = dyn_cast<Type> (V))
-    printTypeInt(Out, Ty, TypeNames);
-
   WriteAsOperandInternal(Out, V, PrintName, TypeNames, 0);
   return Out;
 }
 
+/// WriteAsOperandInternal - Write the name of the specified value out to 
+/// the specified ostream.  This can be useful when you just want to print 
+/// int %reg126, not the whole instruction that generated it.
+///
+static void WriteAsOperandInternal(std::ostream &Out, const Type *T, 
+                                   bool PrintName,
+                                  std::map<const Type*, std::string> &TypeTable,
+                                   SlotMachine *Machine) {
+  Out << ' ';
+  int Slot;
+  if (Machine) {
+    Slot = Machine->getSlot(T);
+    if (Slot != -1)
+      Out << '%' << Slot;
+    else
+      Out << "<badref>";
+  } else {
+    Out << T->getDescription();
+  }
+}
+
+/// WriteAsOperand - Write the name of the specified value out to the specified
+/// ostream.  This can be useful when you just want to print int %reg126, not
+/// the whole instruction that generated it.
+///
+std::ostream &llvm::WriteAsOperand(std::ostream &Out, const Type *Ty,
+                                   bool PrintType, bool PrintName, 
+                                   const Module *Context) {
+  std::map<const Type *, std::string> TypeNames;
+  assert(Context != 0 && "Can't write types as operand without module context");
+
+  fillTypeNameTable(Context, TypeNames);
+
+  // if (PrintType)
+    // printTypeInt(Out, V->getType(), TypeNames);
+  
+  printTypeInt(Out, Ty, TypeNames);
+
+  WriteAsOperandInternal(Out, Ty, PrintName, TypeNames, 0);
+  return Out;
+}
+
 namespace llvm {
 
 class AssemblyWriter {
-  std::ostream *Out;
+  std::ostream &Out;
   SlotMachine &Machine;
   const Module *TheModule;
   std::map<const Type *, std::string> TypeNames;
@@ -574,7 +648,7 @@ class AssemblyWriter {
 public:
   inline AssemblyWriter(std::ostream &o, SlotMachine &Mac, const Module *M,
                         AssemblyAnnotationWriter *AAW)
-    : Out(&o), Machine(Mac), TheModule(M), AnnotationWriter(AAW) {
+    : Out(o), Machine(Mac), TheModule(M), AnnotationWriter(AAW) {
 
     // If the module has a symbol table, take all global types and stuff their
     // names into the TypeNames map.
@@ -593,7 +667,6 @@ public:
   void writeOperand(const Value *Op, bool PrintType, bool PrintName = true);
 
   const Module* getModule() { return TheModule; }
-  void setStream(std::ostream &os) { Out = &os; }
 
 private :
   void printModule(const Module *M);
@@ -609,7 +682,7 @@ private :
   // symbolic version of a type name.
   //
   std::ostream &printType(const Type *Ty) {
-    return printTypeInt(*Out, Ty, TypeNames);
+    return printTypeInt(Out, Ty, TypeNames);
   }
 
   // printTypeAtLeastOneLevel - Print out one level of the possibly complex type
@@ -632,57 +705,77 @@ std::ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) {
     for (FunctionType::param_iterator I = FTy->param_begin(),
            E = FTy->param_end(); I != E; ++I) {
       if (I != FTy->param_begin())
-        *Out << ", ";
+        Out << ", ";
       printType(*I);
     }
     if (FTy->isVarArg()) {
-      if (FTy->getNumParams()) *Out << ", ";
-      *Out << "...";
+      if (FTy->getNumParams()) Out << ", ";
+      Out << "...";
     }
-    *Out << ')';
+    Out << ')';
   } else if (const StructType *STy = dyn_cast<StructType>(Ty)) {
-    *Out << "{ ";
+    Out << "{ ";
     for (StructType::element_iterator I = STy->element_begin(),
            E = STy->element_end(); I != E; ++I) {
       if (I != STy->element_begin())
-        *Out << ", ";
+        Out << ", ";
       printType(*I);
     }
-    *Out << " }";
+    Out << " }";
   } else if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) {
     printType(PTy->getElementType()) << '*';
   } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
-    *Out << '[' << ATy->getNumElements() << " x ";
+    Out << '[' << ATy->getNumElements() << " x ";
     printType(ATy->getElementType()) << ']';
-  } else if (const OpaqueType *OTy = dyn_cast<OpaqueType>(Ty)) {
-    *Out << "opaque";
+  } else if (const PackedType *PTy = dyn_cast<PackedType>(Ty)) {
+    Out << '<' << PTy->getNumElements() << " x ";
+    printType(PTy->getElementType()) << '>';
+  }
+  else if (const OpaqueType *OTy = dyn_cast<OpaqueType>(Ty)) {
+    Out << "opaque";
   } else {
     if (!Ty->isPrimitiveType())
-      *Out << "<unknown derived type>";
+      Out << "<unknown derived type>";
     printType(Ty);
   }
-  return *Out;
+  return Out;
 }
 
 
 void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType, 
                                   bool PrintName) {
-  if (PrintType) { *Out << ' '; printType(Operand->getType()); }
-  WriteAsOperandInternal(*Out, Operand, PrintName, TypeNames, &Machine);
+  if (PrintType) { Out << ' '; printType(Operand->getType()); }
+  WriteAsOperandInternal(Out, Operand, PrintName, TypeNames, &Machine);
 }
 
 
 void AssemblyWriter::printModule(const Module *M) {
   switch (M->getEndianness()) {
-  case Module::LittleEndian: *Out << "target endian = little\n"; break;
-  case Module::BigEndian:    *Out << "target endian = big\n";    break;
+  case Module::LittleEndian: Out << "target endian = little\n"; break;
+  case Module::BigEndian:    Out << "target endian = big\n";    break;
   case Module::AnyEndianness: break;
   }
   switch (M->getPointerSize()) {
-  case Module::Pointer32:    *Out << "target pointersize = 32\n"; break;
-  case Module::Pointer64:    *Out << "target pointersize = 64\n"; break;
+  case Module::Pointer32:    Out << "target pointersize = 32\n"; break;
+  case Module::Pointer64:    Out << "target pointersize = 64\n"; break;
   case Module::AnyPointerSize: break;
   }
+  if (!M->getTargetTriple().empty())
+    Out << "target triple = \"" << M->getTargetTriple() << "\"\n";
+  
+  // Loop over the dependent libraries and emit them
+  Module::lib_iterator LI= M->lib_begin();
+  Module::lib_iterator LE= M->lib_end();
+  if (LI != LE) {
+    Out << "deplibs = [\n";
+    while ( LI != LE ) {
+      Out << "\"" << *LI << "\"";
+      ++LI;
+      if ( LI != LE )
+        Out << ",\n";
+    }
+    Out << " ]\n";
+  }
   
   // Loop over the symbol table, emitting all named constants...
   printSymbolTable(M->getSymbolTable());
@@ -690,7 +783,7 @@ void AssemblyWriter::printModule(const Module *M) {
   for (Module::const_giterator I = M->gbegin(), E = M->gend(); I != E; ++I)
     printGlobal(I);
 
-  *Out << "\nimplementation   ; Functions:\n";
+  Out << "\nimplementation   ; Functions:\n";
   
   // Output all of the functions...
   for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
@@ -698,27 +791,30 @@ void AssemblyWriter::printModule(const Module *M) {
 }
 
 void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
-  if (GV->hasName()) *Out << getLLVMName(GV->getName()) << " = ";
+  if (GV->hasName()) Out << getLLVMName(GV->getName()) << " = ";
 
   if (!GV->hasInitializer()) 
-    *Out << "external ";
+    Out << "external ";
   else
     switch (GV->getLinkage()) {
-    case GlobalValue::InternalLinkage:  *Out << "internal "; break;
-    case GlobalValue::LinkOnceLinkage:  *Out << "linkonce "; break;
-    case GlobalValue::WeakLinkage:      *Out << "weak "; break;
-    case GlobalValue::AppendingLinkage: *Out << "appending "; break;
+    case GlobalValue::InternalLinkage:  Out << "internal "; break;
+    case GlobalValue::LinkOnceLinkage:  Out << "linkonce "; break;
+    case GlobalValue::WeakLinkage:      Out << "weak "; break;
+    case GlobalValue::AppendingLinkage: Out << "appending "; break;
     case GlobalValue::ExternalLinkage: break;
     }
 
-  *Out << (GV->isConstant() ? "constant " : "global ");
+  Out << (GV->isConstant() ? "constant " : "global ");
   printType(GV->getType()->getElementType());
 
-  if (GV->hasInitializer())
-    writeOperand(GV->getInitializer(), false, false);
+  if (GV->hasInitializer()) {
+    Constant* C = cast<Constant>(GV->getInitializer());
+    assert(C &&  "GlobalVar initializer isn't constant?");
+    writeOperand(GV->getInitializer(), false, isa<GlobalValue>(C));
+  }
 
   printInfoComment(*GV);
-  *Out << "\n";
+  Out << "\n";
 }
 
 
@@ -729,7 +825,7 @@ void AssemblyWriter::printSymbolTable(const SymbolTable &ST) {
   // Print the types.
   for (SymbolTable::type_const_iterator TI = ST.type_begin();
        TI != ST.type_end(); ++TI ) {
-    *Out << "\t" << getLLVMName(TI->first) << " = type ";
+    Out << "\t" << getLLVMName(TI->first) << " = type ";
 
     // Make sure we print out at least one level of the type structure, so
     // that we do not get %FILE = type %FILE
@@ -744,8 +840,9 @@ void AssemblyWriter::printSymbolTable(const SymbolTable &ST) {
     SymbolTable::value_const_iterator VE = ST.value_end(PI->first);
 
     for (; VI != VE; ++VI) {
-      const Value *V = VI->second;
-      if (const Constant *CPV = dyn_cast<Constant>(V)) {
+      const Value* V = VI->second;
+      const Constant *CPV = dyn_cast<Constant>(V) ;
+      if (CPV && !isa<GlobalValue>(V)) {
         printConstant(CPV);
       }
     }
@@ -760,40 +857,40 @@ void AssemblyWriter::printConstant(const Constant *CPV) {
   if (!CPV->hasName()) return;
 
   // Print out name...
-  *Out << "\t" << getLLVMName(CPV->getName()) << " =";
+  Out << "\t" << getLLVMName(CPV->getName()) << " =";
 
   // Write the value out now...
   writeOperand(CPV, true, false);
 
   printInfoComment(*CPV);
-  *Out << "\n";
+  Out << "\n";
 }
 
 /// printFunction - Print all aspects of a function.
 ///
 void AssemblyWriter::printFunction(const Function *F) {
   // Print out the return type and name...
-  *Out << "\n";
+  Out << "\n";
 
-  if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, *Out);
+  if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
 
   if (F->isExternal())
-    *Out << "declare ";
+    Out << "declare ";
   else
     switch (F->getLinkage()) {
-    case GlobalValue::InternalLinkage:  *Out << "internal "; break;
-    case GlobalValue::LinkOnceLinkage:  *Out << "linkonce "; break;
-    case GlobalValue::WeakLinkage:      *Out << "weak "; break;
-    case GlobalValue::AppendingLinkage: *Out << "appending "; break;
+    case GlobalValue::InternalLinkage:  Out << "internal "; break;
+    case GlobalValue::LinkOnceLinkage:  Out << "linkonce "; break;
+    case GlobalValue::WeakLinkage:      Out << "weak "; break;
+    case GlobalValue::AppendingLinkage: Out << "appending "; break;
     case GlobalValue::ExternalLinkage: break;
     }
 
   printType(F->getReturnType()) << ' ';
   if (!F->getName().empty())
-    *Out << getLLVMName(F->getName());
+    Out << getLLVMName(F->getName());
   else
-    *Out << "\"\"";
-  *Out << '(';
+    Out << "\"\"";
+  Out << '(';
   Machine.incorporateFunction(F);
 
   // Loop over the arguments, printing them...
@@ -804,21 +901,21 @@ void AssemblyWriter::printFunction(const Function *F) {
 
   // Finish printing arguments...
   if (FT->isVarArg()) {
-    if (FT->getNumParams()) *Out << ", ";
-    *Out << "...";  // Output varargs portion of signature!
+    if (FT->getNumParams()) Out << ", ";
+    Out << "...";  // Output varargs portion of signature!
   }
-  *Out << ')';
+  Out << ')';
 
   if (F->isExternal()) {
-    *Out << "\n";
+    Out << "\n";
   } else {
-    *Out << " {";
+    Out << " {";
   
     // Output all of its basic blocks... for the function
     for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I)
       printBasicBlock(I);
 
-    *Out << "}\n";
+    Out << "}\n";
   }
 
   Machine.purgeFunction();
@@ -829,60 +926,60 @@ void AssemblyWriter::printFunction(const Function *F) {
 ///
 void AssemblyWriter::printArgument(const Argument *Arg) {
   // Insert commas as we go... the first arg doesn't get a comma
-  if (Arg != &Arg->getParent()->afront()) *Out << ", ";
+  if (Arg != &Arg->getParent()->afront()) Out << ", ";
 
   // Output type...
   printType(Arg->getType());
   
   // Output name, if available...
   if (Arg->hasName())
-    *Out << ' ' << getLLVMName(Arg->getName());
+    Out << ' ' << getLLVMName(Arg->getName());
 }
 
 /// printBasicBlock - This member is called for each basic block in a method.
 ///
 void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
   if (BB->hasName()) {              // Print out the label if it exists...
-    *Out << "\n" << BB->getName() << ':';
+    Out << "\n" << BB->getName() << ':';
   } else if (!BB->use_empty()) {      // Don't print block # of no uses...
-    *Out << "\n; <label>:";
+    Out << "\n; <label>:";
     int Slot = Machine.getSlot(BB);
     if (Slot != -1)
-      *Out << Slot;
+      Out << Slot;
     else
-      *Out << "<badref>";
+      Out << "<badref>";
   }
 
   if (BB->getParent() == 0)
-    *Out << "\t\t; Error: Block without parent!";
+    Out << "\t\t; Error: Block without parent!";
   else {
     if (BB != &BB->getParent()->front()) {  // Not the entry block?
       // Output predecessors for the block...
-      *Out << "\t\t;";
+      Out << "\t\t;";
       pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB);
       
       if (PI == PE) {
-        *Out << " No predecessors!";
+        Out << " No predecessors!";
       } else {
-        *Out << " preds =";
+        Out << " preds =";
         writeOperand(*PI, false, true);
         for (++PI; PI != PE; ++PI) {
-          *Out << ',';
+          Out << ',';
           writeOperand(*PI, false, true);
         }
       }
     }
   }
   
-  *Out << "\n";
+  Out << "\n";
 
-  if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, *Out);
+  if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out);
 
   // Output all of the instructions in the basic block...
   for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I)
     printInstruction(*I);
 
-  if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, *Out);
+  if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out);
 }
 
 
@@ -891,38 +988,38 @@ void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
 ///
 void AssemblyWriter::printInfoComment(const Value &V) {
   if (V.getType() != Type::VoidTy) {
-    *Out << "\t\t; <";
+    Out << "\t\t; <";
     printType(V.getType()) << '>';
 
     if (!V.hasName()) {
       int SlotNum = Machine.getSlot(&V);
       if (SlotNum == -1)
-        *Out << ":<badref>";
+        Out << ":<badref>";
       else
-        *Out << ':' << SlotNum; // Print out the def slot taken.
+        Out << ':' << SlotNum; // Print out the def slot taken.
     }
-    *Out << " [#uses=" << V.use_size() << ']';  // Output # uses
+    Out << " [#uses=" << V.use_size() << ']';  // Output # uses
   }
 }
 
 /// printInstruction - This member is called for each Instruction in a function..
 ///
 void AssemblyWriter::printInstruction(const Instruction &I) {
-  if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, *Out);
+  if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out);
 
-  *Out << "\t";
+  Out << "\t";
 
   // Print out name if it exists...
   if (I.hasName())
-    *Out << getLLVMName(I.getName()) << " = ";
+    Out << getLLVMName(I.getName()) << " = ";
 
   // If this is a volatile load or store, print out the volatile marker
   if ((isa<LoadInst>(I)  && cast<LoadInst>(I).isVolatile()) ||
       (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()))
-      *Out << "volatile ";
+      Out << "volatile ";
 
   // Print out the opcode...
-  *Out << I.getOpcodeName();
+  Out << I.getOpcodeName();
 
   // Print out the type of the operands...
   const Value *Operand = I.getNumOperands() ? I.getOperand(0) : 0;
@@ -930,35 +1027,35 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
   // Special case conditional branches to swizzle the condition out to the front
   if (isa<BranchInst>(I) && I.getNumOperands() > 1) {
     writeOperand(I.getOperand(2), true);
-    *Out << ',';
+    Out << ',';
     writeOperand(Operand, true);
-    *Out << ',';
+    Out << ',';
     writeOperand(I.getOperand(1), true);
 
   } else if (isa<SwitchInst>(I)) {
     // Special case switch statement to get formatting nice and correct...
-    writeOperand(Operand        , true); *Out << ',';
-    writeOperand(I.getOperand(1), true); *Out << " [";
+    writeOperand(Operand        , true); Out << ',';
+    writeOperand(I.getOperand(1), true); Out << " [";
 
     for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) {
-      *Out << "\n\t\t";
-      writeOperand(I.getOperand(op  ), true); *Out << ',';
+      Out << "\n\t\t";
+      writeOperand(I.getOperand(op  ), true); Out << ',';
       writeOperand(I.getOperand(op+1), true);
     }
-    *Out << "\n\t]";
+    Out << "\n\t]";
   } else if (isa<PHINode>(I)) {
-    *Out << ' ';
+    Out << ' ';
     printType(I.getType());
-    *Out << ' ';
+    Out << ' ';
 
     for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) {
-      if (op) *Out << ", ";
-      *Out << '[';  
-      writeOperand(I.getOperand(op  ), false); *Out << ',';
-      writeOperand(I.getOperand(op+1), false); *Out << " ]";
+      if (op) Out << ", ";
+      Out << '[';  
+      writeOperand(I.getOperand(op  ), false); Out << ',';
+      writeOperand(I.getOperand(op+1), false); Out << " ]";
     }
   } else if (isa<ReturnInst>(I) && !Operand) {
-    *Out << " void";
+    Out << " void";
   } else if (isa<CallInst>(I)) {
     const PointerType  *PTy = cast<PointerType>(Operand->getType());
     const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
@@ -971,19 +1068,19 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
     if (!FTy->isVarArg() &&
         (!isa<PointerType>(RetTy) || 
          !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) {
-      *Out << ' '; printType(RetTy);
+      Out << ' '; printType(RetTy);
       writeOperand(Operand, false);
     } else {
       writeOperand(Operand, true);
     }
-    *Out << '(';
+    Out << '(';
     if (I.getNumOperands() > 1) writeOperand(I.getOperand(1), true);
     for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; ++op) {
-      *Out << ',';
+      Out << ',';
       writeOperand(I.getOperand(op), true);
     }
 
-    *Out << " )";
+    Out << " )";
   } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
     const PointerType  *PTy = cast<PointerType>(Operand->getType());
     const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
@@ -996,42 +1093,42 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
     if (!FTy->isVarArg() &&
         (!isa<PointerType>(RetTy) || 
          !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) {
-      *Out << ' '; printType(RetTy);
+      Out << ' '; printType(RetTy);
       writeOperand(Operand, false);
     } else {
       writeOperand(Operand, true);
     }
 
-    *Out << '(';
+    Out << '(';
     if (I.getNumOperands() > 3) writeOperand(I.getOperand(3), true);
     for (unsigned op = 4, Eop = I.getNumOperands(); op < Eop; ++op) {
-      *Out << ',';
+      Out << ',';
       writeOperand(I.getOperand(op), true);
     }
 
-    *Out << " )\n\t\t\tto";
+    Out << " )\n\t\t\tto";
     writeOperand(II->getNormalDest(), true);
-    *Out << " unwind";
+    Out << " unwind";
     writeOperand(II->getUnwindDest(), true);
 
   } else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) {
-    *Out << ' ';
+    Out << ' ';
     printType(AI->getType()->getElementType());
     if (AI->isArrayAllocation()) {
-      *Out << ',';
+      Out << ',';
       writeOperand(AI->getArraySize(), true);
     }
   } else if (isa<CastInst>(I)) {
     if (Operand) writeOperand(Operand, true);   // Work with broken code
-    *Out << " to ";
+    Out << " to ";
     printType(I.getType());
   } else if (isa<VAArgInst>(I)) {
     if (Operand) writeOperand(Operand, true);   // Work with broken code
-    *Out << ", ";
+    Out << ", ";
     printType(I.getType());
   } else if (const VANextInst *VAN = dyn_cast<VANextInst>(&I)) {
     if (Operand) writeOperand(Operand, true);   // Work with broken code
-    *Out << ", ";
+    Out << ", ";
     printType(VAN->getArgType());
   } else if (Operand) {   // Print the normal way...
 
@@ -1056,18 +1153,18 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
     }
     
     if (!PrintAllTypes) {
-      *Out << ' ';
+      Out << ' ';
       printType(TheType);
     }
 
     for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) {
-      if (i) *Out << ',';
+      if (i) Out << ',';
       writeOperand(I.getOperand(i), PrintAllTypes);
     }
   }
 
   printInfoComment(I);
-  *Out << "\n";
+  Out << "\n";
 }
 
 
@@ -1112,12 +1209,6 @@ void Instruction::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
 void Constant::print(std::ostream &o) const {
   if (this == 0) { o << "<null> constant value\n"; return; }
 
-  // Handle CPR's special, because they have context information...
-  if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(this)) {
-    CPR->getValue()->print(o);  // Print as a global value, with context info.
-    return;
-  }
-
   o << ' ' << getType()->getDescription() << ' ';
 
   std::map<const Type *, std::string> TypeTable;
@@ -1132,7 +1223,8 @@ void Type::print(std::ostream &o) const {
 }
 
 void Argument::print(std::ostream &o) const {
-  o << getType() << ' ' << getName();
+  WriteAsOperand(o, this, true, true,
+                 getParent() ? getParent()->getParent() : 0);
 }
 
 // Value::dump - allow easy printing of  Values from the debugger.
@@ -1162,28 +1254,29 @@ CachedWriter::~CachedWriter() {
   delete SC;
 }
 
-CachedWriter &CachedWriter::operator<<(const Value *V) {
+CachedWriter &CachedWriter::operator<<(const Value &V) {
   assert(AW && SC && "CachedWriter does not have a current module!");
-  switch (V->getValueType()) {
-  case Value::ConstantVal:
-  case Value::ArgumentVal:       AW->writeOperand(V, true, true); break;
-  case Value::TypeVal:           AW->write(cast<Type>(V)); break;
-  case Value::InstructionVal:    AW->write(cast<Instruction>(V)); break;
-  case Value::BasicBlockVal:     AW->write(cast<BasicBlock>(V)); break;
-  case Value::FunctionVal:       AW->write(cast<Function>(V)); break;
-  case Value::GlobalVariableVal: AW->write(cast<GlobalVariable>(V)); break;
-  default: Out << "<unknown value type: " << V->getValueType() << '>'; break;
-  }
+  if (const Instruction *I = dyn_cast<Instruction>(&V))
+    AW->write(I);
+  else if (const BasicBlock *BB = dyn_cast<BasicBlock>(&V))
+    AW->write(BB);
+  else if (const Function *F = dyn_cast<Function>(&V))
+    AW->write(F);
+  else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(&V))
+    AW->write(GV);
+  else 
+    AW->writeOperand(&V, true, true);
   return *this;
 }
 
-CachedWriter& CachedWriter::operator<<(const Type *X) {
+CachedWriter& CachedWriter::operator<<(const Type &Ty) {
   if (SymbolicTypes) {
     const Module *M = AW->getModule();
-    if (M) WriteTypeSymbolic(Out, X, M);
-    return *this;
-  } else
-    return *this << (const Value*)X;
+    if (M) WriteTypeSymbolic(Out, &Ty, M);
+  } else {
+    AW->write(&Ty);
+  }
+  return *this;
 }
 
 //===----------------------------------------------------------------------===//
@@ -1201,8 +1294,11 @@ CachedWriter& CachedWriter::operator<<(const Type *X) {
 SlotMachine::SlotMachine(const Module *M) 
   : TheModule(M)    ///< Saved for lazy initialization.
   , TheFunction(0)
+  , FunctionProcessed(false)
   , mMap()
+  , mTypes()
   , fMap()
+  , fTypes()
 {
 }
 
@@ -1211,8 +1307,11 @@ SlotMachine::SlotMachine(const Module *M)
 SlotMachine::SlotMachine(const Function *F ) 
   : TheModule( F ? F->getParent() : 0 ) ///< Saved for lazy initialization
   , TheFunction(F) ///< Saved for lazy initialization
+  , FunctionProcessed(false)
   , mMap()
+  , mTypes()
   , fMap()
+  , fTypes()
 {
 }
 
@@ -1221,7 +1320,7 @@ inline void SlotMachine::initialize(void) {
     processModule(); 
     TheModule = 0; ///< Prevent re-processing next time we're called.
   }
-  if ( TheFunction ) { 
+  if ( TheFunction && ! FunctionProcessed) { 
     processFunction(); 
   }
 }
@@ -1265,6 +1364,8 @@ void SlotMachine::processFunction() {
     }
   }
 
+  FunctionProcessed = true;
+
   SC_DEBUG("end processFunction!\n");
 }
 
@@ -1275,7 +1376,9 @@ void SlotMachine::processFunction() {
 void SlotMachine::purgeFunction() {
   SC_DEBUG("begin purgeFunction!\n");
   fMap.clear(); // Simply discard the function level map
+  fTypes.clear();
   TheFunction = 0;
+  FunctionProcessed = false;
   SC_DEBUG("end purgeFunction!\n");
 }
 
@@ -1284,17 +1387,12 @@ void SlotMachine::purgeFunction() {
 /// Types are forbidden because Type does not inherit from Value (any more).
 int SlotMachine::getSlot(const Value *V) {
   assert( V && "Can't get slot for null Value" );
-  assert( !isa<Type>(V) && "Can't get slot for a type" );
   assert(!isa<Constant>(V) || isa<GlobalValue>(V) && 
     "Can't insert a non-GlobalValue Constant into SlotMachine"); 
 
   // Check for uninitialized state and do lazy initialization
   this->initialize();
 
-  // Do not number CPR's at all. They are an abomination
-  if ( const ConstantPointerRef* CPR = dyn_cast<ConstantPointerRef>(V) )
-    V = CPR->getValue() ;
-
   // Get the type of the value
   const Type* VTy = V->getType();
 
@@ -1345,12 +1443,51 @@ int SlotMachine::getSlot(const Value *V) {
   return MVI->second;
 }
 
+/// Get the slot number for a value. This function will assert if you
+/// ask for a Value that hasn't previously been inserted with createSlot.
+/// Types are forbidden because Type does not inherit from Value (any more).
+int SlotMachine::getSlot(const Type *Ty) {
+  assert( Ty && "Can't get slot for null Type" );
+
+  // Check for uninitialized state and do lazy initialization
+  this->initialize();
+
+  if ( TheFunction ) {
+    // Lookup the Type in the function map
+    TypeMap::const_iterator FTI = fTypes.map.find(Ty);
+    // If the Type doesn't exist in the function map
+    if ( FTI == fTypes.map.end() ) {
+      TypeMap::const_iterator MTI = mTypes.map.find(Ty);
+      // If we didn't find it, it wasn't inserted
+      if (MTI == mTypes.map.end()) 
+        return -1;
+      // We found it only at the module level
+      return MTI->second; 
+
+    // else the value exists in the function map
+    } else {
+      // Return the slot number as the module's contribution to
+      // the type plane plus the index in the function's contribution
+      // to the type plane.
+      return mTypes.next_slot + FTI->second;
+    }
+  }
+
+  // N.B. Can get here only if either !TheFunction
+
+  // Lookup the value in the module's map
+  TypeMap::const_iterator MTI = mTypes.map.find(Ty);
+  // Make sure we found it.
+  if (MTI == mTypes.map.end()) return -1;
+  // Return it.
+  return MTI->second;
+}
+
 // Create a new slot, or return the existing slot if it is already
 // inserted. Note that the logic here parallels getSlot but instead
 // of asserting when the Value* isn't found, it inserts the value.
 unsigned SlotMachine::createSlot(const Value *V) {
   assert( V && "Can't insert a null Value to SlotMachine");
-  assert( !isa<Type>(V) && "Can't insert a Type into SlotMachine"); 
   assert(!isa<Constant>(V) || isa<GlobalValue>(V) && 
     "Can't insert a non-GlobalValue Constant into SlotMachine"); 
 
@@ -1427,12 +1564,49 @@ unsigned SlotMachine::createSlot(const Value *V) {
   return insertValue(V);
 }
 
+// Create a new slot, or return the existing slot if it is already
+// inserted. Note that the logic here parallels getSlot but instead
+// of asserting when the Value* isn't found, it inserts the value.
+unsigned SlotMachine::createSlot(const Type *Ty) {
+  assert( Ty && "Can't insert a null Type to SlotMachine");
+
+  if ( TheFunction ) {
+    // Lookup the Type in the function map
+    TypeMap::const_iterator FTI = fTypes.map.find(Ty);
+    // If the type doesn't exist in the function map
+    if ( FTI == fTypes.map.end() ) {
+      // Look up the type in the module map
+      TypeMap::const_iterator MTI = mTypes.map.find(Ty);
+      // If we didn't find it, it wasn't inserted
+      if ( MTI == mTypes.map.end() )
+        return insertValue(Ty);
+      else
+        // We found it only at the module level
+        return MTI->second;
+
+    // else the value exists in the function map
+    } else {
+      // Return the slot number as the module's contribution to
+      // the type plane plus the index in the function's contribution
+      // to the type plane.
+      return mTypes.next_slot + FTI->second;
+    }
+  }
+
+  // N.B. Can only get here if !TheFunction
+
+  // Lookup the type in the module's map
+  TypeMap::const_iterator MTI = mTypes.map.find(Ty);
+  if ( MTI != mTypes.map.end() ) 
+    return MTI->second;
+
+  return insertValue(Ty);
+}
 
 // Low level insert function. Minimal checking is done. This
 // function is just for the convenience of createSlot (above).
 unsigned SlotMachine::insertValue(const Value *V ) {
   assert(V && "Can't insert a null Value into SlotMachine!");
-  assert(!isa<Type>(V) && "Can't insert a Type into SlotMachine!");
   assert(!isa<Constant>(V) || isa<GlobalValue>(V) && 
     "Can't insert a non-GlobalValue Constant into SlotMachine"); 
 
@@ -1449,22 +1623,38 @@ unsigned SlotMachine::insertValue(const Value *V ) {
   if ( TheFunction ) {
     TypedPlanes::iterator I = fMap.find( VTy );
     if ( I == fMap.end() ) 
-      I = fMap.insert(std::make_pair(VTy,Plane())).first;
+      I = fMap.insert(std::make_pair(VTy,ValuePlane())).first;
     DestSlot = I->second.map[V] = I->second.next_slot++;
   } else {
     TypedPlanes::iterator I = mMap.find( VTy );
     if ( I == mMap.end() )
-      I = mMap.insert(std::make_pair(VTy,Plane())).first;
+      I = mMap.insert(std::make_pair(VTy,ValuePlane())).first;
     DestSlot = I->second.map[V] = I->second.next_slot++;
   }
 
   SC_DEBUG("  Inserting value [" << VTy << "] = " << V << " slot=" << 
            DestSlot << " [");
   // G = Global, C = Constant, T = Type, F = Function, o = other
-  SC_DEBUG((isa<GlobalVariable>(V) ? 'G' : (isa<Constant>(V) ? 'C' : 
-           (isa<Function>(V) ? 'F' : 'o'))));
+  SC_DEBUG((isa<GlobalVariable>(V) ? 'G' : (isa<Function>(V) ? 'F' : 
+           (isa<Constant>(V) ? 'C' : 'o'))));
   SC_DEBUG("]\n");
   return DestSlot;
 }
 
+// Low level insert function. Minimal checking is done. This
+// function is just for the convenience of createSlot (above).
+unsigned SlotMachine::insertValue(const Type *Ty ) {
+  assert(Ty && "Can't insert a null Type into SlotMachine!");
+
+  unsigned DestSlot = 0;
+
+  if ( TheFunction ) {
+    DestSlot = fTypes.map[Ty] = fTypes.next_slot++;
+  } else {
+    DestSlot = fTypes.map[Ty] = fTypes.next_slot++;
+  }
+  SC_DEBUG("  Inserting type [" << DestSlot << "] = " << Ty << "\n");
+  return DestSlot;
+}
+
 // vim: sw=2