X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fllvm-dis%2Fllvm-dis.cpp;h=067955e5cc6171513cb218dd8602dee2cbac899c;hb=7172b38af7ed5d1c1e2c97fadfb0ae0c19aff816;hp=deaf3a28fd50acdac68eae17535ad20ef43c367c;hpb=7fc9fe34390c66ca58646d09a87f7dbaacb6c1f8;p=oota-llvm.git diff --git a/tools/llvm-dis/llvm-dis.cpp b/tools/llvm-dis/llvm-dis.cpp index deaf3a28fd5..067955e5cc6 100644 --- a/tools/llvm-dis/llvm-dis.cpp +++ b/tools/llvm-dis/llvm-dis.cpp @@ -1,130 +1,191 @@ -//===------------------------------------------------------------------------=== -// LLVM 'DIS' UTILITY +//===-- llvm-dis.cpp - The low-level LLVM disassembler --------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// // // This utility may be invoked in the following manner: -// dis [options] - Read LLVM bytecode from stdin, write assembly to stdout -// dis [options] x.bc - Read LLVM bytecode from the x.bc file, write assembly -// to the x.ll file. +// llvm-dis [options] - Read LLVM bitcode from stdin, write asm to stdout +// llvm-dis [options] x.bc - Read LLVM bitcode from the x.bc file, write asm +// to the x.ll file. // Options: // --help - Output information about command line switches -// -dfo - Print basic blocks in depth first order -// -rdfo - Print basic blocks in reverse depth first order -// -po - Print basic blocks in post order -// -rpo - Print basic blocks in reverse post order // -// TODO: add -vcg which prints VCG compatible output. -// -//===------------------------------------------------------------------------=== +//===----------------------------------------------------------------------===// -#include -#include -#include "llvm/Module.h" -#include "llvm/Assembly/Writer.h" -#include "llvm/Bytecode/Reader.h" -#include "llvm/Tools/CommandLine.h" -#include "llvm/Method.h" -#include "llvm/CFG.h" +#include "llvm/IR/LLVMContext.h" +#include "llvm/Assembly/AssemblyAnnotationWriter.h" +#include "llvm/Bitcode/ReaderWriter.h" +#include "llvm/DebugInfo.h" +#include "llvm/IR/IntrinsicInst.h" +#include "llvm/IR/Module.h" +#include "llvm/IR/Type.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/Support/DataStream.h" +#include "llvm/Support/FormattedStream.h" +#include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/MemoryBuffer.h" +#include "llvm/Support/PrettyStackTrace.h" +#include "llvm/Support/Signals.h" +#include "llvm/Support/ToolOutputFile.h" +#include "llvm/Support/system_error.h" +using namespace llvm; -int main(int argc, char **argv) { - // WriteMode - The different orderings to print basic blocks in... - enum { - Default = 0, // Method Order (list order) - DepthFirst, // Depth First ordering - ReverseDepthFirst, // Reverse Depth First ordering - PostOrder, // Post Order - ReversePostOrder // Reverse Post Order - } WriteMode = Default; - - ToolCommandLine Opts(argc, argv, false); - - // We only support the options that the system parser does... if it left any - // then we don't know what to do. - // - if (argc > 1) { - for (int i = 1; i < argc; i++) { - if (string(argv[i]) == string("--help")) { - cerr << argv[0] << " usage:\n" - << "\tx.bc - Parse file and output to x.ll\n" - << "\tno .bc file - Parse stdin and write to stdout.\n" - << "\t-dfo - Write basic blocks in depth first order.\n" - << "\t-rdfo - Write basic blocks in reverse DFO.\n" - << "\t-po - Write basic blocks in postorder.\n" - << "\t-rpo - Write basic blocks in reverse postorder.\n" - << "\t--help - Print this usage information\n\n"; - return 1; - } else if (string(argv[i]) == string("-dfo")) { - WriteMode = DepthFirst; - } else if (string(argv[i]) == string("-rdfo")) { - WriteMode = ReverseDepthFirst; - } else if (string(argv[i]) == string("-po")) { - WriteMode = PostOrder; - } else if (string(argv[i]) == string("-rpo")) { - WriteMode = ReversePostOrder; - } else { - cerr << argv[0] << ": argument not recognized: '" << argv[i] << "'!\n"; - } +static cl::opt +InputFilename(cl::Positional, cl::desc(""), cl::init("-")); + +static cl::opt +OutputFilename("o", cl::desc("Override output filename"), + cl::value_desc("filename")); + +static cl::opt +Force("f", cl::desc("Enable binary output on terminals")); + +static cl::opt +DontPrint("disable-output", cl::desc("Don't output the .ll file"), cl::Hidden); + +static cl::opt +ShowAnnotations("show-annotations", + cl::desc("Add informational comments to the .ll file")); + +namespace { + +static void printDebugLoc(const DebugLoc &DL, formatted_raw_ostream &OS) { + OS << DL.getLine() << ":" << DL.getCol(); + if (MDNode *N = DL.getInlinedAt(getGlobalContext())) { + DebugLoc IDL = DebugLoc::getFromDILocation(N); + if (!IDL.isUnknown()) { + OS << "@"; + printDebugLoc(IDL,OS); } } - - ostream *Out = &cout; // Default to printing to stdout... - - Module *C = ParseBytecodeFile(Opts.getInputFilename()); - if (C == 0) { - cerr << "bytecode didn't read correctly.\n"; - return 1; +} +class CommentWriter : public AssemblyAnnotationWriter { +public: + void emitFunctionAnnot(const Function *F, + formatted_raw_ostream &OS) { + OS << "; [#uses=" << F->getNumUses() << ']'; // Output # uses + OS << '\n'; } - - if (Opts.getOutputFilename() != "-") { - Out = new ofstream(Opts.getOutputFilename().c_str(), - (Opts.getForce() ? 0 : ios::noreplace)|ios::out); - if (!Out->good()) { - cerr << "Error opening " << Opts.getOutputFilename() - << ": sending to stdout instead!\n"; - Out = &cout; + void printInfoComment(const Value &V, formatted_raw_ostream &OS) { + bool Padded = false; + if (!V.getType()->isVoidTy()) { + OS.PadToColumn(50); + Padded = true; + OS << "; [#uses=" << V.getNumUses() << " type=" << *V.getType() << "]"; // Output # uses and type + } + if (const Instruction *I = dyn_cast(&V)) { + const DebugLoc &DL = I->getDebugLoc(); + if (!DL.isUnknown()) { + if (!Padded) { + OS.PadToColumn(50); + Padded = true; + OS << ";"; + } + OS << " [debug line = "; + printDebugLoc(DL,OS); + OS << "]"; } - } - - // All that dis does is write the assembly out to a file... which is exactly - // what the writer library is supposed to do... - // - if (WriteMode == Default) { - (*Out) << C; // Print out in list order - } else { - // TODO: This does not print anything other than the basic blocks in the - // methods... more should definately be printed. It should be valid output - // consumable by the assembler. - // - for (Module::iterator I = C->begin(), End = C->end(); I != End; ++I) { - Method *M = *I; - (*Out) << "-------------- Method: " << M->getName() << " -------------\n"; - - switch (WriteMode) { - case DepthFirst: // Depth First ordering - copy(cfg::df_begin(M), cfg::df_end(M), - ostream_iterator(*Out, "\n")); - break; - case ReverseDepthFirst: // Reverse Depth First ordering - copy(cfg::df_begin(M, true), cfg::df_end(M), - ostream_iterator(*Out, "\n")); - break; - case PostOrder: // Post Order - copy(cfg::po_begin(M), cfg::po_end(M), - ostream_iterator(*Out, "\n")); - break; - case ReversePostOrder: { // Reverse Post Order - cfg::ReversePostOrderTraversal RPOT(M); - copy(RPOT.begin(), RPOT.end(), - ostream_iterator(*Out, "\n")); - break; + if (const DbgDeclareInst *DDI = dyn_cast(I)) { + DIVariable Var(DDI->getVariable()); + if (!Padded) { + OS.PadToColumn(50); + OS << ";"; + } + OS << " [debug variable = " << Var.getName() << "]"; } - default: - abort(); - break; + else if (const DbgValueInst *DVI = dyn_cast(I)) { + DIVariable Var(DVI->getVariable()); + if (!Padded) { + OS.PadToColumn(50); + OS << ";"; + } + OS << " [debug variable = " << Var.getName() << "]"; } } } - delete C; +}; + +} // end anon namespace + +int main(int argc, char **argv) { + // Print a stack trace if we signal out. + sys::PrintStackTraceOnErrorSignal(); + PrettyStackTraceProgram X(argc, argv); + + LLVMContext &Context = getGlobalContext(); + llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. + + + cl::ParseCommandLineOptions(argc, argv, "llvm .bc -> .ll disassembler\n"); + + std::string ErrorMessage; + OwningPtr M; + + // Use the bitcode streaming interface + DataStreamer *streamer = getDataFileStreamer(InputFilename, &ErrorMessage); + if (streamer) { + std::string DisplayFilename; + if (InputFilename == "-") + DisplayFilename = ""; + else + DisplayFilename = InputFilename; + M.reset(getStreamedBitcodeModule(DisplayFilename, streamer, Context, + &ErrorMessage)); + if(M.get() != 0 && M->MaterializeAllPermanently(&ErrorMessage)) { + M.reset(); + } + } + + if (M.get() == 0) { + errs() << argv[0] << ": "; + if (ErrorMessage.size()) + errs() << ErrorMessage << "\n"; + else + errs() << "bitcode didn't read correctly.\n"; + return 1; + } + + // Just use stdout. We won't actually print anything on it. + if (DontPrint) + OutputFilename = "-"; + + if (OutputFilename.empty()) { // Unspecified output, infer it. + if (InputFilename == "-") { + OutputFilename = "-"; + } else { + const std::string &IFN = InputFilename; + int Len = IFN.length(); + // If the source ends in .bc, strip it off. + if (IFN[Len-3] == '.' && IFN[Len-2] == 'b' && IFN[Len-1] == 'c') + OutputFilename = std::string(IFN.begin(), IFN.end()-3)+".ll"; + else + OutputFilename = IFN+".ll"; + } + } + + std::string ErrorInfo; + OwningPtr + Out(new tool_output_file(OutputFilename.c_str(), ErrorInfo, + raw_fd_ostream::F_Binary)); + if (!ErrorInfo.empty()) { + errs() << ErrorInfo << '\n'; + return 1; + } + + OwningPtr Annotator; + if (ShowAnnotations) + Annotator.reset(new CommentWriter()); + + // All that llvm-dis does is write the assembly to a file. + if (!DontPrint) + M->print(Out->os(), Annotator.get()); + + // Declare success. + Out->keep(); - if (Out != &cout) delete Out; return 0; }