-//===-- 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"
+#include <iosfwd>
+#include <string>
-class Module;
-class Method;
-class BasicBlock;
-class Instruction;
-
-// 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);
+namespace llvm {
-// 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.
+class Type;
+class Module;
+class Value;
+class raw_ostream;
+template <typename T> class SmallVectorImpl;
+
+/// TypePrinting - Type printing machinery.
+class TypePrinting {
+ void *TypeNames; // A map to remember type names.
+ TypePrinting(const TypePrinting &); // DO NOT IMPLEMENT
+ void operator=(const TypePrinting&); // DO NOT IMPLEMENT
+public:
+ TypePrinting();
+ ~TypePrinting();
+
+ void clear();
+
+ void print(const Type *Ty, raw_ostream &OS, bool IgnoreTopLevelName = false);
+
+ void printAtLeastOneLevel(const Type *Ty, raw_ostream &OS) {
+ print(Ty, OS, true);
+ }
+
+ /// hasTypeName - Return true if the type has a name in TypeNames, false
+ /// otherwise.
+ bool hasTypeName(const Type *Ty) const;
+
+ /// addTypeName - Add a name for the specified type if it doesn't already have
+ /// one. This name will be printed instead of the structural version of the
+ /// type in order to make the output more concise.
+ void addTypeName(const Type *Ty, const std::string &N);
+
+private:
+ void CalcTypeName(const Type *Ty, SmallVectorImpl<const Type *> &TypeStack,
+ raw_ostream &OS, bool IgnoreTopLevelName = false);
+};
+
+// WriteTypeSymbolic - This attempts to write the specified type as a symbolic
+// type, if there is an entry in the Module's symbol table for the specified
+// type or one of its component types.
//
-void WriteToVCG(const Module *Module, const string &Filename);
-void WriteToVCG(const Method *Method, const string &Filename);
-
-
+void WriteTypeSymbolic(raw_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;
-}
+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);
-void DebugValue(const Value *V);
+} // End llvm namespace
#endif
projects / oota-llvm.git / blobdiff