/*
* This file is part of the Jikes RVM project (http://jikesrvm.org).
*
* This file is licensed to You under the Eclipse Public License (EPL);
* You may not use this file except in compliance with the License. You
* may obtain a copy of the License at
*
* http://www.opensource.org/licenses/eclipse-1.0.php
*
* See the COPYRIGHT.txt file distributed with this work for information
* regarding copyright ownership.
*/
package org.jikesrvm.compilers.opt.driver;
import org.jikesrvm.classloader.NormalMethod;
import org.jikesrvm.classloader.TypeReference;
import org.jikesrvm.compilers.opt.OptOptions;
import org.jikesrvm.compilers.opt.inlining.DefaultInlineOracle;
import org.jikesrvm.compilers.opt.inlining.InlineOracle;
import org.jikesrvm.compilers.opt.ir.IR;
/*
* An instance of this class acts instructs the optimizing
* compiler how to compile the specified method.
*/
public final class CompilationPlan {
/**
* The method to be compiled.
*/
public final NormalMethod method;
public NormalMethod getMethod() {
return method;
}
/**
* The specialized parameters to use in place of those defined in method.
*/
public final TypeReference[] params;
/**
* The OptimizationPlanElements to be invoked during compilation.
*/
public final OptimizationPlanElement[] optimizationPlan;
/**
* The instrumentation plan for the method.
*/
public final InstrumentationPlan instrumentationPlan;
/**
* The oracle to be consulted for all inlining decisions.
*/
public InlineOracle inlinePlan;
/**
* The Options object that contains misc compilation control data
*/
public final OptOptions options;
/**
* Whether this compilation is for analysis only?
*/
public boolean analyzeOnly;
public boolean irGeneration;
/**
* Construct a compilation plan
*
* @param m The NormalMethod representing the source method to be compiled
* @param pms The specialized parameters to use in place of those defined in method
* @param op The optimization plan to be executed on m
* @param mp The instrumentation plan to be executed on m
* @param opts The Options to be used for compiling m
*/
public CompilationPlan(NormalMethod m, TypeReference[] pms, OptimizationPlanElement[] op, InstrumentationPlan mp,
OptOptions opts) {
method = m;
params = pms;
inlinePlan = new DefaultInlineOracle();
optimizationPlan = op;
instrumentationPlan = mp;
options = opts;
}
/**
* Construct a compilation plan
*
* @param m The NormalMethod representing the source method to be compiled
* @param op The optimization plan to be executed on m
* @param mp The instrumentation plan to be executed on m
* @param opts The Options to be used for compiling m
*/
public CompilationPlan(NormalMethod m, OptimizationPlanElement[] op, InstrumentationPlan mp,
OptOptions opts) {
this(m, null, op, mp, opts);
}
/**
* Construct a compilation plan
* @param m The NormalMethod representing the source method to be compiled
* @param op A single optimization pass to execute on m
* @param mp The instrumentation plan to be executed on m
* @param opts The Options to be used for compiling m
*/
public CompilationPlan(NormalMethod m, OptimizationPlanElement op, InstrumentationPlan mp,
OptOptions opts) {
this(m, new OptimizationPlanElement[]{op}, mp, opts);
}
public void setInlineOracle(InlineOracle o) {
inlinePlan = o;
}
/**
* Execute a compilation plan by executing each element
* in the optimization plan.
*
* @return the IR created by the execution of the optimization plan
*/
public IR execute() {
IR ir = new IR(method, this);
// If there is instrumentation to perform, do some initialization
if (instrumentationPlan != null) {
instrumentationPlan.initInstrumentation(method);
}
for (OptimizationPlanElement element : optimizationPlan) {
ir.setIdForNextPhase();
element.perform(ir);
}
// If instrumentation has occured, perform some
// cleanup/finalization. NOTE: This code won't execute when
// compilation fails with an exception. TODO: Figure out
// whether this matters.
if (instrumentationPlan != null) {
instrumentationPlan.finalizeInstrumentation(method);
}
return ir;
}
}