Overview  Package  Class   Use  Tree  Serialized  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES    

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

Packages that use BasicBlock
org.jikesrvm.adaptive.recompilation.instrumentation   
org.jikesrvm.compilers.opt   
org.jikesrvm.compilers.opt.bc2ir   
org.jikesrvm.compilers.opt.controlflow   
org.jikesrvm.compilers.opt.depgraph   
org.jikesrvm.compilers.opt.hir2lir   
org.jikesrvm.compilers.opt.instrsched   
org.jikesrvm.compilers.opt.ir   
org.jikesrvm.compilers.opt.ir.operand   
org.jikesrvm.compilers.opt.lir2mir   
org.jikesrvm.compilers.opt.liveness   
org.jikesrvm.compilers.opt.regalloc   
org.jikesrvm.compilers.opt.regalloc.ia32   
org.jikesrvm.compilers.opt.ssa   
 

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

Methods in org.jikesrvm.adaptive.recompilation.instrumentation that return BasicBlock
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
private  void InstrumentationSamplingFramework.appendLoad(BasicBlock bb, IR ir)
          Append a load of the global counter to the given basic block.
private static void InstrumentationSamplingFramework.clearScratchObjects(BasicBlock bb, IR ir)
          Go through all statements in the basic block and clear the scratch objects.
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
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
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
(package private)  BasicBlock BasicBlockLE.block
          Basic block that this BBLE refers to.
 BasicBlock GenerationContext.epilogue
          The basic block into which BC2IR's caller will generate an epilogue.
 BasicBlock GenerationContext.exit
          The exit node of the outermost CFG (used by BC2IR for not-definitely caught athrows and by OSR_Yieldpoints)
 BasicBlock GenerationContext.prologue
          The basic block into which BC2IR's caller will generate a "prologue."
(package 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
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
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.
 

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

Fields in org.jikesrvm.compilers.opt.controlflow declared as BasicBlock
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 ReorderingPhase.Edge.source
           
(package private)  BasicBlock LSTNode.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 ReorderingPhase.Edge.target
           
(package private)  BasicBlock LSTNode.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
private  Enumeration<BasicBlock> LTDominatorInfo.bbEnum
           
private  ArrayList<BasicBlock> AnnotatedLSTNode.BBEnum.blocks
          ArrayList holding basic blocks
private  HashSet<BasicBlock> LTDominatorInfo.bucket
           
private  HashMap<BasicBlock,LSTNode> LSTGraph.loopMap
          Map of bb to LSTNode of innermost loop containing bb
 

Methods in org.jikesrvm.compilers.opt.controlflow that return BasicBlock
(package private) static 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)
          Return the cold predecessor to the argument block.
private  BasicBlock StaticSplitting.findColdSucc(BasicBlock bb, Instruction test)
          Return the off-trace successor of b (on and off relative to the argument test)
 BasicBlock LTDominatorInfo.getAncestor()
          Returns the ancestor for this block
private  BasicBlock LTDominators.getAncestor(BasicBlock block)
          Returns the ancestor for the passed block
 BasicBlock DominatorTreeNode.getBlock()
          Get the basic block for this dominator tree node
(package private)  BasicBlock Diamond.getBottom()
          The bottom of the diamond
 BasicBlock LTDominatorInfo.getChild()
          returns the child
private  BasicBlock LTDominators.getChild(BasicBlock block)
          Get the child node for this block
private  BasicBlock LTDominators.getDom(BasicBlock block)
          Returns the current dominator for the passed 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)
          return the immediate dominator of a basic block.
 BasicBlock LTDominatorInfo.getLabel()
          returns the label
private  BasicBlock LTDominators.getLabel(BasicBlock block)
          returns the label for the passed block or null if the block is null
(package private)  BasicBlock Diamond.getNotTaken()
          The "not-taken" branch of the diamond (might be null)
 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)
          Returns the parent for the passed block
(package private)  BasicBlock Diamond.getTaken()
          The "taken" branch of the diamond (might be null)
(package private)  BasicBlock Diamond.getTop()
          The top of the diamond
static BasicBlock DominatorInfo.idom(BasicBlock bb)
          Return the immediate dominator of a basic block.
private static BasicBlock[] CFGTransformations.inLoopPredecessors(LSTNode n)
          the predecessors of the loop header that are part of the loop.
private static BasicBlock[] CFGTransformations.inLoopSuccessors(LSTNode n)
          the successors of the loop header that are part of the loop.
