| Package | Description |
|---|---|
| org.jikesrvm.compilers.opt.controlflow | |
| org.jikesrvm.compilers.opt.ir | |
| org.jikesrvm.compilers.opt.ssa |
SSA implementation (disabled because of bugs, see entry in issue tracker).
|
| org.jikesrvm.compilers.opt.util | |
| org.jikesrvm.runtime | |
| org.jikesrvm.util |
Provides utility classes and implementations of data structures suitable
for core runtime classes.
|
| Modifier and Type | Field and Description |
|---|---|
private BitVector |
DominatorTreeNode.dominanceFrontier
representation of the dominance frontier for this node
|
(package private) BitVector |
DominatorInfo.dominators
A BitVector which represents the dominators of the basic block
|
(package private) BitVector |
DominatorCell.dominators
Bit set representation of the dominators for this basic block.
|
(package private) BitVector |
DominatorTreeNode.dominators
the cache to hold the set of nodes that dominate this one.
|
(package private) BitVector |
LSTNode.loop
Basic blocks in the loop
|
| Modifier and Type | Method and Description |
|---|---|
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) BitVector |
DominatorTreeNode.dominators(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) BitVector |
DominatorTreeNode.getDominanceFrontier()
Return a bit set representing the dominance frontier for this node
|
BitVector |
DominatorTree.getDominanceFrontier(BasicBlock bb)
Return the (already calculated) dominance frontier for
a basic block
|
BitVector |
DominatorTree.getDominanceFrontier(int number)
Return the (already calculated) dominance frontier for
a basic block
|
static BitVector |
DominanceFrontier.getDominanceFrontier(IR ir,
BitVector bits)
Calculate the dominance frontier for the set of basic blocks
represented by a BitVector.
|
static BitVector |
DominanceFrontier.getIteratedDominanceFrontier(IR ir,
BitVector S)
Calculate the iterated dominance frontier for a set of basic blocks
represented by a BitVector.
|
BitVector |
LSTNode.getLoop() |
| Modifier and Type | Method and Description |
|---|---|
boolean |
DominatorTree.dominates(int b,
BitVector bits)
Does basic block number b dominate all basic blocks in a set?
|
private static boolean |
CFGTransformations.exitsLoop(BasicBlock b,
BitVector loop) |
private void |
LSTGraph.findNaturalLoop(SpaceEffGraphEdge edge,
BitVector loop)
This routine implements part of the algorithm to compute natural loops
as defined in Muchnick p 192.
|
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
|
static BitVector |
DominanceFrontier.getDominanceFrontier(IR ir,
BitVector bits)
Calculate the dominance frontier for the set of basic blocks
represented by a BitVector.
|
static BitVector |
DominanceFrontier.getIteratedDominanceFrontier(IR ir,
BitVector S)
Calculate the iterated dominance frontier for a set of basic blocks
represented by a BitVector.
|
(package private) static boolean |
CFGTransformations.inLoop(BasicBlock b,
BitVector nloop) |
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.
|
(package private) static void |
CFGTransformations.killFallThroughs(IR ir,
BitVector nloop) |
private static boolean |
LoopUnrolling.loopInvariant(Operand op,
BitVector nloop,
int depth) |
(package private) BasicBlock[] |
LoopUnrolling.makeSomeCopies(int unrollFactor,
IR ir,
BitVector nloop,
int blocks,
BasicBlock header,
BasicBlock exitBlock,
BasicBlock seqStart) |
private static boolean |
LoopUnrolling.printDefs(Operand op,
BitVector nloop,
int depth) |
(package private) void |
DominatorTreeNode.setDominanceFrontier(BitVector set)
Set a bit set representing the dominance frontier for this node
|
| Constructor and Description |
|---|
DominatorInfo(BitVector dominators)
Make a structure with a given bit set holding the dominators
of the basic block.
|
| Modifier and Type | Method and Description |
|---|---|
Enumeration<BasicBlock> |
IR.getBasicBlocks(BitVector bits)
Get an enumeration of all the basic blocks whose numbers
appear in the given BitSet.
|
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
|
| Constructor and Description |
|---|
BitSetBBEnum(IR ir,
BitVector bits) |
| Modifier and Type | Field and Description |
|---|---|
private BitVector |
HeapVariable.definedIn
a bit vector representing the basic blocks that write to this
variable
|
| Modifier and Type | Method and Description |
|---|---|
BitVector |
HeapVariable.getDefBlocks()
Return a bit vector that represents the basic blocks that define
this heap variable.
|
private BitVector[] |
EnterSSA.getDefSets()
Calculate the set of blocks that contain defs for each
symbolic register in an IR.
|
| Modifier and Type | Method and Description |
|---|---|
private void |
EnterSSA.insertPhiFunctions(IR ir,
BitVector[] defs,
Register[] symbolics,
boolean excludeGuards)
Insert the necessary phi functions into an IR.
|
private void |
EnterSSA.removePhisThatDominateAllDefs(BitVector needsPhi,
IR ir,
BitVector defs)
If node N dominates all defs of a register r, then N does
not need a phi function for r; this function removes such
nodes N from a Bit Set.
|
| Modifier and Type | Field and Description |
|---|---|
private BitVector |
BitSet.vector
The backing bit vector that determines set membership.
|
| Modifier and Type | Field and Description |
|---|---|
private static BitVector |
Statics.numericFieldVector
Bit vector indicating whether a numeric slot is a field (true) or a
literal (false).
|
| Modifier and Type | Method and Description |
|---|---|
static BitVector |
BitVector.and(BitVector b1,
BitVector b2) |
BitVector |
BitVector.dup() |
static BitVector |
BitVector.not(BitVector s) |
static BitVector |
BitVector.or(BitVector b1,
BitVector b2) |
| Modifier and Type | Method and Description |
|---|---|
void |
BitVector.and(BitVector set)
Logically ANDs this bit set with the specified set of bits.
|
static BitVector |
BitVector.and(BitVector b1,
BitVector b2) |
void |
BitVector.copyBits(BitVector set)
Copies the values of the bits in the specified set into this set.
|
boolean |
BitVector.intersectionEmpty(BitVector other) |
static BitVector |
BitVector.not(BitVector s) |
void |
BitVector.or(BitVector set)
Logically ORs this bit set with the specified set of bits.
|
static BitVector |
BitVector.or(BitVector b1,
BitVector b2) |
void |
BitVector.xor(BitVector set)
Logically XORs this bit set with the specified set of bits.
|
| Constructor and Description |
|---|
BitVector(BitVector s)
Creates a copy of a Bit String
|