use of org.jikesrvm.compilers.opt.ir.operand.RegisterOperand in project JikesRVM by JikesRVM.
the class DepGraph method computeBackwardDependencesUse.
/**
* Compute backward dependences from a given use to a given node.
* @param op source operand
* @param destNode destination node
* @param lastExceptionNode node representing the last PEI
*/
private void computeBackwardDependencesUse(Operand op, DepGraphNode destNode, DepGraphNode lastExceptionNode) {
if (!(op instanceof RegisterOperand))
return;
RegisterOperand regOp = (RegisterOperand) op;
DepGraphNode sourceNode = getDepGraphNode(regOp.getRegister());
if (sourceNode != null) {
int type = regOp.getRegister().isValidation() ? GUARD_ANTI : REG_ANTI;
// create antidependence edge.
// NOTE: sourceNode contains the def and destNode contains the use.
destNode.insertOutEdge(sourceNode, type);
}
}
use of org.jikesrvm.compilers.opt.ir.operand.RegisterOperand in project JikesRVM by JikesRVM.
the class DepGraph method computeForwardDependencesUse.
/**
* Compute forward dependences from a given use to a given node.
* @param op source operand
* @param destNode destination node
* @param lastExceptionNode node representing the last PEI
*/
private void computeForwardDependencesUse(Operand op, DepGraphNode destNode, DepGraphNode lastExceptionNode) {
if (!(op instanceof RegisterOperand))
return;
RegisterOperand regOp = (RegisterOperand) op;
DepGraphNode sourceNode = getDepGraphNode(regOp.getRegister());
// the flow dependence edge.
if (sourceNode != null) {
if (regOp.getRegister().isValidation()) {
sourceNode.insertOutEdge(destNode, GUARD_TRUE);
} else {
for (Enumeration<Register> e = GenericPhysicalDefUse.enumerate(GenericPhysicalDefUse.getMaskTSPDefs(), ir); e.hasMoreElements(); ) {
Register r = e.nextElement();
if (regOp.getRegister() == r) {
sourceNode.insertOutEdge(destNode, REG_MAY_DEF);
return;
}
}
sourceNode.insertRegTrueOutEdge(destNode, regOp);
}
}
}
use of org.jikesrvm.compilers.opt.ir.operand.RegisterOperand in project JikesRVM by JikesRVM.
the class LoopUnrolling method unrollLeaf.
boolean unrollLeaf(LSTNode t, IR ir) {
int instructionsInLoop = 0;
BasicBlock exitBlock = null, backEdgeBlock = null, succBlock = null, predBlock = null;
BitVector nloop = t.getLoop();
BasicBlock header = t.header;
Instruction tmp;
if (ir.hasReachableExceptionHandlers()) {
report("0 IR may have exception handlers");
return false;
}
// determine loop structure by looking at its blocks
Enumeration<BasicBlock> loopBlocks = ir.getBasicBlocks(nloop);
int blocks = 0;
while (loopBlocks.hasMoreElements()) {
BasicBlock b = loopBlocks.nextElement();
blocks++;
// check for size
instructionsInLoop += b.getNumberOfRealInstructions();
if (instructionsInLoop > MaxInstructions) {
report("1 is too big");
return false;
}
// look at the in edges. We want the header to be the only
// block with out of loop incoming edges.
Enumeration<BasicBlock> e = b.getIn();
if (b != header) {
while (e.hasMoreElements()) {
BasicBlock o = e.nextElement();
if (!CFGTransformations.inLoop(o, nloop)) {
report("2 interior pointers.");
return true;
}
}
} else {
// check the headers predecessors: there should be
// one out of loop input and one backedge.
// We can extend this for loops with several backedges,
// if they all have the same conditions.
int inEdges = 0;
while (e.hasMoreElements()) {
inEdges++;
BasicBlock o = e.nextElement();
if (!CFGTransformations.inLoop(o, nloop)) {
if (predBlock == null) {
predBlock = o;
} else {
report("3 multi entry header.");
return true;
}
} else {
if (backEdgeBlock == null) {
backEdgeBlock = o;
} else {
report("4 multiple back edges.");
return true;
}
}
}
}
// look at the out edges to find loop exits
e = b.getOut();
while (e.hasMoreElements()) {
BasicBlock out = e.nextElement();
if (!CFGTransformations.inLoop(out, nloop)) {
if (exitBlock == null) {
exitBlock = b;
} else {
report("5 multiple exit blocks.");
return true;
}
}
}
}
// exitBlock must equal backEdgeBlock
if (exitBlock == null) {
report("6 no exit block found...infinite loop?");
return true;
}
if (exitBlock != backEdgeBlock) {
report("7 exit block is not immediate predecessor of loop head");
return true;
}
// exitBlock must exit (skip over pads in critical edges)
while (exitBlock.getNumberOfOut() == 1 && exitBlock.getNumberOfIn() == 1) {
exitBlock = exitBlock.getIn().nextElement();
}
if (exitBlock == header && blocks > 1) {
report("6 while loop? (" + blocks + ")");
return true;
}
// So far, so good. Examine the exit test.
Instruction origBranch = exitBlock.firstBranchInstruction();
if (origBranch != exitBlock.lastRealInstruction()) {
Instruction aGoto = origBranch.nextInstructionInCodeOrder();
if (aGoto.getOpcode() != GOTO_opcode) {
report("7 too complex exit");
return true;
}
succBlock = Label.getBlock(Goto.getTarget(aGoto).target).block;
if (VM.VerifyAssertions) {
VM._assert(aGoto == exitBlock.lastRealInstruction());
}
} else {
succBlock = exitBlock.getFallThroughBlock();
}
if (origBranch.getOpcode() != INT_IFCMP_opcode) {
report("8 branch isn't int_ifcmp: " + origBranch.operator() + ".");
return true;
}
// examine operands:
Operand op1 = follow(IfCmp.getVal1(origBranch));
Operand op2 = follow(IfCmp.getVal2(origBranch));
ConditionOperand cond = (ConditionOperand) IfCmp.getCond(origBranch).copy();
RegisterOperand ifcmpGuard = IfCmp.getGuardResult(origBranch);
float backBranchProbability = IfCmp.getBranchProfile(origBranch).takenProbability;
if (!loopInvariant(op2, nloop, 4)) {
if (loopInvariant(op1, nloop, 4)) {
Operand op = op1;
op1 = op2;
op2 = op;
cond.flipOperands();
} else {
if (DEBUG) {
printDefs(op1, nloop, 4);
printDefs(op2, nloop, 4);
VM.sysWriteln(origBranch.toString());
}
report("8a op1 and op2 may not be loop invariant");
return true;
}
}
BasicBlock target = Label.getBlock(IfCmp.getTarget(origBranch).target).block;
if (!(op1 instanceof RegisterOperand)) {
report("9 op1 of ifcmp isn't a register");
return true;
}
RegisterOperand rop1 = (RegisterOperand) op1;
Register reg = rop1.getRegister();
if (reg.isPhysical()) {
report("10 loops over physical register");
return false;
}
if (succBlock == header && !CFGTransformations.inLoop(target, nloop)) {
succBlock = target;
target = header;
cond.flipCode();
}
if (target != header) {
report("11 ifcmp doesn't jump to header");
return true;
}
Instruction iterator = null;
Enumeration<Operand> defs = new RealDefs(rop1);
while (defs.hasMoreElements()) {
Operand def = defs.nextElement();
Instruction inst = def.instruction;
BasicBlock block = inst.getBasicBlock();
// VM.sysWriteln(block + ": " + inst);
if (CFGTransformations.inLoop(block, nloop)) {
if (iterator == null) {
iterator = inst;
} else {
report("12 iterator not unique.");
return true;
}
}
}
if (iterator == null) {
report("15 iterator not found.");
return true;
}
if (iterator.getOpcode() != INT_ADD_opcode) {
// dumpIR (ir, "malformed");
report("16 iterator is no addition: " + iterator.operator());
return true;
}
if (!rop1.similar(follow(Binary.getVal1(iterator)))) {
// dumpIR (ir, "malformed");
report("17 malformed iterator.\n" + iterator);
return true;
}
Operand strideOp = follow(Binary.getVal2(iterator));
if (!(strideOp instanceof IntConstantOperand)) {
report("18 stride not constant");
return true;
}
int stride = ((IntConstantOperand) strideOp).value;
if (stride != 1 && stride != -1) {
report("18b stride != +/-1 (" + stride + ")");
return true;
}
if ((stride == 1 && ((cond.value != ConditionOperand.LESS) && cond.value != ConditionOperand.LESS_EQUAL && cond.value != ConditionOperand.NOT_EQUAL)) || (stride == -1 && ((cond.value != ConditionOperand.GREATER) && cond.value != ConditionOperand.GREATER_EQUAL && cond.value != ConditionOperand.NOT_EQUAL))) {
report("19 unexpected condition: " + cond + "\n" + iterator + "\n" + origBranch);
return true;
}
RegisterOperand outerGuard;
BasicBlock outer = predBlock;
while (outer.getNumberOfOut() == 1 && outer.getNumberOfIn() == 1) {
outer = outer.getIn().nextElement();
}
if (outer.getNumberOfIn() > 0 && outer.getNumberOfOut() < 2) {
report("23 no suitable outer guard found.");
return true;
}
tmp = outer.firstBranchInstruction();
if (tmp != null && GuardResultCarrier.conforms(tmp)) {
outerGuard = GuardResultCarrier.getGuardResult(tmp);
} else {
outerGuard = ir.regpool.makeTempValidation();
}
// //////////
// transfom
// transform this:
//
// Orig:
// B
// if i CC b goto Orig
// else goto exit
//
// exit:
//
// into this:
//
//
// stride == 1: common: stride == -1:
// --------------------------------------------------------------------------
// guard0:
// limit = b;
// if a > b goto Orig if b > a goto Orig
// else guard1
//
//
// guard 1:
// remainder = b - a; remainder = a - b;
// if cond == '<=' if cond == '>='
// remainder++; remainder++;
// remainder = remainder & 3
// limit = a + remainder limit = a - remainder
// if cond == '<=' if cond == '>='
// limit--; limit++;
// if remainder == 0 goto mllp
// goto Orig
//
// Orig:
// LOOP;
// if i CC limit goto Orig
// else guard2
//
// guard2: if i CC b goto mllp
// else exit
//
// mllp: // landing pad
// goto ml
//
// ml:
// LOOP;LOOP;LOOP;LOOP;
// if i CC b goto ml
// else exit
//
// exit:
// --------------------------------------------------------------------------
report("...transforming.");
if (DEBUG && ir.options.hasMETHOD_TO_PRINT() && ir.options.fuzzyMatchMETHOD_TO_PRINT(ir.method.toString())) {
dumpIR(ir, "before unroll");
}
CFGTransformations.killFallThroughs(ir, nloop);
BasicBlock[] handles = makeSomeCopies(unrollFactor, ir, nloop, blocks, header, exitBlock, exitBlock);
BasicBlock mainHeader = handles[0];
BasicBlock mainExit = handles[1];
// test block for well formed bounds
BasicBlock guardBlock0 = header.createSubBlock(header.firstInstruction().getBytecodeIndex(), ir);
predBlock.redirectOuts(header, guardBlock0, ir);
// test block for iteration alignemnt
BasicBlock guardBlock1 = header.createSubBlock(header.firstInstruction().getBytecodeIndex(), ir);
// landing pad for orig loop
BasicBlock olp = header.createSubBlock(header.firstInstruction().getBytecodeIndex(), ir);
olp.setLandingPad();
BasicBlock predSucc = predBlock.nextBasicBlockInCodeOrder();
if (predSucc != null) {
ir.cfg.breakCodeOrder(predBlock, predSucc);
ir.cfg.linkInCodeOrder(olp, predSucc);
}
ir.cfg.linkInCodeOrder(predBlock, guardBlock0);
ir.cfg.linkInCodeOrder(guardBlock0, guardBlock1);
ir.cfg.linkInCodeOrder(guardBlock1, olp);
// guard block for main loop
BasicBlock guardBlock2 = header.createSubBlock(header.firstInstruction().getBytecodeIndex(), ir);
// landing pad for main loop
BasicBlock landingPad = header.createSubBlock(header.firstInstruction().getBytecodeIndex(), ir);
landingPad.setLandingPad();
BasicBlock mainLoop = exitBlock.nextBasicBlockInCodeOrder();
ir.cfg.breakCodeOrder(exitBlock, mainLoop);
ir.cfg.linkInCodeOrder(exitBlock, guardBlock2);
ir.cfg.linkInCodeOrder(guardBlock2, landingPad);
ir.cfg.linkInCodeOrder(landingPad, mainLoop);
RegisterOperand remainder = ir.regpool.makeTemp(rop1.getType());
RegisterOperand limit = ir.regpool.makeTemp(rop1.getType());
// test whether a <= b for stride == 1 and a >= b for stride == -1
tmp = guardBlock0.lastInstruction();
tmp.insertBefore(Move.create(INT_MOVE, limit, op2.copy()));
ConditionOperand g0cond = ConditionOperand.GREATER_EQUAL();
if (stride == -1)
g0cond = ConditionOperand.LESS_EQUAL();
tmp.insertBefore(IfCmp.create(INT_IFCMP, outerGuard.copyD2D(), rop1.copyD2U(), op2.copy(), g0cond, olp.makeJumpTarget(), BranchProfileOperand.unlikely()));
tmp.insertBefore(Goto.create(GOTO, guardBlock1.makeJumpTarget()));
// align the loop iterations
tmp = guardBlock1.lastInstruction();
if (stride == 1) {
tmp.insertBefore(Binary.create(INT_SUB, remainder, op2.copy(), rop1.copyD2U()));
} else {
tmp.insertBefore(Binary.create(INT_SUB, remainder, rop1.copyD2U(), op2.copy()));
}
if (cond.isGREATER_EQUAL() || cond.isLESS_EQUAL()) {
tmp.insertBefore(Binary.create(INT_ADD, remainder.copyD2D(), remainder.copyD2U(), new IntConstantOperand(1)));
}
tmp.insertBefore(Binary.create(INT_ADD, remainder.copyD2D(), remainder.copyD2U(), new IntConstantOperand(-1)));
tmp.insertBefore(Binary.create(INT_AND, remainder.copyD2D(), remainder.copyD2U(), new IntConstantOperand(unrollFactor - 1)));
tmp.insertBefore(Binary.create(INT_ADD, remainder.copyD2D(), remainder.copyD2U(), new IntConstantOperand(1)));
if (stride == 1) {
tmp.insertBefore(Binary.create(INT_ADD, limit.copyD2U(), op1.copy(), remainder.copyD2U()));
} else {
tmp.insertBefore(Binary.create(INT_SUB, limit.copyD2U(), op1.copy(), remainder.copyD2U()));
}
if (cond.isLESS_EQUAL()) {
tmp.insertBefore(Binary.create(INT_ADD, limit.copyD2D(), limit.copyD2U(), new IntConstantOperand(-1)));
}
if (cond.isGREATER_EQUAL()) {
tmp.insertBefore(Binary.create(INT_ADD, limit.copyD2D(), limit.copyD2U(), new IntConstantOperand(1)));
}
tmp.insertBefore(Goto.create(GOTO, olp.makeJumpTarget()));
// build landing pad for original loop
tmp = olp.lastInstruction();
tmp.insertBefore(Goto.create(GOTO, header.makeJumpTarget()));
// change the back branch in the original loop
deleteBranches(exitBlock);
tmp = exitBlock.lastInstruction();
tmp.insertBefore(IfCmp.create(INT_IFCMP, outerGuard.copyD2D(), rop1.copyU2U(), limit.copyD2U(), (ConditionOperand) cond.copy(), header.makeJumpTarget(), new BranchProfileOperand(1.0f - 1.0f / (unrollFactor / 2))));
tmp.insertBefore(Goto.create(GOTO, guardBlock2.makeJumpTarget()));
// only enter main loop if iterations left
tmp = guardBlock2.lastInstruction();
tmp.insertBefore(IfCmp.create(INT_IFCMP, outerGuard.copyD2D(), rop1.copyU2U(), op2.copy(), (ConditionOperand) cond.copy(), landingPad.makeJumpTarget(), new BranchProfileOperand(backBranchProbability)));
tmp.insertBefore(Goto.create(GOTO, succBlock.makeJumpTarget()));
// landing pad jumps to mainHeader
tmp = landingPad.lastInstruction();
tmp.insertBefore(Goto.create(GOTO, mainHeader.makeJumpTarget()));
// repair back edge in mainExit
if (VM.VerifyAssertions)
VM._assert(mainExit != null);
tmp = mainExit.lastInstruction();
if (VM.VerifyAssertions) {
VM._assert((mainExit.lastRealInstruction() == null) || !mainExit.lastRealInstruction().isBranch());
}
tmp.insertBefore(IfCmp.create(INT_IFCMP, ifcmpGuard.copyU2U(), rop1.copyU2U(), op2.copy(), (ConditionOperand) cond.copy(), mainHeader.makeJumpTarget(), new BranchProfileOperand(1.0f - (1.0f - backBranchProbability) * unrollFactor)));
tmp.insertBefore(Goto.create(GOTO, succBlock.makeJumpTarget()));
// recompute normal outs
guardBlock0.recomputeNormalOut(ir);
guardBlock1.recomputeNormalOut(ir);
olp.recomputeNormalOut(ir);
guardBlock2.recomputeNormalOut(ir);
exitBlock.recomputeNormalOut(ir);
landingPad.recomputeNormalOut(ir);
mainExit.recomputeNormalOut(ir);
if (DEBUG && ir.options.hasMETHOD_TO_PRINT() && ir.options.fuzzyMatchMETHOD_TO_PRINT(ir.method.toString())) {
dumpIR(ir, "after unroll");
}
return false;
}
use of org.jikesrvm.compilers.opt.ir.operand.RegisterOperand in project JikesRVM by JikesRVM.
the class LoopUnrolling method printDefs.
private static boolean printDefs(Operand op, BitVector nloop, int depth) {
if (depth <= 0)
return false;
if (op instanceof ConstantOperand) {
VM.sysWriteln(">> " + op);
return true;
}
if (op instanceof RegisterOperand) {
boolean invariant = true;
Register reg = ((RegisterOperand) op).getRegister();
Enumeration<RegisterOperand> defs = DefUse.defs(reg);
while (defs.hasMoreElements()) {
Instruction inst = defs.nextElement().instruction;
VM.sysWriteln(">> " + inst.getBasicBlock() + ": " + inst);
if (CFGTransformations.inLoop(inst.getBasicBlock(), nloop)) {
if (Move.conforms(inst)) {
invariant &= printDefs(Move.getVal(inst), nloop, depth - 1);
} else if (inst.getOpcode() == ARRAYLENGTH_opcode) {
invariant &= printDefs(GuardedUnary.getVal(inst), nloop, depth);
} else {
invariant = false;
}
}
if (!invariant)
break;
}
return invariant;
}
return false;
}
use of org.jikesrvm.compilers.opt.ir.operand.RegisterOperand in project JikesRVM by JikesRVM.
the class LoopUnrolling method loopInvariant.
private static boolean loopInvariant(Operand op, BitVector nloop, int depth) {
if (depth <= 0) {
return false;
} else if (op instanceof ConstantOperand) {
return true;
} else if (op instanceof RegisterOperand) {
Register reg = ((RegisterOperand) op).getRegister();
Enumeration<RegisterOperand> defs = DefUse.defs(reg);
// if no definitions of this register (very strange) give up
if (!defs.hasMoreElements())
return false;
Instruction inst = defs.nextElement().instruction;
// fail to give the correct invariant
return !defs.hasMoreElements() && !CFGTransformations.inLoop(inst.getBasicBlock(), nloop);
} else {
return false;
}
}
Aggregations