private static BasicBlock[] CFGTransformations.loopPredecessors(LSTNode n)
          the predecessors of the loop header that are not part of the loop
(package private) static 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
(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)
          Returns an enumeration of the "next" nodes (either out or in) for the passed block depending on which way we are viewing the graph
private  Enumeration<BasicBlock> LTDominators.getPrevNodes(BasicBlock block)
          Returns an enumeration of the "prev" nodes (either in or out) for the passed block depending on which way we are viewing the graph
 

Methods in org.jikesrvm.compilers.opt.controlflow with parameters of type BasicBlock
 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)
          Does this basic block appear in the loop?
private  boolean StaticSplitting.containsOSRPoint(BasicBlock bb)
           
(package private) static 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)
          Evaluate the cost of a basic block, in number of real instructions.
private static boolean CFGTransformations.exitsLoop(BasicBlock b, BitVector loop)
           
private  void LSTGraph.findBackEdges(BasicBlock bb, int numBlocks)
          This routine performs a non-recursive depth-first search starting at the block passed looking for back edges.
private  BasicBlock StaticSplitting.findColdPrev(BasicBlock bb)
          Return the cold predecessor to the argument block.
private  BasicBlock StaticSplitting.findColdSucc(BasicBlock bb, Instruction test)
          Return the off-trace successor of b (on and off relative to the argument test)
private static Diamond Diamond.fourElementDiamond(BasicBlock top, BasicBlock left, BasicBlock right, BasicBlock bottom)
          Given that four blocks form a diamond, return the correct structure.
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)
          Returns the ancestor for the passed 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)
          Return the candidate test in b, or null if b does not have one.
(package private)  DF_LatticeCell[] DominatorSystem.getCellsForPredecessors(BasicBlock bb)
          Return a list of lattice cells corresponding to the predecessors of a basic block.
private  BasicBlock LTDominators.getChild(BasicBlock block)
          Get the child node for this block
 Enumeration<TreeNode> DominatorTree.getChildren(BasicBlock bb)
          Enumerate the children of the vertex corresponding to a basic block
private  BasicBlock LTDominators.getDom(BasicBlock block)
          Returns the current dominator for the passed block
 BitVector DominatorTree.getDominanceFrontier(BasicBlock bb)
          Return the (already calculated) dominance frontier for a basic block
static BasicBlock LTDominatorInfo.getIdom(BasicBlock bb)
          return the immediate dominator of a basic block.
static LTDominatorInfo LTDominatorInfo.getInfo(BasicBlock block)
          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)
          returns the label for the passed block or null if the block is null
 LSTNode LSTGraph.getLoop(BasicBlock b)
           
 int LSTGraph.getLoopNestDepth(BasicBlock bb)
           
private  Enumeration<BasicBlock> LTDominators.getNextNodes(BasicBlock block)
          Returns an enumeration of the "next" nodes (either out or in) for the passed block depending on which way we are viewing the graph
 BasicBlock DominatorTree.getParent(BasicBlock bb)
          Return the parent of the vertex corresponding to a basic block
private  BasicBlock LTDominators.getParent(BasicBlock block)
          Returns the parent for the passed block
private  Enumeration<BasicBlock> LTDominators.getPrevNodes(BasicBlock block)
          Returns an enumeration of the "prev" nodes (either in or out) for the passed block depending on which way we are viewing the graph
private  int LTDominators.getSemi(BasicBlock block)
          Returns the current semidominator for the passed block
private  int LTDominators.getSize(BasicBlock block)
          returns the size associated with the 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?
static BasicBlock DominatorInfo.idom(BasicBlock bb)
          Return the immediate dominator of a basic block.
 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)
          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"
(package private) static boolean DominatorInfo.isDominatedBy(BasicBlock slave, BasicBlock master)
          Is one basic block (the slave) dominated by another (the master)?
 boolean AnnotatedLSTNode.isInLoop(BasicBlock block)
          Is the a particular block in this loop?
 boolean LSTGraph.isLoopExit(BasicBlock source, BasicBlock target)
          Is the edge from source to target an exit from the loop containing source?
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) static 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)
          Process IfCmp branch instruction
(package private) static boolean BranchSimplifier.processIfCmp2(IR ir, BasicBlock bb, Instruction s)
          Process IfCmp2 branch instruction
(package private) static boolean BranchSimplifier.processInlineGuard(IR ir, BasicBlock bb, Instruction s)
          Process InlineGuard branch instruction
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)
          Process LookupSwitch branch instruction
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)
          Process TableSwitch branch instruction
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)
          Given that three blocks form a diamond, return the correct structure.
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
 void LTDominatorInfo.setEnum(Enumeration<BasicBlock> bbEnum)
          set the basic block enum field
 

