X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAssembly%2FWriter.h;h=5e5fe1560585da65c631baf6e45ebfcc4c1dcdcb;hb=f2e19d5dcfa13472493bb18339555686182b7df9;hp=6c7f8e73a8cc11d22773a701c3b537069cf9c79d;hpb=74f4a766c4810fe2b451a173e34e8a47dedc04bd;p=oota-llvm.git diff --git a/include/llvm/Assembly/Writer.h b/include/llvm/Assembly/Writer.h index 6c7f8e73a8c..5e5fe156058 100644 --- a/include/llvm/Assembly/Writer.h +++ b/include/llvm/Assembly/Writer.h @@ -1,109 +1,81 @@ -//===-- 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 -#include "llvm/Type.h" +#include +#include -class Module; -class GlobalVariable; -class Method; -class BasicBlock; -class Instruction; -class SlotCalculator; +namespace llvm { -// 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) +class Type; +class Module; +class Value; +class raw_ostream; +template 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 &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 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); +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 -// 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; -} - - -inline ostream &operator<<(ostream &o, const Type *T) { - if (!T) return o << ""; - return o << T->getDescription(); -} - -inline ostream &operator<<(ostream &o, const Value *I) { - switch (I->getValueType()) { - case Value::TypeVal: return o << I->castTypeAsserting(); - case Value::ConstantVal: WriteToAssembly((const ConstPoolVal*)I, o); break; - case Value::MethodArgumentVal: return o <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::GlobalVal: WriteToAssembly((const GlobalVariable*)I,o);break; - case Value::ModuleVal: WriteToAssembly((const Module *)I, o); break; - default: return o << "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