Workaround for bug in GCC 3.1.1 iostreams library on sparc. It apprarently

[oota-llvm.git] / include / llvm / Assembly / Writer.h

diff --git a/include/llvm/Assembly/Writer.h b/include/llvm/Assembly/Writer.h
index 68a5ed28122b1ded18cece14eaf4af9c2c83e23c..f87dc12ad0fd1952fbe6f83967511f4bf1d9acbc 100644 (file)
--- a/include/llvm/Assembly/Writer.h
+++ b/include/llvm/Assembly/Writer.h
@@ -16,76 +16,26 @@
 #ifndef LLVM_ASSEMBLY_WRITER_H
 #define LLVM_ASSEMBLY_WRITER_H
 
-#include <iostream>
-#include "llvm/Type.h"
-
+#include <iosfwd>
+class Type;
 class Module;
-class Method;
-class BasicBlock;
-class Instruction;
+class Value;
 
-// The only interface defined by this file... convert the internal 
-// representation of an object into an ascii bytestream that the parser can 
-// understand later... (the parser only understands whole classes though)
-//
-void WriteToAssembly(const Module  *Module, ostream &o);
-void WriteToAssembly(const Method  *Method, ostream &o);
-void WriteToAssembly(const BasicBlock  *BB, ostream &o);
-void WriteToAssembly(const Instruction *In, ostream &o);
-void WriteToAssembly(const ConstPoolVal *V, ostream &o);
 
-// WriteToVCG - Dump the specified structure to a VCG file.  If method is
-// dumped, then the file named is created.  If a module is to be written, a
-// family of files with a common base name is created, with a method name
-// suffix.
+// 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;
 //
-void WriteToVCG(const Module *Module, const string &Filename);
-void WriteToVCG(const Method *Method, const string &Filename);
-
+std::ostream &WriteTypeSymbolic(std::ostream &, const Type *, const Module *M);
 
 
-
-// Define operator<< to work on the various classes that we can send to an 
-// ostream...
+// 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.  If you specify a Module for context,
+// then even constants get pretty printed (for example the type of a null 
+// pointer is printed symbolically).
 //
-inline ostream &operator<<(ostream &o, const Module *C) {
-  WriteToAssembly(C, o); return o;
-}
-
-inline ostream &operator<<(ostream &o, const Method *M) {
-  WriteToAssembly(M, o); return o;
-}
-
-inline ostream &operator<<(ostream &o, const BasicBlock *B) {
-  WriteToAssembly(B, o); return o;
-}
-
-inline ostream &operator<<(ostream &o, const Instruction *I) {
-  WriteToAssembly(I, o); return o;
-}
-
-inline ostream &operator<<(ostream &o, const ConstPoolVal *I) {
-  WriteToAssembly(I, o); return o;
-}
-
-
-inline ostream &operator<<(ostream &o, const Type *T) {
-  if (!T) return o << "<null Type>";
-  return o << T->getName();
-}
-
-inline ostream &operator<<(ostream &o, const Value *I) {
-  switch (I->getValueType()) {
-  case Value::TypeVal:        return o << (const Type*)I;
-  case Value::ConstantVal:    WriteToAssembly((const ConstPoolVal*)I, o); break;
-  case Value::MethodArgumentVal: return o <<I->getType() << " " << I->getName();
-  case Value::InstructionVal: WriteToAssembly((const Instruction *)I, o); break;
-  case Value::BasicBlockVal:  WriteToAssembly((const BasicBlock  *)I, o); break;
-  case Value::MethodVal:      WriteToAssembly((const Method      *)I, o); break;
-  case Value::ModuleVal:      WriteToAssembly((const Module      *)I, o); break;
-  default: return o << "<unknown value type: " << I->getValueType() << ">";
-  }
-  return o;
-}
+std::ostream &WriteAsOperand(std::ostream &, const Value *, bool PrintTy = true,
+                             bool PrintName = true, const Module *Context = 0);
 
 #endif