Constructors in org.jikesrvm.compilers.opt.controlflow with parameters of type BasicBlock
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.
LSTNode.Edge(BasicBlock s, BasicBlock t, float p)
           
LSTNode(BasicBlock bb)
           
LTDominatorInfo(BasicBlock block)
           
ReorderingPhase.ChainInfo(BasicBlock h)
           
ReorderingPhase.Edge(BasicBlock s, BasicBlock t, float w)
           
StaticSplitting.CandInfo(BasicBlock c, BasicBlock p, BasicBlock s, Instruction t, StaticSplitting.CandInfo n)
           
 

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

Fields in org.jikesrvm.compilers.opt.depgraph declared as BasicBlock
private  BasicBlock DepGraph.currentBlock
          The basic block we are processing
 

Constructors in org.jikesrvm.compilers.opt.depgraph with parameters of type BasicBlock
DepGraph(IR ir, Instruction start, Instruction end, BasicBlock currentBlock)
          Constructor (computes the dependence graph!).
 

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

Methods in org.jikesrvm.compilers.opt.hir2lir that return BasicBlock
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
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.instrsched
 

Fields in org.jikesrvm.compilers.opt.instrsched declared as BasicBlock
private  BasicBlock DefaultPriority.bb
           
private  BasicBlock Scheduler.bb
          Current basic block.
 

Constructors in org.jikesrvm.compilers.opt.instrsched with parameters of type BasicBlock
DefaultPriority(BasicBlock bb)
          Creates new priority object for a given basic block
 

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

Subclasses of BasicBlock in org.jikesrvm.compilers.opt.ir
 class ExceptionHandlerBasicBlock
          A basic block that marks the start of an exception handler.
 

Fields in org.jikesrvm.compilers.opt.ir declared as BasicBlock
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
private  Stack<BasicBlock> IR.BitSetBBEnum.stack
           
 

Methods in org.jikesrvm.compilers.opt.ir that return BasicBlock
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()
          Get 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()
          Make an EXIT node.
 BasicBlock BasicBlock.nextBasicBlockInCodeOrder()
          Return the next basic block in with respect to the current code linearization order.
 BasicBlock BasicBlock.BBEnum.nextElement()
           
 BasicBlock BasicBlock.ComputedBBEnum.nextElement()
           
 BasicBlock BasicBlock.InEdgeEnum.nextElement()
           
 BasicBlock BasicBlock.OutEdgeEnum.nextElement()
           
 BasicBlock IR.BitSetBBEnum.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
 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
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)
          take an element out f 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
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
IREnumeration.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
 BasicBlock BasicBlockOperand.block
          The basic block
 

Constructors in org.jikesrvm.compilers.opt.ir.operand with parameters of type BasicBlock
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
(package private)  BasicBlock SplitBasicBlock.splitEachBlock(BasicBlock bb, IR ir)
          Splits basic block
 

Methods in org.jikesrvm.compilers.opt.lir2mir with parameters of type BasicBlock
(package private)  void BURS.finalizeBlock(BasicBlock bb)
          Must be called after invoke for all non-empty blocks.
 void MinimalBURS.invoke(BasicBlock bb)
          Build BURS trees for dependence graph bb, label the trees, and then generate MIR instructions based on the labeling.
(package private)  void BURS.prepareForBlock(BasicBlock bb)
          Prepare to convert a block.
(package private)  BasicBlock SplitBasicBlock.splitEachBlock(BasicBlock bb, IR ir)
          Splits basic block
 

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

Methods in org.jikesrvm.compilers.opt.liveness with parameters of type BasicBlock
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 static 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.
static void LiveInterval.createEndLiveRange(LiveSet set, BasicBlock block, Instruction inst)
          This method iterates over each element in the the passed live set.
static 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.
 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)
          Return the set of registers that are live across a basic block, and who are live before the basic block entry.
(package private)  HashSet<Register> LiveAnalysis.getLiveRegistersOnExit(BasicBlock bb)
          Return the set of registers that are live across a basic block, and who are live after the basic block exit.
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
static 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.
static void LiveInterval.printLiveIntervalList(BasicBlock block)
          Print the live intervals for a block.
private  boolean LiveAnalysis.processBlock(BasicBlock block, boolean reuseCurrentSet, IR ir)
          Compute the in set for this block given the out, gen, and kill set
