The TargetData is not used for the isPowerOfTwo determination. It has never

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

diff --git a/include/llvm/Assembly/Writer.h b/include/llvm/Assembly/Writer.h
index 6ce3b92681e21b0d1032d926a49343baa1567764..6b89ae022da3c6131bfd9708c6b79c8e6027543c 100644 (file)
--- a/include/llvm/Assembly/Writer.h
+++ b/include/llvm/Assembly/Writer.h
@@ -1,92 +1,37 @@
-//===-- llvm/Assembly/Writer.h - Printer for VM assembly files ---*- C++ -*--=//
+//===-- llvm/Assembly/Writer.h - Printer for LLVM assembly files --*- C++ -*-=//
 //
-// This functionality is implemented by the lib/Assembly/Writer library.
-// This library is used to print VM assembly language files to an iostream. It
-// can print VM code at a variety of granularities, ranging from a whole class
-// down to an individual instruction.  This makes it useful for debugging.
+//                     The LLVM Compiler Infrastructure
 //
-// This file also defines functions that allow it to output files that a program
-// called VCG can read.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
-// This library uses the Analysis library to figure out offsets for
-// variables in the method tables...
+//===----------------------------------------------------------------------===//
+//
+// This functionality is implemented by lib/VMCore/AsmWriter.cpp.
+// This library is used to print LLVM assembly language files to an iostream. It
+// can print LLVM code at a variety of granularities, including Modules,
+// BasicBlocks, and Instructions.  This makes it useful for debugging.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ASSEMBLY_WRITER_H
 #define LLVM_ASSEMBLY_WRITER_H
 
-#include <iostream>
-#include "llvm/Type.h"
+namespace llvm {
 
 class Module;
-class GlobalVariable;
-class Method;
-class BasicBlock;
-class Instruction;
-class SlotCalculator;
-
-// 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 GlobalVariable *G, 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);
+class Value;
+class raw_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.
-//
-ostream &WriteAsOperand(ostream &o, const Value *V, bool PrintType = true,
-                               bool PrintName = true, SlotCalculator *Table = 0);
-
-
-// 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.
-//
-void WriteToVCG(const Module *Module, const string &Filename);
-void WriteToVCG(const Method *Method, const string &Filename);
-
-
-
-
-// Define operator<< to work on the various classes that we can send to an 
-// ostream...
+// 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 GlobalVariable *G) {
-  WriteToAssembly(G, 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;
-}
-
+void WriteAsOperand(raw_ostream &, const Value *, bool PrintTy = true,
+                    const Module *Context = 0);
 
-inline ostream &operator<<(ostream &o, const Type *T) {
-  if (!T) return o << "<null Type>";
-  return o << T->getDescription();
-}
+} // End llvm namespace
 
 #endif