# HG changeset patch # User Lukas Stadler # Date 1368717803 -7200 # Node ID 8e8ea20621e7e48e2f80dd08032f0f6aa0435dac # Parent e4d8c9b0578397ccb3fbccd239f6893ce701f238 simplify GraphBuilderPhase: append adds the node to the graph diff -r e4d8c9b05783 -r 8e8ea20621e7 graal/com.oracle.graal.java/src/com/oracle/graal/java/GraphBuilderPhase.java --- a/graal/com.oracle.graal.java/src/com/oracle/graal/java/GraphBuilderPhase.java Thu May 16 16:53:25 2013 +0200 +++ b/graal/com.oracle.graal.java/src/com/oracle/graal/java/GraphBuilderPhase.java Thu May 16 17:23:23 2013 +0200 @@ -305,7 +305,7 @@ * @param type the unresolved type of the constant */ protected void handleUnresolvedLoadConstant(JavaType type) { - append(currentGraph.add(new DeoptimizeNode(InvalidateRecompile, Unresolved))); + append(new DeoptimizeNode(InvalidateRecompile, Unresolved)); frameState.push(Kind.Object, appendConstant(Constant.NULL_OBJECT)); } @@ -314,7 +314,7 @@ * @param object the object value whose type is being checked against {@code type} */ protected void handleUnresolvedCheckCast(JavaType type, ValueNode object) { - append(currentGraph.add(new FixedGuardNode(currentGraph.unique(new IsNullNode(object)), Unresolved, InvalidateRecompile))); + append(new FixedGuardNode(currentGraph.unique(new IsNullNode(object)), Unresolved, InvalidateRecompile)); frameState.apush(appendConstant(Constant.NULL_OBJECT)); } @@ -325,8 +325,7 @@ protected void handleUnresolvedInstanceOf(JavaType type, ValueNode object) { BlockPlaceholderNode successor = currentGraph.add(new BlockPlaceholderNode()); DeoptimizeNode deopt = currentGraph.add(new DeoptimizeNode(InvalidateRecompile, Unresolved)); - IfNode ifNode = currentGraph.add(new IfNode(currentGraph.unique(new IsNullNode(object)), successor, deopt, 1)); - append(ifNode); + append(new IfNode(currentGraph.unique(new IsNullNode(object)), successor, deopt, 1)); lastInstr = successor; frameState.ipush(appendConstant(Constant.INT_0)); } @@ -335,7 +334,7 @@ * @param type the type being instantiated */ protected void handleUnresolvedNewInstance(JavaType type) { - append(currentGraph.add(new DeoptimizeNode(InvalidateRecompile, Unresolved))); + append(new DeoptimizeNode(InvalidateRecompile, Unresolved)); frameState.apush(appendConstant(Constant.NULL_OBJECT)); } @@ -344,7 +343,7 @@ * @param length the length of the array */ protected void handleUnresolvedNewObjectArray(JavaType type, ValueNode length) { - append(currentGraph.add(new DeoptimizeNode(InvalidateRecompile, Unresolved))); + append(new DeoptimizeNode(InvalidateRecompile, Unresolved)); frameState.apush(appendConstant(Constant.NULL_OBJECT)); } @@ -353,7 +352,7 @@ * @param dims the dimensions for the multi-array */ protected void handleUnresolvedNewMultiArray(JavaType type, ValueNode[] dims) { - append(currentGraph.add(new DeoptimizeNode(InvalidateRecompile, Unresolved))); + append(new DeoptimizeNode(InvalidateRecompile, Unresolved)); frameState.apush(appendConstant(Constant.NULL_OBJECT)); } @@ -363,7 +362,7 @@ */ protected void handleUnresolvedLoadField(JavaField field, ValueNode receiver) { Kind kind = field.getKind(); - append(currentGraph.add(new DeoptimizeNode(InvalidateRecompile, Unresolved))); + append(new DeoptimizeNode(InvalidateRecompile, Unresolved)); frameState.push(kind.getStackKind(), appendConstant(Constant.defaultForKind(kind))); } @@ -373,7 +372,7 @@ * @param receiver the object containing the field or {@code null} if {@code field} is static */ protected void handleUnresolvedStoreField(JavaField field, ValueNode value, ValueNode receiver) { - append(currentGraph.add(new DeoptimizeNode(InvalidateRecompile, Unresolved))); + append(new DeoptimizeNode(InvalidateRecompile, Unresolved)); } /** @@ -381,12 +380,12 @@ * @param type */ protected void handleUnresolvedExceptionType(Representation representation, JavaType type) { - append(currentGraph.add(new DeoptimizeNode(InvalidateRecompile, Unresolved))); + append(new DeoptimizeNode(InvalidateRecompile, Unresolved)); } protected void handleUnresolvedInvoke(JavaMethod javaMethod, InvokeKind invokeKind) { boolean withReceiver = invokeKind != InvokeKind.Static; - append(currentGraph.add(new DeoptimizeNode(InvalidateRecompile, Unresolved))); + append(new DeoptimizeNode(InvalidateRecompile, Unresolved)); frameState.popArguments(javaMethod.getSignature().getParameterSlots(withReceiver), javaMethod.getSignature().getParameterCount(withReceiver)); Kind kind = javaMethod.getSignature().getReturnKind(); if (kind != Kind.Void) { @@ -450,8 +449,7 @@ ValueNode index = frameState.ipop(); ValueNode array = frameState.apop(); - ValueNode v = append(currentGraph.add(new LoadIndexedNode(array, index, kind))); - frameState.push(kind.getStackKind(), v); + frameState.push(kind.getStackKind(), append(new LoadIndexedNode(array, index, kind))); } private void genStoreIndexed(Kind kind) { @@ -460,8 +458,7 @@ ValueNode value = frameState.pop(kind.getStackKind()); ValueNode index = frameState.ipop(); ValueNode array = frameState.apop(); - StoreIndexedNode result = currentGraph.add(new StoreIndexedNode(array, index, kind, value)); - append(result); + append(new StoreIndexedNode(array, index, kind, value)); } private void stackOp(int opcode) { @@ -586,8 +583,7 @@ default: throw new GraalInternalError("should not reach"); } - ValueNode result1 = append(currentGraph.unique(v)); - frameState.push(result, result1); + frameState.push(result, append(v)); } private void genIntegerDivOp(Kind result, int opcode) { @@ -606,12 +602,11 @@ default: throw new GraalInternalError("should not reach"); } - ValueNode result1 = append(currentGraph.add(v)); - frameState.push(result, result1); + frameState.push(result, append(v)); } private void genNegateOp(Kind kind) { - frameState.push(kind, append(currentGraph.unique(new NegateNode(frameState.pop(kind))))); + frameState.push(kind, append(new NegateNode(frameState.pop(kind)))); } private void genShiftOp(Kind kind, int opcode) { @@ -634,7 +629,7 @@ default: throw new GraalInternalError("should not reach"); } - frameState.push(kind, append(currentGraph.unique(v))); + frameState.push(kind, append(v)); } private void genLogicOp(Kind kind, int opcode) { @@ -657,18 +652,18 @@ default: throw new GraalInternalError("should not reach"); } - frameState.push(kind, append(currentGraph.unique(v))); + frameState.push(kind, append(v)); } private void genCompareOp(Kind kind, boolean isUnorderedLess) { ValueNode y = frameState.pop(kind); ValueNode x = frameState.pop(kind); - frameState.ipush(append(currentGraph.unique(new NormalizeCompareNode(x, y, isUnorderedLess)))); + frameState.ipush(append(new NormalizeCompareNode(x, y, isUnorderedLess))); } private void genConvert(ConvertNode.Op opcode) { ValueNode input = frameState.pop(opcode.from.getStackKind()); - frameState.push(opcode.to.getStackKind(), append(currentGraph.unique(new ConvertNode(opcode, input)))); + frameState.push(opcode.to.getStackKind(), append(new ConvertNode(opcode, input))); } private void genIncrement() { @@ -676,7 +671,7 @@ int delta = stream().readIncrement(); ValueNode x = frameState.loadLocal(index); ValueNode y = appendConstant(Constant.forInt(delta)); - frameState.storeLocal(index, append(currentGraph.unique(new IntegerAddNode(Kind.Int, x, y)))); + frameState.storeLocal(index, append(new IntegerAddNode(Kind.Int, x, y))); } private void genGoto() { @@ -726,7 +721,7 @@ AbstractBeginNode falseSuccessor = createBlockTarget(1 - probability, falseBlock, frameState); IfNode ifNode = negate ? new IfNode(condition, falseSuccessor, trueSuccessor, 1 - probability) : new IfNode(condition, trueSuccessor, falseSuccessor, probability); - append(currentGraph.add(ifNode)); + append(ifNode); } private void genIfZero(Condition cond) { @@ -750,9 +745,8 @@ private void genThrow() { ValueNode exception = frameState.apop(); - FixedGuardNode node = currentGraph.add(new FixedGuardNode(currentGraph.unique(new IsNullNode(exception)), NullCheckException, InvalidateReprofile, true)); - append(node); - append(handleException(exception, bci())); + append(new FixedGuardNode(currentGraph.unique(new IsNullNode(exception)), NullCheckException, InvalidateReprofile, true)); + lastInstr.setNext(handleException(exception, bci())); } private JavaType lookupType(int cpi, int bytecode) { @@ -804,9 +798,8 @@ ValueNode object = frameState.apop(); if (type instanceof ResolvedJavaType) { JavaTypeProfile profileForTypeCheck = getProfileForTypeCheck((ResolvedJavaType) type); - CheckCastNode checkCast = currentGraph.add(new CheckCastNode((ResolvedJavaType) type, object, profileForTypeCheck, false)); - append(checkCast); - frameState.apush(checkCast); + CheckCastNode checkCastNode = append(new CheckCastNode((ResolvedJavaType) type, object, profileForTypeCheck, false)); + frameState.apush(checkCastNode); } else { handleUnresolvedCheckCast(type, object); } @@ -819,8 +812,7 @@ if (type instanceof ResolvedJavaType) { ResolvedJavaType resolvedType = (ResolvedJavaType) type; InstanceOfNode instanceOfNode = new InstanceOfNode((ResolvedJavaType) type, object, getProfileForTypeCheck(resolvedType)); - ConditionalNode conditional = currentGraph.unique(new ConditionalNode(currentGraph.unique(instanceOfNode), ConstantNode.forInt(1, currentGraph), ConstantNode.forInt(0, currentGraph))); - frameState.ipush(append(conditional)); + frameState.ipush(append(new ConditionalNode(currentGraph.unique(instanceOfNode), ConstantNode.forInt(1, currentGraph), ConstantNode.forInt(0, currentGraph)))); } else { handleUnresolvedInstanceOf(type, object); } @@ -829,8 +821,7 @@ void genNewInstance(int cpi) { JavaType type = lookupType(cpi, NEW); if (type instanceof ResolvedJavaType && ((ResolvedJavaType) type).isInitialized()) { - NewInstanceNode n = currentGraph.add(new NewInstanceNode((ResolvedJavaType) type, true)); - frameState.apush(append(n)); + frameState.apush(append(new NewInstanceNode((ResolvedJavaType) type, true))); } else { handleUnresolvedNewInstance(type); } @@ -871,16 +862,14 @@ private void genNewPrimitiveArray(int typeCode) { Class clazz = arrayTypeCodeToClass(typeCode); ResolvedJavaType elementType = runtime.lookupJavaType(clazz); - NewArrayNode nta = currentGraph.add(new NewArrayNode(elementType, frameState.ipop(), true)); - frameState.apush(append(nta)); + frameState.apush(append(new NewArrayNode(elementType, frameState.ipop(), true))); } private void genNewObjectArray(int cpi) { JavaType type = lookupType(cpi, ANEWARRAY); ValueNode length = frameState.ipop(); if (type instanceof ResolvedJavaType) { - NewArrayNode n = currentGraph.add(new NewArrayNode((ResolvedJavaType) type, length, true)); - frameState.apush(append(n)); + frameState.apush(append(new NewArrayNode((ResolvedJavaType) type, length, true))); } else { handleUnresolvedNewObjectArray(type, length); } @@ -895,8 +884,7 @@ dims[i] = frameState.ipop(); } if (type instanceof ResolvedJavaType) { - FixedWithNextNode n = currentGraph.add(new NewMultiArrayNode((ResolvedJavaType) type, dims)); - frameState.apush(append(n)); + frameState.apush(append(new NewMultiArrayNode((ResolvedJavaType) type, dims))); } else { handleUnresolvedNewMultiArray(type, dims); } @@ -908,8 +896,7 @@ Kind kind = field.getKind(); ValueNode receiver = frameState.apop(); if ((field instanceof ResolvedJavaField) && ((ResolvedJavaField) field).getDeclaringClass().isInitialized()) { - LoadFieldNode load = currentGraph.add(new LoadFieldNode(receiver, (ResolvedJavaField) field)); - appendOptimizedLoadField(kind, load); + appendOptimizedLoadField(kind, new LoadFieldNode(receiver, (ResolvedJavaField) field)); } else { handleUnresolvedLoadField(field, receiver); } @@ -932,9 +919,7 @@ } BlockPlaceholderNode trueSucc = currentGraph.add(new BlockPlaceholderNode()); BlockPlaceholderNode falseSucc = currentGraph.add(new BlockPlaceholderNode()); - IfNode ifNode = currentGraph.add(new IfNode(currentGraph.unique(new IsNullNode(receiver)), trueSucc, falseSucc, 0.1)); - - append(ifNode); + append(new IfNode(currentGraph.unique(new IsNullNode(receiver)), trueSucc, falseSucc, 0.1)); lastInstr = falseSucc; if (GraalOptions.OmitHotExceptionStacktrace) { @@ -958,9 +943,7 @@ private void emitBoundsCheck(ValueNode index, ValueNode length) { BlockPlaceholderNode trueSucc = currentGraph.add(new BlockPlaceholderNode()); BlockPlaceholderNode falseSucc = currentGraph.add(new BlockPlaceholderNode()); - IfNode ifNode = currentGraph.add(new IfNode(currentGraph.unique(new IntegerBelowThanNode(index, length)), trueSucc, falseSucc, 0.9)); - - append(ifNode); + append(new IfNode(currentGraph.unique(new IntegerBelowThanNode(index, length)), trueSucc, falseSucc, 0.9)); lastInstr = trueSucc; if (GraalOptions.OmitHotExceptionStacktrace) { @@ -982,7 +965,7 @@ emitNullCheck(receiver); if (outOfBoundsIndex != null) { - ValueNode length = append(currentGraph.add(new ArrayLengthNode(receiver))); + ValueNode length = append(new ArrayLengthNode(receiver)); emitBoundsCheck(outOfBoundsIndex, length); } Debug.metric("ExplicitExceptions").increment(); @@ -994,8 +977,7 @@ ValueNode value = frameState.pop(field.getKind().getStackKind()); ValueNode receiver = frameState.apop(); if (field instanceof ResolvedJavaField && ((ResolvedJavaField) field).getDeclaringClass().isInitialized()) { - StoreFieldNode store = currentGraph.add(new StoreFieldNode(receiver, (ResolvedJavaField) field, value)); - appendOptimizedStoreField(store); + appendOptimizedStoreField(new StoreFieldNode(receiver, (ResolvedJavaField) field, value)); } else { handleUnresolvedStoreField(field, value, receiver); } @@ -1004,8 +986,7 @@ private void genGetStatic(JavaField field) { Kind kind = field.getKind(); if (field instanceof ResolvedJavaField && ((ResolvedJavaType) field.getDeclaringClass()).isInitialized()) { - LoadFieldNode load = currentGraph.add(new LoadFieldNode(null, (ResolvedJavaField) field)); - appendOptimizedLoadField(kind, load); + appendOptimizedLoadField(kind, new LoadFieldNode(null, (ResolvedJavaField) field)); } else { handleUnresolvedLoadField(field, null); } @@ -1014,8 +995,7 @@ private void genPutStatic(JavaField field) { ValueNode value = frameState.pop(field.getKind().getStackKind()); if (field instanceof ResolvedJavaField && ((ResolvedJavaType) field.getDeclaringClass()).isInitialized()) { - StoreFieldNode store = currentGraph.add(new StoreFieldNode(null, (ResolvedJavaField) field, value)); - appendOptimizedStoreField(store); + appendOptimizedStoreField(new StoreFieldNode(null, (ResolvedJavaField) field, value)); } else { handleUnresolvedStoreField(field, value, null); } @@ -1142,8 +1122,7 @@ private void appendInvoke(InvokeKind invokeKind, ResolvedJavaMethod targetMethod, ValueNode[] args) { Kind resultType = targetMethod.getSignature().getReturnKind(); if (GraalOptions.DeoptALot) { - DeoptimizeNode deoptimize = currentGraph.add(new DeoptimizeNode(DeoptimizationAction.None, RuntimeConstraint)); - append(deoptimize); + append(new DeoptimizeNode(DeoptimizationAction.None, RuntimeConstraint)); frameState.pushReturn(resultType, ConstantNode.defaultForKind(resultType, currentGraph)); return; } @@ -1164,15 +1143,12 @@ // be conservative if information was not recorded (could result in endless recompiles // otherwise) if (graphBuilderConfig.omitAllExceptionEdges() || (optimisticOpts.useExceptionProbability() && profilingInfo.getExceptionSeen(bci()) == TriState.FALSE)) { - InvokeNode invoke = new InvokeNode(callTarget, bci()); - ValueNode result = appendWithBCI(currentGraph.add(invoke)); - frameState.pushReturn(resultType, result); - return invoke; + frameState.pushReturn(resultType, append(new InvokeNode(callTarget, bci()))); + return new InvokeNode(callTarget, bci()); } else { DispatchBeginNode exceptionEdge = handleException(null, bci()); - InvokeWithExceptionNode invoke = currentGraph.add(new InvokeWithExceptionNode(callTarget, exceptionEdge, bci())); - ValueNode result = append(invoke); - frameState.pushReturn(resultType, result); + InvokeWithExceptionNode invoke = append(new InvokeWithExceptionNode(callTarget, exceptionEdge, bci())); + frameState.pushReturn(resultType, invoke); Block nextBlock = currentBlock.successors.get(0); assert bci() == currentBlock.endBci; @@ -1193,19 +1169,17 @@ } private MonitorEnterNode genMonitorEnter(ValueNode x) { - MonitorEnterNode monitorEnter = currentGraph.add(new MonitorEnterNode(x, frameState.lockDepth())); + MonitorEnterNode monitorEnter = append(new MonitorEnterNode(x, frameState.lockDepth())); frameState.pushLock(x); - appendWithBCI(monitorEnter); return monitorEnter; } private MonitorExitNode genMonitorExit(ValueNode x) { ValueNode lockedObject = frameState.popLock(); - MonitorExitNode monitorExit = currentGraph.add(new MonitorExitNode(x, frameState.lockDepth())); if (GraphUtil.originalValue(lockedObject) != GraphUtil.originalValue(x)) { throw new BailoutException("unbalanced monitors: mismatch at monitorexit, %s != %s", GraphUtil.originalValue(x), GraphUtil.originalValue(lockedObject)); } - appendWithBCI(monitorExit); + MonitorExitNode monitorExit = append(new MonitorExitNode(x, frameState.lockDepth())); return monitorExit; } @@ -1228,7 +1202,7 @@ ValueNode local = frameState.loadLocal(localIndex); JsrScope scope = currentBlock.jsrScope; int retAddress = scope.nextReturnAddress(); - append(currentGraph.add(new FixedGuardNode(currentGraph.unique(new IntegerEqualsNode(local, ConstantNode.forInt(retAddress, currentGraph))), JavaSubroutineMismatch, InvalidateReprofile))); + append(new FixedGuardNode(currentGraph.unique(new IntegerEqualsNode(local, ConstantNode.forInt(retAddress, currentGraph))), JavaSubroutineMismatch, InvalidateReprofile)); if (!successor.jsrScope.equals(scope.pop())) { throw new JsrNotSupportedBailout("unstructured control flow (ret leaves more than one scope)"); } @@ -1315,12 +1289,11 @@ } double[] successorProbabilities = successorProbabilites(actualSuccessors.size(), keySuccessors, keyProbabilities); - IntegerSwitchNode switchNode = currentGraph.add(new IntegerSwitchNode(value, actualSuccessors.size(), keys, keyProbabilities, keySuccessors)); + IntegerSwitchNode switchNode = append(new IntegerSwitchNode(value, actualSuccessors.size(), keys, keyProbabilities, keySuccessors)); for (int i = 0; i < actualSuccessors.size(); i++) { switchNode.setBlockSuccessor(i, createBlockTarget(successorProbabilities[i], actualSuccessors.get(i), frameState)); } - append(switchNode); } private static class SuccessorInfo { @@ -1339,27 +1312,37 @@ return ConstantNode.forConstant(constant, runtime, currentGraph); } - private ValueNode append(FixedNode fixed) { - lastInstr.setNext(fixed); + private T append(T fixed) { + assert !fixed.isAlive() && !fixed.isDeleted() : "instruction should not have been appended yet"; + assert lastInstr.next() == null : "cannot append instruction to instruction which isn't end (" + lastInstr + "->" + lastInstr.next() + ")"; + T added = currentGraph.add(fixed); + lastInstr.setNext(added); lastInstr = null; - return fixed; - } - - protected ValueNode append(FixedWithNextNode x) { - return appendWithBCI(x); + return added; } - private static ValueNode append(ValueNode v) { - assert !(v instanceof ConstantNode); - return v; + private T append(T fixed) { + assert !fixed.isAlive() && !fixed.isDeleted() : "instruction should not have been appended yet"; + assert lastInstr.next() == null : "cannot append instruction to instruction which isn't end (" + lastInstr + "->" + lastInstr.next() + ")"; + T added = currentGraph.add(fixed); + lastInstr.setNext(added); + lastInstr = null; + return added; } - protected ValueNode appendWithBCI(FixedWithNextNode x) { - assert x.predecessor() == null : "instruction should not have been appended yet"; + protected T append(T fixed) { + assert !fixed.isAlive() && !fixed.isDeleted() : "instruction should not have been appended yet"; assert lastInstr.next() == null : "cannot append instruction to instruction which isn't end (" + lastInstr + "->" + lastInstr.next() + ")"; - lastInstr.setNext(x); - lastInstr = x; - return x; + T added = currentGraph.add(fixed); + lastInstr.setNext(added); + lastInstr = added; + return added; + } + + private T append(T v) { + assert !(v instanceof ConstantNode); + T added = currentGraph.unique(v); + return added; } private static class Target { @@ -1591,11 +1574,9 @@ private void createUnwind() { assert frameState.stackSize() == 1 : frameState; ValueNode exception = frameState.apop(); - FixedGuardNode guard = currentGraph.add(new FixedGuardNode(currentGraph.unique(new IsNullNode(exception)), NullCheckException, InvalidateReprofile, true)); - append(guard); + append(new FixedGuardNode(currentGraph.unique(new IsNullNode(exception)), NullCheckException, InvalidateReprofile, true)); synchronizedEpilogue(FrameState.AFTER_EXCEPTION_BCI); - UnwindNode unwindNode = currentGraph.add(new UnwindNode(exception)); - append(unwindNode); + append(new UnwindNode(exception)); } private void createReturn() { @@ -1604,7 +1585,7 @@ assert frameState.stackSize() == 0; if (Modifier.isSynchronized(method.getModifiers())) { - append(currentGraph.add(new ValueAnchorNode(true, x))); + append(new ValueAnchorNode(true, x)); assert !frameState.rethrowException(); } @@ -1612,15 +1593,13 @@ if (frameState.lockDepth() != 0) { throw new BailoutException("unbalanced monitors"); } - ReturnNode returnNode = currentGraph.add(new ReturnNode(x)); if (graphBuilderConfig.eagerInfopointMode()) { - InfopointNode ipn = currentGraph.add(new InfopointNode(InfopointReason.METHOD_END)); + InfopointNode ipn = append(new InfopointNode(InfopointReason.METHOD_END)); ipn.setStateAfter(frameState.create(FrameState.AFTER_BCI)); - append(ipn); } - append(returnNode); + append(new ReturnNode(x)); } private void synchronizedEpilogue(int bci) { @@ -1666,8 +1645,7 @@ frameState.push(Kind.Object, exception); FixedNode nextDispatch = createTarget(nextBlock, frameState); checkCast.setNext(catchSuccessor); - IfNode ifNode = currentGraph.add(new IfNode(currentGraph.unique(new InstanceOfNode((ResolvedJavaType) catchType, exception, null)), checkCast, nextDispatch, 0.5)); - append(ifNode); + append(new IfNode(currentGraph.unique(new InstanceOfNode((ResolvedJavaType) catchType, exception, null)), checkCast, nextDispatch, 0.5)); } } @@ -1733,9 +1711,8 @@ if (graphBuilderConfig.eagerInfopointMode() && lnt != null) { currentLineNumber = lnt.getLineNumber(bci); if (currentLineNumber != previousLineNumber) { - InfopointNode ipn = currentGraph.add(new InfopointNode(InfopointReason.LINE_NUMBER)); + InfopointNode ipn = append(new InfopointNode(InfopointReason.LINE_NUMBER)); ipn.setStateAfter(frameState.create(bci)); - append(ipn); previousLineNumber = currentLineNumber; } } @@ -2038,6 +2015,6 @@ } private void genArrayLength() { - frameState.ipush(append(currentGraph.add(new ArrayLengthNode(frameState.apop())))); + frameState.ipush(append(new ArrayLengthNode(frameState.apop()))); } }