static 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
private  BasicBlock LiveIntervalElement.bb
          The basic block holding this live interval element
private  BasicBlock LinearScan.IntervalAnalysis.listOfBlocks
          a list of basic blocks in topological order
private  BasicBlock LinearScan.IntervalAnalysis.reverseTopFirst
          a reverse topological list of basic blocks
 

Methods in org.jikesrvm.compilers.opt.regalloc that return BasicBlock
 BasicBlock LiveIntervalElement.getBasicBlock()
           
 

Methods in org.jikesrvm.compilers.opt.regalloc with parameters of type BasicBlock
 void GenericRegisterRestrictions.addArchRestrictions(BasicBlock bb, ArrayList<LiveIntervalElement> symbolics)
          Add architecture-specific register restrictions for a basic block.
(package private)  LinearScan.BasicInterval LinearScan.CompoundInterval.addRange(LiveIntervalElement live, BasicBlock bb)
          Add a new live range to this compound interval.
(package private) static int LinearScan.getDfnBegin(LiveIntervalElement live, BasicBlock bb)
          Return the Depth-first-number of the beginning of the live interval.
(package private) static int LinearScan.getDfnEnd(LiveIntervalElement live, BasicBlock bb)
          Return the Depth-first-number of the end of the live interval.
private  void GenericRegisterRestrictions.processBlock(BasicBlock bb)
          Record all the register restrictions dictated by live ranges on a particular basic block.
private  LinearScan.CompoundInterval LinearScan.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 LinearScan.CompoundInterval.shouldConcatenate(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
 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
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
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
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)
          Get the basic block of an instruction
private  BasicBlock RedundantBranchElimination.RBE.getNotTakenBlock(Instruction s)
          Return the basic block that s's block will goto if s is not taken.
(package private)  BasicBlock LICM.getOrigBlock(Instruction inst)
          Get the block, where the instruction was originally located
(package private)  BasicBlock LICM.scheduleHeapUsesLate(Instruction inst, BasicBlock lateBlock)
          Schedule me as early as possible, but behind the definitions of op[i] and behind earlyPos
(package private)  BasicBlock LICM.scheduleLate(Instruction inst)
          Schedule as late as possible.
private  BasicBlock LICM.scheduleScalarUsesLate(Instruction inst, BasicBlock lateBlock)
          Schedule me as late as possible, but in front of my uses and before latePos
(package private)  BasicBlock LICM.upto(Instruction earlyPos, BasicBlock lateBlock, Instruction inst)
          Visit 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
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
(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)
          check that inside the loop, the heap variable is only used/defed by simple, non-volatile loads/stores returns one of: CL_LOADS_ONLY, CL_STORES_ONLY, CL_LOADS_AND_STORES, CL_COMPLEX
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)
          Create the block containing explict branches to either the optimized or unoptimized loops
(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)
          How expensive is it 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)
          move `inst' behind `pred'
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)
          substitute variables renamed in control parents
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)
          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)
          Schedule me as early as possible, but behind the definitions of op[i] and behind earlyPos
private  BasicBlock LICM.scheduleScalarUsesLate(Instruction inst, BasicBlock lateBlock)
          Schedule me as late as possible, but in front of my uses and before latePos
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)
          Set the basic block for an instruction
(package private)  void LICM.setOrigBlock(Instruction inst, BasicBlock b)
          Set the block, where the instruction is originally located.
private  boolean LICM.simplify(Instruction inst, BasicBlock block)
           
private  void RedundantBranchElimination.RBE.takeCondBranch(BasicBlock source, Instruction cb, IR ir)
          Transform cb into a GOTO, updating PHI nodes to maintain SSA form.
(package private)  BasicBlock LICM.upto(Instruction earlyPos, BasicBlock lateBlock, Instruction inst)
          Visit 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
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)
          Remove unreachable unoptimized loop
private  void LoopVersioning.removeUnoptimizedLoop(AnnotatedLSTNode loop, HashMap<BasicBlock,BasicBlock> unoptimizedLoopMap)
          Remove unreachable unoptimized loop
 

Constructors in org.jikesrvm.compilers.opt.ssa with parameters of type BasicBlock
LiveRangeSplitting.LiveRangeSplittingPhase.BasicBlockPair(BasicBlock src, BasicBlock dest)
           
SSADictionary.AllInstructionEnumeration(BasicBlock bb, SSADictionary dict)
          Construct an enumeration for all instructions, both implicit and explicit in the IR, for a given basic block
 

Overview  Package  Class   Use  Tree  Serialized  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES