Switch the asmprinter (.ll) and all the stuff it requires over to

use raw_ostream instead of std::ostream.  Among other goodness,
this speeds up llvm-dis of kc++ with a release build from 0.85s
to 0.49s (88% faster).

Other interesting changes:
 1) This makes Value::print be non-virtual.
 2) AP[S]Int and ConstantRange can no longer print to ostream directly, 
    use raw_ostream instead.
 3) This fixes a bug in raw_os_ostream where it didn't flush itself 
    when destroyed.
 4) This adds a new SDNode::print method, instead of only allowing "dump".


A lot of APIs have both std::ostream and raw_ostream versions, it would
be useful to go through and systematically anihilate the std::ostream 
versions.

This passes dejagnu, but there may be minor fallout, plz let me know if
so and I'll fix it.



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

examples/Fibonacci/fibonacci.cpp

@@ -32,7 +32,7 @@
 #include "llvm/ExecutionEngine/JIT.h"
 #include "llvm/ExecutionEngine/Interpreter.h"
 #include "llvm/ExecutionEngine/GenericValue.h"
-#include <iostream>
+#include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 static Function *CreateFibFunction(Module *M) {
@@ -100,15 +100,15 @@ int main(int argc, char **argv) {
   ExistingModuleProvider *MP = new ExistingModuleProvider(M);
   ExecutionEngine *EE = ExecutionEngine::create(MP, false);
 
-  std::cerr << "verifying... ";
+  errs() << "verifying... ";
   if (verifyModule(*M)) {
-    std::cerr << argv[0] << ": Error constructing function!\n";
+    errs() << argv[0] << ": Error constructing function!\n";
     return 1;
   }
 
-  std::cerr << "OK\n";
+  errs() << "OK\n";
-  std::cerr << "We just constructed this LLVM module:\n\n---------\n" << *M;
+  errs() << "We just constructed this LLVM module:\n\n---------\n" << *M;
-  std::cerr << "---------\nstarting fibonacci(" << n << ") with JIT...\n";
+  errs() << "---------\nstarting fibonacci(" << n << ") with JIT...\n";
 
   // Call the Fibonacci function with argument n:
   std::vector<GenericValue> Args(1);
@@ -116,6 +116,6 @@ int main(int argc, char **argv) {
   GenericValue GV = EE->runFunction(FibF, Args);
 
   // import result of execution
-  std::cout << "Result: " << GV.IntVal << "\n";
+  outs() << "Result: " << GV.IntVal << "\n";
   return 0;
 }

examples/HowToUseJIT/HowToUseJIT.cpp

@@ -42,7 +42,7 @@
 #include "llvm/ExecutionEngine/JIT.h"
 #include "llvm/ExecutionEngine/Interpreter.h"
 #include "llvm/ExecutionEngine/GenericValue.h"
-#include <iostream>
+#include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 int main() {
@@ -99,14 +99,15 @@ int main() {
   ExistingModuleProvider* MP = new ExistingModuleProvider(M);
   ExecutionEngine* EE = ExecutionEngine::create(MP, false);
 
-  std::cout << "We just constructed this LLVM module:\n\n" << *M;
+  outs() << "We just constructed this LLVM module:\n\n" << *M;
-  std::cout << "\n\nRunning foo: " << std::flush;
+  outs() << "\n\nRunning foo: ";
+  outs().flush();
 
   // Call the `foo' function with no arguments:
   std::vector<GenericValue> noargs;
   GenericValue gv = EE->runFunction(FooF, noargs);
 
   // Import result of execution:
-  std::cout << "Result: " << gv.IntVal << "\n";
+  outs() << "Result: " << gv.IntVal << "\n";
   return 0;
 }

include/llvm/ADT/APInt.h

@@ -19,13 +19,13 @@
 #include "llvm/Support/MathExtras.h"
 #include <cassert>
 #include <cstring>
-#include <iosfwd>
 #include <string>
 
 namespace llvm {
   class Serializer;
   class Deserializer;
   class FoldingSetNodeID;
+  class raw_ostream;
   
   template<typename T>
   class SmallVectorImpl;
@@ -1115,8 +1115,7 @@ public:
   /// @}
   /// @name Conversion Functions
   /// @{
-
+  void print(raw_ostream &OS, bool isSigned) const;
-  void print(std::ostream &OS, bool isSigned) const;
   
   /// toString - Converts an APInt to a string and append it to Str.  Str is
   /// commonly a SmallString.
@@ -1385,7 +1384,7 @@ inline bool operator!=(uint64_t V1, const APInt& V2) {
   return V2 != V1;
 }
 
-inline std::ostream &operator<<(std::ostream &OS, const APInt &I) {
+inline raw_ostream &operator<<(raw_ostream &OS, const APInt &I) {
   I.print(OS, true);
   return OS;
 }

include/llvm/ADT/APSInt.h

@@ -239,7 +239,7 @@ public:
   void Profile(FoldingSetNodeID& ID) const;
 };
   
-inline std::ostream &operator<<(std::ostream &OS, const APSInt &I) {
+inline raw_ostream &operator<<(raw_ostream &OS, const APSInt &I) {
   I.print(OS, I.isSigned());
   return OS;
 }

include/llvm/Argument.h

@@ -65,11 +65,6 @@ public:
   /// removeAttr - Remove a ParamAttr from an argument
   void removeAttr(ParameterAttributes);
 
-  virtual void print(std::ostream &OS) const;
-  void print(std::ostream *OS) const {
-    if (OS) print(*OS);
-  }
-
   /// classof - Methods for support type inquiry through isa, cast, and
   /// dyn_cast:
   ///

include/llvm/Assembly/AsmAnnotationWriter.h

@@ -17,13 +17,12 @@
 #ifndef LLVM_ASSEMBLY_ASMANNOTATIONWRITER_H
 #define LLVM_ASSEMBLY_ASMANNOTATIONWRITER_H
 
-#include <iosfwd>
-
 namespace llvm {
 
 class Function;
 class BasicBlock;
 class Instruction;
+class raw_ostream;
 
 struct AssemblyAnnotationWriter {
 
@@ -31,21 +30,21 @@ struct AssemblyAnnotationWriter {
 
   // emitFunctionAnnot - This may be implemented to emit a string right before
   // the start of a function.
-  virtual void emitFunctionAnnot(const Function *F, std::ostream &OS) {}
+  virtual void emitFunctionAnnot(const Function *F, raw_ostream &OS) {}
 
   // emitBasicBlockStartAnnot - This may be implemented to emit a string right
   // after the basic block label, but before the first instruction in the block.
-  virtual void emitBasicBlockStartAnnot(const BasicBlock *BB, std::ostream &OS){
+  virtual void emitBasicBlockStartAnnot(const BasicBlock *BB, raw_ostream &OS){
   }
 
   // emitBasicBlockEndAnnot - This may be implemented to emit a string right
   // after the basic block.
-  virtual void emitBasicBlockEndAnnot(const BasicBlock *BB, std::ostream &OS){
+  virtual void emitBasicBlockEndAnnot(const BasicBlock *BB, raw_ostream &OS){
   }
 
   // emitInstructionAnnot - This may be implemented to emit a string right
   // before an instruction is emitted.
-  virtual void emitInstructionAnnot(const Instruction *I, std::ostream &OS) {}
+  virtual void emitInstructionAnnot(const Instruction *I, raw_ostream &OS) {}
 };
 
 } // End llvm namespace

include/llvm/Assembly/Writer.h

@@ -24,12 +24,14 @@ namespace llvm {
 class Type;
 class Module;
 class Value;
+class raw_ostream;
 
 // WriteTypeSymbolic - This attempts to write the specified type as a symbolic
 // type, iff there is an entry in the Module's symbol table for the specified
 // type or one of its component types.  This is slower than a simple x << Type;
 //
 void WriteTypeSymbolic(std::ostream &, const Type *, const Module *M);
+void WriteTypeSymbolic(raw_ostream &, const Type *, const Module *M);
 
 // 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
@@ -39,6 +41,8 @@ void WriteTypeSymbolic(std::ostream &, const Type *, const Module *M);
 //
 void WriteAsOperand(std::ostream &, const Value *, bool PrintTy = true,
                     const Module *Context = 0);
+void WriteAsOperand(raw_ostream &, const Value *, bool PrintTy = true,
+                    const Module *Context = 0);
 
 } // End llvm namespace
 

include/llvm/BasicBlock.h

@@ -157,10 +157,6 @@ public:
   const InstListType &getInstList() const { return InstList; }
         InstListType &getInstList()       { return InstList; }
 
-  virtual void print(std::ostream &OS) const { print(OS, 0); }
-  void print(std::ostream *OS) const { if (OS) print(*OS); }
-  void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
-
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const BasicBlock *) { return true; }
   static inline bool classof(const Value *V) {

include/llvm/CodeGen/MachineConstantPool.h

@@ -29,6 +29,7 @@ class TargetData;
 class TargetMachine;
 class Type;
 class MachineConstantPool;
+class raw_ostream;
 
 /// Abstract base class for all machine specific constantpool value subclasses.
 ///
@@ -50,8 +51,9 @@ public:
 
   /// print - Implement operator<<...
   ///
-  virtual void print(std::ostream &O) const = 0;
+  void print(std::ostream &O) const;
   void print(std::ostream *O) const { if (O) print(*O); }
+  virtual void print(raw_ostream &O) const = 0;
 };
 
 inline std::ostream &operator<<(std::ostream &OS,
@@ -59,6 +61,13 @@ inline std::ostream &operator<<(std::ostream &OS,
   V.print(OS);
   return OS;
 }
+  
+inline raw_ostream &operator<<(raw_ostream &OS,
+                               const MachineConstantPoolValue &V) {
+  V.print(OS);
+  return OS;
+}
+  
 
 /// This class is a data container for one entry in a MachineConstantPool.
 /// It contains a pointer to the value and an offset from the start of

include/llvm/CodeGen/SelectionDAGNodes.h

@@ -1260,6 +1260,7 @@ public:
   ///
   std::string getOperationName(const SelectionDAG *G = 0) const;
   static const char* getIndexedModeName(ISD::MemIndexedMode AM);
+  void print(raw_ostream &OS, const SelectionDAG *G = 0) const;
   void dump() const;
   void dump(const SelectionDAG *G) const;
 

include/llvm/Constant.h

@@ -58,9 +58,6 @@ public:
   /// getNullValue.
   virtual bool isNullValue() const = 0;
 
-  virtual void print(std::ostream &O) const;
-  void print(std::ostream *O) const { if (O) print(*O); }
-  
   /// canTrap - Return true if evaluation of this constant could trap.  This is
   /// true for things like constant expressions that could divide by zero.
   bool canTrap() const;

include/llvm/Function.h

@@ -301,10 +301,6 @@ public:
   size_t arg_size() const;
   bool arg_empty() const;
 
-  virtual void print(std::ostream &OS) const { print(OS, 0); }
-  void print(std::ostream *OS) const { if (OS) print(*OS); }
-  void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
-
   /// viewCFG - This function is meant for use from the debugger.  You can just
   /// say 'call F->viewCFG()' and a ghostview window should pop up from the
   /// program, displaying the CFG of the current function with the code for each

include/llvm/GlobalAlias.h

@@ -62,9 +62,6 @@ public:
   ///
   void eraseFromParent();
 
-  virtual void print(std::ostream &OS) const;
-  void print(std::ostream *OS) const { if (OS) print(*OS); }
-
   /// set/getAliasee - These methods retrive and set alias target.
   void setAliasee(Constant* GV);
   const Constant* getAliasee() const {

include/llvm/GlobalVariable.h

@@ -133,9 +133,6 @@ public:
   /// replace constant initializers.
   virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
 
-  virtual void print(std::ostream &OS) const;
-  void print(std::ostream *OS) const { if (OS) print(*OS); }
-
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const GlobalVariable *) { return true; }
   static inline bool classof(const Value *V) {

include/llvm/InlineAsm.h

@@ -21,7 +21,6 @@
 
 namespace llvm {
 
-struct AssemblyAnnotationWriter;
 class PointerType;
 class FunctionType;
 class Module;
@@ -58,10 +57,6 @@ public:
   const std::string &getAsmString() const { return AsmString; }
   const std::string &getConstraintString() const { return Constraints; }
 
-  virtual void print(std::ostream &O) const { print(O, 0); }
-  void print(std::ostream *O) const { if (O) print(*O); }
-  void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
-
   /// Verify - This static method can be used by the parser to check to see if
   /// the specified constraint string is legal for the type.  This returns true
   /// if legal, false if not.

include/llvm/Instruction.h

@@ -20,8 +20,6 @@
 
 namespace llvm {
 
-struct AssemblyAnnotationWriter;
-
 template<typename ValueSubClass, typename ItemParentClass>
   class SymbolTableListTraits;
 
@@ -180,10 +178,6 @@ public:
   }
   static bool isTrapping(unsigned op);
 
-  virtual void print(std::ostream &OS) const { print(OS, 0); }
-  void print(std::ostream *OS) const { if (OS) print(*OS); }
-  void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
-
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Instruction *) { return true; }
   static inline bool classof(const Value *V) {

include/llvm/Module.h

@@ -350,15 +350,11 @@ public:
 /// @name Utility functions for printing and dumping Module objects
 /// @{
 public:
-  /// Print the module to an output stream
-  void print(std::ostream &OS) const { print(OS, 0); }
-  void print(std::ostream *OS) const { if (OS) print(*OS); }
   /// Print the module to an output stream with AssemblyAnnotationWriter.
+  void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW) const;
   void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
-  void print(std::ostream *OS, AssemblyAnnotationWriter *AAW) const {
+  
-    if (OS) print(*OS, AAW);
+  /// Dump the module to stderr (for debugging).
-  }
-  /// Dump the module to std::cerr (for debugging).
   void dump() const;
   /// This function causes all the subinstructions to "let go" of all references
   /// that they are maintaining.  This allows one to 'delete' a whole class at
@@ -385,9 +381,14 @@ public:
 
 /// An iostream inserter for modules.
 inline std::ostream &operator<<(std::ostream &O, const Module &M) {
-  M.print(O);
+  M.print(O, 0);
   return O;
 }
+inline raw_ostream &operator<<(raw_ostream &O, const Module &M) {
+  M.print(O, 0);
+  return O;
+}
+  
 
 inline ValueSymbolTable *
 ilist_traits<Function>::getSymTab(Module *M) {

include/llvm/Support/ConstantRange.h

@@ -32,8 +32,6 @@
 
 #include "llvm/ADT/APInt.h"
 #include "llvm/Support/DataTypes.h"
-#include "llvm/Support/Streams.h"
-#include <iosfwd>
 
 namespace llvm {
 
@@ -180,15 +178,14 @@ class ConstantRange {
 
   /// print - Print out the bounds to a stream...
   ///
-  void print(std::ostream &OS) const;
+  void print(raw_ostream &OS) const;
-  void print(std::ostream *OS) const { if (OS) print(*OS); }
 
   /// dump - Allow printing from a debugger easily...
   ///
   void dump() const;
 };
 
-inline std::ostream &operator<<(std::ostream &OS, const ConstantRange &CR) {
+inline raw_ostream &operator<<(raw_ostream &OS, const ConstantRange &CR) {
   CR.print(OS);
   return OS;
 }

include/llvm/Support/raw_ostream.h

@@ -96,7 +96,7 @@ public:
   raw_ostream &operator<<(long N);
   raw_ostream &operator<<(unsigned long long N);
   raw_ostream &operator<<(long long N);
-  
+  raw_ostream &operator<<(const void *P);
   raw_ostream &operator<<(unsigned int N) {
     return this->operator<<(static_cast<unsigned long>(N));
   }
@@ -201,7 +201,8 @@ class raw_os_ostream : public raw_ostream {
   std::ostream &OS;
 public:
   raw_os_ostream(std::ostream &O) : OS(O) {}
-  
+  ~raw_os_ostream();
+
   /// flush_impl - The is the piece of the class that is implemented by
   /// subclasses.  This outputs the currently buffered data and resets the
   /// buffer to empty.

include/llvm/Type.h

@@ -14,7 +14,6 @@
 #include "llvm/AbstractTypeUser.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/DataTypes.h"
-#include "llvm/Support/Streams.h"
 #include "llvm/ADT/GraphTraits.h"
 #include "llvm/ADT/iterator.h"
 #include <string>
@@ -26,6 +25,7 @@ class DerivedType;
 class PointerType;
 class IntegerType;
 class TypeMapBase;
+class raw_ostream;
 
 /// This file contains the declaration of the Type class.  For more "Type" type
 /// stuff, look in DerivedTypes.h.
@@ -156,6 +156,7 @@ protected:
   PATypeHandle *ContainedTys;
 
 public:
+  void print(raw_ostream &O) const;
   void print(std::ostream &O) const;
   void print(std::ostream *O) const { if (O) print(*O); }
 
@@ -450,6 +451,7 @@ template <> inline bool isa_impl<PointerType, Type>(const Type &Ty) {
 }
 
 std::ostream &operator<<(std::ostream &OS, const Type &T);
+raw_ostream &operator<<(raw_ostream &OS, const Type &T);
 
 } // End llvm namespace
 

include/llvm/Value.h

@@ -35,6 +35,8 @@ class ValueSymbolTable;
 class TypeSymbolTable;
 template<typename ValueTy> class StringMapEntry;
 typedef StringMapEntry<Value*> ValueName;
+class raw_ostream;
+class AssemblyAnnotationWriter;
 
 //===----------------------------------------------------------------------===//
 //                                 Value Class
@@ -76,10 +78,10 @@ public:
   //
   virtual void dump() const;
 
-  /// print - Implement operator<< on Value...
+  /// print - Implement operator<< on Value.
   ///
-  virtual void print(std::ostream &O) const = 0;
+  void print(std::ostream &O, AssemblyAnnotationWriter *AAW = 0) const;
-  void print(std::ostream *O) const { if (O) print(*O); }
+  void print(raw_ostream &O, AssemblyAnnotationWriter *AAW = 0) const;
 
   /// All values are typed, get the type of this value.
   ///
@@ -237,7 +239,11 @@ inline std::ostream &operator<<(std::ostream &OS, const Value &V) {
   V.print(OS);
   return OS;
 }
-
+inline raw_ostream &operator<<(raw_ostream &OS, const Value &V) {
+  V.print(OS);
+  return OS;
+}
+  
 void Use::init(Value *V, User *) {
   Val = V;
   if (V) V->addUse(*this);

lib/Analysis/LoopVR.cpp

@@ -6,6 +6,10 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+//
+// FIXME: What does this do?
+//
+//===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "loopvr"
 #include "llvm/Analysis/LoopVR.h"
@@ -15,13 +19,11 @@
 #include "llvm/Assembly/Writer.h"
 #include "llvm/Support/CFG.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/Streams.h"
+#include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 char LoopVR::ID = 0;
-namespace {
 static RegisterPass<LoopVR> X("loopvr", "Loop Value Ranges", true, true);
-}
 
 /// getRange - determine the range for a particular SCEV within a given Loop
 ConstantRange LoopVR::getRange(SCEVHandle S, Loop *L, ScalarEvolution &SE) {
@@ -220,11 +222,10 @@ ConstantRange LoopVR::getRange(SCEVHandle S, SCEVHandle T, ScalarEvolution &SE){
 bool LoopVR::runOnFunction(Function &F) { Map.clear(); return false; }
 
 void LoopVR::print(std::ostream &os, const Module *) const {
+  raw_os_ostream OS(os);
   for (std::map<Value *, ConstantRange *>::const_iterator I = Map.begin(),
        E = Map.end(); I != E; ++I) {
-    os << *I->first << ": ";
+    OS << *I->first << ": " << *I->second << '\n';
-    I->second->print(os);
-    os << "\n";
   }
 }
 

lib/CodeGen/MachineFunction.cpp

@@ -28,6 +28,7 @@
 #include "llvm/Instructions.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/GraphWriter.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Config/config.h"
 #include <fstream>
@@ -525,6 +526,10 @@ unsigned MachineConstantPool::getConstantPoolIndex(MachineConstantPoolValue *V,
   return Constants.size()-1;
 }
 
+void MachineConstantPoolValue::print(std::ostream &o) const {
+  raw_os_ostream OS(o);
+  print(OS);
+}
 
 void MachineConstantPool::print(std::ostream &OS) const {
   for (unsigned i = 0, e = Constants.size(); i != e; ++i) {

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

@@ -24,12 +24,13 @@
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/PseudoSourceValue.h"
-#include "llvm/Support/MathExtras.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/Target/TargetLowering.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetMachine.h"
+#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallSet.h"
@@ -4980,169 +4981,166 @@ std::string ISD::ArgFlagsTy::getArgFlagsString() {
 
 void SDNode::dump() const { dump(0); }
 void SDNode::dump(const SelectionDAG *G) const {
-  cerr << (void*)this << ": ";
+  print(errs(), G);
+}
+
+void SDNode::print(raw_ostream &OS, const SelectionDAG *G) const {
+  OS << (void*)this << ": ";
 
   for (unsigned i = 0, e = getNumValues(); i != e; ++i) {
-    if (i) cerr << ",";
+    if (i) OS << ",";
     if (getValueType(i) == MVT::Other)
-      cerr << "ch";
+      OS << "ch";
     else
-      cerr << getValueType(i).getMVTString();
+      OS << getValueType(i).getMVTString();
   }
-  cerr << " = " << getOperationName(G);
+  OS << " = " << getOperationName(G);
 
-  cerr << " ";
+  OS << " ";
   for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
-    if (i) cerr << ", ";
+    if (i) OS << ", ";
-    cerr << (void*)getOperand(i).Val;
+    OS << (void*)getOperand(i).Val;
     if (unsigned RN = getOperand(i).ResNo)
-      cerr << ":" << RN;
+      OS << ":" << RN;
   }
 
   if (!isTargetOpcode() && getOpcode() == ISD::VECTOR_SHUFFLE) {
     SDNode *Mask = getOperand(2).Val;
-    cerr << "<";
+    OS << "<";
     for (unsigned i = 0, e = Mask->getNumOperands(); i != e; ++i) {
-      if (i) cerr << ",";
+      if (i) OS << ",";
       if (Mask->getOperand(i).getOpcode() == ISD::UNDEF)
-        cerr << "u";
+        OS << "u";
       else
-        cerr << cast<ConstantSDNode>(Mask->getOperand(i))->getValue();
+        OS << cast<ConstantSDNode>(Mask->getOperand(i))->getValue();
     }
-    cerr << ">";
+    OS << ">";
   }
 
   if (const ConstantSDNode *CSDN = dyn_cast<ConstantSDNode>(this)) {
-    cerr << '<' << CSDN->getAPIntValue() << '>';
+    OS << '<' << CSDN->getAPIntValue() << '>';
   } else if (const ConstantFPSDNode *CSDN = dyn_cast<ConstantFPSDNode>(this)) {
     if (&CSDN->getValueAPF().getSemantics()==&APFloat::IEEEsingle)
-      cerr << '<' << CSDN->getValueAPF().convertToFloat() << '>';
+      OS << '<' << CSDN->getValueAPF().convertToFloat() << '>';
     else if (&CSDN->getValueAPF().getSemantics()==&APFloat::IEEEdouble)
-      cerr << '<' << CSDN->getValueAPF().convertToDouble() << '>';
+      OS << '<' << CSDN->getValueAPF().convertToDouble() << '>';
     else {
-      cerr << "<APFloat(";
+      OS << "<APFloat(";
       CSDN->getValueAPF().convertToAPInt().dump();
-      cerr << ")>";
+      OS << ")>";
     }
   } else if (const GlobalAddressSDNode *GADN =
              dyn_cast<GlobalAddressSDNode>(this)) {
     int offset = GADN->getOffset();
-    cerr << '<';
+    OS << '<';
-    WriteAsOperand(*cerr.stream(), GADN->getGlobal());
+    WriteAsOperand(OS, GADN->getGlobal());
-    cerr << '>';
+    OS << '>';
     if (offset > 0)
-      cerr << " + " << offset;
+      OS << " + " << offset;
     else
-      cerr << " " << offset;
+      OS << " " << offset;
   } else if (const FrameIndexSDNode *FIDN = dyn_cast<FrameIndexSDNode>(this)) {
-    cerr << "<" << FIDN->getIndex() << ">";
+    OS << "<" << FIDN->getIndex() << ">";
   } else if (const JumpTableSDNode *JTDN = dyn_cast<JumpTableSDNode>(this)) {
-    cerr << "<" << JTDN->getIndex() << ">";
+    OS << "<" << JTDN->getIndex() << ">";
   } else if (const ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(this)){
     int offset = CP->getOffset();
     if (CP->isMachineConstantPoolEntry())
-      cerr << "<" << *CP->getMachineCPVal() << ">";
+      OS << "<" << *CP->getMachineCPVal() << ">";
     else
-      cerr << "<" << *CP->getConstVal() << ">";
+      OS << "<" << *CP->getConstVal() << ">";
     if (offset > 0)
-      cerr << " + " << offset;
+      OS << " + " << offset;
     else
-      cerr << " " << offset;
+      OS << " " << offset;
   } else if (const BasicBlockSDNode *BBDN = dyn_cast<BasicBlockSDNode>(this)) {
-    cerr << "<";
+    OS << "<";
     const Value *LBB = (const Value*)BBDN->getBasicBlock()->getBasicBlock();
     if (LBB)
-      cerr << LBB->getName() << " ";
+      OS << LBB->getName() << " ";
-    cerr << (const void*)BBDN->getBasicBlock() << ">";
+    OS << (const void*)BBDN->getBasicBlock() << ">";
   } else if (const RegisterSDNode *R = dyn_cast<RegisterSDNode>(this)) {
     if (G && R->getReg() &&
         TargetRegisterInfo::isPhysicalRegister(R->getReg())) {
-      cerr << " " << G->getTarget().getRegisterInfo()->getName(R->getReg());
+      OS << " " << G->getTarget().getRegisterInfo()->getName(R->getReg());
     } else {
-      cerr << " #" << R->getReg();
+      OS << " #" << R->getReg();
     }
   } else if (const ExternalSymbolSDNode *ES =
              dyn_cast<ExternalSymbolSDNode>(this)) {
-    cerr << "'" << ES->getSymbol() << "'";
+    OS << "'" << ES->getSymbol() << "'";
   } else if (const SrcValueSDNode *M = dyn_cast<SrcValueSDNode>(this)) {
     if (M->getValue())
-      cerr << "<" << M->getValue() << ">";
+      OS << "<" << M->getValue() << ">";
     else
-      cerr << "<null>";
+      OS << "<null>";
   } else if (const MemOperandSDNode *M = dyn_cast<MemOperandSDNode>(this)) {
     if (M->MO.getValue())
-      cerr << "<" << M->MO.getValue() << ":" << M->MO.getOffset() << ">";
+      OS << "<" << M->MO.getValue() << ":" << M->MO.getOffset() << ">";
     else
-      cerr << "<null:" << M->MO.getOffset() << ">";
+      OS << "<null:" << M->MO.getOffset() << ">";
   } else if (const ARG_FLAGSSDNode *N = dyn_cast<ARG_FLAGSSDNode>(this)) {
-    cerr << N->getArgFlags().getArgFlagsString();
+    OS << N->getArgFlags().getArgFlagsString();
   } else if (const VTSDNode *N = dyn_cast<VTSDNode>(this)) {
-    cerr << ":" << N->getVT().getMVTString();
+    OS << ":" << N->getVT().getMVTString();
   }
   else if (const LoadSDNode *LD = dyn_cast<LoadSDNode>(this)) {
     const Value *SrcValue = LD->getSrcValue();
     int SrcOffset = LD->getSrcValueOffset();
-    cerr << " <";
+    OS << " <";
     if (SrcValue)
-      cerr << SrcValue;
+      OS << SrcValue;
     else
-      cerr << "null";
+      OS << "null";
-    cerr << ":" << SrcOffset << ">";
+    OS << ":" << SrcOffset << ">";
 
     bool doExt = true;
     switch (LD->getExtensionType()) {
     default: doExt = false; break;
-    case ISD::EXTLOAD:
+    case ISD::EXTLOAD: OS << " <anyext "; break;
-      cerr << " <anyext ";
+    case ISD::SEXTLOAD: OS << " <sext "; break;
-      break;
+    case ISD::ZEXTLOAD: OS << " <zext "; break;
-    case ISD::SEXTLOAD:
-      cerr << " <sext ";
-      break;
-    case ISD::ZEXTLOAD:
-      cerr << " <zext ";
-      break;
     }
     if (doExt)
-      cerr << LD->getMemoryVT().getMVTString() << ">";
+      OS << LD->getMemoryVT().getMVTString() << ">";
 
     const char *AM = getIndexedModeName(LD->getAddressingMode());
     if (*AM)
-      cerr << " " << AM;
+      OS << " " << AM;
     if (LD->isVolatile())
-      cerr << " <volatile>";
+      OS << " <volatile>";
-    cerr << " alignment=" << LD->getAlignment();
+    OS << " alignment=" << LD->getAlignment();
   } else if (const StoreSDNode *ST = dyn_cast<StoreSDNode>(this)) {
     const Value *SrcValue = ST->getSrcValue();
     int SrcOffset = ST->getSrcValueOffset();
-    cerr << " <";
+    OS << " <";
     if (SrcValue)
-      cerr << SrcValue;
+      OS << SrcValue;
     else
-      cerr << "null";
+      OS << "null";
-    cerr << ":" << SrcOffset << ">";
+    OS << ":" << SrcOffset << ">";
 
     if (ST->isTruncatingStore())
-      cerr << " <trunc "
+      OS << " <trunc " << ST->getMemoryVT().getMVTString() << ">";
-           << ST->getMemoryVT().getMVTString() << ">";
 
     const char *AM = getIndexedModeName(ST->getAddressingMode());
     if (*AM)
-      cerr << " " << AM;
+      OS << " " << AM;
     if (ST->isVolatile())
-      cerr << " <volatile>";
+      OS << " <volatile>";
-    cerr << " alignment=" << ST->getAlignment();
+    OS << " alignment=" << ST->getAlignment();
   } else if (const AtomicSDNode* AT = dyn_cast<AtomicSDNode>(this)) {
     const Value *SrcValue = AT->getSrcValue();
     int SrcOffset = AT->getSrcValueOffset();
-    cerr << " <";
+    OS << " <";
     if (SrcValue)
-      cerr << SrcValue;
+      OS << SrcValue;
     else
-      cerr << "null";
+      OS << "null";
-    cerr << ":" << SrcOffset << ">";
+    OS << ":" << SrcOffset << ">";
     if (AT->isVolatile())
-      cerr << " <volatile>";
+      OS << " <volatile>";
-    cerr << " alignment=" << AT->getAlignment();
+    OS << " alignment=" << AT->getAlignment();
   }
 }
 

lib/Support/APInt.cpp

@@ -18,6 +18,7 @@
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cmath>
 #include <limits>
 #include <cstring>
@@ -41,8 +42,7 @@ inline static uint64_t* getMemory(uint32_t numWords) {
   return result;
 }
 
-void APInt::initSlowCase(uint32_t numBits, uint64_t val, bool isSigned) 
+void APInt::initSlowCase(uint32_t numBits, uint64_t val, bool isSigned) {
-{
   pVal = getClearedMemory(getNumWords());
   pVal[0] = val;
   if (isSigned && int64_t(val) < 0) 
@@ -51,7 +51,7 @@ void APInt::initSlowCase(uint32_t numBits, uint64_t val, bool isSigned)
 }
 
 APInt::APInt(uint32_t numBits, uint32_t numWords, const uint64_t bigVal[])
-  : BitWidth(numBits), VAL(0)  {
+  : BitWidth(numBits), VAL(0) {
   assert(BitWidth && "bitwidth too small");
   assert(bigVal && "Null pointer detected!");
   if (isSingleWord())
@@ -1995,13 +1995,12 @@ void APInt::dump() const {
   fprintf(stderr, "APInt(%db, %su %ss)", BitWidth, U.c_str(), S.c_str());
 }
 
-void APInt::print(std::ostream &OS, bool isSigned) const {
+void APInt::print(raw_ostream &OS, bool isSigned) const {
   SmallString<40> S;
   this->toString(S, 10, isSigned);
   OS << S.c_str();
 }
 
-
 // This implements a variety of operations on a representation of
 // arbitrary precision, two's-complement, bignum integer values.
 

lib/Support/ConstantRange.cpp

@@ -22,8 +22,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/ConstantRange.h"
-#include "llvm/Support/Streams.h"
+#include "llvm/Support/raw_ostream.h"
-#include <ostream>
 using namespace llvm;
 
 /// Initialize a full (the default) or empty set for the specified type.
@@ -462,12 +461,12 @@ ConstantRange ConstantRange::truncate(uint32_t DstTySize) const {
 
 /// print - Print out the bounds to a stream...
 ///
-void ConstantRange::print(std::ostream &OS) const {
+void ConstantRange::print(raw_ostream &OS) const {
   OS << "[" << Lower << "," << Upper << ")";
 }
 
 /// dump - Allow printing from a debugger easily...
 ///
 void ConstantRange::dump() const {
-  print(cerr);
+  print(errs());
 }

lib/Support/raw_ostream.cpp

@@ -99,6 +99,12 @@ raw_ostream &raw_ostream::operator<<(long long N) {
   return this->operator<<(static_cast<unsigned long long>(N));
 }
 
+raw_ostream &raw_ostream::operator<<(const void *P) {
+  // FIXME: This could be much faster if it matters.
+  return *this << format("%p", P);
+}
+
+
 raw_ostream &raw_ostream::write(const char *Ptr, unsigned Size) {
   if (OutBufCur+Size > OutBufEnd)
     flush_impl();
@@ -250,6 +256,10 @@ raw_ostream &llvm::errs() {
 //  raw_os_ostream
 //===----------------------------------------------------------------------===//
 
+raw_os_ostream::~raw_os_ostream() {
+  flush();
+}
+
 /// flush_impl - The is the piece of the class that is implemented by
 /// subclasses.  This outputs the currently buffered data and resets the
 /// buffer to empty.

lib/Target/ARM/ARMConstantPoolValue.cpp

@@ -15,6 +15,7 @@
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/GlobalValue.h"
 #include "llvm/Type.h"
+#include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 ARMConstantPoolValue::ARMConstantPoolValue(GlobalValue *gv, unsigned id,
@@ -72,7 +73,7 @@ ARMConstantPoolValue::AddSelectionDAGCSEId(FoldingSetNodeID &ID) {
   ID.AddInteger(PCAdjust);
 }
 
-void ARMConstantPoolValue::print(std::ostream &O) const {
+void ARMConstantPoolValue::print(raw_ostream &O) const {
   if (GV)
     O << GV->getName();
   else

lib/Target/ARM/ARMConstantPoolValue.h

@@ -69,7 +69,7 @@ public:
 
   virtual void AddSelectionDAGCSEId(FoldingSetNodeID &ID);
 
-  virtual void print(std::ostream &O) const;
+  virtual void print(raw_ostream &O) const;
 };
   
 }

lib/Target/PIC16/PIC16ConstantPoolValue.cpp

@@ -15,6 +15,7 @@
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/GlobalValue.h"
 #include "llvm/Type.h"
+#include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 PIC16ConstantPoolValue::PIC16ConstantPoolValue(GlobalValue *gv, unsigned id,
@@ -70,7 +71,7 @@ PIC16ConstantPoolValue::AddSelectionDAGCSEId(FoldingSetNodeID &ID) {
   ID.AddInteger(PCAdjust);
 }
 
-void PIC16ConstantPoolValue::print(std::ostream &O) const {
+void PIC16ConstantPoolValue::print(raw_ostream &O) const {
   if (GV)
     O << GV->getName();
   else

lib/Target/PIC16/PIC16ConstantPoolValue.h

@@ -69,7 +69,7 @@ public:
 
   virtual void AddSelectionDAGCSEId(FoldingSetNodeID &ID);
 
-  virtual void print(std::ostream &O) const;
+  virtual void print(raw_ostream &O) const;
 };
   
 }

lib/Transforms/Scalar/PredicateSimplifier.cpp

@@ -922,7 +922,7 @@ namespace {
       void dump(std::ostream &os) const {
         os << "{";
         for (const_iterator I = begin(), E = end(); I != E; ++I) {
-          os << I->second << " (" << I->first->getDFSNumIn() << "), ";
+          os << &I->second << " (" << I->first->getDFSNumIn() << "), ";
         }
         os << "}";
       }

lib/Transforms/Utils/LowerSwitch.cpp

@@ -22,6 +22,7 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 using namespace llvm;
 
@@ -144,9 +145,10 @@ BasicBlock* LowerSwitch::switchConvert(CaseItr Begin, CaseItr End,
   DOUT << "RHS: " << RHS << "\n";
 
   CaseRange& Pivot = *(Begin + Mid);
-  DEBUG(cerr << "Pivot ==> " 
+  DEBUG(errs() << "Pivot ==> " 
-             << cast<ConstantInt>(Pivot.Low)->getValue() << " -"
+               << cast<ConstantInt>(Pivot.Low)->getValue() << " -"
-             << cast<ConstantInt>(Pivot.High)->getValue() << "\n");
+               << cast<ConstantInt>(Pivot.High)->getValue() << "\n";
+        errs().flush());
 
   BasicBlock* LBranch = switchConvert(LHS.begin(), LHS.end(), Val,
                                       OrigBlock, Default);

lib/VMCore/AsmWriter.cpp

@@ -31,7 +31,6 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/CFG.h"
 #include "llvm/Support/MathExtras.h"
-#include "llvm/Support/Streams.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cctype>
@@ -126,7 +125,7 @@ enum PrefixType {
 /// PrintLLVMName - Turn the specified name 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).  Print it out.
-static void PrintLLVMName(std::ostream &OS, const char *NameStr,
+static void PrintLLVMName(raw_ostream &OS, const char *NameStr,
                           unsigned NameLen, PrefixType Prefix) {
   assert(NameStr && "Cannot get empty name!");
   switch (Prefix) {
@@ -184,7 +183,7 @@ static void PrintLLVMName(std::ostream &OS, const char *NameStr,
 /// PrintLLVMName - Turn the specified name 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).  Print it out.
-static void PrintLLVMName(std::ostream &OS, const Value *V) {
+static void PrintLLVMName(raw_ostream &OS, const Value *V) {
   PrintLLVMName(OS, V->getNameStart(), V->getNameLen(),
                 isa<GlobalValue>(V) ? GlobalPrefix : LocalPrefix);
 }
@@ -439,7 +438,7 @@ void SlotTracker::CreateFunctionSlot(const Value *V) {
 // AsmWriter Implementation
 //===----------------------------------------------------------------------===//
 
-static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
+static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
                                std::map<const Type *, std::string> &TypeTable,
                                    SlotTracker *Machine);
 
@@ -579,7 +578,7 @@ static void calcTypeName(const Type *Ty,
 /// printTypeInt - The internal guts of printing out a type that has a
 /// potentially named portion.
 ///
-static void printTypeInt(std::ostream &Out, const Type *Ty,
+static void printTypeInt(raw_ostream &Out, const Type *Ty,
                          std::map<const Type *, std::string> &TypeNames) {
   // Primitive types always print out their description, regardless of whether
   // they have been named or not.
@@ -614,6 +613,11 @@ static void printTypeInt(std::ostream &Out, const Type *Ty,
 ///
 void llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty,
                              const Module *M) {
+  raw_os_ostream RO(Out);
+  WriteTypeSymbolic(RO, Ty, M);
+}
+
+void llvm::WriteTypeSymbolic(raw_ostream &Out, const Type *Ty, const Module *M){
   Out << ' ';
 
   // If they want us to print out a type, but there is no context, we can't
@@ -629,7 +633,7 @@ void llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty,
 
 // PrintEscapedString - Print each character of the specified string, escaping
 // it if it is not printable or if it is an escape char.
-static void PrintEscapedString(const std::string &Str, std::ostream &Out) {
+static void PrintEscapedString(const std::string &Str, raw_ostream &Out) {
   for (unsigned i = 0, e = Str.size(); i != e; ++i) {
     unsigned char C = Str[i];
     if (isprint(C) && C != '"' && C != '\\') {
@@ -675,7 +679,7 @@ static const char *getPredicateText(unsigned predicate) {
   return pred;
 }
 
-static void WriteConstantInt(std::ostream &Out, const Constant *CV,
+static void WriteConstantInt(raw_ostream &Out, const Constant *CV,
                              std::map<const Type *, std::string> &TypeTable,
                              SlotTracker *Machine) {
   if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
@@ -873,7 +877,7 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV,
 /// 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 Value *V,
+static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
                                   std::map<const Type*, std::string> &TypeTable,
                                    SlotTracker *Machine) {
   Out << ' ';
@@ -936,6 +940,12 @@ static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
 ///
 void llvm::WriteAsOperand(std::ostream &Out, const Value *V, bool PrintType,
                           const Module *Context) {
+  raw_os_ostream OS(Out);
+  WriteAsOperand(OS, V, PrintType, Context);
+}
+
+void llvm::WriteAsOperand(raw_ostream &Out, const Value *V, bool PrintType,
+                          const Module *Context) {
   std::map<const Type *, std::string> TypeNames;
   if (Context == 0) Context = getModuleFromVal(V);
 
@@ -952,13 +962,13 @@ void llvm::WriteAsOperand(std::ostream &Out, const Value *V, bool PrintType,
 namespace {
 
 class AssemblyWriter {
-  std::ostream &Out;
+  raw_ostream &Out;
   SlotTracker &Machine;
   const Module *TheModule;
   std::map<const Type *, std::string> TypeNames;
   AssemblyAnnotationWriter *AnnotationWriter;
 public:
-  inline AssemblyWriter(std::ostream &o, SlotTracker &Mac, const Module *M,
+  inline AssemblyWriter(raw_ostream &o, SlotTracker &Mac, const Module *M,
                         AssemblyAnnotationWriter *AAW)
     : Out(o), Machine(Mac), TheModule(M), AnnotationWriter(AAW) {
 
@@ -968,10 +978,19 @@ public:
     fillTypeNameTable(M, TypeNames);
   }
 
-  void write(const Module *M)         { printModule(M);       }
+  void write(const Module *M) { printModule(M);       }
-  void write(const GlobalVariable *G) { printGlobal(G);       }
+  
-  void write(const GlobalAlias *G)    { printAlias(G);        }
+  void write(const GlobalValue *G) {
-  void write(const Function *F)       { printFunction(F);     }
+    if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(G))
+      printGlobal(GV);
+    else if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(G))
+      printAlias(GA);
+    else if (const Function *F = dyn_cast<Function>(G))
+      printFunction(F);
+    else
+      assert(0 && "Unknown global");
+  }
+  
   void write(const BasicBlock *BB)    { printBasicBlock(BB);  }
   void write(const Instruction *I)    { printInstruction(*I); }
   void write(const Type *Ty)          { printType(Ty);        }
@@ -1176,7 +1195,7 @@ void AssemblyWriter::printModule(const Module *M) {
     printFunction(I);
 }
 
-static void PrintLinkage(GlobalValue::LinkageTypes LT, std::ostream &Out) {
+static void PrintLinkage(GlobalValue::LinkageTypes LT, raw_ostream &Out) {
   switch (LT) {
   case GlobalValue::InternalLinkage:     Out << "internal "; break;
   case GlobalValue::LinkOnceLinkage:     Out << "linkonce "; break;
@@ -1195,7 +1214,7 @@ static void PrintLinkage(GlobalValue::LinkageTypes LT, std::ostream &Out) {
       
 
 static void PrintVisibility(GlobalValue::VisibilityTypes Vis,
-                            std::ostream &Out) {
+                            raw_ostream &Out) {
   switch (Vis) {
   default: assert(0 && "Invalid visibility style!");
   case GlobalValue::DefaultVisibility: break;
@@ -1705,74 +1724,75 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
 //===----------------------------------------------------------------------===//
 
 void Module::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
+  raw_os_ostream OS(o);
+  print(OS, AAW);
+}
+void Module::print(raw_ostream &OS, AssemblyAnnotationWriter *AAW) const {
   SlotTracker SlotTable(this);
-  AssemblyWriter W(o, SlotTable, this, AAW);
+  AssemblyWriter W(OS, SlotTable, this, AAW);
   W.write(this);
 }
 
-void GlobalVariable::print(std::ostream &o) const {
-  SlotTracker SlotTable(getParent());
-  AssemblyWriter W(o, SlotTable, getParent(), 0);
-  W.write(this);
-}
-
-void GlobalAlias::print(std::ostream &o) const {
-  SlotTracker SlotTable(getParent());
-  AssemblyWriter W(o, SlotTable, getParent(), 0);
-  W.write(this);
-}
-
-void Function::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
-  SlotTracker SlotTable(getParent());
-  AssemblyWriter W(o, SlotTable, getParent(), AAW);
-
-  W.write(this);
-}
-
-void InlineAsm::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
-  WriteAsOperand(o, this, true, 0);
-}
-
-void BasicBlock::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
-  SlotTracker SlotTable(getParent());
-  AssemblyWriter W(o, SlotTable,
-                   getParent() ? getParent()->getParent() : 0, AAW);
-  W.write(this);
-}
-
-void Instruction::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
-  const Function *F = getParent() ? getParent()->getParent() : 0;
-  SlotTracker SlotTable(F);
-  AssemblyWriter W(o, SlotTable, F ? F->getParent() : 0, AAW);
-
-  W.write(this);
-}
-
-void Constant::print(std::ostream &o) const {
-  if (this == 0) { o << "<null> constant value\n"; return; }
-
-  o << ' ' << getType()->getDescription() << ' ';
-
-  std::map<const Type *, std::string> TypeTable;
-  WriteConstantInt(o, this, TypeTable, 0);
-}
-
 void Type::print(std::ostream &o) const {
+  raw_os_ostream OS(o);
+  print(OS);
+}
+
+void Type::print(raw_ostream &o) const {
   if (this == 0)
     o << "<null Type>";
   else
     o << getDescription();
 }
 
-void Argument::print(std::ostream &o) const {
+void Value::print(raw_ostream &OS, AssemblyAnnotationWriter *AAW) const {
-  WriteAsOperand(o, this, true, getParent() ? getParent()->getParent() : 0);
+  if (this == 0) {
+    OS << "printing a <null> value\n";
+    return;
+  }
+
+  if (const Instruction *I = dyn_cast<Instruction>(this)) {
+    const Function *F = I->getParent() ? I->getParent()->getParent() : 0;
+    SlotTracker SlotTable(F);
+    AssemblyWriter W(OS, SlotTable, F ? F->getParent() : 0, AAW);
+    W.write(I);
+  } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(this)) {
+    SlotTracker SlotTable(BB->getParent());
+    AssemblyWriter W(OS, SlotTable,
+                     BB->getParent() ? BB->getParent()->getParent() : 0, AAW);
+    W.write(BB);
+  } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) {
+    SlotTracker SlotTable(GV->getParent());
+    AssemblyWriter W(OS, SlotTable, GV->getParent(), 0);
+    W.write(GV);
+  } else if (const Constant *C = dyn_cast<Constant>(this)) {
+    OS << ' ' << C->getType()->getDescription() << ' ';
+    std::map<const Type *, std::string> TypeTable;
+    WriteConstantInt(OS, C, TypeTable, 0);
+  } else if (const Argument *A = dyn_cast<Argument>(this)) {
+    WriteAsOperand(OS, this, true,
+                   A->getParent() ? A->getParent()->getParent() : 0);
+  } else if (isa<InlineAsm>(this)) {
+    WriteAsOperand(OS, this, true, 0);
+  } else {
+    assert(0 && "Unknown value to print out!");
+  }
+}
+
+void Value::print(std::ostream &O, AssemblyAnnotationWriter *AAW) const {
+  raw_os_ostream OS(O);
+  print(OS, AAW);
 }
 
 // Value::dump - allow easy printing of  Values from the debugger.
 // Located here because so much of the needed functionality is here.
-void Value::dump() const { print(*cerr.stream()); cerr << '\n'; }
+void Value::dump() const { print(errs()); errs() << '\n'; }
 
 // Type::dump - allow easy printing of  Values from the debugger.
 // Located here because so much of the needed functionality is here.
-void Type::dump() const { print(*cerr.stream()); cerr << '\n'; }
+void Type::dump() const { print(errs()); errs() << '\n'; }
+
+// Module::dump() - Allow printing from debugger
+void Module::dump() const { print(errs(), 0); }
+
 

lib/VMCore/Module.cpp

@@ -88,11 +88,6 @@ Module::~Module() {
   delete TypeSymTab;
 }
 
-// Module::dump() - Allow printing from debugger
-void Module::dump() const {
-  print(*cerr.stream());
-}
-
 /// Target endian information...
 Module::Endianness Module::getEndianness() const {
   std::string temp = DataLayout;

tools/llvm-prof/llvm-prof.cpp

@@ -21,6 +21,7 @@
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/System/Signals.h"
 #include <algorithm>
 #include <iostream>
@@ -71,12 +72,12 @@ namespace {
                      std::map<ProfileInfoLoader::Edge, unsigned> &EF)
       : FuncFreqs(FF), BlockFreqs(BF), EdgeFreqs(EF) {}
 
-    virtual void emitFunctionAnnot(const Function *F, std::ostream &OS) {
+    virtual void emitFunctionAnnot(const Function *F, raw_ostream &OS) {
       OS << ";;; %" << F->getName() << " called " << FuncFreqs[F]
          << " times.\n;;;\n";
     }
     virtual void emitBasicBlockStartAnnot(const BasicBlock *BB,
-                                          std::ostream &OS) {
+                                          raw_ostream &OS) {
       if (BlockFreqs.empty()) return;
       if (unsigned Count = BlockFreqs[BB])
         OS << "\t;;; Basic block executed " << Count << " times.\n";
@@ -84,7 +85,7 @@ namespace {
         OS << "\t;;; Never executed!\n";
     }
 
-    virtual void emitBasicBlockEndAnnot(const BasicBlock *BB, std::ostream &OS){
+    virtual void emitBasicBlockEndAnnot(const BasicBlock *BB, raw_ostream &OS) {
       if (EdgeFreqs.empty()) return;
 
       // Figure out how many times each successor executed.
@@ -235,7 +236,7 @@ int main(int argc, char **argv) {
       if (FunctionsToPrint.empty() || PrintAllCode)
         M->print(std::cout, &PA);
       else
-        // Print just a subset of the functions...
+        // Print just a subset of the functions.
         for (std::set<Function*>::iterator I = FunctionsToPrint.begin(),
                E = FunctionsToPrint.end(); I != E; ++I)
           (*I)->print(std::cout, &PA);