# HG changeset patch # User Gilles Duboscq # Date 1310130016 -7200 # Node ID 38792f9594791b72529dd14193a35d1e0a0bdbbb # Parent 536b02e3cd2b8c5b0c2624f2a4c6ee720acab8b8# Parent 3d68684b7161946d4d61a3ea7d31aa087231c5d6 Merge diff -r 536b02e3cd2b -r 38792f959479 .hgignore --- a/.hgignore Fri Jul 08 14:49:01 2011 +0200 +++ b/.hgignore Fri Jul 08 15:00:16 2011 +0200 @@ -20,6 +20,7 @@ ^Test.java$ ^diff1.txt$ ^diff2.txt$ +^examples.jar$ ^test.xml$ java\.hprof\.txt$ /nbproject/private/ diff -r 536b02e3cd2b -r 38792f959479 create_examples.xml --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/create_examples.xml Fri Jul 08 15:00:16 2011 +0200 @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff -r 536b02e3cd2b -r 38792f959479 graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/GraalCompilation.java --- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/GraalCompilation.java Fri Jul 08 14:49:01 2011 +0200 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/GraalCompilation.java Fri Jul 08 15:00:16 2011 +0200 @@ -30,7 +30,7 @@ import com.oracle.max.graal.compiler.asm.*; import com.oracle.max.graal.compiler.debug.*; import com.oracle.max.graal.compiler.gen.*; -import com.oracle.max.graal.compiler.gen.LIRGenerator.*; +import com.oracle.max.graal.compiler.gen.LIRGenerator.DeoptimizationStub; import com.oracle.max.graal.compiler.graph.*; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.observer.*; @@ -239,8 +239,8 @@ lirGenerator = compiler.backend.newLIRGenerator(this); - for (LIRBlock begin : hir.linearScanOrder()) { - lirGenerator.doBlock(begin); + for (LIRBlock b : hir.linearScanOrder()) { + lirGenerator.doBlock(b); } if (GraalOptions.Time) { @@ -258,7 +258,7 @@ private CiTargetMethod emitCode() { if (GraalOptions.GenLIR && GraalOptions.GenCode) { final LIRAssembler lirAssembler = compiler.backend.newLIRAssembler(this); - lirAssembler.emitCode(hir.linearScanOrder()); + lirAssembler.emitCode(hir.codeEmittingOrder()); // generate code for slow cases lirAssembler.emitLocalStubs(); diff -r 536b02e3cd2b -r 38792f959479 graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/GraalOptions.java --- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/GraalOptions.java Fri Jul 08 14:49:01 2011 +0200 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/GraalOptions.java Fri Jul 08 15:00:16 2011 +0200 @@ -85,6 +85,8 @@ public static boolean PrintDOTGraphToPdf = ____; public static boolean OmitDOTFrameStates = ____; + public static boolean Extend = ____; + // Ideal graph visualizer output settings public static boolean Plot = ____; public static boolean PlotOnError = ____; @@ -129,6 +131,7 @@ public static boolean UseBranchPrediction = true; public static boolean UseExceptionProbability = ____; public static int MatureInvocationCount = 100; + public static boolean GenSafepoints = true; public static boolean UseConstDirectCall = ____; @@ -153,8 +156,11 @@ public static boolean CommentedAssembly = ____; public static boolean PrintLIRWithAssembly = ____; + public static boolean OptReadElimination = ____; public static boolean OptGVN = ____; public static boolean OptCanonicalizer = true; public static boolean OptLoops = ____; + public static boolean OptOptimisticSchedule = ____; + public static boolean OptReorderLoops = ____; public static boolean LoopPeeling = ____; } diff -r 536b02e3cd2b -r 38792f959479 graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/ControlFlowOptimizer.java --- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/ControlFlowOptimizer.java Fri Jul 08 14:49:01 2011 +0200 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/ControlFlowOptimizer.java Fri Jul 08 15:00:16 2011 +0200 @@ -42,7 +42,7 @@ */ public static void optimize(IR ir) { ControlFlowOptimizer optimizer = new ControlFlowOptimizer(ir); - List code = ir.linearScanOrder(); + List code = ir.codeEmittingOrder(); optimizer.reorderShortLoops(code); optimizer.deleteEmptyBlocks(code); optimizer.deleteUnnecessaryJumps(code); diff -r 536b02e3cd2b -r 38792f959479 graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/LinearScan.java --- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/LinearScan.java Fri Jul 08 14:49:01 2011 +0200 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/alloc/LinearScan.java Fri Jul 08 15:00:16 2011 +0200 @@ -26,20 +26,23 @@ import static java.lang.reflect.Modifier.*; import java.util.*; +import java.util.Map.Entry; import com.oracle.max.graal.compiler.*; -import com.oracle.max.graal.compiler.alloc.Interval.*; +import com.oracle.max.graal.compiler.alloc.Interval.RegisterBinding; +import com.oracle.max.graal.compiler.alloc.Interval.RegisterPriority; +import com.oracle.max.graal.compiler.alloc.Interval.SpillState; import com.oracle.max.graal.compiler.debug.*; import com.oracle.max.graal.compiler.gen.*; import com.oracle.max.graal.compiler.graph.*; import com.oracle.max.graal.compiler.ir.*; import com.oracle.max.graal.compiler.lir.*; -import com.oracle.max.graal.compiler.lir.LIRInstruction.*; +import com.oracle.max.graal.compiler.lir.LIRInstruction.OperandMode; import com.oracle.max.graal.compiler.observer.*; -import com.oracle.max.graal.compiler.phases.EscapeAnalysisPhase.EscapeField; import com.oracle.max.graal.compiler.util.*; import com.oracle.max.graal.compiler.value.*; -import com.oracle.max.graal.compiler.value.FrameState.*; +import com.oracle.max.graal.compiler.value.FrameState.ValueProcedure; +import com.oracle.max.graal.extensions.*; import com.oracle.max.graal.graph.*; import com.sun.cri.ci.*; import com.sun.cri.ri.*; @@ -634,6 +637,7 @@ // Add uses of live locals from interpreter's point of view for proper debug information generation LIRDebugInfo info = op.info; if (info != null) { + assert info.state != null; info.state.forEachLiveStateValue(new ValueProcedure() { public void doValue(Value value) { CiValue operand = value.operand(); @@ -1837,117 +1841,183 @@ } } - CiValue toCiValue(int opId, Value value) { - if (value instanceof VirtualObject) { - return toCiVirtualObject(opId, (VirtualObject) value); - } else if (value != null && value.operand() != CiValue.IllegalValue) { - CiValue operand = value.operand(); - Constant con = null; - if (value instanceof Constant) { - con = (Constant) value; - } - - assert con == null || operand.isVariable() || operand.isConstant() || operand.isIllegal() : "Constant instructions have only constant operands (or illegal if constant is optimized away)"; + public static ThreadLocal> frameModifierLoader = new ThreadLocal>(); - if (operand.isVariable()) { - OperandMode mode = OperandMode.Input; - LIRBlock block = blockForId(opId); - if (block.numberOfSux() == 1 && opId == block.lastLirInstructionId()) { - // generating debug information for the last instruction of a block. - // if this instruction is a branch, spill moves are inserted before this branch - // and so the wrong operand would be returned (spill moves at block boundaries are not - // considered in the live ranges of intervals) - // Solution: use the first opId of the branch target block instead. - final LIRInstruction instr = block.lir().instructionsList().get(block.lir().instructionsList().size() - 1); - if (instr instanceof LIRBranch) { - if (block.liveOut.get(operandNumber(operand))) { - opId = block.suxAt(0).firstLirInstructionId(); - mode = OperandMode.Output; - } - } - } + private CiFrame overrideFrame(CiFrame frame) { + ServiceLoader serviceLoader = frameModifierLoader.get(); + if (serviceLoader == null) { + serviceLoader = ServiceLoader.load(FrameModifier.class); + frameModifierLoader.set(serviceLoader); + } - // Get current location of operand - // The operand must be live because debug information is considered when building the intervals - // if the interval is not live, colorLirOperand will cause an assert on failure - operand = colorLirOperand((CiVariable) operand, opId, mode); - assert !hasCall(opId) || operand.isStackSlot() || !isCallerSave(operand) : "cannot have caller-save register operands at calls"; - return operand; - } else if (operand.isRegister()) { - assert false : "must not reach here"; - return operand; - } else { - assert value instanceof Constant; - assert operand.isConstant() : "operand must be constant"; - return operand; - } - } else { - // return a dummy value because real value not needed - return CiValue.IllegalValue; + CiFrame result = frame; + for (FrameModifier modifier : serviceLoader) { + result = modifier.getFrame(compilation.runtime, result); } + return result; } - private CiVirtualObject toCiVirtualObject(int opId, VirtualObject obj) { - RiType type = obj.type(); - EscapeField[] escapeFields = obj.fields(); - CiValue[] values = new CiValue[escapeFields.length]; - int valuesFilled = 0; + + private class DebugFrameBuilder { + + private final FrameState topState; + private final int opId; + private final BitMap frameRefMap; + + private HashMap virtualObjects; + + public DebugFrameBuilder(FrameState topState, int opId, BitMap frameRefMap) { + this.topState = topState; + this.opId = opId; + this.frameRefMap = frameRefMap; + } + + private CiValue toCiValue(Value value) { + if (value instanceof VirtualObject) { + if (virtualObjects == null) { + virtualObjects = new HashMap(); + } + VirtualObject obj = (VirtualObject) value; + CiVirtualObject ciObj = virtualObjects.get(value); + if (ciObj == null) { + ciObj = CiVirtualObject.get(obj.type(), null, value.id()); + virtualObjects.put(obj, ciObj); + } + return ciObj; + } else if (value != null && value.operand() != CiValue.IllegalValue) { + CiValue operand = value.operand(); + Constant con = null; + if (value instanceof Constant) { + con = (Constant) value; + } + + assert con == null || operand.isVariable() || operand.isConstant() || operand.isIllegal() : "Constant instructions have only constant operands (or illegal if constant is optimized away)"; - VirtualObject current = obj; - do { - boolean found = false; - for (int i = 0; i < escapeFields.length; i++) { - if (escapeFields[i].representation() == current.field().representation()) { - if (values[i] == null) { - values[i] = toCiValue(opId, current.input()); - valuesFilled++; + int tempOpId = this.opId; + if (operand.isVariable()) { + OperandMode mode = OperandMode.Input; + LIRBlock block = blockForId(tempOpId); + if (block.numberOfSux() == 1 && tempOpId == block.lastLirInstructionId()) { + // generating debug information for the last instruction of a block. + // if this instruction is a branch, spill moves are inserted before this branch + // and so the wrong operand would be returned (spill moves at block boundaries are not + // considered in the live ranges of intervals) + // Solution: use the first opId of the branch target block instead. + final LIRInstruction instr = block.lir().instructionsList().get(block.lir().instructionsList().size() - 1); + if (instr instanceof LIRBranch) { + if (block.liveOut.get(operandNumber(operand))) { + tempOpId = block.suxAt(0).firstLirInstructionId(); + mode = OperandMode.Output; + } + } } - found = true; - break; + + // Get current location of operand + // The operand must be live because debug information is considered when building the intervals + // if the interval is not live, colorLirOperand will cause an assert on failure + operand = colorLirOperand((CiVariable) operand, tempOpId, mode); + assert !hasCall(tempOpId) || operand.isStackSlot() || !isCallerSave(operand) : "cannot have caller-save register operands at calls"; + return operand; + } else if (operand.isRegister()) { + assert false : "must not reach here"; + return operand; + } else { + assert value instanceof Constant; + assert operand.isConstant() : "operand must be constant"; + return operand; } + } else { + // return a dummy value because real value not needed + return CiValue.IllegalValue; } - assert found : type + "." + current.field() + " not found"; - current = current.object(); - } while (current != null && valuesFilled < values.length); - - for (int i = 0; i < escapeFields.length; i++) { - assert values[i] != null : type + "." + escapeFields[i]; } - return CiVirtualObject.get(type, values, obj.id()); - } + private CiFrame computeFrameForState(FrameState state) { + CiValue[] values = new CiValue[state.valuesSize() + state.locksSize()]; + int valueIndex = 0; + + for (int i = 0; i < state.valuesSize(); i++) { + values[valueIndex++] = toCiValue(state.valueAt(i)); + } - CiFrame computeFrameForState(FrameState state, int opId, BitMap frameRefMap) { - CiValue[] values = new CiValue[state.valuesSize() + state.locksSize()]; - int valueIndex = 0; - - for (int i = 0; i < state.valuesSize(); i++) { - values[valueIndex++] = toCiValue(opId, state.valueAt(i)); + for (int i = 0; i < state.locksSize(); i++) { + if (compilation.runtime.sizeOfBasicObjectLock() != 0) { + CiStackSlot monitorAddress = frameMap.toMonitorBaseStackAddress(i); + values[valueIndex++] = monitorAddress; + CiStackSlot objectAddress = frameMap.toMonitorObjectStackAddress(i); + frameRefMap.set(objectAddress.index()); + } else { + Value lock = state.lockAt(i); + if (lock.isConstant() && compilation.runtime.asJavaClass(lock.asConstant()) != null) { + // lock on class for synchronized static method + values[valueIndex++] = lock.asConstant(); + } else { + values[valueIndex++] = toCiValue(lock); + } + } + } + CiFrame caller = null; + if (state.outerFrameState() != null) { + caller = computeFrameForState(state.outerFrameState()); + } + CiFrame frame = new CiFrame(caller, state.method, state.bci, state.rethrowException(), values, state.localsSize(), state.stackSize(), state.locksSize()); + if (GraalOptions.Extend) { + frame = overrideFrame(frame); + } + return frame; } - for (int i = 0; i < state.locksSize(); i++) { - if (compilation.runtime.sizeOfBasicObjectLock() != 0) { - CiStackSlot monitorAddress = frameMap.toMonitorBaseStackAddress(i); - values[valueIndex++] = monitorAddress; - assert frameRefMap != null; - CiStackSlot objectAddress = frameMap.toMonitorObjectStackAddress(i); -// LIRDebugInfo.setBit(frameRefMap, objectAddress.index()); - frameRefMap.set(objectAddress.index()); - } else { - Value lock = state.lockAt(i); - if (lock.isConstant() && compilation.runtime.asJavaClass(lock.asConstant()) != null) { - // lock on class for synchronized static method - values[valueIndex++] = lock.asConstant(); - } else { - values[valueIndex++] = toCiValue(opId, lock); - } + public CiFrame build() { + CiFrame frame = computeFrameForState(topState); + + if (virtualObjects != null) { + // collect all VirtualObjectField instances: + HashMap objectStates = new HashMap(); + FrameState current = topState; + do { + for (Node n : current.virtualObjectMappings()) { + VirtualObjectField field = (VirtualObjectField) n; + // null states occur for objects with 0 fields + if (field != null && !objectStates.containsKey(field.object())) { + objectStates.put(field.object(), field); + } + } + current = current.outerFrameState(); + } while (current != null); + // fill in the CiVirtualObject values: + // during this process new CiVirtualObjects might be discovered, so repeat until no more changes occur. + boolean changed; + do { + changed = false; + HashMap virtualObjectsCopy = new HashMap(virtualObjects); + for (Entry entry : virtualObjectsCopy.entrySet()) { + if (entry.getValue().values() == null) { + VirtualObject vobj = entry.getKey(); + CiValue[] values = new CiValue[vobj.fields().length]; + entry.getValue().setValues(values); + if (vobj.fields().length > 0) { + changed = true; + FloatingNode currentField = objectStates.get(vobj); + assert currentField != null; + do { + if (currentField instanceof VirtualObjectField) { + int index = ((VirtualObjectField) currentField).index(); + if (values[index] == null) { + values[index] = toCiValue(((VirtualObjectField) currentField).input()); + } + currentField = ((VirtualObjectField) currentField).lastState(); + } else { + assert currentField instanceof Phi : currentField; + currentField = (FloatingNode) ((Phi) currentField).valueAt(0); + } + } while (currentField != null); + } + } + } + } while (changed); } + return frame; } - CiFrame caller = null; - if (state.outerFrameState() != null) { - caller = computeFrameForState(state.outerFrameState(), opId, frameRefMap); - } - return new CiFrame(caller, state.method, state.bci, state.rethrowException(), values, state.localsSize(), state.stackSize(), state.locksSize()); } private void computeDebugInfo(IntervalWalker iw, LIRInstruction op) { @@ -1983,7 +2053,7 @@ if (GraalOptions.TraceLinearScanLevel >= 3) { TTY.println("creating debug information at opId %d", opId); } - return computeFrameForState(state, opId, frameRefMap); + return new DebugFrameBuilder(state, opId, frameRefMap).build(); } private void assignLocations(List instructions, IntervalWalker iw) { diff -r 536b02e3cd2b -r 38792f959479 graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/debug/IdealGraphPrinterObserver.java --- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/debug/IdealGraphPrinterObserver.java Fri Jul 08 14:49:01 2011 +0200 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/debug/IdealGraphPrinterObserver.java Fri Jul 08 15:00:16 2011 +0200 @@ -109,7 +109,7 @@ return; } - printer = new IdealGraphPrinter(stream); + printer = new IdealGraphPrinter(new BufferedOutputStream(stream)); if (GraalOptions.OmitDOTFrameStates) { printer.addOmittedClass(FrameState.class); } diff -r 536b02e3cd2b -r 38792f959479 graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/gen/LIRGenerator.java --- a/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/gen/LIRGenerator.java Fri Jul 08 14:49:01 2011 +0200 +++ b/graal/com.oracle.max.graal.compiler/src/com/oracle/max/graal/compiler/gen/LIRGenerator.java Fri Jul 08 15:00:16 2011 +0200 @@ -39,9 +39,11 @@ import com.oracle.max.graal.compiler.graph.*; import com.oracle.max.graal.compiler.ir.*; import com.oracle.max.graal.compiler.ir.Deoptimize.DeoptAction; +import com.oracle.max.graal.compiler.ir.Phi.PhiType; import com.oracle.max.graal.compiler.lir.*; import com.oracle.max.graal.compiler.util.*; import com.oracle.max.graal.compiler.value.*; +import com.oracle.max.graal.compiler.value.FrameState.ValueProcedure; import com.oracle.max.graal.graph.*; import com.sun.cri.bytecode.Bytecodes.MemoryBarriers; import com.sun.cri.ci.*; @@ -239,11 +241,35 @@ TTY.println("BEGIN Generating LIR for block B" + block.blockID()); } - if (block.blockPredecessors().size() > 1) { + if (block == ir.startBlock) { + XirSnippet prologue = xir.genPrologue(null, compilation.method); + if (prologue != null) { + emitXir(prologue, null, null, null, false); + } + FrameState fs = setOperandsForLocals(); + if (GraalOptions.TraceLIRGeneratorLevel >= 2) { + TTY.println("STATE CHANGE (setOperandsForLocals)"); + if (GraalOptions.TraceLIRGeneratorLevel >= 3) { + TTY.println(fs.toString()); + } + } + lastState = fs; + } else if (block.blockPredecessors().size() > 1) { if (GraalOptions.TraceLIRGeneratorLevel >= 2) { TTY.println("STATE RESET"); } lastState = null; + } else if (block.blockPredecessors().size() == 1) { + LIRBlock pred = block.blockPredecessors().get(0); + FrameState fs = pred.lastState(); + assert fs != null : "block B" + block.blockID() + " pred block B" + pred.blockID(); + if (GraalOptions.TraceLIRGeneratorLevel >= 2) { + TTY.println("STATE CHANGE (singlePred)"); + if (GraalOptions.TraceLIRGeneratorLevel >= 3) { + TTY.println(fs.toString()); + } + } + lastState = fs; } for (Node instr : block.getInstructions()) { @@ -442,13 +468,13 @@ public void visitExceptionObject(ExceptionObject x) { XirSnippet snippet = xir.genExceptionObject(site(x)); emitXir(snippet, x, null, null, true); - lastState = lastState.duplicateWithException(lastState.bci, x); - if (GraalOptions.TraceLIRGeneratorLevel >= 2) { - TTY.println("STATE CHANGE (visitExceptionObject)"); - if (GraalOptions.TraceLIRGeneratorLevel >= 3) { - TTY.println(lastState.toString()); - } - } +// lastState = lastState.duplicateWithException(lastState.bci, x); +// if (GraalOptions.TraceLIRGeneratorLevel >= 2) { +// TTY.println("STATE CHANGE (visitExceptionObject)"); +// if (GraalOptions.TraceLIRGeneratorLevel >= 3) { +// TTY.println(lastState.toString()); +// } +// } } @Override @@ -478,12 +504,14 @@ } public void emitBooleanBranch(Node node, LIRBlock trueSuccessor, LIRBlock falseSuccessor, LIRDebugInfo info) { - if (node instanceof Compare) { + if (node instanceof NegateBooleanNode) { + emitBooleanBranch(((NegateBooleanNode) node).value(), falseSuccessor, trueSuccessor, info); + } else if (node instanceof Compare) { emitCompare((Compare) node, trueSuccessor, falseSuccessor); } else if (node instanceof InstanceOf) { emitInstanceOf((TypeCheck) node, trueSuccessor, falseSuccessor, info); - } else if (node instanceof NotInstanceOf) { - emitInstanceOf((TypeCheck) node, falseSuccessor, trueSuccessor, info); + } else if (node instanceof Constant) { + emitConstantBranch(((Constant) node).asConstant().asBoolean(), trueSuccessor, falseSuccessor, info); } else { throw Util.unimplemented(node.toString()); } @@ -498,6 +526,21 @@ instr.setFalseSuccessor(falseSuccessor); } + + public void emitConstantBranch(boolean value, LIRBlock trueSuccessorBlock, LIRBlock falseSuccessorBlock, LIRDebugInfo info) { + if (value) { + emitConstantBranch(trueSuccessorBlock, info); + } else { + emitConstantBranch(falseSuccessorBlock, info); + } + } + + private void emitConstantBranch(LIRBlock block, LIRDebugInfo info) { + if (block != null) { + lir.jump(block); + } + } + public void emitCompare(Compare compare, LIRBlock trueSuccessorBlock, LIRBlock falseSuccessorBlock) { CiKind kind = compare.x().kind; @@ -580,16 +623,11 @@ } protected FrameState stateBeforeInvokeReturn(Invoke invoke) { - return invoke.stateAfter().duplicateModified(getBeforeInvokeBci(invoke), invoke.stateAfter().rethrowException(), invoke.kind); + return invoke.stateAfter().duplicateModified(invoke.bci, invoke.stateAfter().rethrowException(), invoke.kind); } protected FrameState stateBeforeInvokeWithArguments(Invoke invoke) { - return invoke.stateAfter().duplicateModified(getBeforeInvokeBci(invoke), invoke.stateAfter().rethrowException(), invoke.kind, invoke.arguments().toArray(new Value[0])); - } - - private int getBeforeInvokeBci(Invoke invoke) { - // Cannot calculate BCI, because the invoke can have changed from e.g. invokeinterface to invokespecial because of optimizations. - return invoke.bci; + return invoke.stateAfter().duplicateModified(invoke.bci, invoke.stateAfter().rethrowException(), invoke.kind, invoke.arguments().toArray(new Value[0])); } @Override @@ -745,7 +783,7 @@ for (Node n : fixedGuard.inputs()) { if (n != null) { emitGuardComp((BooleanNode) n); - } + } } } @@ -763,19 +801,33 @@ XirSnippet typeCheck = xir.genTypeCheck(site(x), toXirArgument(x.object()), clazz, x.type()); emitXir(typeCheck, x, info, compilation.method, false); } else { - FrameState state = lastState; - assert state != null : "deoptimize instruction always needs a state"; - - if (deoptimizationStubs == null) { - deoptimizationStubs = new ArrayList(); + if (comp instanceof Constant && comp.asConstant().asBoolean()) { + // Nothing to emit. + } else { + DeoptimizationStub stub = createDeoptStub(); + emitBooleanBranch(comp, null, new LIRBlock(stub.label, stub.info), stub.info); } - DeoptimizationStub stub = new DeoptimizationStub(DeoptAction.InvalidateReprofile, state); - deoptimizationStubs.add(stub); - - emitBooleanBranch(comp, null, new LIRBlock(stub.label, stub.info), stub.info); } } + private DeoptimizationStub createDeoptStub() { + if (deoptimizationStubs == null) { + deoptimizationStubs = new ArrayList(); + } + + FrameState state = lastState; + assert state != null : "deoptimize instruction always needs a state"; + DeoptimizationStub stub = new DeoptimizationStub(DeoptAction.InvalidateReprofile, state); + deoptimizationStubs.add(stub); + return stub; + } + + public void deoptimizeOn(Condition cond) { + DeoptimizationStub stub = createDeoptStub(); + lir.branch(cond, stub.label, stub.info); + } + + @Override public void visitPhi(Phi i) { Util.shouldNotReachHere(); @@ -1062,30 +1114,6 @@ block.setLir(lir); lir.branchDestination(block.label()); - if (block == ir.startBlock) { - XirSnippet prologue = xir.genPrologue(null, compilation.method); - if (prologue != null) { - emitXir(prologue, null, null, null, false); - } - FrameState fs = setOperandsForLocals(); - if (GraalOptions.TraceLIRGeneratorLevel >= 2) { - TTY.println("STATE CHANGE (setOperandsForLocals)"); - if (GraalOptions.TraceLIRGeneratorLevel >= 3) { - TTY.println(fs.toString()); - } - } - lastState = fs; - } else if (block.blockPredecessors().size() == 1) { - FrameState fs = block.blockPredecessors().get(0).lastState(); - //assert fs != null : "B" + block.blockID() + ", pred=B" + block.blockPredecessors().get(0).blockID(); - if (GraalOptions.TraceLIRGeneratorLevel >= 2) { - TTY.println("STATE CHANGE (singlePred)"); - if (GraalOptions.TraceLIRGeneratorLevel >= 3) { - TTY.println(fs.toString()); - } - } - lastState = fs; - } } /** @@ -1097,7 +1125,7 @@ * @return the operand that is guaranteed to be a stack location when it is * initially defined a by move from {@code value} */ - CiValue forceToSpill(CiValue value, CiKind kind, boolean mustStayOnStack) { + public CiValue forceToSpill(CiValue value, CiKind kind, boolean mustStayOnStack) { assert value.isLegal() : "value should not be illegal"; assert kind.jvmSlots == value.kind.jvmSlots : "size mismatch"; if (!value.isVariableOrRegister()) { @@ -1212,7 +1240,7 @@ } } - protected void arithmeticOpInt(int code, CiValue result, CiValue left, CiValue right, CiValue tmp) { + public void arithmeticOpInt(int code, CiValue result, CiValue left, CiValue right, CiValue tmp) { CiValue leftOp = left; if (isTwoOperand && leftOp != result) { @@ -1252,7 +1280,7 @@ } } - protected void arithmeticOpLong(int code, CiValue result, CiValue left, CiValue right) { + public void arithmeticOpLong(int code, CiValue result, CiValue left, CiValue right) { CiValue leftOp = left; if (isTwoOperand && leftOp != result) { @@ -1487,6 +1515,9 @@ public void visitLoopEnd(LoopEnd x) { setNoResult(x); moveToPhi(x.loopBegin(), x); + if (GraalOptions.GenSafepoints) { + xir.genSafepoint(site(x)); + } lir.jump(getLIRBlock(x.loopBegin())); } @@ -1497,7 +1528,7 @@ int nextSuccIndex = merge.phiPredecessorIndex(pred); PhiResolver resolver = new PhiResolver(this); for (Phi phi : merge.phis()) { - if (!phi.isDead()) { + if (phi.type() == PhiType.Value) { Value curVal = phi.valueAt(nextSuccIndex); if (curVal != null && curVal != phi) { if (curVal instanceof Phi) { @@ -1559,7 +1590,7 @@ } private CiValue operandForPhi(Phi phi) { - assert !phi.isDead() : "dead phi: " + phi.id(); + assert phi.type() == PhiType.Value : "wrong phi type: " + phi.id(); if (phi.operand().isIllegal()) { // allocate a variable for this phi createResultVariable(phi); @@ -1581,7 +1612,7 @@ x.clearOperand(); } - protected CiValue setResult(Value x, CiVariable operand) { + public CiValue setResult(Value x, CiVariable operand) { x.setOperand(operand); if (GraalOptions.DetailedAsserts) { operands.recordResult(operand, x); @@ -1615,57 +1646,25 @@ } } - protected void walkState(Node x, FrameState state) { + protected void walkState(final Node x, FrameState state) { if (state == null) { return; } - walkState(x, state.outerFrameState()); - - for (int index = 0; index < state.stackSize(); index++) { - Value value = state.stackAt(index); - if (value != x) { - walkStateValue(value); - } - } - for (int index = 0; index < state.localsSize(); index++) { - final Value value = state.localAt(index); - if (value != null) { - if (!(value instanceof Phi && ((Phi) value).isDead())) { - walkStateValue(value); + state.forEachLiveStateValue(new ValueProcedure() { + public void doValue(Value value) { + if (value == x) { + // nothing to do, will be visited shortly + } else if (value instanceof Phi && ((Phi) value).type() == PhiType.Value) { + // phi's are special + operandForPhi((Phi) value); + } else if (value.operand().isIllegal()) { + // instruction doesn't have an operand yet + CiValue operand = makeOperand(value); + assert operand.isLegal() : "must be evaluated now"; } } - } - } - - private void walkStateValue(Value value) { - if (value != null) { - if (value instanceof VirtualObject) { - walkVirtualObject((VirtualObject) value); - } else if (value instanceof Phi && !((Phi) value).isDead()) { - // phi's are special - operandForPhi((Phi) value); - } else if (value.operand().isIllegal()) { - // instruction doesn't have an operand yet - CiValue operand = makeOperand(value); - assert operand.isLegal() : "must be evaluated now"; - } - } - } - - private void walkVirtualObject(VirtualObject value) { - if (value.input() instanceof Phi) { - assert !((Phi) value.input()).isDead(); - } - HashSet