Next batch of implementation:

1. Get rid of old AsmWriter cruft that's not needed.
2. Implement several instructions. Enough to get by globalvars.ll and
   alignment.ll in the Feature test suite.
3. Handle constants properly (don't repeat definitions).
4. Make the output compatible with llvm-dis for diff purposes.


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

1 files changed, 265 insertions, 1148 deletions

diff --git a/tools/llvm2cpp/CppWriter.cpp b/tools/llvm2cpp/CppWriter.cpp
index 0f28e30e16..bd49a07937 100644
--- a/tools/llvm2cpp/CppWriter.cpp
+++ b/tools/llvm2cpp/CppWriter.cpp
@@ -2,8 +2,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file was developed by Reid Spencer and is distributed under the
+// University of Illinois Open Source License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -30,582 +30,12 @@
 using namespace llvm;
 
 namespace {
-/// This class provides computation of slot numbers for LLVM Assembly writing.
-/// @brief LLVM Assembly Writing Slot Computation.
-class SlotMachine {
-
-/// @name Types
-/// @{
-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 ValuePlane {
-    unsigned next_slot;        ///< The next slot number to use
-    ValueMap map;              ///< The map of Value* -> unsigned
-    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*, ValuePlane> TypedPlanes;
-
-/// @}
-/// @name Constructors
-/// @{
-public:
-  /// @brief Construct from a module
-  SlotMachine(const Module *M );
-
-/// @}
-/// @name Accessors
-/// @{
-public:
-  /// Return the slot number of the specified value in it's type
-  /// 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
-/// @{
-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;
-    FunctionProcessed = false;
-  }
-
-  /// After calling incorporateFunction, use this method to remove the
-  /// most recently incorporated function from the SlotMachine. This
-  /// will reset the state of the machine back to just the module contents.
-  void purgeFunction();
-
-/// @}
-/// @name Implementation Details
-/// @{
-private:
-  /// Values can be crammed into here at will. If they haven't
-  /// 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.
-  void processModule();
-
-  /// Add all of the functions arguments, basic blocks, and instructions
-  void processFunction();
-
-  SlotMachine(const SlotMachine &);  // DO NOT IMPLEMENT
-  void operator=(const SlotMachine &);  // DO NOT IMPLEMENT
-
-/// @}
-/// @name Data
-/// @{
-public:
-
-  /// @brief The module for which we are holding slot numbers
-  const Module* TheModule;
-
-  /// @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;
-
-/// @}
-
-};
-
 typedef std::vector<const Type*> TypeList;
 typedef std::map<const Type*,std::string> TypeMap;
 typedef std::map<const Value*,std::string> ValueMap;
 
-void WriteAsOperandInternal(std::ostream &Out, const Value *V,
-                                   bool PrintName, TypeMap &TypeTable,
-                                   SlotMachine *Machine);
-
-void WriteAsOperandInternal(std::ostream &Out, const Type *T,
-                                   bool PrintName, TypeMap& TypeTable,
-                                   SlotMachine *Machine);
-
-const Module *getModuleFromVal(const Value *V) {
-  if (const Argument *MA = dyn_cast<Argument>(V))
-    return MA->getParent() ? MA->getParent()->getParent() : 0;
-  else if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
-    return BB->getParent() ? BB->getParent()->getParent() : 0;
-  else if (const Instruction *I = dyn_cast<Instruction>(V)) {
-    const Function *M = I->getParent() ? I->getParent()->getParent() : 0;
-    return M ? M->getParent() : 0;
-  } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
-    return GV->getParent();
-  return 0;
-}
-
-// getLLVMName - Turn the specified string into an 'LLVM name', which is either
-// prefixed with % (if the string only contains simple characters) or is
-// surrounded with ""'s (if it has special chars in it).
-std::string getLLVMName(const std::string &Name,
-                               bool prefixName = true) {
-  assert(!Name.empty() && "Cannot get empty name!");
-
-  // First character cannot start with a number...
-  if (Name[0] >= '0' && Name[0] <= '9')
-    return "\"" + Name + "\"";
-
-  // Scan to see if we have any characters that are not on the "white list"
-  for (unsigned i = 0, e = Name.size(); i != e; ++i) {
-    char C = Name[i];
-    assert(C != '"' && "Illegal character in LLVM value name!");
-    if ((C < 'a' || C > 'z') && (C < 'A' || C > 'Z') && (C < '0' || C > '9') &&
-        C != '-' && C != '.' && C != '_')
-      return "\"" + Name + "\"";
-  }
-
-  // If we get here, then the identifier is legal to use as a "VarID".
-  if (prefixName)
-    return "%"+Name;
-  else
-    return Name;
-}
-
-
-/// fillTypeNameTable - If the module has a symbol table, take all global types
-/// and stuff their names into the TypeNames map.
-///
-void fillTypeNameTable(const Module *M, TypeMap& TypeNames) {
-  if (!M) return;
-  const SymbolTable &ST = M->getSymbolTable();
-  SymbolTable::type_const_iterator TI = ST.type_begin();
-  for (; TI != ST.type_end(); ++TI ) {
-    // As a heuristic, don't insert pointer to primitive types, because
-    // they are used too often to have a single useful name.
-    //
-    const Type *Ty = cast<Type>(TI->second);
-    if (!isa<PointerType>(Ty) ||
-        !cast<PointerType>(Ty)->getElementType()->isPrimitiveType() ||
-        isa<OpaqueType>(cast<PointerType>(Ty)->getElementType()))
-      TypeNames.insert(std::make_pair(Ty, getLLVMName(TI->first)));
-  }
-}
-
-void calcTypeName(const Type *Ty,
-                         std::vector<const Type *> &TypeStack,
-                         TypeMap& TypeNames,
-                         std::string & Result){
-  if (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty)) {
-    Result += Ty->getDescription();  // Base case
-    return;
-  }
-
-  // Check to see if the type is named.
-  TypeMap::iterator I = TypeNames.find(Ty);
-  if (I != TypeNames.end()) {
-    Result += I->second;
-    return;
-  }
-
-  if (isa<OpaqueType>(Ty)) {
-    Result += "opaque";
-    return;
-  }
-
-  // Check to see if the Type is already on the stack...
-  unsigned Slot = 0, CurSize = TypeStack.size();
-  while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type
-
-  // This is another base case for the recursion.  In this case, we know
-  // that we have looped back to a type that we have previously visited.
-  // Generate the appropriate upreference to handle this.
-  if (Slot < CurSize) {
-    Result += "\\" + utostr(CurSize-Slot);     // Here's the upreference
-    return;
-  }
-
-  TypeStack.push_back(Ty);    // Recursive case: Add us to the stack..
-
-  switch (Ty->getTypeID()) {
-  case Type::FunctionTyID: {
-    const FunctionType *FTy = cast<FunctionType>(Ty);
-    calcTypeName(FTy->getReturnType(), TypeStack, TypeNames, Result);
-    Result += " (";
-    for (FunctionType::param_iterator I = FTy->param_begin(),
-           E = FTy->param_end(); I != E; ++I) {
-      if (I != FTy->param_begin())
-        Result += ", ";
-      calcTypeName(*I, TypeStack, TypeNames, Result);
-    }
-    if (FTy->isVarArg()) {
-      if (FTy->getNumParams()) Result += ", ";
-      Result += "...";
-    }
-    Result += ")";
-    break;
-  }
-  case Type::StructTyID: {
-    const StructType *STy = cast<StructType>(Ty);
-    Result += "{ ";
-    for (StructType::element_iterator I = STy->element_begin(),
-           E = STy->element_end(); I != E; ++I) {
-      if (I != STy->element_begin())
-        Result += ", ";
-      calcTypeName(*I, TypeStack, TypeNames, Result);
-    }
-    Result += " }";
-    break;
-  }
-  case Type::PointerTyID:
-    calcTypeName(cast<PointerType>(Ty)->getElementType(),
-                          TypeStack, TypeNames, Result);
-    Result += "*";
-    break;
-  case Type::ArrayTyID: {
-    const ArrayType *ATy = cast<ArrayType>(Ty);
-    Result += "[" + utostr(ATy->getNumElements()) + " x ";
-    calcTypeName(ATy->getElementType(), TypeStack, TypeNames, Result);
-    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;
-  default:
-    Result += "<unrecognized-type>";
-  }
-
-  TypeStack.pop_back();       // Remove self from stack...
-  return;
-}
-
-
-/// printTypeInt - The internal guts of printing out a type that has a
-/// potentially named portion.
-///
-std::ostream &printTypeInt(std::ostream &Out, const Type *Ty,TypeMap&TypeNames){
-  // Primitive types always print out their description, regardless of whether
-  // they have been named or not.
-  //
-  if (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty))
-    return Out << Ty->getDescription();
-
-  // Check to see if the type is named.
-  TypeMap::iterator I = TypeNames.find(Ty);
-  if (I != TypeNames.end()) return Out << I->second;
-
-  // Otherwise we have a type that has not been named but is a derived type.
-  // Carefully recurse the type hierarchy to print out any contained symbolic
-  // names.
-  //
-  std::vector<const Type *> TypeStack;
-  std::string TypeName;
-  calcTypeName(Ty, TypeStack, TypeNames, TypeName);
-  TypeNames.insert(std::make_pair(Ty, TypeName));//Cache type name for later use
-  return (Out << TypeName);
-}
-
-
-/// WriteTypeSymbolic - This attempts to write the specified type as a symbolic
-/// type, iff there is an entry in the modules symbol table for the specified
-/// type or one of it's component types. This is slower than a simple x << Type
-///
-std::ostream &WriteTypeSymbolic(std::ostream &Out, const Type *Ty,
-                                      const Module *M) {
-  Out << ' ';
-
-  // If they want us to print out a type, attempt to make it symbolic if there
-  // is a symbol table in the module...
-  if (M) {
-    TypeMap TypeNames;
-    fillTypeNameTable(M, TypeNames);
-
-    return printTypeInt(Out, Ty, TypeNames);
-  } else {
-    return Out << Ty->getDescription();
-  }
-}
-
-// PrintEscapedString - Print each character of the specified string, escaping
-// it if it is not printable or if it is an escape char.
-void PrintEscapedString(const std::string &Str, std::ostream &Out) {
-  for (unsigned i = 0, e = Str.size(); i != e; ++i) {
-    unsigned char C = Str[i];
-    if (isprint(C) && C != '"' && C != '\\') {
-      Out << C;
-    } else {
-      Out << '\\'
-          << (char) ((C/16  < 10) ? ( C/16 +'0') : ( C/16 -10+'A'))
-          << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A'));
-    }
-  }
-}
-
-/// @brief Internal constant writer.
-void WriteConstantInternal(std::ostream &Out, const Constant *CV,
-                             bool PrintName,
-                             TypeMap& TypeTable,
-                             SlotMachine *Machine) {
-  const int IndentSize = 4;
-  static std::string Indent = "\n";
-  if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) {
-    Out << (CB == ConstantBool::True ? "true" : "false");
-  } else if (const ConstantSInt *CI = dyn_cast<ConstantSInt>(CV)) {
-    Out << CI->getValue();
-  } else if (const ConstantUInt *CI = dyn_cast<ConstantUInt>(CV)) {
-    Out << CI->getValue();
-  } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
-    // We would like to output the FP constant value in exponential notation,
-    // but we cannot do this if doing so will lose precision.  Check here to
-    // make sure that we only output it in exponential format if we can parse
-    // the value back and get the same value.
-    //
-    std::string StrVal = ftostr(CFP->getValue());
-
-    // Check to make sure that the stringized number is not some string like
-    // "Inf" or NaN, that atof will accept, but the lexer will not.  Check that
-    // the string matches the "[-+]?[0-9]" regex.
-    //
-    if ((StrVal[0] >= '0' && StrVal[0] <= '9') ||
-        ((StrVal[0] == '-' || StrVal[0] == '+') &&
-         (StrVal[1] >= '0' && StrVal[1] <= '9')))
-      // Reparse stringized version!
-      if (atof(StrVal.c_str()) == CFP->getValue()) {
-        Out << StrVal;
-        return;
-      }
-
-    // Otherwise we could not reparse it to exactly the same value, so we must
-    // output the string in hexadecimal format!
-    assert(sizeof(double) == sizeof(uint64_t) &&
-           "assuming that double is 64 bits!");
-    Out << "0x" << utohexstr(DoubleToBits(CFP->getValue()));
-
-  } else if (isa<ConstantAggregateZero>(CV)) {
-    Out << "zeroinitializer";
-  } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
-    // As a special case, print the array as a string if it is an array of
-    // ubytes or an array of sbytes with positive values.
-    //
-    const Type *ETy = CA->getType()->getElementType();
-    if (CA->isString()) {
-      Out << "c\"";
-      PrintEscapedString(CA->getAsString(), Out);
-      Out << "\"";
-
-    } else {                // Cannot output in string format...
-      Out << '[';
-      if (CA->getNumOperands()) {
-        Out << ' ';
-        printTypeInt(Out, ETy, TypeTable);
-        WriteAsOperandInternal(Out, CA->getOperand(0),
-                               PrintName, TypeTable, Machine);
-        for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) {
-          Out << ", ";
-          printTypeInt(Out, ETy, TypeTable);
-          WriteAsOperandInternal(Out, CA->getOperand(i), PrintName,
-                                 TypeTable, Machine);
-        }
-      }
-      Out << " ]";
-    }
-  } else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
-    Out << '{';
-    unsigned N = CS->getNumOperands();
-    if (N) {
-      if (N > 2) {
-        Indent += std::string(IndentSize, ' ');
-        Out << Indent;
-      } else {
-        Out << ' ';
-      }
-      printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable);
-
-      WriteAsOperandInternal(Out, CS->getOperand(0),
-                             PrintName, TypeTable, Machine);
-
-      for (unsigned i = 1; i < N; i++) {
-        Out << ", ";
-        if (N > 2) Out << Indent;
-        printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable);
-
-        WriteAsOperandInternal(Out, CS->getOperand(i),
-                               PrintName, TypeTable, Machine);
-      }
-      if (N > 2) Indent.resize(Indent.size() - IndentSize);
-    }
- 
-    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 (isa<UndefValue>(CV)) {
-    Out << "undef";
-
-  } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
-    Out << CE->getOpcodeName() << " (";
-
-    for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
-      printTypeInt(Out, (*OI)->getType(), TypeTable);
-      WriteAsOperandInternal(Out, *OI, PrintName, TypeTable, Machine);
-      if (OI+1 != CE->op_end())
-        Out << ", ";
-    }
-
-    if (CE->getOpcode() == Instruction::Cast) {
-      Out << " to ";
-      printTypeInt(Out, CE->getType(), TypeTable);
-    }
-    Out << ')';
-
-  } else {
-    Out << "<placeholder or erroneous Constant>";
-  }
-}
-
-
-/// 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.
-///
-void WriteAsOperandInternal(std::ostream &Out, const Value *V,
-                                   bool PrintName, TypeMap& TypeTable,
-                                   SlotMachine *Machine) {
-  Out << ' ';
-  if ((PrintName || isa<GlobalValue>(V)) && V->hasName())
-    Out << getLLVMName(V->getName());
-  else {
-    const Constant *CV = dyn_cast<Constant>(V);
-    if (CV && !isa<GlobalValue>(CV)) {
-      WriteConstantInternal(Out, CV, PrintName, TypeTable, Machine);
-    } else if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
-      Out << "asm ";
-      if (IA->hasSideEffects())
-        Out << "sideeffect ";
-      Out << '"';
-      PrintEscapedString(IA->getAsmString(), Out);
-      Out << "\", \"";
-      PrintEscapedString(IA->getConstraintString(), Out);
-      Out << '"';
-    } else {
-      int Slot = Machine->getSlot(V);
-      if (Slot != -1)
-        Out << '%' << Slot;
-      else
-        Out << "<badref>";
-    }
-  }
-}
-
-/// 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 &WriteAsOperand(std::ostream &Out, const Value *V,
-                                   bool PrintType, bool PrintName,
-                                   const Module *Context) {
-  TypeMap TypeNames;
-  if (Context == 0) Context = getModuleFromVal(V);
-
-  if (Context)
-    fillTypeNameTable(Context, TypeNames);
-
-  if (PrintType)
-    printTypeInt(Out, V->getType(), 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.
-///
-void WriteAsOperandInternal(std::ostream &Out, const Type *T,
-                                   bool PrintName, TypeMap& TypeTable,
-                                   SlotMachine *Machine) {
-  Out << ' ';
-  int Slot = Machine->getSlot(T);
-  if (Slot != -1)
-    Out << '%' << Slot;
-  else
-    Out << "<badref>";
-}
-
-/// 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 &WriteAsOperand(std::ostream &Out, const Type *Ty,
-                                   bool PrintType, bool PrintName,
-                                   const Module *Context) {
-  TypeMap 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;
-}
-
 class CppWriter {
   std::ostream &Out;
-  SlotMachine &Machine;
   const Module *TheModule;
   unsigned long uniqueNum;
   TypeMap TypeNames;
@@ -614,53 +44,25 @@ class CppWriter {
   TypeList TypeStack;
 
 public:
-  inline CppWriter(std::ostream &o, SlotMachine &Mac, const Module *M)
-    : Out(o), Machine(Mac), TheModule(M), uniqueNum(0), TypeNames(),
+  inline CppWriter(std::ostream &o, const Module *M)
+    : Out(o), TheModule(M), uniqueNum(0), TypeNames(),
       ValueNames(), UnresolvedTypes(), TypeStack() { }
 
-  inline void write(const Module *M)         { printModule(M);      }
-  inline void write(const GlobalVariable *G) { printGlobal(G);      }
-  inline void write(const Function *F)       { printFunction(F);    }
-  inline void write(const BasicBlock *BB)    { printBasicBlock(BB); }
-  inline void write(const Instruction *I)    { printInstruction(*I); }
-  inline void write(const Constant *CPV)     { printConstant(CPV);  }
-  inline void write(const Type *Ty)          { printType(Ty);       }
-
-  void writeOperand(const Value *Op, bool PrintType, bool PrintName = true);
-
   const Module* getModule() { return TheModule; }
 
-private:
   void printModule(const Module *M);
+
+private:
   void printTypes(const Module* M);
   void printConstants(const Module* M);
   void printConstant(const Constant *CPV);
   void printGlobal(const GlobalVariable *GV);
   void printFunction(const Function *F);
-  void printArgument(const Argument *FA);
-  void printBasicBlock(const BasicBlock *BB);
-  void printInstruction(const Instruction &I);
+  void printInstruction(const Instruction *I, const std::string& bbname);
   void printSymbolTable(const SymbolTable &ST);
   void printLinkageType(GlobalValue::LinkageTypes LT);
   void printCallingConv(unsigned cc);
 
-
-  // printType - Go to extreme measures to attempt to print out a short,
-  // symbolic version of a type name.
-  //
-  std::ostream &printType(const Type *Ty) {
-    return printTypeInt(Out, Ty, TypeNames);
-  }
-
-  // printTypeAtLeastOneLevel - Print out one level of the possibly complex type
-  // without considering any symbolic types that we may have equal to it.
-  //
-  std::ostream &printTypeAtLeastOneLevel(const Type *Ty);
-
-  // printInfoComment - Print a little comment after the instruction indicating
-  // which slot it occupies.
-  void printInfoComment(const Value &V);
-
   std::string getCppName(const Type* val);
   std::string getCppName(const Value* val);
   inline void printCppName(const Value* val);
@@ -668,8 +70,25 @@ private:
   bool isOnStack(const Type*) const;
   inline void printTypeDef(const Type* Ty);
   bool printTypeDefInternal(const Type* Ty);
+  void printEscapedString(const std::string& str);
 };
 
+// printEscapedString - Print each character of the specified string, escaping
+// it if it is not printable or if it is an escape char.
+void 
+CppWriter::printEscapedString(const std::string &Str) {
+  for (unsigned i = 0, e = Str.size(); i != e; ++i) {
+    unsigned char C = Str[i];
+    if (isprint(C) && C != '"' && C != '\\') {
+      Out << C;
+    } else {
+      Out << '\\'
+          << (char) ((C/16  < 10) ? ( C/16 +'0') : ( C/16 -10+'A'))
+          << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A'));
+    }
+  }
+}
+
 std::string
 CppWriter::getCppName(const Value* val) {
   std::string name;
@@ -707,13 +126,13 @@ CppWriter::getCppName(const Value* val) {
 
 void
 CppWriter::printCppName(const Value* val) {
-  PrintEscapedString(getCppName(val),Out);
+  printEscapedString(getCppName(val));
 }
 
 void
 CppWriter::printCppName(const Type* Ty)
 {
-  PrintEscapedString(getCppName(Ty),Out);
+  printEscapedString(getCppName(Ty));
 }
 
 // Gets the C++ name for a type. Returns true if we already saw the type,
@@ -785,67 +204,13 @@ CppWriter::getCppName(const Type* Ty)
   return TypeNames[Ty] = name;
 }
 
-/// printTypeAtLeastOneLevel - Print out one level of the possibly complex type
-/// without considering any symbolic types that we may have equal to it.
-///
-std::ostream &CppWriter::printTypeAtLeastOneLevel(const Type *Ty) {
-  if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
-    printType(FTy->getReturnType()) << " (";
-    for (FunctionType::param_iterator I = FTy->param_begin(),
-           E = FTy->param_end(); I != E; ++I) {
-      if (I != FTy->param_begin())
-        Out << ", ";
-      printType(*I);
-    }
-    if (FTy->isVarArg()) {
-      if (FTy->getNumParams()) Out << ", ";
-      Out << "...";
-    }
-    Out << ')';
-  } else if (const StructType *STy = dyn_cast<StructType>(Ty)) {
-    Out << "{ ";
-    for (StructType::element_iterator I = STy->element_begin(),
-           E = STy->element_end(); I != E; ++I) {
-      if (I != STy->element_begin())
-        Out << ", ";
-      printType(*I);
-    }
-    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 ";
-    printType(ATy->getElementType()) << ']';
-  } 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>";
-    printType(Ty);
-  }
-  return Out;
-}
-
-
-void CppWriter::writeOperand(const Value *Operand, bool PrintType,
-                                  bool PrintName) {
-  if (Operand != 0) {
-    if (PrintType) { Out << ' '; printType(Operand->getType()); }
-    WriteAsOperandInternal(Out, Operand, PrintName, TypeNames, &Machine);
-  } else {
-    Out << "<null operand!>";
-  }
-}
-
-
 void CppWriter::printModule(const Module *M) {
   Out << "\n// Module Construction\n";
   Out << "Module* mod = new Module(\"";
-  PrintEscapedString(M->getModuleIdentifier(),Out);
+  if (M->getModuleIdentifier() == "-")
+    printEscapedString("<stdin>");
+  else 
+    printEscapedString(M->getModuleIdentifier());
   Out << "\");\n";
   Out << "mod->setEndianness(";
   switch (M->getEndianness()) {
@@ -864,7 +229,7 @@ void CppWriter::printModule(const Module *M) {
 
   if (!M->getModuleInlineAsm().empty()) {
     Out << "mod->setModuleInlineAsm(\"";
-    PrintEscapedString(M->getModuleInlineAsm(),Out);
+    printEscapedString(M->getModuleInlineAsm());
     Out << "\");\n";
   }
   
@@ -945,13 +310,13 @@ void CppWriter::printGlobal(const GlobalVariable *GV) {
     Out << "0";
   }
   Out << ",\n  /*Name=*/\"";
-  PrintEscapedString(GV->getName(),Out);
+  printEscapedString(GV->getName());
   Out << "\",\n  mod);\n";
 
   if (GV->hasSection()) {
     printCppName(GV);
     Out << "->setSection(\"";
-    PrintEscapedString(GV->getSection(),Out);
+    printEscapedString(GV->getSection());
     Out << "\");\n";
   }
   if (GV->getAlignment()) {
@@ -993,10 +358,9 @@ CppWriter::printTypeDef(const Type* Ty) {
       case Type::OpaqueTyID:   Out << "OpaqueType"; break;
       default:                 Out << "NoSuchDerivedType"; break;
     }
-    Out << ">(" << I->second << "_fwd.get());\n";
+    Out << ">(" << I->second << "_fwd.get());\n\n";
     UnresolvedTypes.erase(I);
   }
-  Out << "\n";
 }
 
 bool
@@ -1129,6 +493,7 @@ CppWriter::printTypeDefInternal(const Type* Ty) {
 
   // Pop us off the type stack
   TypeStack.pop_back();
+  Out << "\n";
 
   // We weren't a recursive type
   return false;
@@ -1169,51 +534,37 @@ CppWriter::printTypes(const Module* M) {
 
 void
 CppWriter::printConstants(const Module* M) {
-  const SymbolTable& ST = M->getSymbolTable();
-
-  // Print the constants, in type plane order.
-  for (SymbolTable::plane_const_iterator PI = ST.plane_begin();
-       PI != ST.plane_end(); ++PI ) {
-    SymbolTable::value_const_iterator VI = ST.value_begin(PI->first);
-    SymbolTable::value_const_iterator VE = ST.value_end(PI->first);
-
-    for (; VI != VE; ++VI) {
-      const Value* V = VI->second;
-      const Constant *CPV = dyn_cast<Constant>(V) ;
-      if (CPV && !isa<GlobalValue>(V)) {
-        printConstant(CPV);
-      }
-    }
-  }
-
   // Add all of the global variables to the value table...
   for (Module::const_global_iterator I = TheModule->global_begin(), 
        E = TheModule->global_end(); I != E; ++I)
     if (I->hasInitializer())
       printConstant(I->getInitializer());
-}
 
-// printSymbolTable - Run through symbol table looking for constants
-// and types. Emit their declarations.
-void CppWriter::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 ";
-
-    // Make sure we print out at least one level of the type structure, so
-    // that we do not get %FILE = type %FILE
-    //
-    printTypeAtLeastOneLevel(TI->second) << "\n";
+  // Traverse the LLVM functions looking for constants
+  for (Module::const_iterator FI = TheModule->begin(), FE = TheModule->end();
+       FI != FE; ++FI) {
+    // Add all of the basic blocks and instructions
+    for (Function::const_iterator BB = FI->begin(),
+         E = FI->end(); BB != E; ++BB) {
+      for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; 
+           ++I) {
+        for (unsigned i = 0; i < I->getNumOperands(); ++i) {
+          if (Constant* C = dyn_cast<Constant>(I->getOperand(i))) {
+            printConstant(C);
+          }
+        }
+      }
+    }
   }
-
 }
 
-
-/// printConstant - Print out a constant pool entry...
-///
+// printConstant - Print out a constant pool entry...
 void CppWriter::printConstant(const Constant *CV) {
+  // First, if the constant is in the constant list then we've printed it
+  // already and we shouldn't reprint it.
+  if (ValueNames.find(CV) != ValueNames.end())
+    return;
+
   const int IndentSize = 2;
   static std::string Indent = "\n";
   std::string constName(getCppName(CV));
@@ -1223,6 +574,10 @@ void CppWriter::printConstant(const Constant *CV) {
         << typeName << ");\n";
     return;
   }
+  if (isa<GlobalValue>(CV)) {
+    // Skip variables and functions, we emit them elsewhere
+    return;
+  }
   if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) {
     Out << "Constant* " << constName << " = ConstantBool::get(" 
         << (CB == ConstantBool::True ? "true" : "false")
@@ -1267,9 +622,9 @@ void CppWriter::printConstant(const Constant *CV) {
            "assuming that double is 64 bits!");
     Out << "0x" << utohexstr(DoubleToBits(CFP->getValue())) << ");";
   } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
-    if (CA->isString()) {
+    if (CA->isString() && CA->getType()->getElementType() == Type::SByteTy) {
       Out << "Constant* " << constName << " = ConstantArray::get(\"";
-      PrintEscapedString(CA->getAsString(),Out);
+      printEscapedString(CA->getAsString());
       Out << "\");";
     } else {
       Out << "std::vector<Constant*> " << constName << "_elems;\n";
@@ -1304,25 +659,55 @@ void CppWriter::printConstant(const Constant *CV) {
         << typeName << ", " << constName << "_elems);";
   } else if (isa<UndefValue>(CV)) {
     Out << "Constant* " << constName << " = UndefValue::get(" 
-        << typeName << ");\n";
+        << typeName << ");";
   } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
-    Out << CE->getOpcodeName() << " (";
-
-    for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
-      //printTypeInt(Out, (*OI)->getType(), TypeTable);
-      //WriteAsOperandInternal(Out, *OI, PrintName, TypeTable, Machine);
-      if (OI+1 != CE->op_end())
-        Out << ", ";
-    }
-
-    if (CE->getOpcode() == Instruction::Cast) {
-      Out << " to ";
-      // printTypeInt(Out, CE->getType(), TypeTable);
+    if (CE->getOpcode() == Instruction::GetElementPtr) {
+      Out << "std::vector<Constant*> " << constName << "_indices;\n";
+      for (unsigned i = 1; i < CE->getNumOperands(); ++i ) {
+        Out << constName << "_indices.push_back("
+            << getCppName(CE->getOperand(i)) << ");\n";
+      }
+      Out << "Constant* " << constName << " = new GetElementPtrInst(" 
+          << getCppName(CE->getOperand(0)) << ", " << constName << "_indices";
+    } else if (CE->getOpcode() == Instruction::Cast) {
+      Out << "Constant* " << constName << " = ConstantExpr::getCast(";
+      Out << getCppName(CE->getOperand(0)) << ", " << getCppName(CE->getType())
+          << ");";
+    } else {
+      Out << "Constant* " << constName << " = ConstantExpr::";
+      switch (CE->getOpcode()) {
+        case Instruction::Add:    Out << "getAdd";  break;
+        case Instruction::Sub:    Out << "getSub"; break;
+        case Instruction::Mul:    Out << "getMul"; break;
+        case Instruction::Div:    Out << "getDiv"; break;
+        case Instruction::Rem:    Out << "getRem"; break;
+        case Instruction::And:    Out << "getAnd"; break;
+        case Instruction::Or:     Out << "getOr"; break;
+        case Instruction::Xor:    Out << "getXor"; break;
+        case Instruction::SetEQ:  Out << "getSetEQ"; break;
+        case Instruction::SetNE:  Out << "getSetNE"; break;
+        case Instruction::SetLE:  Out << "getSetLE"; break;
+        case Instruction::SetGE:  Out << "getSetGE"; break;
+        case Instruction::SetLT:  Out << "getSetLT"; break;
+        case Instruction::SetGT:  Out << "getSetGT"; break;
+        case Instruction::Shl:    Out << "getShl"; break;
+        case Instruction::Shr:    Out << "getShr"; break;
+        case Instruction::Select: Out << "getSelect"; break;
+        case Instruction::ExtractElement: Out << "getExtractElement"; break;
+        case Instruction::InsertElement:  Out << "getInsertElement"; break;
+        case Instruction::ShuffleVector:  Out << "getShuffleVector"; break;
+        default:
+          assert(!"Invalid constant expression");
+          break;
+      }
+      Out << getCppName(CE->getOperand(0));
+      for (unsigned i = 1; i < CE->getNumOperands(); ++i) 
+        Out << ", " << getCppName(CE->getOperand(i));
+      Out << ");";
     }
-    Out << ')';
-
   } else {
-    Out << "<placeholder or erroneous Constant>";
+    assert(!"Bad Constant");
+    Out << "Constant* " << constName << " = 0; ";
   }
   Out << "\n";
 }
@@ -1336,7 +721,7 @@ void CppWriter::printFunction(const Function *F) {
   printCppName(F);
   Out << " = new Function(" << funcTypeName << ", " ;
   printLinkageType(F->getLinkage());
-  Out << ", \"" << F->getName() << "\", mod);\n";
+  Out << ",\n  \"" << F->getName() << "\", mod);\n";
   printCppName(F);
   Out << "->setCallingConv(";
   printCallingConv(F->getCallingConv());
@@ -1350,101 +735,170 @@ void CppWriter::printFunction(const Function *F) {
     Out << "->setAlignment(" << F->getAlignment() << ");\n";
   }
 
-  Machine.incorporateFunction(F);
-
   if (!F->isExternal()) {
-    Out << "{";
+    Out << "{\n";
+    // Create all the argument values
+    for (Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end();
+         AI != AE; ++AI) {
+      Out << "  Argument* " << getCppName(AI) << " = new Argument("
+          << getCppName(AI->getType()) << ", \"";
+      printEscapedString(AI->getName());
+      Out << "\", " << getCppName(F) << ");\n";
+    }
+    // Create all the basic blocks
+    for (Function::const_iterator BI = F->begin(), BE = F->end(); 
+         BI != BE; ++BI) {
+      std::string bbname(getCppName(BI));
+      Out << "  BasicBlock* " << bbname << " = new BasicBlock(\"";
+      if (BI->hasName())
+        printEscapedString(BI->getName());
+      Out << "\"," << getCppName(BI->getParent()) << ",0);\n";
+    }
     // Output all of its basic blocks... for the function
-    for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I)
-      printBasicBlock(I);
+    for (Function::const_iterator BI = F->begin(), BE = F->end(); 
+         BI != BE; ++BI) {
+      // Output all of the instructions in the basic block...
+      Out << "  {\n";
+      for (BasicBlock::const_iterator I = BI->begin(), E = BI->end(); 
+           I != E; ++I) {
+        std::string bbname(getCppName(BI));
+        printInstruction(I,bbname);
+      }
+      Out << "  }\n";
+    }
     Out << "}\n";
   }
-
-  Machine.purgeFunction();
 }
 
-/// printArgument - This member is called for every argument that is passed into
-/// the function.  Simply print it out
-///
-void CppWriter::printArgument(const Argument *Arg) {
-  // Insert commas as we go... the first arg doesn't get a comma
-  if (Arg != Arg->getParent()->arg_begin()) Out << ", ";
-
-  // Output type...
-  printType(Arg->getType());
-
-  // Output name, if available...
-  if (Arg->hasName())
-    Out << ' ' << getLLVMName(Arg->getName());
-}
-
-/// printBasicBlock - This member is called for each basic block in a method.
-///
-void CppWriter::printBasicBlock(const BasicBlock *BB) {
-  if (BB->hasName()) {              // Print out the label if it exists...
-    Out << "\n" << getLLVMName(BB->getName(), false) << ':';
-  } else if (!BB->use_empty()) {      // Don't print block # of no uses...
-    Out << "\n; <label>:";
-    int Slot = Machine.getSlot(BB);
-    if (Slot != -1)
-      Out << Slot;
-    else
-      Out << "<badref>";
-  }
-
-  if (BB->getParent() == 0)
-    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;";
-      pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB);
-
-      if (PI == PE) {
-        Out << " No predecessors!";
+// printInstruction - This member is called for each Instruction in a function.
+void 
+CppWriter::printInstruction(const Instruction *I, const std::string& bbname) 
+{
+  std::string iName(getCppName(I));
+
+  switch (I->getOpcode()) {
+    case Instruction::Ret: {
+      const ReturnInst* ret =  cast<ReturnInst>(I);
+      Out << "    ReturnInst* " << iName << " = new ReturnInst(";
+      if (ret->getReturnValue())
+        Out << getCppName(ret->getReturnValue()) << ", ";
+      Out << bbname << ");";
+      break;
+    }
+    case Instruction::Br: {
+      const BranchInst* br = cast<BranchInst>(I);
+      Out << "    BranchInst* " << iName << " = new BranchInst(" ;
+      if (br->getNumOperands() == 3 ) {
+        Out << getCppName(br->getOperand(0)) << ", " 
+            << getCppName(br->getOperand(1)) << ", "
+            << getCppName(br->getOperand(2)) << ", ";
+
+      } else if (br->getNumOperands() == 1) {
+        Out << getCppName(br->getOperand(0)) << ", ";
+      } else {
+        assert(!"branch with 2 operands?");
+      }
+      Out << bbname << ");";
+      break;
+    }
+    case Instruction::Switch:
+    case Instruction::Invoke:
+    case Instruction::Unwind:
+    case Instruction::Unreachable:
+    case Instruction::Add:
+    case Instruction::Sub:
+    case Instruction::Mul:
+    case Instruction::Div:
+    case Instruction::Rem:
+    case Instruction::And:
+    case Instruction::Or:
+    case Instruction::Xor:
+    case Instruction::SetEQ:
+    case Instruction::SetNE:
+    case Instruction::SetLE:
+    case Instruction::SetGE:
+    case Instruction::SetLT:
+    case Instruction::SetGT:
+        break;
+    case Instruction::Malloc: {
+      const MallocInst* mallocI = cast<MallocInst>(I);
+      Out << "    MallocInst* " << iName << " = new MallocInst("
+          << getCppName(mallocI->getAllocatedType()) << ", ";
+      if (mallocI->isArrayAllocation())
+        Out << getCppName(mallocI->getArraySize()) << ", ";
+      Out << "\"";
+      printEscapedString(mallocI->getName());
+      Out << "\", " << bbname << ");";
+      if (mallocI->getAlignment())
+        Out << "\n    " << iName << "->setAlignment(" 
+            << mallocI->getAlignment() << ");";
+      break;
+    }
+    case Instruction::Free:
+    case Instruction::Alloca: {
+      const AllocaInst* allocaI = cast<AllocaInst>(I);
+      Out << "    AllocaInst* " << iName << " = new AllocaInst("
+          << getCppName(allocaI->getAllocatedType()) << ", ";
+      if (allocaI->isArrayAllocation())
+        Out << getCppName(allocaI->getArraySize()) << ", ";
+      Out << "\"";
+      printEscapedString(allocaI->getName());
+      Out << "\", " << bbname << ");";
+      if (allocaI->getAlignment())
+        Out << "\n    " << iName << "->setAlignment(" 
+            << allocaI->getAlignment() << ");";
+      break;
+    }
+    case Instruction::Load:
+        break;
+    case Instruction::Store: {
+      const StoreInst* store = cast<StoreInst>(I);
+      Out << "    StoreInst* " << iName << " = new StoreInst(" 
+          << getCppName(store->getOperand(0)) << ", "
+          << getCppName(store->getOperand(1)) << ", " << bbname << ");\n";
+      if (store->isVolatile()) 
+        Out << "iName->setVolatile(true);";
+      break;
+    }
+    case Instruction::GetElementPtr: {
+      const GetElementPtrInst* gep = cast<GetElementPtrInst>(I);
+      if (gep->getNumOperands() <= 2) {
+        Out << "    GetElementPtrInst* " << iName << " = new GetElementPtrInst("
+            << getCppName(gep->getOperand(0)); 
+        if (gep->getNumOperands() == 2)
+          Out << ", " << getCppName(gep->getOperand(1));
+        Out << ", " << bbname;
       } else {
-        Out << " preds =";
-        writeOperand(*PI, false, true);
-        for (++PI; PI != PE; ++PI) {
-          Out << ',';
-          writeOperand(*PI, false, true);
+        Out << "    std::vector<Value*> " << iName << "_indices;\n";
+        for (unsigned i = 1; i < gep->getNumOperands(); ++i ) {
+          Out << "    " << iName << "_indices.push_back("
+              << getCppName(gep->getOperand(i)) << ");\n";
         }
+        Out << "    Instruction* " << iName << " = new GetElementPtrInst(" 
+            << getCppName(gep->getOperand(0)) << ", " << iName << "_indices";
       }
+      Out << ", \"";
+      printEscapedString(gep->getName());
+      Out << "\", " << bbname << ");";
+      break;
     }
+    case Instruction::PHI:
+    case Instruction::Cast:
+    case Instruction::Call:
+    case Instruction::Shl:
+    case Instruction::Shr:
+    case Instruction::Select:
+    case Instruction::UserOp1:
+    case Instruction::UserOp2:
+    case Instruction::VAArg:
+    case Instruction::ExtractElement:
+    case Instruction::InsertElement:
+    case Instruction::ShuffleVector:
+      break;
   }
-
   Out << "\n";
 
-  // Output all of the instructions in the basic block...
-  for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I)
-    printInstruction(*I);
-}
-
-
-/// printInfoComment - Print a little comment after the instruction indicating
-/// which slot it occupies.
-///
-void CppWriter::printInfoComment(const Value &V) {
-  if (V.getType() != Type::VoidTy) {
-    Out << "\t\t; <";
-    printType(V.getType()) << '>';
-
-    if (!V.hasName()) {
-      int SlotNum = Machine.getSlot(&V);
-      if (SlotNum == -1)
-        Out << ":<badref>";
-      else
-        Out << ':' << SlotNum; // Print out the def slot taken.
-    }
-    Out << " [#uses=" << V.getNumUses() << ']';  // Output # uses
-  }
-}
-
-/// printInstruction - This member is called for each Instruction in a function..
-///
-void CppWriter::printInstruction(const Instruction &I) {
-  Out << "\t";
-
+/*
   // Print out name if it exists...
   if (I.hasName())
     Out << getLLVMName(I.getName()) << " = ";
@@ -1621,346 +1075,8 @@ void CppWriter::printInstruction(const Instruction &I) {
     }
   }
 
-  printInfoComment(I);
   Out << "\n";
-}
-
-
-//===----------------------------------------------------------------------===//
-//                       External Interface declarations
-//===----------------------------------------------------------------------===//
-
-
-//===----------------------------------------------------------------------===//
-//===--                    SlotMachine Implementation
-//===----------------------------------------------------------------------===//
-
-#if 0
-#define SC_DEBUG(X) std::cerr << X
-#else
-#define SC_DEBUG(X)
-#endif
-
-// Module level constructor. Causes the contents of the Module (sans functions)
-// to be added to the slot table.
-SlotMachine::SlotMachine(const Module *M)
-  : TheModule(M)    ///< Saved for lazy initialization.
-  , mMap()
-  , mTypes()
-  , fMap()
-  , fTypes()
-{
-  assert(M != 0 && "Invalid Module");
-  processModule();
-}
-
-// Iterate through all the global variables, functions, and global
-// variable initializers and create slots for them.
-void SlotMachine::processModule() {
-  // Add all of the global variables to the value table...
-  for (Module::const_global_iterator I = TheModule->global_begin(), E = TheModule->global_end();
-       I != E; ++I)
-    createSlot(I);
-
-  // Add all the functions to the table
-  for (Module::const_iterator FI = TheModule->begin(), FE = TheModule->end();
-       FI != FE; ++FI) {
-    createSlot(FI);
-    // Add all the function arguments
-    for(Function::const_arg_iterator AI = FI->arg_begin(),
-        AE = FI->arg_end(); AI != AE; ++AI)
-      createSlot(AI);
-
-    // Add all of the basic blocks and instructions
-    for (Function::const_iterator BB = FI->begin(),
-         E = FI->end(); BB != E; ++BB) {
-      createSlot(BB);
-      for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; 
-           ++I) {
-        createSlot(I);
-      }
-    }
-  }
-}
-
-// Process the arguments, basic blocks, and instructions  of a function.
-void SlotMachine::processFunction() {
-
-}
-
-// Clean up after incorporating a function. This is the only way
-// to get out of the function incorporation state that affects the
-// getSlot/createSlot lock. Function incorporation state is indicated
-// by TheFunction != 0.
-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");
-}
-
-/// 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 Value *V) {
-  assert( V && "Can't get slot for null Value" );
-  assert(!isa<Constant>(V) || isa<GlobalValue>(V) &&
-    "Can't insert a non-GlobalValue Constant into SlotMachine");
-
-  // Get the type of the value
-  const Type* VTy = V->getType();
-
-  // Find the type plane in the module map
-  TypedPlanes::const_iterator MI = mMap.find(VTy);
-
-  if ( TheFunction ) {
-    // Lookup the type in the function map too
-    TypedPlanes::const_iterator FI = fMap.find(VTy);
-    // If there is a corresponding type plane in the function map
-    if ( FI != fMap.end() ) {
-      // Lookup the Value in the function map
-      ValueMap::const_iterator FVI = FI->second.map.find(V);
-      // If the value doesn't exist in the function map
-      if ( FVI == FI->second.map.end() ) {
-        // Look up the value in the module map.
-        if (MI == mMap.end()) return -1;
-        ValueMap::const_iterator MVI = MI->second.map.find(V);
-        // If we didn't find it, it wasn't inserted
-        if (MVI == MI->second.map.end()) return -1;
-        assert( MVI != MI->second.map.end() && "Value not found");
-        // We found it only at the module level
-        return MVI->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.
-        if (MI != mMap.end())
-          return MI->second.next_slot + FVI->second;
-        else
-          return FVI->second;
-      }
-    }
-  }
-
-  // N.B. Can get here only if either !TheFunction or the function doesn't
-  // have a corresponding type plane for the Value
-
-  // Make sure the type plane exists
-  if (MI == mMap.end()) return -1;
-  // Lookup the value in the module's map
-  ValueMap::const_iterator MVI = MI->second.map.find(V);
-  // Make sure we found it.
-  if (MVI == MI->second.map.end()) return -1;
-  // Return it.
-  return MVI->second;
-}
-
-/// Get the slot number for a type. This function will assert if you
-/// ask for a Type that hasn't previously been inserted with createSlot.
-int SlotMachine::getSlot(const Type *Ty) {
-  assert( Ty && "Can't get slot for null Type" );
-
-  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 !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<Constant>(V) || isa<GlobalValue>(V) &&
-    "Can't insert a non-GlobalValue Constant into SlotMachine");
-
-  const Type* VTy = V->getType();
-
-  // Just ignore void typed things
-  if (VTy == Type::VoidTy) return 0; // FIXME: Wrong return value!
-
-  // Look up the type plane for the Value's type from the module map
-  TypedPlanes::const_iterator MI = mMap.find(VTy);
-
-  if ( TheFunction ) {
-    // Get the type plane for the Value's type from the function map
-    TypedPlanes::const_iterator FI = fMap.find(VTy);
-    // If there is a corresponding type plane in the function map
-    if ( FI != fMap.end() ) {
-      // Lookup the Value in the function map
-      ValueMap::const_iterator FVI = FI->second.map.find(V);
-      // If the value doesn't exist in the function map
-      if ( FVI == FI->second.map.end() ) {
-        // If there is no corresponding type plane in the module map
-        if ( MI == mMap.end() )
-          return insertValue(V);
-        // Look up the value in the module map
-        ValueMap::const_iterator MVI = MI->second.map.find(V);
-        // If we didn't find it, it wasn't inserted
-        if ( MVI == MI->second.map.end() )
-          return insertValue(V);
-        else
-          // We found it only at the module level
-          return MVI->second;
-
-      // else the value exists in the function map
-      } else {
-        if ( MI == mMap.end() )
-          return FVI->second;
-        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 MI->second.next_slot + FVI->second;
-      }
-
-    // else there is not a corresponding type plane in the function map
-    } else {
-      // If the type plane doesn't exists at the module level
-      if ( MI == mMap.end() ) {
-        return insertValue(V);
-      // else type plane exists at the module level, examine it
-      } else {
-        // Look up the value in the module's map
-        ValueMap::const_iterator MVI = MI->second.map.find(V);
-        // If we didn't find it there either
-        if ( MVI == MI->second.map.end() )
-          // Return the slot number as the module's contribution to
-          // the type plane plus the index of the function map insertion.
-          return MI->second.next_slot + insertValue(V);
-        else
-          return MVI->second;
-      }
-    }
-  }
-
-  // N.B. Can only get here if !TheFunction
-
-  // If the module map's type plane is not for the Value's type
-  if ( MI != mMap.end() ) {
-    // Lookup the value in the module's map
-    ValueMap::const_iterator MVI = MI->second.map.find(V);
-    if ( MVI != MI->second.map.end() )
-      return MVI->second;
-  }
-
-  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<Constant>(V) || isa<GlobalValue>(V) &&
-    "Can't insert a non-GlobalValue Constant into SlotMachine");
-
-  // If this value does not contribute to a plane (is void)
-  // or if the value already has a name then ignore it.
-  if (V->getType() == Type::VoidTy || V->hasName() ) {
-      SC_DEBUG("ignored value " << *V << "\n");
-      return 0;   // FIXME: Wrong return value
-  }
-
-  const Type *VTy = V->getType();
-  unsigned DestSlot = 0;
-
-  if ( TheFunction ) {
-    TypedPlanes::iterator I = fMap.find( VTy );
-    if ( I == fMap.end() )
-      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,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<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 = fTypes.map[Ty] = fTypes.next_slot++;
-  SC_DEBUG("  Inserting type [" << DestSlot << "] = " << Ty << "\n");
-  return DestSlot;
+*/
 }
 
 }  // end anonymous llvm
@@ -1987,15 +1103,16 @@ void WriteModuleToCppFile(Module* mod, std::ostream& o) {
   o << "int main(int argc, char**argv) {\n";
   o << "  Module* Mod = makeLLVMModule();\n";
   o << "  verifyModule(*Mod, PrintMessageAction);\n";
+  o << "  std::cerr.flush();\n";
+  o << "  std::cout.flush();\n";
   o << "  PassManager PM;\n";
   o << "  PM.add(new PrintModulePass(&std::cout));\n";
   o << "  PM.run(*Mod);\n";
   o << "  return 0;\n";
   o << "}\n\n";
   o << "Module* makeLLVMModule() {\n";
-  SlotMachine SlotTable(mod);
-  CppWriter W(o, SlotTable, mod);
-  W.write(mod);
+  CppWriter W(o, mod);
+  W.printModule(mod);
   o << "return mod;\n";
   o << "}\n";
 }