X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAssembly%2FWriter.h;h=5e5fe1560585da65c631baf6e45ebfcc4c1dcdcb;hb=104cf9e02b0ed94d4173869a598af6c6972a8660;hp=da247f6b51e2591f83638ab155b69be941aef6e6;hpb=ec0c497877f8019e07e47d8bfd8f8d34c45c5d5c;p=oota-llvm.git diff --git a/include/llvm/Assembly/Writer.h b/include/llvm/Assembly/Writer.h index da247f6b51e..5e5fe156058 100644 --- a/include/llvm/Assembly/Writer.h +++ b/include/llvm/Assembly/Writer.h @@ -1,93 +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 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 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 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 << ""; - 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 <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 << "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