private static void usage() {
System.err.println(
"\nUsage: java EDU.purdue.cs.bloat.optimize.Main"
+ "\n [-options] classes dir"
+ "\n"
+ "\nwhere options include:"
+ "\n -help print out this message"
+ "\n -v -verbose turn on verbose mode"
+ "\n -debug display a hideous amount of debug info"
+ "\n -classpath <directories separated by colons>"
+ "\n list directories in which to look for classes"
+ "\n -f optimize files even if up-to-date"
+ "\n -closure recursively optimize referenced classes"
+ "\n -relax-loading don't report errors if a class is not found"
+ "\n -skip <class|package.*>"
+ "\n skip the given class or package"
+ "\n -only <class|package.*>"
+ "\n skip all but the given class or package"
+ "\n -preserve-debug try to preserve debug information"
+ "\n -[no]anno insert an annotation in the contant pool"
+ "\n -[no]stack-alloc try to push locals onto the operand stack"
+ "\n -peel-loops <n|all>"
+ "\n peel innermost loops to enable code hoisting"
+ "\n (n >= 0 is the maximum loop level to peel)"
+ "\n -[no]pre perform partial redundency elimination"
+ "\n -[no]dce perform dead code elimination"
+ "\n -diva perform demand-driven induction variable analysis"
+ "\n -[no]prop perform copy and constant propagation"
+ "");
System.exit(0);
}
/** Performs peephole optimizations on a program's live methods. */
private static void peephole(final BloatContext context) {
final Set liveMethods = new TreeSet(new MemberRefComparator());
final CallGraph cg = context.getCallGraph();
liveMethods.addAll(cg.liveMethods());
// Perform peephole optimizations. We do this separately because
// some peephole optimizations do things to the stack that
// inlining doesn't like. For instance, a peephole optimizations
// might make it so that a method has a non-empty stack upon
// return. Inlining will barf at the sight of this.
BloatBenchmark.tr("Performing peephole optimizations");
final Iterator iter = liveMethods.iterator();
while (BloatBenchmark.PEEPHOLE && iter.hasNext()) {
try {
final MethodEditor live = context.editMethod((MemberRef) iter.next());
Peephole.transform(live);
context.commit(live.methodInfo());
context.release(live.methodInfo());
} catch (final NoSuchMethodException ex314) {
BloatBenchmark.err.println("** Could not find method " + ex314.getMessage());
ex314.printStackTrace(System.err);
System.exit(1);
}
}
}
private static void usage() {
System.err.println(
"Usage: java EDU.purdue.cs.bloat.decorate.Main "
+ "\n [-options] classes output_dir"
+ "\n"
+ "\nwhere options include:"
+ "\n -help print out this message"
+ "\n -v -verbose turn on verbose mode "
+ "(can be given multiple times)"
+ "\n -classpath <directories separated by colons>"
+ "\n list directories in which to look for classes"
+ "\n -f decorate files even if up-to-date"
+ "\n -closure recursively decorate referenced classes"
+ "\n -relax-loading don't report errors if a class is not found"
+ "\n -skip <class|package.*>"
+ "\n skip the given class or package"
+ "\n (this option can be given more than once)"
+ "\n -only <class|package.*>"
+ "\n skip all but the given class or package"
+ "\n (this option can be given more than once)"
+ "\n -rc insert residency checks (default)"
+ "\n -norc don't insert residency checks"
+ "\n -uc insert update checks (default)"
+ "\n -sc insert array swizzle checks (default)"
+ "\n -nosc don't insert array swizzle checks");
System.exit(0);
}
/**
* Returns the live methods of a program whose root methods are the <tt>main</tt> method of a set
* of classes.
*
* @param classes Names of classes containing root methods
* @param context Repository for accessing BLOAT stuff
* @return The <tt>MemberRef</tt>s of the live methods
*/
private static Collection liveMethods(final Collection classes, final BloatContext context) {
// Determine the roots of the call graph
final Set roots = new HashSet();
Iterator iter = classes.iterator();
while (iter.hasNext()) {
final String className = (String) iter.next();
try {
final ClassEditor ce = context.editClass(className);
final MethodInfo[] methods = ce.methods();
for (int i = 0; i < methods.length; i++) {
final MethodEditor me = context.editMethod(methods[i]);
if (!me.name().equals("main")) {
continue;
}
BloatBenchmark.tr(" Root " + ce.name() + "." + me.name() + me.type());
roots.add(me.memberRef());
}
} catch (final ClassNotFoundException ex1) {
BloatBenchmark.err.println("** Could not find class: " + ex1.getMessage());
System.exit(1);
}
}
if (roots.isEmpty()) {
BloatBenchmark.err.print("** No main method found in classes: ");
iter = classes.iterator();
while (iter.hasNext()) {
final String name = (String) iter.next();
BloatBenchmark.err.print(name);
if (iter.hasNext()) {
BloatBenchmark.err.print(", ");
}
}
BloatBenchmark.err.println("");
}
context.setRootMethods(roots);
final CallGraph cg = context.getCallGraph();
final Set liveMethods = new TreeSet(new MemberRefComparator());
liveMethods.addAll(cg.liveMethods());
return (liveMethods);
}
/** Specializes the live methods in a program. */
private static void specialize(final BloatContext context) {
final CallGraph cg = context.getCallGraph();
final Set liveMethods = new TreeSet(new MemberRefComparator());
liveMethods.addAll(cg.liveMethods());
// Specialize all possible methods
final InlineStats stats = context.getInlineStats();
if (BloatBenchmark.statsFile != null) {
Specialize.STATS = true;
stats.setConfigName("BloatBenchmark");
}
if (BloatBenchmark.MORPH != -1) {
Specialize.MAX_MORPH = BloatBenchmark.MORPH;
}
final Specialize spec = new Specialize(context);
if (Specialize.STATS) {
stats.noteLiveMethods(liveMethods.size());
stats.noteLiveClasses(cg.liveClasses().size());
}
BloatBenchmark.tr("Specializing live methods");
final Iterator iter = liveMethods.iterator();
for (int count = 0; iter.hasNext(); count++) {
try {
final MethodEditor live = context.editMethod((MemberRef) iter.next());
if (context.ignoreMethod(live.memberRef())) {
// Don't display ignored methods, it's misleading.
continue;
}
BloatBenchmark.tr(
" " + count + ") " + live.declaringClass().name() + "." + live.name() + live.type());
spec.specialize(live);
} catch (final NoSuchMethodException ex2) {
BloatBenchmark.err.println("** Could not find method " + ex2.getMessage());
System.exit(1);
}
}
}
/** Inlines calls to static methods in the live methods of a given program. */
private static void inline(final BloatContext context) {
final Set liveMethods = new TreeSet(new MemberRefComparator());
final CallGraph cg = context.getCallGraph();
liveMethods.addAll(cg.liveMethods());
BloatBenchmark.tr("Inlining " + liveMethods.size() + " live methods");
if (BloatBenchmark.CALLEE_SIZE != -1) {
Inline.CALLEE_SIZE = BloatBenchmark.CALLEE_SIZE;
}
final Iterator iter = liveMethods.iterator();
for (int count = 0; BloatBenchmark.INLINE && iter.hasNext(); count++) {
try {
final MethodEditor live = context.editMethod((MemberRef) iter.next());
if (context.ignoreMethod(live.memberRef())) {
// Don't display ignored methods, it's misleading.
continue;
}
BloatBenchmark.tr(
" " + count + ") " + live.declaringClass().name() + "." + live.name() + live.type());
final Inline inline = new Inline(context, BloatBenchmark.SIZE);
inline.setMaxCallDepth(BloatBenchmark.DEPTH);
inline.inline(live);
// Commit here in an attempt to conserve memory
context.commit(live.methodInfo());
context.release(live.methodInfo());
} catch (final NoSuchMethodException ex3) {
BloatBenchmark.err.println("** Could not find method " + ex3.getMessage());
System.exit(1);
}
}
}
private static void usage() {
BloatBenchmark.err.println("java TestSpecialize [options] classNames outputDir");
BloatBenchmark.err.println("where [options] are:");
BloatBenchmark.err.println(" -calleeSize size Max method size to inline");
BloatBenchmark.err.println(" -classpath path Classpath is always prepended");
BloatBenchmark.err.println(" -depth depth Max inline depth");
BloatBenchmark.err.println(" -inline Inline calls to static methods");
BloatBenchmark.err.println(" -intra Intraprocedural BLOAT");
BloatBenchmark.err.println(" -lookIn dir Look for classes here");
BloatBenchmark.err.println(" -morph morph Max morphosity of call sites");
BloatBenchmark.err.println(" -no-verify Don't verify CFG");
BloatBenchmark.err.println(" -no-opt-stack Don't optimize stack usage");
BloatBenchmark.err.println(" -no-stack-vars Don't use stack vars in CFG");
BloatBenchmark.err.println(
" -no-stack-alloc Don't try to push locals onto the operand stack");
BloatBenchmark.err.println(
" -peel-loops <n|all>"
+ "\n Peel innermost loops to enable code hoisting"
+ "\n (n >= 0 is the maximum loop level to peel)");
BloatBenchmark.err.println(" -no-pre Don't perform partial redundency elimination");
BloatBenchmark.err.println(" -no-dce Don't perform dead code elimination");
BloatBenchmark.err.println(" -no-prop Don't perform copy and constant propagation");
BloatBenchmark.err.println(" -no-color Don't do graph coloring");
BloatBenchmark.err.println(" -peephole Perform peephole after inter");
BloatBenchmark.err.println(" -size size Max method size");
BloatBenchmark.err.println(" -specialize Specialize virtual method calls");
BloatBenchmark.err.println(" -stats statsFile Generate stats");
BloatBenchmark.err.println(" -sun Include sun packages");
BloatBenchmark.err.println(" -times timesFile Print timings");
BloatBenchmark.err.println(" -trace Print trace information");
BloatBenchmark.err.println(" -no-check Don't check that my options 'make sense'");
BloatBenchmark.err.println(
" -skip <class|package.*>" + "\n Skip the given class or package");
BloatBenchmark.err.println(" -1.1 BLOAT for JDK1.1");
BloatBenchmark.err.println(" -1.2 BLOAT for JDK1.2");
BloatBenchmark.err.println("");
System.exit(1);
}
/** Runs BLOAT on a method. */
public static void bloatMethod(final MethodEditor m, final BloatContext context) {
try {
if (Main.COMPACT_ARRAY_INIT) {
// Compact the initialization of arrays of the basic types by
// putting the values of the array into a string in the constant
// pool. The initialization code is replaced with a loop that
// loads the array from the string in the constant pool.
if (Main.TRACE) {
System.out.println(" Compacting Arrays: " + Main.dateFormat.format(new Date()));
}
CompactArrayInitializer.transform(m);
if (Main.DEBUG) {
System.out.println("---------- After compaction:");
m.print(System.out);
System.out.println("---------- end print");
}
}
FlowGraph cfg; // The control flow graph for a method
if (Main.TRACE) {
System.out.println(" Constructing CFG: " + Main.dateFormat.format(new Date()));
}
try {
// Construct the control flow graph for method m
cfg = new FlowGraph(m);
} catch (final ClassFormatException ex) {
System.err.println(ex.getMessage());
context.release(m.methodInfo());
return;
}
// We separate out initialization since before this the FlowGraph
// more exactly represents the input program.
cfg.initialize();
if (Main.TRACE) {
System.out.println(" Transforming to SSA: " + Main.dateFormat.format(new Date()));
}
SSA.transform(cfg);
if (FlowGraph.DEBUG) {
System.out.println("---------- After SSA:");
cfg.print(System.out);
System.out.println("---------- end print");
}
if (Main.DEBUG) {
cfg.visit(new VerifyCFG(false));
}
if (!Tree.USE_STACK) {
// Do copy propagation and value numbering first to get rid of
// all the extra copies inserted for dups. If they're left in,
// it really slows down value numbering.
if (Main.PROP) {
if (Main.DEBUG) {
System.out.println("-----Before Copy Propagation-----");
}
if (Main.TRACE) {
System.out.println(" Copy propagation: " + Main.dateFormat.format(new Date()));
}
final ExprPropagation copy = new ExprPropagation(cfg);
copy.transform();
if (Main.DEBUG) {
cfg.visit(new VerifyCFG(false));
}
if (Main.DEBUG) {
System.out.println("------After Copy Propagation-----");
cfg.print(System.out);
}
}
}
DeadCodeElimination dce = null;
if (Main.DCE) {
if (Main.TRACE) {
System.out.println(" Dead Code Elimination: " + Main.dateFormat.format(new Date()));
}
if (Main.DEBUG) {
System.out.println("---Before Dead Code Elimination--");
}
dce = new DeadCodeElimination(cfg);
dce.transform();
if (Main.DEBUG) {
cfg.visit(new VerifyCFG(false));
}
if (Main.DEBUG) {
System.out.println("---After Dead Code Elimination---");
cfg.print(System.out);
}
}
if (Main.INFER) {
if (Main.DEBUG) {
System.out.println("---------Doing type inference--------");
}
if (Main.TRACE) {
System.out.println(" Type Inferencing: " + Main.dateFormat.format(new Date()));
}
TypeInference.transform(cfg, context.getHierarchy());
}
if (Main.NUMBER) {
if (Main.TRACE) {
System.out.println(" Value Numbering: " + Main.dateFormat.format(new Date()));
}
if (Main.DEBUG) {
System.out.println("--------Doing value numbering--------");
}
(new ValueNumbering()).transform(cfg);
}
if (Main.FOLD) {
if (Main.DEBUG) {
System.out.println("--------Before Value Folding---------");
}
if (Main.TRACE) {
System.out.println(" Value Folding: " + Main.dateFormat.format(new Date()));
}
(new ValueFolding()).transform(cfg);
if (Main.DEBUG) {
cfg.visit(new VerifyCFG());
}
if (Main.DEBUG) {
System.out.println("---------After Value Folding---------");
cfg.print(System.out);
}
}
if (Main.PRE) {
if (Main.DEBUG) {
System.out.println("-------------Before SSAPRE-----------");
}
if (Main.TRACE) {
System.out.println(" SSAPRE: " + Main.dateFormat.format(new Date()));
}
final SSAPRE pre = new SSAPRE(cfg, context);
pre.transform();
if (Main.DEBUG) {
cfg.visit(new VerifyCFG());
}
if (Main.DEBUG) {
System.out.println("-------------After SSAPRE------------");
cfg.print(System.out);
}
}
if (Main.FOLD) {
if (Main.DEBUG) {
System.out.println("--------Before Value Folding---------");
}
if (Main.TRACE) {
System.out.println(" Value Folding: " + Main.dateFormat.format(new Date()));
}
(new ValueFolding()).transform(cfg);
if (Main.DEBUG) {
cfg.visit(new VerifyCFG());
}
if (Main.DEBUG) {
System.out.println("---------After Value Folding---------");
cfg.print(System.out);
}
}
if (Main.PROP) {
if (Main.DEBUG) {
System.out.println("-------Before Copy Propagation-------");
}
if (Main.TRACE) {
System.out.println(" Copy Propagation " + Main.dateFormat.format(new Date()));
}
final ExprPropagation copy = new ExprPropagation(cfg);
copy.transform();
if (Main.DEBUG) {
cfg.visit(new VerifyCFG());
}
if (Main.DEBUG) {
System.out.println("--------After Copy Propagation-------");
cfg.print(System.out);
}
}
// make sure we've done at least one thing since the last DCE
if (Main.DCE && (Main.INFER || Main.NUMBER || Main.FOLD || Main.PRE || Main.PROP)) {
if (Main.DEBUG) {
System.out.println("-----Before Dead Code Elimination----");
}
if (Main.TRACE) {
System.out.println(" Dead Code Elimination: " + Main.dateFormat.format(new Date()));
}
dce = new DeadCodeElimination(cfg);
dce.transform();
if (Main.DEBUG) {
cfg.visit(new VerifyCFG());
}
if (Main.DEBUG) {
System.out.println("-----After Dead Code Elimination-----");
cfg.print(System.out);
}
}
if (Main.PERSIST) {
(new PersistentCheckElimination()).transform(cfg);
}
if (Main.DIVA) {
if (Main.DEBUG) {
System.out.println("-----Before DIVA------");
}
if (Main.TRACE) {
System.out.println(" DIVA: " + Main.dateFormat.format(new Date()));
}
(new InductionVarAnalyzer()).transform(cfg);
if (Main.DEBUG) {
System.out.println("-----After DIVA-----");
cfg.print(System.out);
}
}
/*
* if (STACK_ALLOC) { if (DEBUG) {
* System.out.println("------------Before StackPRE----------"); }
*
* StackPRE pre = new StackPRE(cfg); pre.transform();
*
* if (DEBUG) { cfg.visit(new VerifyCFG()); }
*
* if (DEBUG) { System.out.println("------------After
* StackPRE-----------"); cfg.print(System.out); } }
*/
// Do the new stack optimization
if (Main.OPT_STACK_2) {
if (Main.TRACE) {
System.out.println(" New stack optimization: " + Main.dateFormat.format(new Date()));
}
// generate code without doing liveness or register allocation
final CodeGenerator codegen = new CodeGenerator(m);
codegen.replacePhis(cfg);
m.clearCode2();
cfg.visit(codegen);
// do stack optimization on the bytecode
final StackOpt so = new StackOpt();
so.transform(m);
// convert it back to a cfg
cfg = new FlowGraph(m);
cfg.initialize();
// convert it back to SSA
SSA.transform(cfg);
// do more dead code elimination (eliminate stores)
dce = new DeadCodeElimination(cfg);
dce.transform();
}
if (Main.TRACE) {
System.out.println(" Register allocation: " + Main.dateFormat.format(new Date()));
}
if (Main.VERIFY) {
try {
cfg.visit(new VerifyCFG());
} catch (final IllegalArgumentException ee) {
System.out.println(
" NOTE: CFG did not verify while "
+ "bloating "
+ m.name()
+ " after all optimizations. Exception: "
+ ee);
}
}
// We're all done performing optimizations. Let's generate some code
// and go home.
// Perform liveness analysis of variables in the method.
// Assign local variables ("registers") to expression values.
final Liveness liveness = new Liveness(cfg);
final RegisterAllocator alloc = new RegisterAllocator(cfg, liveness);
// Gather information which can be used to optimize use of the stack
if (CodeGenerator.OPT_STACK) {
if (Main.TRACE) {
System.out.println(" Old stack optimization: " + Main.dateFormat.format(new Date()));
}
StackOptimizer.optimizeCFG(cfg);
}
if (Main.TRACE) {
System.out.println(" Code Generation: " + Main.dateFormat.format(new Date()));
}
// Start the code generation process.
final CodeGenerator codegen = new CodeGenerator(m);
codegen.replacePhis(cfg);
if (Main.DEBUG) {
System.out.println("After fixing Phis------------------------");
cfg.print(System.out);
System.out.println("End print--------------------------------");
}
codegen.simplifyControlFlow(cfg);
codegen.allocReturnAddresses(cfg, alloc);
if (Main.DEBUG) {
System.out.println("After removing empty blocks--------------");
cfg.print(System.out);
System.out.println("End print--------------------------------");
}
// Clear the old contents of the bytecode store and generate new
// code.
// Code is generated using a visitor pattern on the CFG.
m.clearCode();
cfg.visit(codegen);
Peephole.transform(m);
// Commit any changes that have been made to the method
context.commit(m.methodInfo());
} catch (final Exception ex99) {
final String msg =
"** Exception while optimizing "
+ m.name()
+ m.type()
+ " of class "
+ m.declaringClass().name();
System.err.println(msg);
System.err.println(ex99.getMessage());
ex99.printStackTrace(System.err);
System.exit(1);
}
}
/**
* Performs the actual editing of a class. Does a whole mess of stuff including reading in the
* classfile, building data structures to represent the class file, converting the CFG for each
* method in the class into SSA form, perform some anlayses and optimizations on the method, and
* finally committing it back to the class file. Phew.
*/
private static void editClass(final String className) {
ClassFile classFile; // Holds info about a class (implements
// ClassInfo)
// Get information about the class className
try {
classFile = (ClassFile) Main.context.loadClass(className);
} catch (final ClassNotFoundException ex) {
System.err.println("** Couldn't find class: " + ex.getMessage());
return;
}
if (!Main.FORCE) {
// Check to see if the file is up-to-date (i.e. has been
// recompiled since it was last optimized). If so, do nothing
// because the FORCE flag is false.
final File source = classFile.file();
final File target = classFile.outputFile();
if ((source != null)
&& (target != null)
&& source.exists()
&& target.exists()
&& (source.lastModified() < target.lastModified())) {
if (Main.VERBOSE) {
System.out.println(classFile.name() + " is up to date");
}
return;
}
}
if (Main.DEBUG) {
// Print the contents of the class file to System.out
classFile.print(System.out);
}
final ClassEditor c = Main.context.editClass(classFile);
boolean skip = false;
final String name = c.type().className();
final String qual = c.type().qualifier() + "/*";
// Edit only classes explicitly mentioned.
if (Main.ONLY.size() > 0) {
skip = true;
// Only edit classes we explicitly don't name.
for (int i = 0; i < Main.ONLY.size(); i++) {
final String pkg = (String) Main.ONLY.get(i);
if (name.equals(pkg) || qual.equals(pkg)) {
skip = false;
break;
}
}
}
// Don't edit classes we explicitly skip.
if (!skip) {
for (int i = 0; i < Main.SKIP.size(); i++) {
final String pkg = (String) Main.SKIP.get(i);
if (name.equals(pkg) || qual.equals(pkg)) {
skip = true;
break;
}
}
}
if (skip) {
if (Main.VERBOSE) {
System.out.println("Skipping " + c.type().className());
}
// We're done with this class file, decrement its reference count
Main.context.release(classFile);
return;
}
// Touch the output file first. That is, create the file, but make
// it empty, just to make sure we can create it.
try {
final File f = classFile.outputFile();
if (f.exists()) {
f.delete();
}
final File dir = new File(f.getParent());
dir.mkdirs();
if (!dir.exists()) {
throw new RuntimeException("Couldn't create directory: " + dir);
}
final DataOutputStream out = new DataOutputStream(new FileOutputStream(f));
new PrintStream(out).println();
out.close();
} catch (final IOException e) {
e.printStackTrace();
System.exit(1);
}
if (Main.VERBOSE) {
System.out.println("Optimizing " + c.type().className());
}
// Finally, we can start playing with the methods...
final MethodInfo[] methods = c.methods();
final int numMethods = methods.length + 1;
;
int whichMethod = 0;
for (int j = 0; j < methods.length; j++) {
final MethodEditor m;
try {
m = Main.context.editMethod(methods[j]);
} catch (final ClassFormatException ex) {
System.err.println(ex.getMessage());
continue;
}
if (Main.TRACE) {
whichMethod++;
System.out.println(
"Optimizing "
+ name
+ "."
+ m.name()
+ " (method "
+ whichMethod
+ " of "
+ numMethods
+ ")");
}
if (Main.METHOD != null) {
// A method name has been specified on the command line using
// -only-method.
boolean pass = true;
String t = m.name() + m.type();
if (t.equals(Main.METHOD)) {
pass = false;
}
t = m.name();
if (t.equals(Main.METHOD)) {
pass = false;
}
if (pass) {
// This isn't the method we're looking for.
// Decrement its reference count.
Main.context.release(methods[j]);
continue;
}
}
if (Main.DEBUG) {
m.print(System.out);
}
if (m.isNative() || m.isAbstract()) {
// We can't edit native or abstract methods
Main.context.release(methods[j]);
continue;
}
Main.bloatMethod(m, Main.context);
}
if (Main.ANNO) {
String s = "Optimized with: EDU.purdue.cs.bloat.optimize.Main";
for (int i = 0; i < Main.ARGS.length; i++) {
if ((Main.ARGS[i].indexOf(' ') >= 0)
|| (Main.ARGS[i].indexOf('\t') >= 0)
|| (Main.ARGS[i].indexOf('\r') >= 0)
|| (Main.ARGS[i].indexOf('\n') >= 0)) {
s += " '" + Main.ARGS[i] + "'";
} else {
s += " " + Main.ARGS[i];
}
}
System.out.println(s);
// c.constants().addConstant(Constant.UTF8, s);
}
Main.context.commit(classFile);
Main.context.release(classFile);
if (Main.TRACE) {
System.out.println(Main.context.toString());
}
}
/**
* Parses the command line. The user must specify at least one class to optimize and the directory
* in which to place the optimized class files. The methods of the specified classes are then
* optimized according to the command line options.
*
* @see ClassEditor
* @see ClassFileLoader
* @see ClassFile
* @see MethodEditor
* @see MethodInfo
* @see CompactArrayInitializer
* @see FlowGraph
*/
public static void main(final String[] args) {
try {
Main.loader = new ClassFileLoader();
List classes = new ArrayList(args.length); // The classes to
// optimize
boolean gotdir = false; // Has an output directory been specified?
Main.ARGS = args;
for (int i = 0; i < args.length; i++) {
if (args[i].equals("-v") || args[i].equals("-verbose")) {
Main.VERBOSE = true;
Main.loader.setVerbose(true);
} else if (args[i].equals("-debug")) {
Main.DEBUG = true;
Main.loader.setVerbose(true);
ClassFileLoader.DEBUG = true;
CompactArrayInitializer.DEBUG = true;
ClassEditor.DEBUG = true;
FlowGraph.DEBUG = true;
DominatorTree.DEBUG = true;
Tree.DEBUG = true;
CodeGenerator.DEBUG = true;
Liveness.DEBUG = true;
SSA.DEBUG = true;
SSAGraph.DEBUG = true;
PersistentCheckElimination.DEBUG = true;
ValueNumbering.DEBUG = true;
ValueFolding.DEBUG = true;
ClassHierarchy.DEBUG = true;
TypeInference.DEBUG = true;
SSAPRE.DEBUG = true;
StackPRE.DEBUG = true;
ExprPropagation.DEBUG = true;
DeadCodeElimination.DEBUG = true;
CodeGenerator.DB_OPT_STACK = true;
} else if (args[i].equals("-trace")) {
Main.TRACE = true;
} else if (args[i].equals("-db")) {
if (++i >= args.length) {
System.err.println("** No debugging option specified");
Main.usage();
}
if (args[i].equals("bc")) {
CodeArray.DEBUG = true;
} else if (args[i].equals("cfg")) {
FlowGraph.DEBUG = true;
} else if (args[i].equals("ssa")) {
SSA.DEBUG = true;
SSAGraph.DEBUG = true;
} else if (args[i].equals("graphs")) {
FlowGraph.DB_GRAPHS = true;
} else if (args[i].startsWith("-")) {
i--;
} else {
System.err.println("** Unknown debugging option: " + args[i]);
Main.usage();
}
} else if (args[i].equals("-debugvf")) {
ValueFolding.DUMP = true;
} else if (args[i].equals("-debugbc")) {
BloatContext.DEBUG = true;
} else if (args[i].equals("-help")) {
Main.usage();
} else if (args[i].equals("-noanno")) {
Main.ANNO = false;
} else if (args[i].equals("-anno")) {
Main.ANNO = true;
} else if (args[i].equals("-print-flow-graph")) {
FlowGraph.PRINT_GRAPH = true;
} else if (args[i].equals("-preserve-debug")) {
MethodEditor.PRESERVE_DEBUG = true;
} else if (args[i].equals("-nouse-stack-vars")) {
Tree.USE_STACK = false;
} else if (args[i].equals("-use-stack-vars")) {
Tree.USE_STACK = true;
} else if (args[i].equals("-unique-handlers")) {
MethodEditor.UNIQUE_HANDLERS = true;
} else if (args[i].equals("-nocompact-array-init")) {
Main.COMPACT_ARRAY_INIT = false;
} else if (args[i].equals("-compact-array-init")) {
Main.COMPACT_ARRAY_INIT = true;
} else if (args[i].equals("-nostack-alloc")) {
Main.STACK_ALLOC = false;
} else if (args[i].equals("-stack-alloc")) {
Main.STACK_ALLOC = true;
} else if (args[i].equals("-no-verify")) {
Main.VERIFY = false;
} else if (args[i].equals("-peel-loops")) {
if (++i >= args.length) {
Main.usage();
}
final String n = args[i];
if (n.equals("all")) {
FlowGraph.PEEL_LOOPS_LEVEL = FlowGraph.PEEL_ALL_LOOPS;
} else {
try {
FlowGraph.PEEL_LOOPS_LEVEL = Integer.parseInt(n);
if (FlowGraph.PEEL_LOOPS_LEVEL < 0) {
Main.usage();
}
} catch (final NumberFormatException ex) {
Main.usage();
}
}
} else if (args[i].equals("-color")) {
Liveness.UNIQUE = false;
} else if (args[i].equals("-nocolor")) {
Liveness.UNIQUE = true;
} else if (args[i].equals("-only-method")) {
if (++i >= args.length) {
Main.usage();
}
Main.METHOD = args[i];
} else if (args[i].equals("-classpath")) {
if (++i >= args.length) {
Main.usage();
}
final String classpath = args[i];
Main.loader.setClassPath(classpath);
} else if (args[i].equals("-classpath/p")) {
if (++i >= args.length) {
Main.usage();
}
final String classpath = args[i];
Main.loader.prependClassPath(classpath);
} else if (args[i].equals("-skip")) {
if (++i >= args.length) {
Main.usage();
}
String pkg = args[i];
// Account for class file name on command line
if (pkg.endsWith(".class")) {
pkg = pkg.substring(0, pkg.lastIndexOf('.'));
}
Main.SKIP.add(pkg.replace('.', '/'));
} else if (args[i].equals("-only")) {
if (++i >= args.length) {
Main.usage();
}
String pkg = args[i];
// Account for class file name on command line
if (pkg.endsWith(".class")) {
pkg = pkg.substring(0, pkg.lastIndexOf('.'));
}
Main.ONLY.add(pkg.replace('.', '/'));
} else if (args[i].equals("-nodce")) {
Main.DCE = false;
} else if (args[i].equals("-noprop")) {
Main.PROP = false;
} else if (args[i].equals("-noappre")) {
SSAPRE.NO_ACCESS_PATHS = true;
} else if (args[i].equals("-nopre")) {
Main.PRE = false;
} else if (args[i].equals("-dce")) {
Main.DCE = true;
} else if (args[i].equals("-prop")) {
Main.PROP = true;
} else if (args[i].equals("-appre")) {
SSAPRE.NO_ACCESS_PATHS = false;
} else if (args[i].equals("-pre")) {
Main.PRE = true;
} else if (args[i].equals("-closure")) {
Main.CLOSURE = true;
} else if (args[i].equals("-opt-stack-1")) {
Main.OPT_STACK_1 = true;
CodeGenerator.OPT_STACK = true;
} else if (args[i].equals("-opt-stack-2")) {
Main.OPT_STACK_2 = true;
MethodEditor.OPT_STACK_2 = true;
} else if (args[i].equals("-diva")) {
Main.DIVA = true;
} else if (args[i].equals("-no-thread")) {
SSAPRE.NO_THREAD = true;
} else if (args[i].equals("-no-precise")) {
SSAPRE.NO_PRECISE = true;
} else if (args[i].equals("-relax-loading")) {
ClassHierarchy.RELAX = true;
} else if (args[i].equals("-f") || args[i].equals("-force")) {
Main.FORCE = true;
} else if (args[i].startsWith("-")) {
System.err.println("No such option: " + args[i]);
Main.usage();
} else if (i == args.length - 1) {
// Last argument is the name of the output directory
final File f = new File(args[i]);
if (f.exists() && !f.isDirectory()) {
System.err.println("No such directory: " + f.getPath());
System.exit(2);
}
if (!f.exists()) {
f.mkdirs();
}
if (!f.exists()) {
System.err.println("Couldn't create directory: " + f.getPath());
System.exit(2);
}
// Tell class loader to put optimized classes in f directory
Main.loader.setOutputDir(f);
gotdir = true;
} else {
// The argument must be a class name...
classes.add(args[i]);
}
}
if (!gotdir) {
System.err.println("No output directory specified");
Main.usage();
}
if (classes.size() == 0) {
System.err.println("** No classes specified");
Main.usage();
}
// Use the CachingBloatingContext
Main.context = new CachingBloatContext(Main.loader, classes, Main.CLOSURE);
boolean errors = false;
final Iterator iter = classes.iterator();
// Now that we've parsed the command line, load the classes into the
// class loader
while (iter.hasNext()) {
final String name = (String) iter.next();
try {
Main.context.loadClass(name);
} catch (final ClassNotFoundException ex) {
System.err.println("Couldn't find class: " + ex.getMessage());
errors = true;
}
}
if (errors) {
System.exit(1);
}
if (!Main.CLOSURE) {
final Iterator e = classes.iterator();
// Edit only the classes that were specified on the command line
while (e.hasNext()) {
final String name = (String) e.next();
Main.editClass(name);
}
} else {
// Edit all the classes in the class file editor and their
// superclasses
classes = null;
if (Main.TRACE) {
System.out.println("Computing closure " + Main.dateFormat.format(new Date()));
}
final Iterator e = Main.context.getHierarchy().classes().iterator();
while (e.hasNext()) {
final Type t = (Type) e.next();
if (t.isObject()) {
Main.editClass(t.className());
}
}
}
} catch (final ExceptionInInitializerError ex) {
ex.printStackTrace();
System.out.println(ex.getException());
}
}
/**
* Parse the command line. Inserts residency, update, and swizzle checks into the bytecode of the
* methods of the specified classes.
*/
public static void main(final String[] args) {
final ClassFileLoader loader = new ClassFileLoader();
List classes = new ArrayList(); // Names of classes from command line
boolean gotdir = false; // Did user specify an output dir?
for (int i = 0; i < args.length; i++) {
if (args[i].equals("-v") || args[i].equals("-verbose")) {
Main.VERBOSE++;
} else if (args[i].equals("-help")) {
Main.usage();
} else if (args[i].equals("-classpath")) {
if (++i >= args.length) {
Main.usage();
}
final String classpath = args[i];
loader.setClassPath(classpath);
} else if (args[i].equals("-skip")) {
if (++i >= args.length) {
Main.usage();
}
final String pkg = args[i].replace('.', '/');
Main.SKIP.add(pkg);
} else if (args[i].equals("-only")) {
if (++i >= args.length) {
Main.usage();
}
final String pkg = args[i].replace('.', '/');
Main.ONLY.add(pkg);
} else if (args[i].equals("-closure")) {
Main.CLOSURE = true;
} else if (args[i].equals("-relax-loading")) {
ClassHierarchy.RELAX = true;
} else if (args[i].equals("-f")) {
Main.FORCE = true;
} else if (args[i].equals("-norc")) {
Main.RC = false;
} else if (args[i].equals("-rc")) {
Main.RC = true;
} else if (args[i].equals("-nouc")) {
Main.UC = false;
} else if (args[i].equals("-uc")) {
Main.UC = true;
} else if (args[i].equals("-nosc")) {
Main.SC = false;
} else if (args[i].equals("-sc")) {
Main.SC = true;
} else if (args[i].startsWith("-")) {
Main.usage();
} else if (i == args.length - 1) {
// Last argument is the name of the outpu directory
final File f = new File(args[i]);
if (f.exists() && !f.isDirectory()) {
System.err.println("No such directory: " + f.getPath());
System.exit(2);
}
loader.setOutputDir(f);
gotdir = true;
} else {
classes.add(args[i]);
}
}
if (!gotdir) {
Main.usage();
}
if (classes.size() == 0) {
Main.usage();
}
if (Main.VERBOSE > 3) {
ClassFileLoader.DEBUG = true;
ClassEditor.DEBUG = true;
}
boolean errors = false;
final Iterator iter = classes.iterator();
// Load each class specified on the command line
while (iter.hasNext()) {
final String name = (String) iter.next();
try {
loader.loadClass(name);
} catch (final ClassNotFoundException ex) {
System.err.println("Couldn't find class: " + ex.getMessage());
errors = true;
}
}
if (errors) {
System.exit(1);
}
final BloatContext context = new CachingBloatContext(loader, classes, Main.CLOSURE);
if (!Main.CLOSURE) {
final Iterator e = classes.iterator();
while (e.hasNext()) {
final String name = (String) e.next();
try {
final ClassInfo info = loader.loadClass(name);
Main.decorateClass(context, info);
} catch (final ClassNotFoundException ex) {
System.err.println("Couldn't find class: " + ex.getMessage());
System.exit(1);
}
}
} else {
classes = null;
final ClassHierarchy hier = context.getHierarchy();
final Iterator e = hier.classes().iterator();
while (e.hasNext()) {
final Type t = (Type) e.next();
if (t.isObject()) {
try {
final ClassInfo info = loader.loadClass(t.className());
Main.decorateClass(context, info);
} catch (final ClassNotFoundException ex) {
System.err.println("Couldn't find class: " + ex.getMessage());
System.exit(1);
}
}
}
}
}
/**
* Performs intraprocedural BLOAT on a program's live methods.
*
* @param liveMethods Should be alphabetized. This way we can commit a class once we've BLOATed
* all of its methods.
*/
private static void intraBloat(final Collection liveMethods, final BloatContext context) {
ClassEditor prevClass = null;
final Iterator iter = liveMethods.iterator();
for (int count = 0; iter.hasNext(); count++) {
MethodEditor live = null;
ClassEditor ce = null; // Hack to make sure commit happens
try {
live = context.editMethod((MemberRef) iter.next());
ce = context.editClass(live.declaringClass().classInfo());
} catch (final NoSuchMethodException ex3) {
BloatBenchmark.err.println("** Could not find method " + ex3.getMessage());
System.exit(1);
}
/* So we can skip classes or packages */
final String name = ce.type().className();
final String qual = ce.type().qualifier() + "/*";
boolean skip = false;
for (int i = 0; i < BloatBenchmark.SKIP.size(); i++) {
final String pkg = (String) BloatBenchmark.SKIP.get(i);
if (name.equals(pkg) || qual.equals(pkg)) {
skip = true;
break;
}
}
if (context.ignoreMethod(live.memberRef()) || skip) {
// Don't display ignored methods, it's misleading.
context.release(live.methodInfo());
continue;
}
final Runtime runtime = Runtime.getRuntime();
runtime.gc();
final Date start = new Date();
BloatBenchmark.tr(
" " + count + ") " + live.declaringClass().name() + "." + live.name() + live.type());
BloatBenchmark.tr(" Start: " + start);
try {
EDU.purdue.cs.bloat.optimize.Main.TRACE = BloatBenchmark.TRACE;
if (!BloatBenchmark.VERIFY) {
EDU.purdue.cs.bloat.optimize.Main.VERIFY = false;
}
EDU.purdue.cs.bloat.optimize.Main.bloatMethod(live, context);
} catch (final Exception oops) {
BloatBenchmark.err.println("******************************************");
BloatBenchmark.err.println(
"Exception while BLOATing "
+ live.declaringClass().name()
+ "."
+ live.name()
+ live.type());
BloatBenchmark.err.println(oops.getMessage());
oops.printStackTrace(System.err);
BloatBenchmark.err.println("******************************************");
}
// Commit here in an attempt to conserve memory
context.commit(live.methodInfo());
context.release(live.methodInfo());
if (prevClass == null) {
prevClass = ce;
} else if (!prevClass.equals(ce)) {
// We've finished BLOATed the methods for prevClass, commit
// prevClass and move on
BloatBenchmark.tr(prevClass.type() + " != " + ce.type());
context.commit(prevClass.classInfo());
context.release(prevClass.classInfo());
// context.commitDirty();
// tr(context.toString());
prevClass = ce;
} else {
context.release(ce.classInfo());
}
final Date end = new Date();
BloatBenchmark.tr(" Ellapsed time: " + (end.getTime() - start.getTime()) + " ms");
}
context.commitDirty();
}
