1 //===------------------------------------------------------------------------=== 2 // LLVM 'OPT' UTILITY 3 // 4 // This utility may be invoked in the following manner: 5 // opt --help - Output information about command line switches 6 // opt [options] -dce - Run a dead code elimination pass on input 7 // bytecodes 8 // opt [options] -constprop - Run a constant propogation pass on input 9 // bytecodes 10 // opt [options] -inline - Run a method inlining pass on input bytecodes 11 // opt [options] -strip - Strip symbol tables out of methods 12 // opt [options] -mstrip - Strip module & method symbol tables 13 // 14 // Optimizations may be specified an arbitrary number of times on the command 15 // line, they are run in the order specified. 16 // 17 // TODO: Add a -all option to keep applying all optimizations until the program 18 // stops permuting. 19 // 20 //===------------------------------------------------------------------------=== 21 22 #include <iostream.h> 23 #include <fstream.h> 24 #include "llvm/Module.h" 25 #include "llvm/Bytecode/Reader.h" 26 #include "llvm/Bytecode/Writer.h" 27 #include "llvm/Support/CommandLine.h" 28 #include "llvm/Optimizations/AllOpts.h" 29 30 using namespace opt; 31 32 enum Opts { 33 // Basic optimizations 34 dce, constprop, inlining, strip, mstrip, 35 36 // More powerful optimizations 37 indvars, sccp, adce, raise, 38 }; 39 40 struct { 41 enum Opts OptID; 42 bool (*OptPtr)(Module *C); 43 } OptTable[] = { 44 { dce , DoDeadCodeElimination }, 45 { constprop, DoConstantPropogation }, 46 { inlining , DoMethodInlining }, 47 { strip , DoSymbolStripping }, 48 { mstrip , DoFullSymbolStripping }, 49 { indvars , DoInductionVariableCannonicalize }, 50 { sccp , DoSCCP }, 51 { adce , DoADCE }, 52 { raise , DoRaiseRepresentation }, 53 }; 54 55 cl::String InputFilename ("", "Load <arg> file to optimize", cl::NoFlags, "-"); 56 cl::String OutputFilename("o", "Override output filename", cl::NoFlags, ""); 57 cl::Flag Force ("f", "Overwrite output files", cl::NoFlags, false); 58 cl::Flag Quiet ("q", "Don't print modifying pass names", 0, false); 59 cl::Alias QuietA ("quiet", "Alias for -q", cl::NoFlags, Quiet); 60 cl::EnumList<enum Opts> OptimizationList(cl::NoFlags, 61 clEnumVal(dce , "Dead Code Elimination"), 62 clEnumVal(constprop, "Simple Constant Propogation"), 63 clEnumValN(inlining , "inline", "Method Integration"), 64 clEnumVal(strip , "Strip Symbols"), 65 clEnumVal(mstrip , "Strip Module Symbols"), 66 clEnumVal(indvars , "Simplify Induction Variables"), 67 clEnumVal(sccp , "Sparse Conditional Constant Propogation"), 68 clEnumVal(adce , "Agressive DCE"), 69 clEnumVal(raise , "Raise to Higher Level"), 70 0); 71 72 73 int main(int argc, char **argv) { 74 cl::ParseCommandLineOptions(argc, argv, 75 " llvm .bc -> .bc modular optimizer\n"); 76 77 Module *C = ParseBytecodeFile(InputFilename); 78 if (C == 0) { 79 cerr << "bytecode didn't read correctly.\n"; 80 return 1; 81 } 82 83 for (unsigned i = 0; i < OptimizationList.size(); ++i) { 84 enum Opts Opt = OptimizationList[i]; 85 86 unsigned j; 87 for (j = 0; j < sizeof(OptTable)/sizeof(OptTable[0]); ++j) { 88 if (Opt == OptTable[j].OptID) { 89 if (OptTable[j].OptPtr(C) && !Quiet) 90 cerr << OptimizationList.getArgName(Opt) 91 << " pass made modifications!\n"; 92 break; 93 } 94 } 95 96 if (j == sizeof(OptTable)/sizeof(OptTable[0])) 97 cerr << "Optimization tables inconsistent!!\n"; 98 } 99 100 ostream *Out = &cout; // Default to printing to stdout... 101 if (OutputFilename != "") { 102 Out = new ofstream(OutputFilename.c_str(), 103 (Force ? 0 : ios::noreplace)|ios::out); 104 if (!Out->good()) { 105 cerr << "Error opening " << OutputFilename << "!\n"; 106 delete C; 107 return 1; 108 } 109 } 110 111 // Okay, we're done now... write out result... 112 WriteBytecodeToFile(C, *Out); 113 delete C; 114 115 if (Out != &cout) delete Out; 116 return 0; 117 } 118