X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fllvm-dis%2Fdis.cpp;h=166a178d5745e480ab08cf2ce59e3d8bb20cf4a7;hb=fe4f677a9752f90d6bd3d17cd513220d7fa09ec3;hp=ed1b79e3c4866307cb7fad6176e77d891acdb34d;hpb=9bff2e952226a80b65a993a81e87abe5216ffc48;p=oota-llvm.git diff --git a/tools/llvm-dis/dis.cpp b/tools/llvm-dis/dis.cpp index ed1b79e3c48..166a178d574 100644 --- a/tools/llvm-dis/dis.cpp +++ b/tools/llvm-dis/dis.cpp @@ -1,4 +1,4 @@ -//===------------------------------------------------------------------------=== +//===----------------------------------------------------------------------===// // LLVM 'DIS' UTILITY // // This utility may be invoked in the following manner: @@ -7,125 +7,118 @@ // 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 +// -c - Print C code instead of LLVM assembly // -// TODO: add -vcg which prints VCG compatible output. -// -//===------------------------------------------------------------------------=== +//===----------------------------------------------------------------------===// -#include -#include #include "llvm/Module.h" -#include "llvm/Assembly/Writer.h" +#include "llvm/PassManager.h" #include "llvm/Bytecode/Reader.h" -#include "llvm/Tools/CommandLine.h" -#include "llvm/Method.h" -#include "llvm/CFG.h" +#include "llvm/Assembly/CWriter.h" +#include "llvm/Assembly/PrintModulePass.h" +#include "Support/CommandLine.h" +#include "Support/Signals.h" +#include +#include +using std::cerr; + +// OutputMode - The different orderings to print basic blocks in... +enum OutputMode { + llvm = 0, // Generate LLVM assembly (the default) + c, // Generate C code +}; + +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("Overwrite output files")); + +static cl::opt +WriteMode(cl::desc("Specify the output format:"), + cl::values( + clEnumVal(llvm, "Output LLVM assembly"), + clEnumVal(c , "Output C code for program"), + 0)); 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"; - } - } - } - - ostream *Out = &cout; // Default to printing to stdout... + cl::ParseCommandLineOptions(argc, argv, " llvm .bc -> .ll disassembler\n"); + std::ostream *Out = &std::cout; // Default to printing to stdout... - Module *C = ParseBytecodeFile(Opts.getInputFilename()); - if (C == 0) { - cerr << "bytecode didn't read correctly.\n"; + std::auto_ptr M(ParseBytecodeFile(InputFilename)); + if (M.get() == 0) { + cerr << argv[0] << ": bytecode didn't read correctly.\n"; return 1; } - 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; - } - } - - // 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 + if (OutputFilename != "") { // Specified an output filename? + if (!Force && std::ifstream(OutputFilename.c_str())) { + // If force is not specified, make sure not to overwrite a file! + cerr << argv[0] << ": error opening '" << OutputFilename + << "': file exists! Sending to standard output.\n"; + } else { + Out = new std::ofstream(OutputFilename.c_str()); + } } 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::MethodListType::iterator I = C->getMethodList().begin(); - I != C->getMethodList().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 (InputFilename == "-") { + OutputFilename = "-"; + } else { + std::string IFN = InputFilename; + int Len = IFN.length(); + if (IFN[Len-3] == '.' && IFN[Len-2] == 'b' && IFN[Len-1] == 'c') { + // Source ends in .bc + OutputFilename = std::string(IFN.begin(), IFN.end()-3); + } else { + OutputFilename = IFN; // Append a .ll to it } - default: - abort(); - break; + if (WriteMode == c) + OutputFilename += ".c"; + else + OutputFilename += ".ll"; + + if (!Force && std::ifstream(OutputFilename.c_str())) { + // If force is not specified, make sure not to overwrite a file! + cerr << argv[0] << ": error opening '" << OutputFilename + << "': file exists! Sending to standard output.\n"; + } else { + Out = new std::ofstream(OutputFilename.c_str()); + + // Make sure that the Out file gets unlink'd from the disk if we get a + // SIGINT + RemoveFileOnSignal(OutputFilename); } } } - delete C; - if (Out != &cout) delete Out; + if (!Out->good()) { + cerr << argv[0] << ": error opening " << OutputFilename + << ": sending to stdout instead!\n"; + Out = &std::cout; + } + + // All that dis does is write the assembly or C out to a file... + // + PassManager Passes; + + switch (WriteMode) { + case llvm: // Output LLVM assembly + Passes.add(new PrintModulePass(Out)); + break; + case c: // Convert LLVM to C + Passes.add(createWriteToCPass(*Out)); + break; + } + + Passes.run(*M.get()); + + if (Out != &std::cout) { + ((std::ofstream*)Out)->close(); + delete Out; + } return 0; } +