Uses of Class
org.jikesrvm.compilers.opt.ir.BasicBlock

Packages that use BasicBlock

Package	Description
org.jikesrvm.adaptive.recompilation.instrumentation
org.jikesrvm.compilers.opt
org.jikesrvm.compilers.opt.bc2ir	Provides classes that implement the transformation from bytecode to the high-level intermediate representation (HIR).
org.jikesrvm.compilers.opt.controlflow
org.jikesrvm.compilers.opt.depgraph	Provides classes that implement a dependence graph.
org.jikesrvm.compilers.opt.driver
org.jikesrvm.compilers.opt.hir2lir
org.jikesrvm.compilers.opt.ir
org.jikesrvm.compilers.opt.ir.operand
org.jikesrvm.compilers.opt.lir2mir	Provides classes that implement the transition from low-level IR to machine-specific IR.
org.jikesrvm.compilers.opt.liveness
org.jikesrvm.compilers.opt.regalloc
org.jikesrvm.compilers.opt.regalloc.ia32
org.jikesrvm.compilers.opt.ssa	SSA implementation (disabled because of bugs, see entry in issue tracker).

Uses of BasicBlock in org.jikesrvm.adaptive.recompilation.instrumentation

Methods in org.jikesrvm.adaptive.recompilation.instrumentation that return BasicBlock

Modifier and Type	Method and Description
private static BasicBlock	InstrumentationSamplingFramework.myCopyWithoutLinks(BasicBlock bb, IR ir) The same as BasicBlock.copyWithoutLinks except that it renames all temp variables that are never used outside the basic block.

Methods in org.jikesrvm.adaptive.recompilation.instrumentation with parameters of type BasicBlock

Modifier and Type	Method and Description
private void	InstrumentationSamplingFramework.appendLoad(BasicBlock bb, IR ir) Append a load of the global counter to the given basic block.
private void	InstrumentationSamplingFramework.conditionalizeInstrumentationOperation(IR ir, Instruction i, BasicBlock bb) Take an instrumentation operation (an instruction) and guard it with a counter-based check.
private void	InstrumentationSamplingFramework.createCheck(BasicBlock checkBB, BasicBlock noInstBB, BasicBlock instBB, boolean fallthroughToInstBB, IR ir) Append a check to a basic block, and make it jump to the right places.
private static Instruction	InstrumentationSamplingFramework.getFirstInstWithOperator(Operator operator, BasicBlock bb) Go through all instructions and find the first with the given operator.
static Instruction	InstrumentationSamplingFramework.getFirstInstWithYieldPoint(BasicBlock bb) Go through all instructions and find one that is a yield point
private static BasicBlock	InstrumentationSamplingFramework.myCopyWithoutLinks(BasicBlock bb, IR ir) The same as BasicBlock.copyWithoutLinks except that it renames all temp variables that are never used outside the basic block.
private void	InstrumentationSamplingFramework.prependCounterReset(BasicBlock bb, IR ir) Prepend the code to reset the global counter to the given basic block.
private void	InstrumentationSamplingFramework.prependDecrement(BasicBlock bb, IR ir) Append a decrement of the global counter to the given basic block.
private void	InstrumentationSamplingFramework.prependStore(BasicBlock bb, IR ir) Append a store of the global counter to the given basic block.
private static void	InstrumentationSamplingFramework.updateTemps(BasicBlock bb, IR ir) Given an basic block, rename all of the temporary registers that are local to the block.

Method parameters in org.jikesrvm.adaptive.recompilation.instrumentation with type arguments of type BasicBlock

Modifier and Type	Method and Description
private static void	InstrumentationSamplingFramework.adjustPointersInDuplicatedCode(IR ir, HashMap<BasicBlock,BasicBlock> origToDupMap) Go through all blocks in duplicated code and adjust the edges as follows: All edges (in duplicated code) that go into a block with a yieldpoint must jump to back to the original code.
private static void	InstrumentationSamplingFramework.adjustPointersInDuplicatedCode(IR ir, HashMap<BasicBlock,BasicBlock> origToDupMap) Go through all blocks in duplicated code and adjust the edges as follows: All edges (in duplicated code) that go into a block with a yieldpoint must jump to back to the original code.
private void	InstrumentationSamplingFramework.duplicateCode(IR ir, HashMap<BasicBlock,BasicBlock> origToDupMap, HashSet<BasicBlock> exceptionHandlerBlocks) Make a duplicate of all basic blocks down at the bottom of the code order.
private void	InstrumentationSamplingFramework.duplicateCode(IR ir, HashMap<BasicBlock,BasicBlock> origToDupMap, HashSet<BasicBlock> exceptionHandlerBlocks) Make a duplicate of all basic blocks down at the bottom of the code order.
private void	InstrumentationSamplingFramework.duplicateCode(IR ir, HashMap<BasicBlock,BasicBlock> origToDupMap, HashSet<BasicBlock> exceptionHandlerBlocks) Make a duplicate of all basic blocks down at the bottom of the code order.
private void	InstrumentationSamplingFramework.insertCBSChecks(IR ir, HashMap<BasicBlock,BasicBlock> origToDupMap, HashSet<BasicBlock> exceptionHandlerBlocks) In the checking code, insert CBS checks at each yieldpoint, to transfer code into the duplicated (instrumented) code.
private void	InstrumentationSamplingFramework.insertCBSChecks(IR ir, HashMap<BasicBlock,BasicBlock> origToDupMap, HashSet<BasicBlock> exceptionHandlerBlocks) In the checking code, insert CBS checks at each yieldpoint, to transfer code into the duplicated (instrumented) code.
private void	InstrumentationSamplingFramework.insertCBSChecks(IR ir, HashMap<BasicBlock,BasicBlock> origToDupMap, HashSet<BasicBlock> exceptionHandlerBlocks) In the checking code, insert CBS checks at each yieldpoint, to transfer code into the duplicated (instrumented) code.
private static void	InstrumentationSamplingFramework.removeInstrumentationFromOrig(IR ir, HashMap<BasicBlock,BasicBlock> origToDupMap) Remove instrumentation from the original version of all duplicated basic blocks.
private static void	InstrumentationSamplingFramework.removeInstrumentationFromOrig(IR ir, HashMap<BasicBlock,BasicBlock> origToDupMap) Remove instrumentation from the original version of all duplicated basic blocks.

Uses of BasicBlock in org.jikesrvm.compilers.opt

Methods in org.jikesrvm.compilers.opt with parameters of type BasicBlock

Modifier and Type	Method and Description
private boolean	AdjustBranchProbabilities.findInfrequentInstruction(BasicBlock bb)
private void	LocalCSE.optimizeBasicBlockHIR(IR ir, BasicBlock bb) Perform Local CSE for a basic block in HIR.
private void	LocalCSE.optimizeBasicBlockLIR(IR ir, BasicBlock bb) Perform Local CSE for a basic block in LIR.

Uses of BasicBlock in org.jikesrvm.compilers.opt.bc2ir

Fields in org.jikesrvm.compilers.opt.bc2ir declared as BasicBlock

Modifier and Type	Field and Description
(package private) BasicBlock	BasicBlockLE.block Basic block that this BBLE refers to.
private BasicBlock	GenerationContext.epilogue The basic block into which BC2IR's caller will generate an epilogue.
private BasicBlock	GenerationContext.exit The exit node of the outermost CFG (used by BC2IR for not-definitely caught athrows and by OSR_Yieldpoints)
private BasicBlock	GenerationContext.prologue The basic block into which BC2IR's caller will generate a "prologue."
private BasicBlock	GenerationContext.unlockAndRethrow A catch, unlock, and rethrow exception handler used for synchronized methods.

Methods in org.jikesrvm.compilers.opt.bc2ir that return BasicBlock

