org.jikesrvm.compilers.opt.bc2ir

Class GenerationContext

java.lang.Object

org.jikesrvm.compilers.opt.bc2ir.GenerationContext

public final class GenerationContext
extends Object

Defines the context in which BC2IR will abstractly interpret a method's bytecodes and populate targetIR with instructions.

Field Summary

Fields

Modifier and Type	Field and Description
private HashMap<Register,RegisterOperand>	_ncGuards
private Register[]	addressLocals
private boolean	allocFrame Did BC2IR encounter a magic that requires us to allocate a stack frame?
private Operand[]	arguments The parameters which BC2IR should use to seed the local state for the entry basic block.
private BranchProfiles	branchProfiles The BranchProfile data for method, if available
private ControlFlowGraph	cfg The CFG object into which instructions should be generated.
private Register[]	doubleLocals
private ExceptionHandlerBasicBlockBag	enclosingHandlers The enclosing exception handlers (null if there are none).
private BasicBlock	epilogue The basic block into which BC2IR's caller will generate an epilogue.
private BasicBlock	exit The exit node of the outermost CFG (used by BC2IR for not-definitely caught athrows and by OSR_Yieldpoints)
private Register[]	floatLocals
private boolean	generatedExceptionHandlers Did BC2IR generate a reachable exception handler while generating the IR for this method
private InlineOracle	inlinePlan The InlineOracle to be consulted for all inlining decisions during the generation of this IR.
private InlineSequence	inlineSequence Inlining context of the method to be generated
private Map<Instruction,Instruction>	instToOSRBarriers Mapping of instructions to on-stack replacement (OSR) barriers.
private Register[]	intLocals
private Register[]	longLocals
private NormalMethod	method The method to be generated
private OptOptions	options The options to control the generation
private CompiledMethod	original_cm The compiled method assigned for this compilation of original_method
private GenerationContext	parent The parent of this context is the context that the method createChildContext(ExceptionHandlerBasicBlockBag, NormalMethod, Instruction) was called upon in order to create this context.
private BasicBlock	prologue The basic block into which BC2IR's caller will generate a "prologue."
private Operand	result Used to communicate the meet of the return values back to the caller Mainly useful when BC2IR is doing inlining....allows the caller BC2IR object to exploit knowledge the callee BC2IR object had about the result.
private Register	resultReg The Register to which BC2IR should assign the return value(s) of the method.
private GenericRegisterPool	temps The register pool to be used during generation
private BasicBlock	unlockAndRethrow A catch, unlock, and rethrow exception handler used for synchronized methods.

Constructor Summary

Constructors

Modifier	Constructor and Description
private	GenerationContext() for internal use only (in createInlinedContext)
(package private)	GenerationContext(NormalMethod meth, TypeReference[] params, CompiledMethod cm, OptOptions opts, InlineOracle ip) Use this constructor to create an outermost (non-inlined) GenerationContext.

Method Summary

Modifier and Type	Method and Description
private void	appendInstruction(BasicBlock b, Instruction s, int bcIndex)
void	close() Kill ncGuards, so we do not use outdated mappings unintendedly later on
private void	completeEpilogue(boolean isOutermost) Fill in the rest of the method epilogue.
private void	completeExceptionHandlers(boolean isOutermost) If the method is synchronized then we wrap it in a synthetic exception handler that unlocks & rethrows PRECONDITION: cfg, arguments & temps have been setup/initialized.
private void	completePrologue(boolean isOutermost) Fills in the rest of the method prologue.
GenerationContext	createChildContext(ExceptionHandlerBasicBlockBag ebag, NormalMethod callee, Instruction callSite) Creates a child generation context from this context and callerBB to generate IR for callsite.
static GenerationContext	createSynthetic(GenerationContext parent, ExceptionHandlerBasicBlockBag ebag) Only for internal use by Inliner (when inlining multiple targets) This is probably not the prettiest way to handle this, but it requires no changes to BC2IR's & Inliner's high level control logic.
void	discardOSRBarrierInformation()
void	forceFrameAllocation() Forces allocation of a stack frame for this method.
boolean	generatedExceptionHandlers()
(package private) Operand[]	getArguments()
(package private) BranchProfiles	getBranchProfiles()
ControlFlowGraph	getCfg()
(package private) BranchProfileOperand	getConditionalBranchProfileOperand(int bcIndex, boolean backwards)
(package private) ExceptionHandlerBasicBlockBag	getEnclosingHandlers()
BasicBlock	getEpilogue()
BasicBlock	getExit()
(package private) InlineOracle	getInlinePlan()
InlineSequence	getInlineSequence()
(package private) int	getLocalNumberFor(Register reg, TypeReference type) Gets the local number for a given register
private Operand	getLockObject() Get the object for locking for synchronized methods.
NormalMethod	getMethod()
OptOptions	getOptions()
(package private) CompiledMethod	getOriginalCompiledMethod()
(package private) NormalMethod	getOriginalMethod()
Instruction	getOSRBarrierFromInst(Instruction inst)
private GenerationContext	getOutermostContext()
private Register[]	getPool(TypeReference type)
BasicBlock	getPrologue()
Operand	getResult()
(package private) Register	getResultReg()
(package private) SwitchBranchProfile	getSwitchProfile(int bcIndex)
GenericRegisterPool	getTemps()
(package private) BasicBlock	getUnlockAndRethrow()
private void	initLocalPool()
(package private) boolean	isLocal(Operand op, int i, TypeReference type) Is the operand a particular bytecode local?
(package private) Register	localReg(int i, TypeReference type) Returns the Register used to for local i of TypeReference type.
(package private) RegisterOperand	makeLocal(int i, RegisterOperand props) Makes a register operand that refers to the given local variable number, and inherits its properties (type, flags) from props
(package private) RegisterOperand	makeLocal(int i, TypeReference type) Makes a register operand that refers to the given local variable number and has the given type.
(package private) RegisterOperand	makeNullCheckGuard(Register ref) Makes a register operand to use as a null check guard for the given register.
void	markExceptionHandlersAsGenerated()
(package private) boolean	methodIsSelectedForDebuggingWithMethodToPrint() Is this method selected for debugging with method to print?
(package private) boolean	noBoundsChecks()
(package private) boolean	noCheckStoreChecks()
(package private) boolean	noNullChecks()
boolean	requiresStackFrame()
private boolean	requiresUnintMarker()
private void	resync_ncGuards() This method makes sure that _ncGuard only maps to registers that are actually in the IRs register pool.
void	resync() Make sure, the generation context is still in sync with the IR, even if we applied some optimizations.
void	saveOSRBarrierForInst(Instruction osrBarrier, Instruction inst)
void	setEpilogue(BasicBlock epilogue)
void	setResult(Operand result)
void	transferStateToParent() Transfers the state from this context back to its direct parent.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

parent

private GenerationContext parent

The parent of this context is the context that the method createChildContext(ExceptionHandlerBasicBlockBag, NormalMethod, Instruction) was called upon in order to create this context. This field is null if this context is the outermost one.

original_cm

private CompiledMethod original_cm

The compiled method assigned for this compilation of original_method

method

private NormalMethod method

The method to be generated

branchProfiles

private BranchProfiles branchProfiles

The BranchProfile data for method, if available

options

private OptOptions options

The options to control the generation

cfg

private ControlFlowGraph cfg

The CFG object into which instructions should be generated.

temps

private GenericRegisterPool temps

The register pool to be used during generation

arguments

private Operand[] arguments

The parameters which BC2IR should use to seed the local state for the entry basic block.

prologue

private BasicBlock prologue

The basic block into which BC2IR's caller will generate a "prologue." BC2IR will add a CFG edge from prologue to the block containing the instructions generated for bytecode 0, but it is its caller's responsibility to populate the prologue with instructions. All blocks generated by BC2IR will be injected by BC2IR.doFinalPass immediately after prologue in the code ordering (ie prologue can assume it will fallthrough to the first basic block in the ir generated for method.

epilogue

private BasicBlock epilogue

The basic block into which BC2IR's caller will generate an epilogue. BC2IR will add CFG edges to this node, but it is its caller's responsibility to populate it with instructions. NOTE: After IR is generated one of two conditions will hold:

• epilogue == cfg.lastInCodeOrder(): (if it is to be inlined, then the generated cfg is expecting to "fallthrough" to the next bblock)
• epilogue == null: implies that there is no "normal" exit from the callee (all exits via throw)

NOTE: BC2IR assumes that epilogue is a single basic block (i.e. it has no out edges)

exit

private BasicBlock exit

The exit node of the outermost CFG (used by BC2IR for not-definitely caught athrows and by OSR_Yieldpoints)

unlockAndRethrow

private BasicBlock unlockAndRethrow

A catch, unlock, and rethrow exception handler used for synchronized methods.

resultReg

private Register resultReg

The Register to which BC2IR should assign the return value(s) of the method. It will be null when the method has a void return.

enclosingHandlers

private ExceptionHandlerBasicBlockBag enclosingHandlers

The enclosing exception handlers (null if there are none).

inlineSequence

private InlineSequence inlineSequence

Inlining context of the method to be generated

inlinePlan

private InlineOracle inlinePlan

The InlineOracle to be consulted for all inlining decisions during the generation of this IR.

generatedExceptionHandlers

private boolean generatedExceptionHandlers

Did BC2IR generate a reachable exception handler while generating the IR for this method

allocFrame

private boolean allocFrame

Did BC2IR encounter a magic that requires us to allocate a stack frame?

result

private Operand result

Used to communicate the meet of the return values back to the caller Mainly useful when BC2IR is doing inlining....allows the caller BC2IR object to exploit knowledge the callee BC2IR object had about the result.

instToOSRBarriers

private Map<Instruction,Instruction> instToOSRBarriers

Mapping of instructions to on-stack replacement (OSR) barriers. The key is always a call instruction or an OSR yieldpoint instruction, the value is an OSR barrier instruction.

Child contexts save this information in their outermost parent context, so this field will be null for child contexts.

intLocals

private Register[] intLocals

addressLocals

private Register[] addressLocals

floatLocals

private Register[] floatLocals

longLocals

private Register[] longLocals

doubleLocals

private Register[] doubleLocals

_ncGuards

private HashMap<Register,RegisterOperand> _ncGuards

Constructor Detail

GenerationContext

GenerationContext(NormalMethod meth,
                  TypeReference[] params,
                  CompiledMethod cm,
                  OptOptions opts,
                  InlineOracle ip)

Use this constructor to create an outermost (non-inlined) GenerationContext.

Parameters:

meth - The NormalMethod whose IR will be generated

params - The known types of the parameters to the method. For method specialization.

cm - The compiled method id to be used for this compilation

opts - The Options to be used for the generation

ip - The InlineOracle to be used for the generation

GenerationContext

private GenerationContext()

for internal use only (in createInlinedContext)

Method Detail

createChildContext

public GenerationContext createChildContext(ExceptionHandlerBasicBlockBag ebag,
                                            NormalMethod callee,
                                            Instruction callSite)

Creates a child generation context from this context and callerBB to generate IR for callsite.

Parameters:

ebag - the enclosing exception handlers (null if none)

callee - the callee method to be inlined (may _not_ be equal to Call.getMethod(callSite).method)

callSite - the Call instruction to be inlined.

Returns:

the child context

createSynthetic

public static GenerationContext createSynthetic(GenerationContext parent,
                                                ExceptionHandlerBasicBlockBag ebag)

Only for internal use by Inliner (when inlining multiple targets) This is probably not the prettiest way to handle this, but it requires no changes to BC2IR's & Inliner's high level control logic.

Parameters:

parent - the parent GC

ebag - the enclosing exception handlers (null if none)

Returns:

the synthetic context

transferStateToParent

public void transferStateToParent()

Transfers the state from this context back to its direct parent.

Throws:

IllegalStateException - when this context does not have a parent

initLocalPool

private void initLocalPool()

getPool

private Register[] getPool(TypeReference type)

localReg

Register localReg(int i,
                  TypeReference type)

Returns the Register used to for local i of TypeReference type.

Parameters:

i - local number

type - local's type

Returns:

the Register for the local

noNullChecks

boolean noNullChecks()

Returns:

true if and only if null checks should be generated

noBoundsChecks

boolean noBoundsChecks()

Returns:

true if and only if bounds checks should be generated

noCheckStoreChecks

boolean noCheckStoreChecks()

Returns:

true if and only if checkstore checks should be generated

makeLocal

RegisterOperand makeLocal(int i,
                          TypeReference type)

Makes a register operand that refers to the given local variable number and has the given type.

Parameters:

i - local variable number

type - desired data type

Returns:

the newly created register operand

makeLocal

RegisterOperand makeLocal(int i,
                          RegisterOperand props)

Makes a register operand that refers to the given local variable number, and inherits its properties (type, flags) from props

Parameters:

i - local variable number

props - RegisterOperand to inherit flags from

Returns:

the newly created register operand

getLocalNumberFor

int getLocalNumberFor(Register reg,
                      TypeReference type)

Gets the local number for a given register

Parameters:

reg - the register whose local number should be found out

type - the register's type

Returns:

the local number of -1 if not found

isLocal

boolean isLocal(Operand op,
                int i,
                TypeReference type)

Is the operand a particular bytecode local?

Parameters:

op - the operand to check

i - the local's index

type - the local's type

Returns:

true if and only if the given operand is a an operand for the given bytecode local

makeNullCheckGuard

RegisterOperand makeNullCheckGuard(Register ref)

Makes a register operand to use as a null check guard for the given register.

Parameters:

ref - the register to check for null

Returns:

the guard operand

getConditionalBranchProfileOperand

BranchProfileOperand getConditionalBranchProfileOperand(int bcIndex,
                                                        boolean backwards)

getSwitchProfile

SwitchBranchProfile getSwitchProfile(int bcIndex)

completePrologue

private void completePrologue(boolean isOutermost)

Fills in the rest of the method prologue. PRECONDITION: arguments & temps have been setup/initialized.

Parameters:

isOutermost - is this the outermost context (i.e. not an inlined context)

completeEpilogue

private void completeEpilogue(boolean isOutermost)

Fill in the rest of the method epilogue. PRECONDITION: arguments & temps have been setup/initialized.

Parameters:

isOutermost - is this the outermost context (i.e. not an inlined context)

completeExceptionHandlers

private void completeExceptionHandlers(boolean isOutermost)

If the method is synchronized then we wrap it in a synthetic exception handler that unlocks & rethrows PRECONDITION: cfg, arguments & temps have been setup/initialized.

Parameters:

isOutermost - is this the outermost context (i.e. not an inlined context)

getLockObject

private Operand getLockObject()

Get the object for locking for synchronized methods. either the class object or the this ptr.

Returns:

an operand for the appropriate lock object

appendInstruction

private void appendInstruction(BasicBlock b,
                               Instruction s,
                               int bcIndex)

requiresUnintMarker

private boolean requiresUnintMarker()

resync

public void resync()

Make sure, the generation context is still in sync with the IR, even if we applied some optimizations. This method should be called before hir2lir conversions which might trigger inlining.

resync_ncGuards

private void resync_ncGuards()

This method makes sure that _ncGuard only maps to registers that are actually in the IRs register pool.

close

public void close()

Kill ncGuards, so we do not use outdated mappings unintendedly later on

methodIsSelectedForDebuggingWithMethodToPrint

boolean methodIsSelectedForDebuggingWithMethodToPrint()

Is this method selected for debugging with method to print?

A method is selected if the name of the original method is contained in the set of methods to print. This ensures that debug output is not omitted during generation of IR for methods that are inlined into a method that is supposed to be printed.

Returns:

true if and only if this method is selected for debugging as described above

See Also:

BC2IR.DBG_SELECTIVE

forceFrameAllocation

public void forceFrameAllocation()

Forces allocation of a stack frame for this method.

requiresStackFrame

public boolean requiresStackFrame()

generatedExceptionHandlers

public boolean generatedExceptionHandlers()

markExceptionHandlersAsGenerated

public void markExceptionHandlersAsGenerated()

saveOSRBarrierForInst

public void saveOSRBarrierForInst(Instruction osrBarrier,
                                  Instruction inst)

getOSRBarrierFromInst

public Instruction getOSRBarrierFromInst(Instruction inst)

discardOSRBarrierInformation

public void discardOSRBarrierInformation()

getMethod

public NormalMethod getMethod()

getOptions

public OptOptions getOptions()

getCfg

public ControlFlowGraph getCfg()

getTemps

public GenericRegisterPool getTemps()

getPrologue

public BasicBlock getPrologue()

getEpilogue

public BasicBlock getEpilogue()

setEpilogue

public void setEpilogue(BasicBlock epilogue)

getExit

public BasicBlock getExit()

getInlineSequence

public InlineSequence getInlineSequence()

getResult

public Operand getResult()

setResult

public void setResult(Operand result)

getOriginalMethod

NormalMethod getOriginalMethod()

Returns:

the original method (root of the calling context tree)

getOriginalCompiledMethod

CompiledMethod getOriginalCompiledMethod()

getBranchProfiles

BranchProfiles getBranchProfiles()

getArguments

Operand[] getArguments()

getUnlockAndRethrow

BasicBlock getUnlockAndRethrow()

getResultReg

Register getResultReg()

getEnclosingHandlers

ExceptionHandlerBasicBlockBag getEnclosingHandlers()

getInlinePlan

InlineOracle getInlinePlan()

getOutermostContext

private GenerationContext getOutermostContext()