Uses of Class org.jikesrvm.compilers.opt.controlflow.AnnotatedLSTNode (Jikes RVM API)

Packages that use AnnotatedLSTNode
org.jikesrvm.compilers.opt.ssa

Methods in org.jikesrvm.compilers.opt.ssa with parameters of type AnnotatedLSTNode
`private boolean`	`LoopVersioning.createBranchBlocks(AnnotatedLSTNode loop, BasicBlock block, ArrayList<Instruction> checksToEliminate, BasicBlock unoptimizedLoopEntry, BasicBlock optimizedLoopEntry, HashMap<Register,Register> optimalRegMap)` Create the block containing explict branches to either the optimized or unoptimized loops
`private HashMap<BasicBlock,BasicBlock>`	`LoopVersioning.createCloneLoop(AnnotatedLSTNode loop, HashMap<Register,Register> regMap, HashMap<Register,BasicBlock> regToBlockMap)` Create a clone of the loop replacing definitions in the cloned loop with those found in the register map
`private HashMap<BasicBlock,BasicBlock>`	`LoopVersioning.createOptimizedLoop(AnnotatedLSTNode loop, HashMap<Register,Register> regMap, ArrayList<Instruction> instrToEliminate, HashMap<Register,BasicBlock> regToBlockMap)` Create a clone of the loop replacing definitions in the cloned loop with those found in the register map and eliminate unnecessary bound checks
`private boolean`	`LoopVersioning.findLoopToOptimise(AnnotatedLSTNode loop)` Find an outermost loop to optimise and optimise it.
`private BasicBlock`	`LoopVersioning.generateNullCheckBranchBlocks(AnnotatedLSTNode loop, ArrayList<Instruction> checksToEliminate, HashMap<Register,Register> optimalRegMap, BasicBlock block, BasicBlock unoptimizedLoopEntry)` Generate null check branch blocks
`private void`	`LoopVersioning.generatePhiNodes(AnnotatedLSTNode loop, ArrayList<Register> registers, ArrayList<TypeReference> types, ArrayList<Instruction> phiInstructions, HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap)` Generate into a new block phi nodes that define the original register defined by the loop and use two newly created registers.
`private void`	`LoopVersioning.getListOfChecksToEliminate(AnnotatedLSTNode loop, ArrayList<Instruction> instrToEliminate)` Create a list of instructions to be eliminated
`private void`	`LoopVersioning.getRegistersDefinedInLoop(AnnotatedLSTNode loop, ArrayList<Register> registers, ArrayList<TypeReference> types, ArrayList<Instruction> definingInstructions)` Get registers defined in the given loop.
`private void`	`LoopVersioning.modifyOriginalLoop(AnnotatedLSTNode loop, ArrayList<Instruction> phiInstructions, ArrayList<Instruction> definingInstrInOriginalLoop, HashMap<Register,Register> subOptimalRegMap, HashMap<Register,Register> optimalRegMap)` Remove loop and replace register definitions in the original loop with phi instructions
`private void`	`LoopVersioning.removeUnoptimizedLoop(AnnotatedLSTNode loop, HashMap<BasicBlock,BasicBlock> unoptimizedLoopMap)` Remove unreachable unoptimized loop

private boolean

LoopVersioning.createBranchBlocks(AnnotatedLSTNode loop,
                                     BasicBlock block,
                                     ArrayList<Instruction> checksToEliminate,
                                     BasicBlock unoptimizedLoopEntry,
                                     BasicBlock optimizedLoopEntry,
                                     HashMap<Register,Register> optimalRegMap)

Create the block containing explict branches to either the optimized or unoptimized loops

private HashMap<BasicBlock,BasicBlock>

LoopVersioning.createCloneLoop(AnnotatedLSTNode loop,
                               HashMap<Register,Register> regMap,
                               HashMap<Register,BasicBlock> regToBlockMap)

Create a clone of the loop replacing definitions in the cloned loop with those found in the register map

private HashMap<BasicBlock,BasicBlock>

LoopVersioning.createOptimizedLoop(AnnotatedLSTNode loop,
                                       HashMap<Register,Register> regMap,
                                       ArrayList<Instruction> instrToEliminate,
                                       HashMap<Register,BasicBlock> regToBlockMap)

Create a clone of the loop replacing definitions in the cloned loop with those found in the register map and eliminate unnecessary bound checks

private boolean

LoopVersioning.findLoopToOptimise(AnnotatedLSTNode loop)
Find an outermost loop to optimise and optimise it.

private BasicBlock

LoopVersioning.generateNullCheckBranchBlocks(AnnotatedLSTNode loop,
                                                           ArrayList<Instruction> checksToEliminate,
                                                           HashMap<Register,Register> optimalRegMap,
                                                           BasicBlock block,
                                                           BasicBlock unoptimizedLoopEntry)

Generate null check branch blocks

private void

LoopVersioning.generatePhiNodes(AnnotatedLSTNode loop,
                                 ArrayList<Register> registers,
                                 ArrayList<TypeReference> types,
                                 ArrayList<Instruction> phiInstructions,
                                 HashMap<Register,Register> subOptimalRegMap,
                                 HashMap<Register,Register> optimalRegMap)

Generate into a new block phi nodes that define the original register defined by the loop and use two newly created registers.

private void

LoopVersioning.getListOfChecksToEliminate(AnnotatedLSTNode loop,
                                                     ArrayList<Instruction> instrToEliminate)

Create a list of instructions to be eliminated

private void

LoopVersioning.getRegistersDefinedInLoop(AnnotatedLSTNode loop,
                                                   ArrayList<Register> registers,
                                                   ArrayList<TypeReference> types,
                                                   ArrayList<Instruction> definingInstructions)

Get registers defined in the given loop.

private void

LoopVersioning.modifyOriginalLoop(AnnotatedLSTNode loop,
                                     ArrayList<Instruction> phiInstructions,
                                     ArrayList<Instruction> definingInstrInOriginalLoop,
                                     HashMap<Register,Register> subOptimalRegMap,
                                     HashMap<Register,Register> optimalRegMap)

Remove loop and replace register definitions in the original loop with phi instructions

private void

LoopVersioning.removeUnoptimizedLoop(AnnotatedLSTNode loop,
                                           HashMap<BasicBlock,BasicBlock> unoptimizedLoopMap)

Remove unreachable unoptimized loop

Uses of Classorg.jikesrvm.compilers.opt.controlflow.AnnotatedLSTNode

Uses of Class
org.jikesrvm.compilers.opt.controlflow.AnnotatedLSTNode