Modifier and Type	Method and Description
BasicBlock	GenerationContext.getEpilogue()
BasicBlock	GenerationContext.getExit()
BasicBlock	GenerationContext.getPrologue()
(package private) BasicBlock	GenerationContext.getUnlockAndRethrow()
private BasicBlock	BC2IR.rectifyStateWithArithmeticExceptionHandler()
private BasicBlock	BC2IR.rectifyStateWithArithmeticExceptionHandler(boolean linkToExitIfUncaught)
private BasicBlock	BC2IR.rectifyStateWithArrayBoundsExceptionHandler()
private BasicBlock	BC2IR.rectifyStateWithArrayBoundsExceptionHandler(boolean linkToExitIfUncaught)
private BasicBlock	BC2IR.rectifyStateWithArrayStoreExceptionHandler()
private BasicBlock	BC2IR.rectifyStateWithArrayStoreExceptionHandler(boolean linkToExitIfUncaught)
private BasicBlock	BC2IR.rectifyStateWithErrorHandler()
private BasicBlock	BC2IR.rectifyStateWithErrorHandler(boolean linkToExitIfUncaught)
BasicBlock	BC2IR.rectifyStateWithExceptionHandler(TypeReference exceptionType)
private BasicBlock	BC2IR.rectifyStateWithExceptionHandler(TypeReference exceptionType, boolean linkToExitIfUncaught)
private BasicBlock	BC2IR.rectifyStateWithNullPtrExceptionHandler()
private BasicBlock	BC2IR.rectifyStateWithNullPtrExceptionHandler(boolean linkToExitIfUncaught)

Methods in org.jikesrvm.compilers.opt.bc2ir with parameters of type BasicBlock

Modifier and Type	Method and Description
private void	GenerationContext.appendInstruction(BasicBlock b, Instruction s, int bcIndex)
private void	BBSet.injectMove(BasicBlock block, RegisterOperand res, Operand val)
(package private) void	BBSet.rectifyStacks(BasicBlock block, OperandStack stack, BasicBlockLE p) Rectify the given stack state with the state contained in the given BBLE, adding the necessary move instructions to the end of the given basic block to make register numbers agree and rectify mis-matched constants.
void	GenerationContext.setEpilogue(BasicBlock epilogue)

Uses of BasicBlock in org.jikesrvm.compilers.opt.controlflow

Fields in org.jikesrvm.compilers.opt.controlflow declared as BasicBlock

Modifier and Type	Field and Description
private BasicBlock	LTDominatorInfo.ancestor
(package private) BasicBlock	DominatorCell.block The basic block corresponding to this lattice cell.
private BasicBlock	DominatorTreeNode.block the basic block this node represents
private BasicBlock	Diamond.bottom The bottom of the diamond
(package private) BasicBlock	StaticSplitting.CandInfo.candBB
private BasicBlock	LTDominatorInfo.child
private BasicBlock	LTDominatorInfo.dominator the immediate dominator
BasicBlock	AnnotatedLSTNode.exit The in loop block that either loops or leaves the loop
(package private) BasicBlock	ReorderingPhase.ChainInfo.head
BasicBlock	LSTNode.header Basic block which is the loop head
(package private) BasicBlock	DominatorInfo.idom The basic block's immediate dominator.
private BasicBlock	LTDominatorInfo.label
private BasicBlock	Diamond.notTaken The "not-taken" branch of the diamond (might be null)
private BasicBlock	LTDominatorInfo.parent
BasicBlock	AnnotatedLSTNode.predecessor The out of loop block before the header
(package private) BasicBlock	StaticSplitting.CandInfo.prevBB
(package private) BasicBlock	LSTNode.Edge.source
(package private) BasicBlock	ReorderingPhase.Edge.source
(package private) BasicBlock	StaticSplitting.CandInfo.succBB
BasicBlock	AnnotatedLSTNode.successor The out of loop block following the exit block
private BasicBlock	Diamond.taken The "taken" branch of the diamond (might be null)
(package private) BasicBlock	LSTNode.Edge.target
(package private) BasicBlock	ReorderingPhase.Edge.target
private BasicBlock	Diamond.top The top of the diamond
private BasicBlock[]	EstimateBlockFrequencies.topOrder Topological ordering (ignoring backedges) of CFG
private BasicBlock[]	LTDominators.vertex a mapping from DFS number to their basic blocks

Fields in org.jikesrvm.compilers.opt.controlflow with type parameters of type BasicBlock

Modifier and Type	Field and Description
private Enumeration<BasicBlock>	LTDominatorInfo.bbEnum
private ArrayList<BasicBlock>	AnnotatedLSTNode.BBEnum.blocks ArrayList holding basic blocks
private HashSet<BasicBlock>	LTDominatorInfo.bucket
private Map<BasicBlock,BasicBlock>	LoopUnrolling.copiedBlocks
private Map<BasicBlock,BasicBlock>	LoopUnrolling.copiedBlocks
private Map<BasicBlock,DominatorInfo>	Dominators.dominatorInfo
private HashMap<BasicBlock,LSTNode>	LSTGraph.loopMap Map of bb to LSTNode of innermost loop containing bb
private Map<BasicBlock,LTDominatorInfo>	LTDominators.ltDominators

Methods in org.jikesrvm.compilers.opt.controlflow that return BasicBlock

Modifier and Type	Method and Description
(package private) BasicBlock	LoopUnrolling.copyAndLinkBlock(IR ir, BasicBlock seqLast, BasicBlock block)
BasicBlock	DominatorTree.deepestCommonAncestor(BasicBlock a, BasicBlock b) Return the deepest common dominance ancestor of blocks a and b
private BasicBlock	LTDominators.EVAL(BasicBlock block) This method inspects the passed block and returns the following: block, if block is a root of a tree in the forest any vertex, u !
private BasicBlock	StaticSplitting.findColdPrev(BasicBlock bb)
private BasicBlock	StaticSplitting.findColdSucc(Instruction test)
BasicBlock	LTDominatorInfo.getAncestor() Returns the ancestor for this block
private BasicBlock	LTDominators.getAncestor(BasicBlock block)
BasicBlock	DominatorTreeNode.getBlock() Get the basic block for this dominator tree node
(package private) BasicBlock	Diamond.getBottom()
BasicBlock	LTDominatorInfo.getChild() returns the child
private BasicBlock	LTDominators.getChild(BasicBlock block)
private BasicBlock	LTDominators.getDom(BasicBlock block)
BasicBlock	LTDominatorInfo.getDominator() Returns the immediate dominator for this node
private BasicBlock	DominatorTree.getFirstNode() Get the first node, either entry or exit depending on which way we are viewing the graph
private BasicBlock	LTDominators.getFirstNode() Get the first node, either entry or exit depending on which way we are viewing the graph
BasicBlock	LSTNode.getHeader()
static BasicBlock	LTDominatorInfo.getIdom(BasicBlock bb, IR ir) return the immediate dominator of a basic block.
BasicBlock	LTDominatorInfo.getLabel() returns the label
private BasicBlock	LTDominators.getLabel(BasicBlock block)
(package private) BasicBlock	Diamond.getNotTaken()
BasicBlock	LTDominatorInfo.getParent() Returns the parent of this block
BasicBlock	DominatorTree.getParent(BasicBlock bb) Return the parent of the vertex corresponding to a basic block
private BasicBlock	LTDominators.getParent(BasicBlock block)
(package private) BasicBlock	Diamond.getTaken()
(package private) BasicBlock	Diamond.getTop()
private static BasicBlock[]	CFGTransformations.inLoopPredecessors(LSTNode n)
private static BasicBlock[]	CFGTransformations.inLoopSuccessors(LSTNode n)
private static BasicBlock[]	CFGTransformations.loopPredecessors(LSTNode n)
(package private) BasicBlock[]	LoopUnrolling.makeSomeCopies(int unrollFactor, IR ir, BitVector nloop, int blocks, BasicBlock header, BasicBlock exitBlock, BasicBlock seqStart)
BasicBlock	AnnotatedLSTNode.BBEnum.nextElement() Get the next element from the vector and move the current block along

Methods in org.jikesrvm.compilers.opt.controlflow that return types with arguments of type BasicBlock

