BasicBlock

java.lang.Object
- kilim.analysis.BasicBlock

All Implemented Interfaces:

java.lang.Comparable<BasicBlock>
```
public class BasicBlock
extends java.lang.Object
implements java.lang.Comparable<BasicBlock>
```
A basic block is a contiguous set of instructions that has one label at the first instruction and a transfer-of-control instruction at the very end. A transfer-of-control instruction includes all branching instructions that have labelled targets (IF_x, GOTO, and JSR) and the rest (ATHROW, xRETURN, RET). There can be no target labels in the middle of a basic block; in other words, you can't jump into the middle of a basic block. This is the standard definition; we make a few changes.

We create BasicBlocks whenever we encounter a label (in a linear scanning of a method's instructions. Some labels are meant for catch handlers and debug (line number) information only; they are not the target of a branching instruction, but we don't know that in the first pass. We coalesce those BasicBlocks that merely follow another, provided the preceding BB is the only preceder. Note that blocks connected with a GOTO can't coalesce because they are not likely to be contiguous, even if they obey the constraint of a single edge. We also don't coalesce blocks starting with a pausable method invocation with their predecessor, because we need these blocks to tell us about downstream usage of local vars to help us generate optimal continuations.

All catch handlers that intersect a basic block are treated as successors to the block, for the purposes of liveness analysis.
Subroutines (targets of JSR) are treated specially. We inline all JSR calls, including nested JSRs, to simplify liveness analysis. In this phase, a JSR/RET is treated the same as a GOTO sub followed by a GOTO to the caller. During the weaving phase, we ignore the inlining information if the subroutine doesn't have any pausable methods. If it does, then we spit out duplicate code, complete with GOTOs as described above. This allows us to jump in the middle of a "finally" block during rewinding. Note: The JVM reference doesn't specify the boundaries of a JSR instruction; in other words, there is no definitive way of saying which blocks belong to a subroutine. This code treats the set of all nodes reachable via branching instructions from the subroutine's entry point. (exception catch blocks don't count)

Field Summary

Fields
Modifier and Type	Field and Description
`int`	`endPos`
`MethodFlow`	`flow` The flow to which this BB belongs.
`java.util.ArrayList<Handler>`	`handlers`
`int`	`id` A number handed out in increasing order of starting position, to ease sorting as well as for debug information
`Frame`	`startFrame` The frame at the BB's entry point.
`LabelNode`	`startLabel` The label that starts this BB.
`int`	`startPos` Start and end points (both inclusive) in the current method's list of instructions (this.flow.instructions)
`java.util.ArrayList<BasicBlock>`	`successors` List of successors (follower and all branch targets).
`Usage`	`usage` usage initially contains the usage of local variables in this block (without reference to any other block).

Constructor Summary

Constructors
Constructor and Description

BasicBlock(MethodFlow aflow, LabelNode aStartLabel)

Constructors
Constructor and Description
`BasicBlock(MethodFlow aflow, LabelNode aStartLabel)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`chooseCatchHandlers(java.util.ArrayList<Handler> handlerList)`
`int`	`compareTo(BasicBlock o)`
`boolean`	`flowVarUsage()` calculate the liveness usage by evolution (assume born usage has already been calculated)
`AbstractInsnNode`	`getInstruction(int pos)`
`BasicBlock`	`getJSRTarget()`
`java.util.ArrayList<BasicBlock>`	`getSubBlocks()`
`Usage`	`getVarUsage()`
`boolean`	`hasFlag(int bitFlag)`
`boolean`	`isCatchHandler()`
`boolean`	`isGetCurrentTask()`
`boolean`	`isPausable()`
`void`	`setFlag(int bitFlag)`
`java.lang.String`	`toString()`
`void`	`unsetFlag(int bitFlag)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - id
```
public int id
```
    A number handed out in increasing order of starting position, to ease sorting as well as for debug information
  - flow
```
public MethodFlow flow
```
    The flow to which this BB belongs.
  - startLabel
```
public LabelNode startLabel
```
    The label that starts this BB. In some cases we create a label where it didn't exist originally (after a jmp instruction, for example). This allows us a unique indexing scheme.
  - startPos
```
public int startPos
```
    Start and end points (both inclusive) in the current method's list of instructions (this.flow.instructions)
  - endPos
```
public int endPos
```
  - successors
```
public java.util.ArrayList<BasicBlock> successors
```
    List of successors (follower and all branch targets). Should be null
  - handlers
```
public java.util.ArrayList<Handler> handlers
```
  - usage
```
public Usage usage
```
    usage initially contains the usage of local variables in this block (without reference to any other block). After flow analysis it contains the combined effect of this and all downstream blocks
  - startFrame
```
public Frame startFrame
```
    The frame at the BB's entry point. It changes when propagating changes from its predeccessors, until there's a fixed point.
- Constructor Detail
  - BasicBlock
```
public BasicBlock(MethodFlow aflow,
                  LabelNode aStartLabel)
```
- Method Detail
  - getVarUsage
```
public Usage getVarUsage()
```
  - setFlag
```
public void setFlag(int bitFlag)
```
  - unsetFlag
```
public void unsetFlag(int bitFlag)
```
  - hasFlag
```
public boolean hasFlag(int bitFlag)
```
  - compareTo
```
public int compareTo(BasicBlock o)
```
    Specified by:
    
    compareTo in interface java.lang.Comparable<BasicBlock>
  - isCatchHandler
```
public boolean isCatchHandler()
```
  - chooseCatchHandlers
```
public void chooseCatchHandlers(java.util.ArrayList<Handler> handlerList)
```
  - getInstruction
```
public AbstractInsnNode getInstruction(int pos)
```
  - flowVarUsage
```
public boolean flowVarUsage()
```
    calculate the liveness usage by evolution (assume born usage has already been calculated)
  - getJSRTarget
```
public BasicBlock getJSRTarget()
```
  - getSubBlocks
```
public java.util.ArrayList<BasicBlock> getSubBlocks()
                                             throws KilimException
```
    Throws:
    
    KilimException
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - isPausable
```
public boolean isPausable()
```
  - isGetCurrentTask
```
public boolean isGetCurrentTask()
```

Class BasicBlock

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

id

flow

startLabel

startPos

endPos

successors

handlers

usage

startFrame

Constructor Detail

BasicBlock

Method Detail

getVarUsage

setFlag

unsetFlag

hasFlag

compareTo

isCatchHandler

chooseCatchHandlers

getInstruction

flowVarUsage

getJSRTarget

getSubBlocks

toString

isPausable

isGetCurrentTask