Modifier and Type	Method and Description
(package private) Enumeration<BasicBlock>	DominatorTreeNode.domFrontierEnumerator(IR ir) Enumerate the basic blocks in the dominance frontier for this node.
Enumeration<BasicBlock>	AnnotatedLSTNode.getBasicBlocks() Return an enumeration of basic blocks corresponding to a depth first traversal of the blocks in the loops graphs
Iterator<BasicBlock>	LTDominatorInfo.getBucketIterator() Returns an iterator over this block's bucket
Enumeration<BasicBlock>	LTDominatorInfo.getEnum() Helper method to return the Info field associated with a block
private Enumeration<BasicBlock>	LTDominators.getNextNodes(BasicBlock block)
private Enumeration<BasicBlock>	LTDominators.getPrevNodes(BasicBlock block)

Methods in org.jikesrvm.compilers.opt.controlflow with parameters of type BasicBlock

Modifier and Type	Method and Description
void	AnnotatedLSTNode.BBEnum.add(BasicBlock block) Insert a block to the end of the list
void	LSTNode.addLoopExit(BasicBlock source, BasicBlock target, float prob)
private void	DominatorTree.addNode(BasicBlock b) Creates dominator tree nodes for the passed block and adds them to the map.
void	DominatorCell.addSingleBlock(BasicBlock bb) Include a single basic block in this set.
void	LTDominatorInfo.addToBucket(BasicBlock block) Adds the passed block from the bucket for this node
(package private) static Diamond	Diamond.buildDiamond(BasicBlock bb) See if bb is the root of a diamond.
private void	AnnotatedLSTNode.checkInEdgesAreInLoop(BasicBlock block) Check the edges into a block are from within the loop
private void	AnnotatedLSTNode.checkOutEdgesAreInLoop(BasicBlock block) Check the edges out of a block are within the loop
private void	LTDominators.compress(BasicBlock block) This recursive method performs the path compression
boolean	AnnotatedLSTNode.contains(BasicBlock block)
private boolean	StaticSplitting.containsOSRPoint(BasicBlock bb)
(package private) BasicBlock	LoopUnrolling.copyAndLinkBlock(IR ir, BasicBlock seqLast, BasicBlock block)
private Instruction[]	BranchOptimizations.copyAndMapInstructions(BasicBlock bb, HashMap<Instruction,Instruction> map) For each real non-branch instruction s in bb, Copy s to s', and store s' in the returned array Insert the function s->s' in the map
BasicBlock	DominatorTree.deepestCommonAncestor(BasicBlock a, BasicBlock b) Return the deepest common dominance ancestor of blocks a and b
(package private) static void	LoopUnrolling.deleteBranches(BasicBlock b)
int	DominatorTree.depth(BasicBlock b) Return the distance from the root of the dominator tree to a given basic block
protected void	LTDominators.DFS(BasicBlock block) The non-recursive depth-first numbering code called from Step 1.
boolean	DominatorTree.dominates(BasicBlock master, BasicBlock slave) Does basic block number "master" dominate basic block number "slave"?
BitVector	LTDominatorInfo.dominators(BasicBlock block, IR ir) This method returns the set of blocks that dominates the passed block, i.e., it answers the question "Who dominates me?"
(package private) void	AnnotatedLSTNode.dumpBlock(BasicBlock block) Dump a human readable description of a basic block within the loop
private void	ReorderingPhase.dumpChain(BasicBlock head)
private static float	CFGTransformations.edgeFrequency(BasicBlock a, BasicBlock b)
private BasicBlock	LTDominators.EVAL(BasicBlock block) This method inspects the passed block and returns the following: block, if block is a root of a tree in the forest any vertex, u !
private int	BranchOptimizations.evaluateCost(BasicBlock bb) Evaluates the cost of a basic block, in number of real instructions excluding branches.
private static boolean	CFGTransformations.exitsLoop(BasicBlock b, BitVector loop)
private void	LSTGraph.findBackEdges(BasicBlock bb, int numBlocks, Map<SpaceEffGraphNode,Integer> dfnMap) This routine performs a non-recursive depth-first search starting at the block passed looking for back edges.
private BasicBlock	StaticSplitting.findColdPrev(BasicBlock bb)
private static Diamond	Diamond.fourElementDiamond(BasicBlock top, BasicBlock left, BasicBlock right, BasicBlock bottom)
private boolean	BranchOptimizations.generateBooleanCompare(IR ir, BasicBlock bb, Instruction cb, BasicBlock tb) Attempt to generate a boolean compare opcode from a conditional branch.
private boolean	BranchOptimizations.generateCondMove(IR ir, BasicBlock bb, Instruction cb) Attempt to generate a straight-line sequence using conditional move instructions, to replace a diamond control flow structure.
Operand	AnnotatedLSTNode.generateLoopInvariantOperand(BasicBlock block, Operand op) Loop invariants may not be accessible before a loop, so generate the instructions so they are
private BasicBlock	LTDominators.getAncestor(BasicBlock block)
private AnnotatedLSTNode.BBEnum	AnnotatedLSTNode.getBasicBlocks(BasicBlock block, AnnotatedLSTNode.BBEnum bbs, BitVector blocksLeftToVisit) Return an enumeration of basic blocks corresponding to a depth first traversal of the blocks in the loops graphs
private Instruction	StaticSplitting.getCandidateTest(BasicBlock bb)
(package private) DF_LatticeCell[]	DominatorSystem.getCellsForPredecessors(BasicBlock bb)
private BasicBlock	LTDominators.getChild(BasicBlock block)
Enumeration<TreeNode>	DominatorTree.getChildren(BasicBlock bb) Enumerate the children of the vertex corresponding to a basic block
private BasicBlock	LTDominators.getDom(BasicBlock block)
BitVector	DominatorTree.getDominanceFrontier(BasicBlock bb) Return the (already calculated) dominance frontier for a basic block
DominatorInfo	Dominators.getDominatorInfo(BasicBlock b)
static BasicBlock	LTDominatorInfo.getIdom(BasicBlock bb, IR ir) return the immediate dominator of a basic block.
(package private) LTDominatorInfo	LTDominators.getInfo(BasicBlock bb)
static LTDominatorInfo	LTDominatorInfo.getInfo(BasicBlock block, IR ir) Helper method to return the Info field associated with a block
(package private) Object	DominatorSystem.getKey(BasicBlock bb) Get the DF_LatticeCell key corresponding to a basic block
private BasicBlock	LTDominators.getLabel(BasicBlock block)
LSTNode	LSTGraph.getLoop(BasicBlock b)
int	LSTGraph.getLoopNestDepth(BasicBlock bb)
private Enumeration<BasicBlock>	LTDominators.getNextNodes(BasicBlock block)
BasicBlock	DominatorTree.getParent(BasicBlock bb) Return the parent of the vertex corresponding to a basic block
private BasicBlock	LTDominators.getParent(BasicBlock block)
private Enumeration<BasicBlock>	LTDominators.getPrevNodes(BasicBlock block)
private int	LTDominators.getSemi(BasicBlock block)
private int	LTDominators.getSize(BasicBlock block)
private boolean	BranchOptimizations.hasCMTaboo(BasicBlock bb) Do any of the instructions in a basic block preclude eliminating the basic block with conditional moves?
private static boolean	BranchOptimizations.hasFloatingPointDef(BasicBlock bb, boolean invert) Do any of the instructions in a basic block define a floating-point register?
private boolean	BranchOptimizations.hasLongDef(BasicBlock bb) Do any of the instructions in a basic block define a long register?
boolean	LSTGraph.inInnermostLoop(BasicBlock bb) Is a given basic block in an innermost loop?
(package private) static boolean	CFGTransformations.inLoop(BasicBlock b, BitVector nloop)
boolean	DominatorInfo.isDominatedBy(BasicBlock bb) Is the basic block represented by this structure dominated by another basic block?
static boolean	LTDominatorInfo.isDominatedBy(BasicBlock block, BasicBlock master, IR ir) This method determines if the 1st parameter (block) is dominated by the 2nd parameter (master), i.e., must control pass through "master" before reaching "block"
boolean	AnnotatedLSTNode.isInLoop(BasicBlock block) Is the a particular block in this loop?
boolean	LSTGraph.isLoopExit(BasicBlock source, BasicBlock target)
private static boolean	AnnotatedLSTNode.isLoopInvariant(Operand op, BitVector loop, BasicBlock header) Test whether operand value will be invariant in a loop by tracing back earlier definitions.
private void	LTDominators.LINK(BasicBlock block1, BasicBlock block2) Adds edge (block1, block2) to the forest maintained as an auxiliary data structure.
(package private) BasicBlock[]	LoopUnrolling.makeSomeCopies(int unrollFactor, IR ir, BitVector nloop, int blocks, BasicBlock header, BasicBlock exitBlock, BasicBlock seqStart)
protected boolean	MIRBranchOptimizations.optimizeBranchInstruction(IR ir, Instruction s, BasicBlock bb) This method actually does the work of attempting to peephole optimize a branch instruction.
protected boolean	BranchOptimizations.optimizeBranchInstruction(IR ir, Instruction s, BasicBlock bb) This method actually does the work of attempting to peephole optimize a branch instruction.
protected abstract boolean	BranchOptimizationDriver.optimizeBranchInstruction(IR ir, Instruction s, BasicBlock bb) This method actually does the work of attempting to peephole optimize a branch instruction.
private void	YieldPoints.prependYield(BasicBlock bb, Operator yp, int bcIndex, InlineSequence position) Add a YIELD instruction to the appropriate place for the basic block passed.
private void	LTDominators.printNextNodes(BasicBlock block) Print the "next" nodes (either out or in) for the passed block depending on which way we are viewing the graph
private boolean	MIRBranchOptimizations.processCondBranch(IR ir, Instruction cb, BasicBlock bb) Perform optimizations for a conditional branch.
private boolean	BranchOptimizations.processConditionalBranch(IR ir, Instruction cb, BasicBlock bb) Perform optimizations for a conditional branch.
private void	EstimateBlockFrequencies.processEdge(LSTNode n, BasicBlock source, BasicBlock target, float prob, float weight)
private boolean	MIRBranchOptimizations.processGoto(IR ir, Instruction g, BasicBlock bb) Perform optimizations for an unconditonal branch.
private boolean	BranchOptimizations.processGoto(IR ir, Instruction g, BasicBlock bb) Perform optimizations for a Goto.
(package private) static boolean	BranchSimplifier.processIfCmp(IR ir, BasicBlock bb, Instruction s)
(package private) static boolean	BranchSimplifier.processIfCmp2(IR ir, BasicBlock bb, Instruction s)
(package private) static boolean	BranchSimplifier.processInlineGuard(IR ir, BasicBlock bb, Instruction s)
private boolean	BranchOptimizations.processInlineGuard(IR ir, Instruction cb, BasicBlock bb) Perform optimizations for an inline guard.
(package private) static boolean	BranchSimplifier.processLookupSwitch(IR ir, BasicBlock bb, Instruction s)
private void	AnnotatedLSTNode.processLoopBlock(BasicBlock block) Process a regular block within the loop
(package private) static boolean	BranchSimplifier.processTableSwitch(IR ir, BasicBlock bb, Instruction s)
private boolean	MIRBranchOptimizations.processTwoTargetConditionalBranch(IR ir, Instruction cb, BasicBlock bb) Perform optimizations for a two way conditional branch.
private boolean	BranchOptimizations.processTwoTargetConditionalBranch(IR ir, Instruction cb, BasicBlock bb) Perform optimizations for a two way conditional branch.
private void	StaticSplitting.pushCandidate(BasicBlock cand, BasicBlock prev, BasicBlock succ, Instruction test)
private static void	BranchSimplifier.removeBranchesAfterGotos(BasicBlock bb) To maintain IR integrity, remove any branches that are after the first GOTO in the basic block.
void	LTDominatorInfo.removeFromBucket(BasicBlock block) Removes the passed block from the bucket for this node
void	LTDominatorInfo.setAncestor(BasicBlock value) Sets the ancestor for the value passed
void	LTDominatorInfo.setChild(BasicBlock value) sets the child field
void	LTDominatorInfo.setDominator(BasicBlock value) Sets the immediate dominator for this node
void	LTDominatorInfo.setLabel(BasicBlock value) sets the label
void	LTDominatorInfo.setParent(BasicBlock value) Sets the parent of this block
static boolean	BranchSimplifier.simplify(BasicBlock bb, IR ir) Given a basic block, attempt to simplify any conditional branch instructions with constant operands.
private static Diamond	Diamond.threeElementDiamond(BasicBlock top, BasicBlock side, BasicBlock bottom)
private boolean	StaticSplitting.tooBig(BasicBlock bb, int maxCost) Simplistic cost estimate; since we are doing the splitting based on static hints, we are only willing to copy a very small amount of code.
(package private) Instruction	TailRecursionElimination.transform(Instruction call, Instruction prologue, BasicBlock target, IR ir) Transform the tail recursive call into a loop.

Method parameters in org.jikesrvm.compilers.opt.controlflow with type arguments of type BasicBlock

Modifier and Type	Method and Description
void	LTDominatorInfo.setEnum(Enumeration<BasicBlock> bbEnum) set the basic block enum field

Constructors in org.jikesrvm.compilers.opt.controlflow with parameters of type BasicBlock

Constructor and Description
CandInfo(BasicBlock c, BasicBlock p, BasicBlock s, Instruction t, StaticSplitting.CandInfo n)
ChainInfo(BasicBlock h)
Diamond(BasicBlock top, BasicBlock taken, BasicBlock notTaken, BasicBlock bottom)
DominatorCell(BasicBlock bb, IR ir) Make a bit set for a basic block
DominatorTreeNode(BasicBlock block) Construct a dominator tree node for a given basic block.
Edge(BasicBlock s, BasicBlock t, float p)
Edge(BasicBlock s, BasicBlock t, float w)
LSTNode(BasicBlock bb)
LTDominatorInfo(BasicBlock block)

Uses of BasicBlock in org.jikesrvm.compilers.opt.depgraph

Fields in org.jikesrvm.compilers.opt.depgraph declared as BasicBlock

Modifier and Type	Field and Description
private BasicBlock	DepGraph.currentBlock The basic block we are processing

Constructors in org.jikesrvm.compilers.opt.depgraph with parameters of type BasicBlock

Constructor and Description
DepGraph(IR ir, Instruction start, Instruction end, BasicBlock currentBlock) Constructor (computes the dependence graph!).

Uses of BasicBlock in org.jikesrvm.compilers.opt.driver

Methods in org.jikesrvm.compilers.opt.driver with parameters of type BasicBlock

Modifier and Type	Method and Description
protected void	CFGVisualization.dfsCFG(BasicBlock bb, IR ir)
protected String	CFGVisualization.enumerateAndFormatInstructions(BasicBlock succBB)
protected String	CFGVisualization.formatHighlighting(BasicBlock bb)
void	CFGVisualization.markBlockAsHighlighted(BasicBlock bb)
protected CFGVisualization.StringWrapper	CFGVisualization.setDirectionalEdges(BasicBlock succBB, BasicBlock bb) Generates control-flow edge descriptions for basic blocks.

Uses of BasicBlock in org.jikesrvm.compilers.opt.hir2lir

Methods in org.jikesrvm.compilers.opt.hir2lir that return BasicBlock

Modifier and Type	Method and Description
private static BasicBlock	ConvertToLowLevelIR._lookupswitchHelper(Instruction switchInstr, RegisterOperand reg, BasicBlock defaultBB, IR ir, BasicBlock curBlock, int low, int high, int min, int max) Helper function to generate the binary search tree for a lookupswitch bytecode
private static BasicBlock	DynamicTypeCheckExpansion.advanceBlock(int bcIndex, BasicBlock curBlock, IR ir)
private static BasicBlock	DynamicTypeCheckExpansion.fallThroughBB(Instruction s, IR ir)

Methods in org.jikesrvm.compilers.opt.hir2lir with parameters of type BasicBlock

Modifier and Type	Method and Description
private static BasicBlock	ConvertToLowLevelIR._lookupswitchHelper(Instruction switchInstr, RegisterOperand reg, BasicBlock defaultBB, IR ir, BasicBlock curBlock, int low, int high, int min, int max) Helper function to generate the binary search tree for a lookupswitch bytecode
private static BasicBlock	DynamicTypeCheckExpansion.advanceBlock(int bcIndex, BasicBlock curBlock, IR ir)
private static Instruction	DynamicTypeCheckExpansion.generateBranchingTypeCheck(Instruction s, IR ir, Operand RHSobj, TypeReference LHStype, Operand RHStib, BasicBlock trueBlock, BasicBlock falseBlock, RegisterOperand oldGuard, BranchProfileOperand falseProb) Generate a branching dynamic type check.

Uses of BasicBlock in org.jikesrvm.compilers.opt.ir

Subclasses of BasicBlock in org.jikesrvm.compilers.opt.ir

Modifier and Type	Class and Description
class	ExceptionHandlerBasicBlock A basic block that marks the start of an exception handler.

Fields in org.jikesrvm.compilers.opt.ir declared as BasicBlock

Modifier and Type	Field and Description
private BasicBlock	ControlFlowGraph._exitNode The distinguished exit node of the FCFG
BasicBlock	MIRInfo.backedgeYieldpointBlock A basic block holding the call to Thread.threadSwitch for a backedge.
private BasicBlock[]	IR.basicBlockMap Backing store for IR.getBasicBlock(int).
private BasicBlock[]	BasicBlock.ComputedBBEnum.blocks
protected BasicBlock	BasicBlock.BBEnum.current
BasicBlock	MIRInfo.epilogueYieldpointBlock A basic block holding the call to Thread.threadSwitch for an epilogue.
BasicBlock	MIRInfo.osrYieldpointBlock A basic block holding the call to yieldpointFromOsrOpt for an OSR invalidation.
BasicBlock	MIRInfo.prologueYieldpointBlock A basic block holding the call to Thread.threadSwitch for a prologue.
private BasicBlock[]	WeightedBranchTargets.targets

Fields in org.jikesrvm.compilers.opt.ir with type parameters of type BasicBlock

Modifier and Type	Field and Description
private Stack<BasicBlock>	IR.BitSetBBEnum.stack

Methods in org.jikesrvm.compilers.opt.ir that return BasicBlock

Modifier and Type	Method and Description
protected abstract BasicBlock	BasicBlock.BBEnum.advance()
protected BasicBlock	BasicBlock.NormalOutEdgeEnum.advance()
protected BasicBlock	BasicBlock.ExceptionOutEdgeEnum.advance()
BasicBlock	BasicBlock.copyWithoutLinks(IR ir) Copies a basic block.
BasicBlock	BasicBlock.createSubBlock(int bc, IR ir)
BasicBlock	BasicBlock.createSubBlock(int bc, IR ir, float wf) Creates a new basic block that inherits its exception handling, etc from 'this'.
BasicBlock	WeightedBranchTargets.curBlock()
BasicBlock	ControlFlowGraph.entry() Return the entry node of the FCFG.
BasicBlock	ControlFlowGraph.exit() Return the "exit" node of the FCFG.
BasicBlock	IR.firstBasicBlockInCodeOrder() Return the first basic block with respect to the current code linearization order.
BasicBlock	ControlFlowGraph.firstInCodeOrder() Return the first basic block with respect to the current code linearization order.
BasicBlock	Instruction.getBasicBlock() Gets the basic block that contains this instruction.
BasicBlock	IR.getBasicBlock(int number) Get the basic block with a given number.
BasicBlock	Instruction.getBranchTarget() Returns the basic block jumped to by this BRANCH instruction.
BasicBlock	BasicBlock.getFallThroughBlock() If there is a fallthrough FCFG successor of this node return it.
BasicBlock	BasicBlock.getNotTakenNextBlock()
BasicBlock	IR.lastBasicBlockInCodeOrder() Return the last basic block with respect to the current code linearization order.
BasicBlock	ControlFlowGraph.lastInCodeOrder() Return the last basic block with respect to the current code linearization order.
static BasicBlock	IRTools.makeBlockOnEdge(BasicBlock in, BasicBlock out, IR ir) Make an empty basic block on an edge in the control flow graph, and fix up the control flow graph and IR instructions accordingly.
(package private) static BasicBlock	BasicBlock.makeExit()
BasicBlock	BasicBlock.nextBasicBlockInCodeOrder() Return the next basic block in with respect to the current code linearization order.
BasicBlock	IR.BitSetBBEnum.nextElement()
BasicBlock	BasicBlock.BBEnum.nextElement()
BasicBlock	BasicBlock.ComputedBBEnum.nextElement()
BasicBlock	BasicBlock.InEdgeEnum.nextElement()
BasicBlock	BasicBlock.OutEdgeEnum.nextElement()
BasicBlock	BasicBlock.prevBasicBlockInCodeOrder() Return the previous basic block in with respect to the current code linearization order.
BasicBlock	BasicBlock.replicateThisOut(IR ir, BasicBlock b) For basic block b which has to be a "normal" successor of this, make a copy of b, and set up the CFG so that this block has normal out edges to the copy.
BasicBlock	BasicBlock.replicateThisOut(IR ir, BasicBlock b, BasicBlock pred) For basic block b which has to be a "normal" successor of this, make a copy of b, and set up the CFG so that this block has normal out edges to the copy.
BasicBlock	BasicBlock.segregateInstruction(Instruction target, IR ir) Ensure that the target instruction is the only real instruction in its basic block and that it has exactly one successor and one predecessor basic blocks that are linked to it by fall through edges.
BasicBlock	BasicBlock.splitNodeAt(Instruction last_instr_BB1, IR ir) Splits a node at an instruction point.
BasicBlock	BasicBlock.splitNodeWithLinksAt(Instruction last_instr_BB1, IR ir) Splits a node at an instruction point.

Methods in org.jikesrvm.compilers.opt.ir that return types with arguments of type BasicBlock

Modifier and Type	Method and Description
Enumeration<BasicBlock>	ControlFlowGraph.basicBlocks()
Enumeration<BasicBlock>	ExceptionHandlerBasicBlockBag.enumerator() An enumeration of all the exception handler basic blocks (transitively) in the EHBBB.
static Enumeration<BasicBlock>	IREnumeration.forwardBE(IR ir) A forward enumeration of all the basic blocks in the IR.
Enumeration<BasicBlock>	IR.forwardBlockEnumerator() Forward (with respect to the current code linearization order) iteration overal all the basic blocks in the IR.
Enumeration<BasicBlock>	BasicBlock.getApplicableExceptionalOut(Instruction instr) An enumeration of the subset of exceptional out edges that are applicable to the given instruction (assumed to be in instruction in 'this')
Enumeration<BasicBlock>	IR.getBasicBlocks() Enumerate the basic blocks in the IR in an arbitrary order.
Enumeration<BasicBlock>	IR.getBasicBlocks(BitVector bits) Get an enumeration of all the basic blocks whose numbers appear in the given BitSet.
Enumeration<BasicBlock>	Instruction.getBranchTargets() Return an enumeration of the basic blocks that are targets of this branch instruction.
Enumeration<BasicBlock>	BasicBlock.getExceptionalOut() An enumeration of the 'exceptional' (reached via exceptional control flow) out nodes of the block.
Enumeration<BasicBlock>	BasicBlock.getExceptionHandlers() An enumeration of the in scope exception handlers for this basic block.
Enumeration<BasicBlock>	BasicBlock.getIn() An enumeration of the FCFG in nodes.
Enumeration<BasicBlock>	BasicBlock.getInNodes() An enumeration of the FCFG in nodes.
Enumeration<BasicBlock>	BasicBlock.getNormalOut() An enumeration of the 'normal' (not reached via exceptional control flow) out nodes of the block.
Enumeration<BasicBlock>	BasicBlock.getReachableExceptionHandlers() Returns an Enumeration of the in scope exception handlers that are actually reachable from this basic block in the order that they are applicable (which is semantically meaningful).
static Enumeration<BasicBlock>	IREnumeration.reverseBE(IR ir) A reverse enumeration of all the basic blocks in the IR.
Enumeration<BasicBlock>	IR.reverseBlockEnumerator() Reverse (with respect to the current code linearization order) iteration overal all the basic blocks in the IR.

Methods in org.jikesrvm.compilers.opt.ir with parameters of type BasicBlock

Modifier and Type	Method and Description
private void	WeightedBranchTargets.addEdge(BasicBlock target, float weight)
(package private) void	BasicBlock.ComputedBBEnum.addElement(BasicBlock b)
void	ControlFlowGraph.addLastInCodeOrder(BasicBlock bb) Add a block not currently in the code ordering to the end of the code ordering.
(package private) void	BasicBlock.ComputedBBEnum.addPossiblyDuplicateElement(BasicBlock b)
void	ControlFlowGraph.breakCodeOrder(BasicBlock bb1, BasicBlock bb2) Create a break in the code order between bb1 and bb2 (bb1 and bb2 must be currently adjacent in the code order).
void	ControlFlowGraph.insertAfterInCodeOrder(BasicBlock old, BasicBlock toAdd) Insert a block 'toAdd' not currently in the code ordering after a block 'old' that is currently in the code ordering.
void	ControlFlowGraph.insertBeforeInCodeOrder(BasicBlock old, BasicBlock toAdd) Insert a block 'toAdd' not currently in the code ordering before a block 'old' that is currently in the code ordering.
static void	IRTools.insertInstructionsAfter(Instruction after, BasicBlock temp) Inserts the instructions in the given basic block after the given instruction.
boolean	BasicBlock.isExceptionalOut(BasicBlock bb) Is there an 'exceptional' out edge to the given basic block?
boolean	BasicBlock.isExceptionHandlerEquivalent(BasicBlock other) Compare the in scope exception handlers of two blocks.
boolean	BasicBlock.isIn(BasicBlock bb) Is there an in edge from the given basic block?
boolean	BasicBlock.isNormalOut(BasicBlock bb) Is there a 'normal' out edge to the given basic block?
boolean	BasicBlock.isOut(BasicBlock bb) Is there an out edge to the given basic block?
void	ControlFlowGraph.linkInCodeOrder(BasicBlock bb1, BasicBlock bb2) Make BB2 follow BB1 in the code ordering.
void	ControlFlowGraph.linkToExit(BasicBlock bb) Add an FCFG edge from the given basic block to the exit node.
static BasicBlock	IRTools.makeBlockOnEdge(BasicBlock in, BasicBlock out, IR ir) Make an empty basic block on an edge in the control flow graph, and fix up the control flow graph and IR instructions accordingly.
void	BasicBlock.moveBehind(BasicBlock pred, IR ir) Move me behind `pred'.
void	BasicBlock.redirectOuts(BasicBlock b, BasicBlock bCopy, IR ir) Change all branches from this to b to branches that go to bCopy instead.
void	ExceptionHandlerBasicBlockBag.remove(BasicBlock bb) Takes an element out of the bag.
void	ControlFlowGraph.removeFromCFG(BasicBlock bb) Remove a basic block from the FCFG, leaving the code ordering unchanged.
void	ControlFlowGraph.removeFromCFGAndCodeOrder(BasicBlock bb) Remove a basic block from both the CFG and code ordering
void	ControlFlowGraph.removeFromCodeOrder(BasicBlock bb) Remove a basic block from the code ordering, leaving the FCFG unchanged.
BasicBlock	BasicBlock.replicateThisOut(IR ir, BasicBlock b) For basic block b which has to be a "normal" successor of this, make a copy of b, and set up the CFG so that this block has normal out edges to the copy.
BasicBlock	BasicBlock.replicateThisOut(IR ir, BasicBlock b, BasicBlock pred) For basic block b which has to be a "normal" successor of this, make a copy of b, and set up the CFG so that this block has normal out edges to the copy.
private void	IR.verifyAllBlocksAreReachable(String where, BasicBlock curBB, BitVector visitedNormalBBs, BitVector visitedExceptionalBBs, boolean fromExceptionEdge) Verify that every block in the CFG is reachable as failing to do so will cause EnterSSA.insertPhiFunctions to possibly access elements in DominanceFrontier.getIteratedDominanceFrontier and then DominanceFrontier.getDominanceFrontier that aren't defined.
private void	IR.verifyUseFollowsDef(String where, HashSet<Object> definedVariables, BasicBlock curBB, BitVector visitedBBs, ArrayList<BasicBlock> path, int maxPathLength, boolean traceExceptionEdges) Check whether uses follow definitions and in SSA form that variables aren't multiply defined

Method parameters in org.jikesrvm.compilers.opt.ir with type arguments of type BasicBlock

Modifier and Type	Method and Description
private void	IR.verifyUseFollowsDef(String where, HashSet<Object> definedVariables, BasicBlock curBB, BitVector visitedBBs, ArrayList<BasicBlock> path, int maxPathLength, boolean traceExceptionEdges) Check whether uses follow definitions and in SSA form that variables aren't multiply defined

Constructors in org.jikesrvm.compilers.opt.ir with parameters of type BasicBlock

Constructor and Description
AllInstructionsEnum(IR ir, BasicBlock block) Construct an enumeration for all instructions, both implicit and explicit in the IR, for a given basic block
WeightedBranchTargets(BasicBlock bb)

Uses of BasicBlock in org.jikesrvm.compilers.opt.ir.operand

Fields in org.jikesrvm.compilers.opt.ir.operand declared as BasicBlock

Modifier and Type	Field and Description
BasicBlock	BasicBlockOperand.block The basic block

Constructors in org.jikesrvm.compilers.opt.ir.operand with parameters of type BasicBlock

Constructor and Description
BasicBlockOperand(BasicBlock b) Construct a new basic block operand with the given block.

Uses of BasicBlock in org.jikesrvm.compilers.opt.lir2mir

Methods in org.jikesrvm.compilers.opt.lir2mir that return BasicBlock

Modifier and Type	Method and Description
(package private) BasicBlock	SplitBasicBlock.splitEachBlock(BasicBlock bb, IR ir) Splits a basic block.

Methods in org.jikesrvm.compilers.opt.lir2mir with parameters of type BasicBlock

Modifier and Type	Method and Description
(package private) void	BURS.finalizeBlock(BasicBlock bb) Finalizes a block.
void	MinimalBURS.invoke(BasicBlock bb) Build BURS trees for the basic block bb, label the trees, and then generate MIR instructions based on the labeling.
(package private) void	BURS.prepareForBlock(BasicBlock bb) Prepares for conversion of a block.
(package private) BasicBlock	SplitBasicBlock.splitEachBlock(BasicBlock bb, IR ir) Splits a basic block.

Constructors in org.jikesrvm.compilers.opt.lir2mir with parameters of type BasicBlock

Constructor and Description
NormalBURS_DepGraph(IR ir, Instruction start, Instruction end, BasicBlock currentBlock)

Uses of BasicBlock in org.jikesrvm.compilers.opt.liveness

Fields in org.jikesrvm.compilers.opt.liveness with type parameters of type BasicBlock

Modifier and Type	Field and Description
private HashMap<BasicBlock,LiveIntervalElement>	LiveInterval.liveIntervals

Methods in org.jikesrvm.compilers.opt.liveness with parameters of type BasicBlock

Modifier and Type	Method and Description
private void	LiveAnalysis.computeBlockGenAndKill(BasicBlock bblock, IR ir) Compute summary (local) live variable analysis for a basic block, which is basically Gen and Kill information.
private boolean	LiveInterval.containsUnresolvedElement(BasicBlock block, Register reg) Check to see if an unresolved LiveIntervalElement node for the register passed exists for the basic block passed.
void	LiveInterval.createEndLiveRange(LiveSet set, BasicBlock block, Instruction inst) This method iterates over each element in the the passed live set.
void	LiveInterval.createEndLiveRange(Register reg, BasicBlock block, Instruction inst) This method checks if an existing unresolved live interval node, i.e., one that has an end instruction, but no beginning instruction, is present for the register and basic block passed.
LiveIntervalEnumeration	LiveInterval.enumerateLiveIntervals(BasicBlock bb)
LiveIntervalElement	LiveInterval.getFirstLiveIntervalElement(BasicBlock bb)
LiveAnalysis.BBLiveElement	LiveAnalysis.getLiveInfo(BasicBlock bb) REturns the live information for a particular block
HashSet<Register>	LiveAnalysis.getLiveRegistersOnEdge(BasicBlock bb1, BasicBlock bb2) Return the set of registers that are live on the control-flow edge basic block bb1 to basic block bb2
(package private) HashSet<Register>	LiveAnalysis.getLiveRegistersOnEntry(BasicBlock bb)
(package private) HashSet<Register>	LiveAnalysis.getLiveRegistersOnExit(BasicBlock bb)
private void	LiveAnalysis.getUsesFromPhis(BasicBlock bblock) The rvals of phi nodes are logically uses in the phi's predecessor blocks, so here we collect phi rvals from the current block's successors into the gen set for this block, being careful to collect only the appropriate rval
void	LiveInterval.moveUpwardExposedRegsToFront(BasicBlock block) This method finds any LiveInterval node that does not have a start instruction (it is null) and moves this node to the front of the list.
private void	LiveInterval.prependLiveIntervalElement(BasicBlock block, LiveIntervalElement elem)
void	LiveInterval.printLiveIntervalList(BasicBlock block) Print the live intervals for a block.
private boolean	LiveAnalysis.processBlock(BasicBlock block, boolean reuseCurrentSet, IR ir) Computes the in set for this block given the out, gen, and kill set
void	LiveInterval.setStartLiveRange(Register reg, Instruction inst, BasicBlock block) This method finds the LiveInterval node for the register and basic block passed.

Uses of BasicBlock in org.jikesrvm.compilers.opt.regalloc

Fields in org.jikesrvm.compilers.opt.regalloc declared as BasicBlock

Modifier and Type	Field and Description
private BasicBlock	LiveIntervalElement.bb The basic block holding this live interval element
private BasicBlock	IntervalAnalysis.listOfBlocks a list of basic blocks in topological order
private BasicBlock	IntervalAnalysis.reverseTopFirst a reverse topological list of basic blocks

Methods in org.jikesrvm.compilers.opt.regalloc that return BasicBlock

Modifier and Type	Method and Description
BasicBlock	LiveIntervalElement.getBasicBlock()

Methods in org.jikesrvm.compilers.opt.regalloc with parameters of type BasicBlock

Modifier and Type	Method and Description
void	GenericRegisterRestrictions.addArchRestrictions(BasicBlock bb, ArrayList<LiveIntervalElement> symbolics) Add architecture-specific register restrictions for a basic block.
(package private) BasicInterval	CompoundInterval.addRange(RegisterAllocatorState regAllocState, LiveIntervalElement live, BasicBlock bb) Add a new live range to this compound interval.
(package private) int	RegisterAllocatorState.getDfnBegin(LiveIntervalElement live, BasicBlock bb)
(package private) int	RegisterAllocatorState.getDfnEnd(LiveIntervalElement live, BasicBlock bb)
private boolean	GenericStackManager.isPEIWithCatch(Instruction s, BasicBlock instructionsBB)
private void	GenericRegisterRestrictions.processBlock(BasicBlock bb, LiveInterval liveness) Records all the register restrictions dictated by live ranges on a particular basic block.
private CompoundInterval	IntervalAnalysis.processLiveInterval(LiveIntervalElement live, BasicBlock bb) for each live interval associated with this block we either add a new interval, or extend a previous interval if it is contiguous
void	LiveIntervalElement.setBasicBlock(BasicBlock bb)
private boolean	CompoundInterval.shouldConcatenate(RegisterAllocatorState regAllocState, LiveIntervalElement live, BasicBlock bb) Should we simply merge the live interval live into a previous BasicInterval?

Uses of BasicBlock in org.jikesrvm.compilers.opt.regalloc.ia32

Methods in org.jikesrvm.compilers.opt.regalloc.ia32 with parameters of type BasicBlock

Modifier and Type	Method and Description
void	RegisterRestrictions.addArchRestrictions(BasicBlock bb, ArrayList<LiveIntervalElement> symbolics)

Uses of BasicBlock in org.jikesrvm.compilers.opt.ssa

Fields in org.jikesrvm.compilers.opt.ssa declared as BasicBlock

Modifier and Type	Field and Description
private BasicBlock[]	LICM.block
(package private) BasicBlock	LiveRangeSplitting.LiveRangeSplittingPhase.BasicBlockPair.dest The sink of a control-flow edge
private BasicBlock[]	LICM.origBlock
(package private) BasicBlock	LiveRangeSplitting.LiveRangeSplittingPhase.BasicBlockPair.src The source of a control-flow edge

Fields in org.jikesrvm.compilers.opt.ssa with type parameters of type BasicBlock

Modifier and Type	Field and Description
private HashMap<BasicBlock,ArrayList<Instruction>>	SSADictionary.heapPhi A mapping from BasicBlock to ArrayList of Instruction .

Methods in org.jikesrvm.compilers.opt.ssa that return BasicBlock

Modifier and Type	Method and Description
private BasicBlock	LICM.commonDominator(BasicBlock a, BasicBlock b)
private BasicBlock	LoopVersioning.generateExplicitBoundCheck(Instruction boundCheckInstr, Operand minIndexValue, Operand maxIndexValue, HashMap<Register,Register> optimalRegMap, BasicBlock block, BasicBlock unoptimizedLoopEntry) Generate bound check branch blocks
private BasicBlock	LoopVersioning.generateNullCheckBranchBlocks(AnnotatedLSTNode loop, ArrayList<Instruction> checksToEliminate, HashMap<Register,Register> optimalRegMap, BasicBlock block, BasicBlock unoptimizedLoopEntry) Generate null check branch blocks
(package private) BasicBlock	LICM.getBlock(Instruction inst)
private BasicBlock	RedundantBranchElimination.RBE.getNotTakenBlock(Instruction s)
(package private) BasicBlock	LICM.getOrigBlock(Instruction inst)
(package private) BasicBlock	LICM.scheduleHeapUsesLate(Instruction inst, BasicBlock lateBlock)
(package private) BasicBlock	LICM.scheduleLate(Instruction inst)
private BasicBlock	LICM.scheduleScalarUsesLate(Instruction inst, BasicBlock lateBlock)
(package private) BasicBlock	LICM.upto(Instruction earlyPos, BasicBlock lateBlock, Instruction inst) Visits the blocks between the late and the early position along their path in the dominator tree.
(package private) BasicBlock	LICM.useBlock(Instruction use, Operand op)

Methods in org.jikesrvm.compilers.opt.ssa that return types with arguments of type BasicBlock

Modifier and Type	Method and Description
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.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 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

Methods in org.jikesrvm.compilers.opt.ssa with parameters of type BasicBlock

Modifier and Type	Method and Description
(package private) static void	SSA.addAtEnd(IR ir, BasicBlock bb, Instruction c, boolean exp) Add a move instruction at the end of a basic block, renaming with a temporary register if needed to protect conditional branches at the end of the block.
(package private) void	SSADictionary.addExceptionStateToDefs(Instruction s, BasicBlock b) Register that an instruction defines the exception state.
private void	SSADictionary.aloadHelper(Instruction s, BasicBlock b) Record the effects of a aload instruction on the heap array SSA form.
private void	SSADictionary.arraylengthHelper(Instruction s, BasicBlock b) Record the effects of an arraylength instruction on the heap array SSA form.
private void	SSADictionary.astoreHelper(Instruction s, BasicBlock b) Record the effects of an astore instruction on the heap array SSA form.
private void	SSADictionary.bbendHelper(Instruction s, BasicBlock b) Record the effects of a bbend instruction on the heap array SSA form.
private int	LICM.checkLoop(Instruction inst, HeapOperand<Object> hop, int xidx, BasicBlock block)
private BasicBlock	LICM.commonDominator(BasicBlock a, BasicBlock b)
private boolean	LoopVersioning.createBranchBlocks(AnnotatedLSTNode loop, BasicBlock block, ArrayList<Instruction> checksToEliminate, BasicBlock unoptimizedLoopEntry, BasicBlock optimizedLoopEntry, HashMap<Register,Register> optimalRegMap)
(package private) void	SSADictionary.createHeapPhiInstruction(BasicBlock bb, HeapVariable<Object> H) Create a heap control phi instruction, and store it at the beginning of a basic block.
private static HashSet<Register>	LiveRangeSplitting.LiveRangeSplittingPhase.findOrCreateSplitSet(HashMap<LiveRangeSplitting.LiveRangeSplittingPhase.BasicBlockPair,HashSet<Register>> map, BasicBlock b1, BasicBlock b2) Given a mapping from BasicBlockPair -> HashSet, find or create the hash set corresponding to a given basic block pair
private void	LoopVersioning.fixUpPhiPredecessors(ArrayList<Instruction> phiInstructions, BasicBlock unoptimizedLoopExit, BasicBlock optimizedLoopExit) When phi nodes were generated the basic blocks weren't known for the predecessors, fix this up now.
(package private) float	LICM.frequency(BasicBlock b) Determines how expensive it is to place an instruction in this block.
private BasicBlock	LoopVersioning.generateExplicitBoundCheck(Instruction boundCheckInstr, Operand minIndexValue, Operand maxIndexValue, HashMap<Register,Register> optimalRegMap, BasicBlock block, BasicBlock unoptimizedLoopEntry) Generate bound check branch blocks
private BasicBlock	LoopVersioning.generateNullCheckBranchBlocks(AnnotatedLSTNode loop, ArrayList<Instruction> checksToEliminate, HashMap<Register,Register> optimalRegMap, BasicBlock block, BasicBlock unoptimizedLoopEntry) Generate null check branch blocks
(package private) SSADictionary.AllInstructionEnumeration	SSADictionary.getAllInstructions(BasicBlock bb) Return an enumeration of all instructions for a basic block, including the control-PHI functions for heap variables stored implicitly here.
private void	SSADictionary.getFieldHelper(Instruction s, BasicBlock b) Record the effects of a getfield instruction on the heap array SSA form.
Iterator<Instruction>	SSADictionary.getHeapPhiInstructions(BasicBlock bb) Return an enumeration of the control-phi functions for Heap variables at the beginning of a basic block.
private void	SSADictionary.getStaticHelper(Instruction s, BasicBlock b) Record the effects of a getstatic instruction on the heap array SSA form.
private void	GlobalCSE.globalCSE(BasicBlock b) Recursively descend over all blocks dominated by b.
private void	LeaveSSA.insertCopies(BasicBlock bb, DominatorTree dom, LiveAnalysis live) Insert copy instructions into a basic block to safely translate out of SSA form.
private void	EnterSSA.insertPhi(BasicBlock bb, Register r) Insert a phi function for a symbolic register at the head of a basic block.
private boolean	LICM.inVariantLocation(Instruction inst, BasicBlock block)
private void	SSADictionary.labelHelper(Instruction s, BasicBlock b) Record the effects of a label instruction on the heap array SSA form.
private static Instruction	SSADictionary.makePhiInstruction(HeapVariable<Object> H, BasicBlock bb) Create a phi-function instruction for a heap variable
private Instruction	EnterSSA.makePhiInstruction(Register r, BasicBlock bb) Create a phi-function instruction
(package private) void	LICM.move(Instruction inst, BasicBlock to)
private void	SSADictionary.newArrayHelper(Instruction s, BasicBlock b) Update the heap array SSA form for an array allocation instruction
private void	SSADictionary.newHelper(Instruction s, BasicBlock b) Update the heap array SSA form for an allocation instruction
private RegisterOperand	LoopVersioning.nullCheckPerformedInLoopPredecessors(BasicBlock header, Instruction instr) Can we eliminate a null check as it has lready been performed?
private void	LeaveSSA.performRename(BasicBlock bb, DominatorTree dom, LeaveSSA.VariableStacks s)
private void	SSADictionary.phiHelper(Instruction s, BasicBlock b) Record the effects of a phi instruction on the heap array SSA form.
(package private) boolean	LICM.postDominates(BasicBlock a, BasicBlock b, IR ir) does a post dominate b?
(package private) static void	SSA.purgeBlockFromPHIs(BasicBlock source, BasicBlock target) Fix up any PHI instructions in the given target block to reflect that the given source block is no longer a predecessor of target.
private void	SSADictionary.putFieldHelper(Instruction s, BasicBlock b) Record the effects of a putfield instruction on the heap array SSA form.
private void	SSADictionary.putStaticHelper(Instruction s, BasicBlock b) Record the effects of a putstatic instruction on the heap array SSA form.
void	HeapVariable.registerDef(BasicBlock b) Note that this heap variable is defined in a given basic block.
private void	SSADictionary.registerDef(Instruction s, BasicBlock b, FieldReference fr) Register that instruction s writes a heap variable for a given field.
private void	SSADictionary.registerDef(Instruction s, BasicBlock b, String a) Register that the instruction s writes a heap variable for a given field.
private void	SSADictionary.registerDef(Instruction s, BasicBlock b, TypeReference t) Register that an instruction writes a heap variable for a given type.
(package private) void	SSADictionary.registerExit(Instruction s, BasicBlock b) Register that an instruction s can potentially leave the procedure.
(package private) void	SSADictionary.registerInstruction(Instruction s, BasicBlock b) Record the heap variables that instruction s defines and uses.
(package private) void	SSADictionary.registerUnknown(Instruction s, BasicBlock b) Register that an instruction s has unknown side effects.
private void	RedundantBranchElimination.RBE.removeCondBranch(BasicBlock source, Instruction cb, IR ir, Instruction di) Remove cb from source, updating PHI nodes to maintain SSA form.
(package private) static void	SSA.replaceBlockInPhis(BasicBlock target, BasicBlock B1, BasicBlock B2) Update PHI instructions in the target block so that any PHIs that come from basic block B1, now come from basic block B2.
(package private) HeapOperand<Object>[]	SSADictionary.replaceDefs(Instruction s, BasicBlock b) Replace all heap variables that an instruction defs with new heap variables.
private void	LeaveSSA.scheduleCopies(BasicBlock bb, LiveAnalysis live) Record pending copy operations needed to insert at the end of a basic block.
(package private) BasicBlock	LICM.scheduleHeapUsesLate(Instruction inst, BasicBlock lateBlock)
private BasicBlock	LICM.scheduleScalarUsesLate(Instruction inst, BasicBlock lateBlock)
private void	EnterSSA.search(BasicBlock X, Stack<RegisterOperand>[] S) This routine is the guts of the SSA construction phase for scalars.
private void	EnterSSA.search2(BasicBlock X, HashMap<Object,Stack<HeapOperand<Object>>> stacks) This routine is the guts of the SSA construction phase for heap array SSA.
(package private) void	LICM.setBlock(Instruction inst, BasicBlock b)
(package private) void	LICM.setOrigBlock(Instruction inst, BasicBlock b)
private boolean	LICM.simplify(Instruction inst, BasicBlock block)
private void	RedundantBranchElimination.RBE.takeCondBranch(BasicBlock source, Instruction cb, IR ir) Transforms a conditional branch into a GOTO, updating PHI nodes to maintain SSA form.
(package private) BasicBlock	LICM.upto(Instruction earlyPos, BasicBlock lateBlock, Instruction inst) Visits the blocks between the late and the early position along their path in the dominator tree.
private boolean	LeaveSSA.usedBelowCopy(BasicBlock bb, Register r)
private boolean	LICM.useDominates(Operand op, BasicBlock block)

Method parameters in org.jikesrvm.compilers.opt.ssa with type arguments of type BasicBlock

Modifier and Type	Method and Description
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 void	LoopVersioning.removeUnoptimizedLoop(AnnotatedLSTNode loop, HashMap<BasicBlock,BasicBlock> unoptimizedLoopMap)
private void	LoopVersioning.removeUnoptimizedLoop(AnnotatedLSTNode loop, HashMap<BasicBlock,BasicBlock> unoptimizedLoopMap)

Constructors in org.jikesrvm.compilers.opt.ssa with parameters of type BasicBlock

Constructor and Description
AllInstructionEnumeration(BasicBlock bb, SSADictionary dict) Construct an enumeration for all instructions, both implicit and explicit in the IR, for a given basic block
BasicBlockPair(BasicBlock src, BasicBlock dest)