# HG changeset patch # User Doug Simon # Date 1340098710 -7200 # Node ID d05664608cb71b895cf6ab04095a900453866ef0 # Parent 8d420cfd2a6f1cd3b65e166a1378e6303dc70edd# Parent 419df70cc6a2a1f600f246815d9b9e73e6811e86 Merge. diff -r 8d420cfd2a6f -r d05664608cb7 graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/DebugInfoBuilder.java --- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/DebugInfoBuilder.java Tue Jun 19 11:37:39 2012 +0200 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/DebugInfoBuilder.java Tue Jun 19 11:38:30 2012 +0200 @@ -82,7 +82,7 @@ VirtualObjectState currentField = objectStates.get(vobj); assert currentField != null; for (int i = 0; i < vobj.fieldsCount(); i++) { - values[i] = toCiValue(currentField.fields().get(i)); + values[i] = toCiValue(currentField.fieldValues().get(i)); } } } @@ -100,7 +100,7 @@ private BytecodeFrame computeFrameForState(FrameState state, LockScope locks, long leafGraphId) { int numLocals = state.localsSize(); int numStack = state.stackSize(); - int numLocks = (locks != null && locks.callerState == state.outerFrameState()) ? locks.stateDepth + 1 : 0; + int numLocks = (locks != null && locks.inliningIdentifier == state.inliningIdentifier()) ? locks.stateDepth + 1 : 0; Value[] values = new Value[numLocals + numStack + numLocks]; for (int i = 0; i < numLocals; i++) { @@ -112,7 +112,7 @@ LockScope nextLock = locks; for (int i = numLocks - 1; i >= 0; i--) { - assert locks != null && nextLock.callerState == state.outerFrameState() && nextLock.stateDepth == i; + assert locks != null && nextLock.inliningIdentifier == state.inliningIdentifier() && nextLock.stateDepth == i; Value owner = toCiValue(nextLock.monitor.object()); Value lockData = nextLock.lockData; @@ -153,7 +153,7 @@ } else if (value != null) { Debug.metric("StateVariables").increment(); Value operand = nodeOperands.get(value); - assert operand != null && (operand instanceof Variable || operand instanceof Constant); + assert operand != null && (operand instanceof Variable || operand instanceof Constant) : operand; return operand; } else { diff -r 8d420cfd2a6f -r d05664608cb7 graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/LIRGenerator.java --- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/LIRGenerator.java Tue Jun 19 11:37:39 2012 +0200 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/LIRGenerator.java Tue Jun 19 11:38:30 2012 +0200 @@ -45,6 +45,7 @@ import com.oracle.graal.lir.StandardOp.PhiLabelOp; import com.oracle.graal.lir.cfg.*; import com.oracle.graal.nodes.*; +import com.oracle.graal.nodes.FrameState.InliningIdentifier; import com.oracle.graal.nodes.PhiNode.PhiType; import com.oracle.graal.nodes.calc.*; import com.oracle.graal.nodes.extended.*; @@ -94,12 +95,10 @@ public final LockScope outer; /** - * The frame state of the caller of the method performing the lock, or null if the outermost method + * The identifier of the actual inlined method instance performing the lock, or null if the outermost method * performs the lock. This information is used to compute the {@link BytecodeFrame} that this lock belongs to. - * We cannot use the actual frame state of the locking method, because it is not unique for a method. The - * caller frame states are unique, i.e., all frame states of inlined methods refer to the same caller frame state. */ - public final FrameState callerState; + public final InliningIdentifier inliningIdentifier; /** * The number of locks already found for this frame state. @@ -116,12 +115,12 @@ */ public final StackSlot lockData; - public LockScope(LockScope outer, FrameState callerState, MonitorEnterNode monitor, StackSlot lockData) { + public LockScope(LockScope outer, InliningIdentifier inliningIdentifier, MonitorEnterNode monitor, StackSlot lockData) { this.outer = outer; - this.callerState = callerState; + this.inliningIdentifier = inliningIdentifier; this.monitor = monitor; this.lockData = lockData; - if (outer != null && outer.callerState == callerState) { + if (outer != null && outer.inliningIdentifier == inliningIdentifier) { this.stateDepth = outer.stateDepth + 1; } else { this.stateDepth = 0; @@ -539,7 +538,7 @@ if (x.eliminated()) { // No code is emitted for eliminated locks, but for proper debug information generation we need to // register the monitor and its lock data. - curLocks = new LockScope(curLocks, x.stateAfter().outerFrameState(), x, lockData); + curLocks = new LockScope(curLocks, x.stateAfter().inliningIdentifier(), x, lockData); return; } @@ -548,7 +547,7 @@ LIRDebugInfo stateBefore = state(); // The state before the monitor enter is used for null checks, so it must not contain the newly locked object. - curLocks = new LockScope(curLocks, x.stateAfter().outerFrameState(), x, lockData); + curLocks = new LockScope(curLocks, x.stateAfter().inliningIdentifier(), x, lockData); // The state after the monitor enter is used for deoptimization, after the monitor has blocked, so it must contain the newly locked object. LIRDebugInfo stateAfter = stateFor(x.stateAfter(), -1); diff -r 8d420cfd2a6f -r d05664608cb7 graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/util/InliningUtil.java --- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/util/InliningUtil.java Tue Jun 19 11:37:39 2012 +0200 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/util/InliningUtil.java Tue Jun 19 11:38:30 2012 +0200 @@ -35,6 +35,7 @@ import com.oracle.graal.debug.*; import com.oracle.graal.graph.*; import com.oracle.graal.nodes.*; +import com.oracle.graal.nodes.FrameState.*; import com.oracle.graal.nodes.calc.*; import com.oracle.graal.nodes.extended.*; import com.oracle.graal.nodes.java.*; @@ -190,7 +191,7 @@ ReadHubNode objectClass = graph.add(new ReadHubNode(receiver)); IsTypeNode isTypeNode = graph.unique(new IsTypeNode(objectClass, type)); FixedGuardNode guard = graph.add(new FixedGuardNode(isTypeNode, DeoptimizationReason.TypeCheckedInliningViolated, DeoptimizationAction.InvalidateReprofile, invoke.leafGraphId())); - AnchorNode anchor = graph.add(new AnchorNode()); + ValueAnchorNode anchor = graph.add(new ValueAnchorNode()); assert invoke.predecessor() != null; ValueNode anchoredReceiver = createAnchoredReceiver(graph, anchor, type, receiver); @@ -771,6 +772,7 @@ * @param receiverNullCheck true if a null check needs to be generated for non-static inlinings, false if no such check is required */ public static void inline(Invoke invoke, StructuredGraph inlineGraph, boolean receiverNullCheck) { + InliningIdentifier identifier = new InliningIdentifier(inlineGraph.method(), invoke.toString()); NodeInputList parameters = invoke.callTarget().arguments(); StructuredGraph graph = (StructuredGraph) invoke.node().graph(); @@ -874,6 +876,7 @@ outerFrameState.setDuringCall(true); } frameState.setOuterFrameState(outerFrameState); + frameState.setInliningIdentifier(identifier); } } } diff -r 8d420cfd2a6f -r d05664608cb7 graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/snippets/ArrayCopySnippets.java --- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/snippets/ArrayCopySnippets.java Tue Jun 19 11:37:39 2012 +0200 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/snippets/ArrayCopySnippets.java Tue Jun 19 11:38:30 2012 +0200 @@ -28,11 +28,43 @@ import com.oracle.graal.nodes.spi.*; import com.oracle.graal.nodes.type.*; import com.oracle.graal.snippets.*; +import com.oracle.graal.snippets.Snippet.ConstantParameter; import com.oracle.graal.snippets.Snippet.Fold; @SuppressWarnings("unused") public class ArrayCopySnippets implements SnippetsInterface{ + private static final Kind VECTOR_KIND = Kind.Long; + private static final long VECTOR_SIZE = arrayIndexScale(Kind.Long); + + //@Snippet + public static void vectorizedCopy(Object src, int srcPos, Object dest, int destPos, int length, @ConstantParameter("baseKind") Kind baseKind) { + int header = arrayBaseOffset(baseKind); + long byteLength = length * arrayIndexScale(baseKind); + long nonVectorBytes = byteLength % VECTOR_SIZE; + long srcOffset = srcPos * arrayIndexScale(baseKind); + long destOffset = destPos * arrayIndexScale(baseKind); + if (src == dest && srcPos < destPos) { // bad aliased case + for (long i = byteLength - 1; i > byteLength - 1 - nonVectorBytes; i--) { + Byte a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Byte); + UnsafeStoreNode.store(dest, header, i + destOffset, a.byteValue(), Kind.Byte); + } + long vectorLength = byteLength - nonVectorBytes; + for (long i = vectorLength - VECTOR_SIZE; i >= 0; i -= VECTOR_SIZE) { + Long a = UnsafeLoadNode.load(src, header, i + srcOffset, VECTOR_KIND); + UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), VECTOR_KIND); + } + } else { + for (long i = 0; i < nonVectorBytes; i++) { + Byte a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Byte); + UnsafeStoreNode.store(dest, header, i + destOffset, a.byteValue(), Kind.Byte); + } + for (long i = nonVectorBytes; i < byteLength; i += VECTOR_SIZE) { + Long a = UnsafeLoadNode.load(src, header, i + srcOffset, VECTOR_KIND); + UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), VECTOR_KIND); + } + } + } @Snippet public static void arraycopy(byte[] src, int srcPos, byte[] dest, int destPos, int length) { @@ -42,34 +74,30 @@ if (srcPos < 0 || destPos < 0 || length < 0 || srcPos + length > src.length || destPos + length > dest.length) { throw new IndexOutOfBoundsException(); } - + Kind baseKind = Kind.Byte; + int header = arrayBaseOffset(baseKind); + long byteLength = length * arrayIndexScale(baseKind); + long nonVectorBytes = byteLength % VECTOR_SIZE; + long srcOffset = srcPos * arrayIndexScale(baseKind); + long destOffset = destPos * arrayIndexScale(baseKind); if (src == dest && srcPos < destPos) { // bad aliased case - if ((length & 0x01) == 0) { - if ((length & 0x02) == 0) { - if ((length & 0x04) == 0) { - copyLongsDown(src, srcPos, dest, destPos, length >> 3); - } else { - copyIntsDown(src, srcPos, dest, destPos, length >> 2); - } - } else { - copyShortsDown(src, srcPos, dest, destPos, length >> 1); - } - } else { - copyBytesDown(src, srcPos, dest, destPos, length); + for (long i = byteLength - 1; i > byteLength - 1 - nonVectorBytes; i--) { + Byte a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Byte); + UnsafeStoreNode.store(dest, header, i + destOffset, a.byteValue(), Kind.Byte); + } + long vectorLength = byteLength - nonVectorBytes; + for (long i = vectorLength - VECTOR_SIZE; i >= 0; i -= VECTOR_SIZE) { + Long a = UnsafeLoadNode.load(src, header, i + srcOffset, VECTOR_KIND); + UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), VECTOR_KIND); } } else { - if ((length & 0x01) == 0) { - if ((length & 0x02) == 0) { - if ((length & 0x04) == 0) { - copyLongsUp(src, srcPos, dest, destPos, length >> 3); - } else { - copyIntsUp(src, srcPos, dest, destPos, length >> 2); - } - } else { - copyShortsUp(src, srcPos, dest, destPos, length >> 1); - } - } else { - copyBytesUp(src, srcPos, dest, destPos, length); + for (long i = 0; i < nonVectorBytes; i++) { + Byte a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Byte); + UnsafeStoreNode.store(dest, header, i + destOffset, a.byteValue(), Kind.Byte); + } + for (long i = nonVectorBytes; i < byteLength; i += VECTOR_SIZE) { + Long a = UnsafeLoadNode.load(src, header, i + srcOffset, VECTOR_KIND); + UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), VECTOR_KIND); } } } @@ -82,25 +110,30 @@ if (srcPos < 0 || destPos < 0 || length < 0 || srcPos + length > src.length || destPos + length > dest.length) { throw new IndexOutOfBoundsException(); } + Kind baseKind = Kind.Char; + int header = arrayBaseOffset(baseKind); + long byteLength = length * arrayIndexScale(baseKind); + long nonVectorBytes = byteLength % VECTOR_SIZE; + long srcOffset = srcPos * arrayIndexScale(baseKind); + long destOffset = destPos * arrayIndexScale(baseKind); if (src == dest && srcPos < destPos) { // bad aliased case - if ((length & 0x01) == 0) { - if ((length & 0x02) == 0) { - copyLongsDown(src, srcPos * 2L, dest, destPos * 2L, length >> 2); - } else { - copyIntsDown(src, srcPos * 2L, dest, destPos * 2L, length >> 1); - } - } else { - copyShortsDown(src, srcPos * 2L, dest, destPos * 2L, length); + for (long i = byteLength - 1; i > byteLength - 1 - nonVectorBytes; i--) { + Byte a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Byte); + UnsafeStoreNode.store(dest, header, i + destOffset, a.byteValue(), Kind.Byte); + } + long vectorLength = byteLength - nonVectorBytes; + for (long i = vectorLength - VECTOR_SIZE; i >= 0; i -= VECTOR_SIZE) { + Long a = UnsafeLoadNode.load(src, header, i + srcOffset, VECTOR_KIND); + UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), VECTOR_KIND); } } else { - if ((length & 0x01) == 0) { - if ((length & 0x02) == 0) { - copyLongsUp(src, srcPos * 2L, dest, destPos * 2L, length >> 2); - } else { - copyIntsUp(src, srcPos * 2L, dest, destPos * 2L, length >> 1); - } - } else { - copyShortsUp(src, srcPos * 2L, dest, destPos * 2L, length); + for (long i = 0; i < nonVectorBytes; i++) { + Byte a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Byte); + UnsafeStoreNode.store(dest, header, i + destOffset, a.byteValue(), Kind.Byte); + } + for (long i = nonVectorBytes; i < byteLength; i += VECTOR_SIZE) { + Long a = UnsafeLoadNode.load(src, header, i + srcOffset, VECTOR_KIND); + UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), VECTOR_KIND); } } } @@ -113,25 +146,30 @@ if (srcPos < 0 || destPos < 0 || length < 0 || srcPos + length > src.length || destPos + length > dest.length) { throw new IndexOutOfBoundsException(); } + Kind baseKind = Kind.Short; + int header = arrayBaseOffset(baseKind); + long byteLength = length * arrayIndexScale(baseKind); + long nonVectorBytes = byteLength % VECTOR_SIZE; + long srcOffset = srcPos * arrayIndexScale(baseKind); + long destOffset = destPos * arrayIndexScale(baseKind); if (src == dest && srcPos < destPos) { // bad aliased case - if ((length & 0x01) == 0) { - if ((length & 0x02) == 0) { - copyLongsDown(src, srcPos * 2L, dest, destPos * 2L, length >> 2); - } else { - copyIntsDown(src, srcPos * 2L, dest, destPos * 2L, length >> 1); - } - } else { - copyShortsDown(src, srcPos * 2L, dest, destPos * 2L, length); + for (long i = byteLength - 1; i > byteLength - 1 - nonVectorBytes; i--) { + Byte a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Byte); + UnsafeStoreNode.store(dest, header, i + destOffset, a.byteValue(), Kind.Byte); + } + long vectorLength = byteLength - nonVectorBytes; + for (long i = vectorLength - VECTOR_SIZE; i >= 0; i -= VECTOR_SIZE) { + Long a = UnsafeLoadNode.load(src, header, i + srcOffset, VECTOR_KIND); + UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), VECTOR_KIND); } } else { - if ((length & 0x01) == 0) { - if ((length & 0x02) == 0) { - copyLongsUp(src, srcPos * 2L, dest, destPos * 2L, length >> 2); - } else { - copyIntsUp(src, srcPos * 2L, dest, destPos * 2L, length >> 1); - } - } else { - copyShortsUp(src, srcPos * 2L, dest, destPos * 2L, length); + for (long i = 0; i < nonVectorBytes; i++) { + Byte a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Byte); + UnsafeStoreNode.store(dest, header, i + destOffset, a.byteValue(), Kind.Byte); + } + for (long i = nonVectorBytes; i < byteLength; i += VECTOR_SIZE) { + Long a = UnsafeLoadNode.load(src, header, i + srcOffset, VECTOR_KIND); + UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), VECTOR_KIND); } } } @@ -144,17 +182,30 @@ if (srcPos < 0 || destPos < 0 || length < 0 || srcPos + length > src.length || destPos + length > dest.length) { throw new IndexOutOfBoundsException(); } + Kind baseKind = Kind.Int; + int header = arrayBaseOffset(baseKind); + long byteLength = length * arrayIndexScale(baseKind); + long nonVectorBytes = byteLength % VECTOR_SIZE; + long srcOffset = srcPos * arrayIndexScale(baseKind); + long destOffset = destPos * arrayIndexScale(baseKind); if (src == dest && srcPos < destPos) { // bad aliased case - if ((length & 0x01) == 0) { - copyLongsDown(src, srcPos * 4L, dest, destPos * 4L, length >> 1); - } else { - copyIntsDown(src, srcPos * 4L, dest, destPos * 4L, length); + for (long i = byteLength - 1; i > byteLength - 1 - nonVectorBytes; i--) { + Byte a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Byte); + UnsafeStoreNode.store(dest, header, i + destOffset, a.byteValue(), Kind.Byte); + } + long vectorLength = byteLength - nonVectorBytes; + for (long i = vectorLength - VECTOR_SIZE; i >= 0; i -= VECTOR_SIZE) { + Long a = UnsafeLoadNode.load(src, header, i + srcOffset, VECTOR_KIND); + UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), VECTOR_KIND); } } else { - if ((length & 0x01) == 0) { - copyLongsUp(src, srcPos * 4L, dest, destPos * 4L, length >> 1); - } else { - copyIntsUp(src, srcPos * 4L, dest, destPos * 4L, length); + for (long i = 0; i < nonVectorBytes; i++) { + Byte a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Byte); + UnsafeStoreNode.store(dest, header, i + destOffset, a.byteValue(), Kind.Byte); + } + for (long i = nonVectorBytes; i < byteLength; i += VECTOR_SIZE) { + Long a = UnsafeLoadNode.load(src, header, i + srcOffset, VECTOR_KIND); + UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), VECTOR_KIND); } } } @@ -167,17 +218,30 @@ if (srcPos < 0 || destPos < 0 || length < 0 || srcPos + length > src.length || destPos + length > dest.length) { throw new IndexOutOfBoundsException(); } + Kind baseKind = Kind.Float; + int header = arrayBaseOffset(baseKind); + long byteLength = length * arrayIndexScale(baseKind); + long nonVectorBytes = byteLength % VECTOR_SIZE; + long srcOffset = srcPos * arrayIndexScale(baseKind); + long destOffset = destPos * arrayIndexScale(baseKind); if (src == dest && srcPos < destPos) { // bad aliased case - if ((length & 0x01) == 0) { - copyLongsDown(src, srcPos * 4L, dest, destPos * 4L, length >> 1); - } else { - copyIntsDown(src, srcPos * 4L, dest, destPos * 4L, length); + for (long i = byteLength - 1; i > byteLength - 1 - nonVectorBytes; i--) { + Byte a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Byte); + UnsafeStoreNode.store(dest, header, i + destOffset, a.byteValue(), Kind.Byte); + } + long vectorLength = byteLength - nonVectorBytes; + for (long i = vectorLength - VECTOR_SIZE; i >= 0; i -= VECTOR_SIZE) { + Long a = UnsafeLoadNode.load(src, header, i + srcOffset, VECTOR_KIND); + UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), VECTOR_KIND); } } else { - if ((length & 0x01) == 0) { - copyLongsUp(src, srcPos * 4L, dest, destPos * 4L, length >> 1); - } else { - copyIntsUp(src, srcPos * 4L, dest, destPos * 4L, length); + for (long i = 0; i < nonVectorBytes; i++) { + Byte a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Byte); + UnsafeStoreNode.store(dest, header, i + destOffset, a.byteValue(), Kind.Byte); + } + for (long i = nonVectorBytes; i < byteLength; i += VECTOR_SIZE) { + Long a = UnsafeLoadNode.load(src, header, i + srcOffset, VECTOR_KIND); + UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), VECTOR_KIND); } } } @@ -190,10 +254,21 @@ if (srcPos < 0 || destPos < 0 || length < 0 || srcPos + length > src.length || destPos + length > dest.length) { throw new IndexOutOfBoundsException(); } + Kind baseKind = Kind.Long; + int header = arrayBaseOffset(baseKind); + long byteLength = length * arrayIndexScale(baseKind); + long srcOffset = srcPos * arrayIndexScale(baseKind); + long destOffset = destPos * arrayIndexScale(baseKind); if (src == dest && srcPos < destPos) { // bad aliased case - copyLongsDown(src, srcPos * 8L, dest, destPos * 8L, length); + for (long i = byteLength - VECTOR_SIZE; i >= 0; i -= VECTOR_SIZE) { + Long a = UnsafeLoadNode.load(src, header, i + srcOffset, VECTOR_KIND); + UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), VECTOR_KIND); + } } else { - copyLongsUp(src, srcPos * 8L, dest, destPos * 8L, length); + for (long i = 0; i < byteLength; i += VECTOR_SIZE) { + Long a = UnsafeLoadNode.load(src, header, i + srcOffset, VECTOR_KIND); + UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), VECTOR_KIND); + } } } @@ -205,10 +280,21 @@ if (srcPos < 0 || destPos < 0 || length < 0 || srcPos + length > src.length || destPos + length > dest.length) { throw new IndexOutOfBoundsException(); } + Kind baseKind = Kind.Double; + int header = arrayBaseOffset(baseKind); + long byteLength = length * arrayIndexScale(baseKind); + long srcOffset = srcPos * arrayIndexScale(baseKind); + long destOffset = destPos * arrayIndexScale(baseKind); if (src == dest && srcPos < destPos) { // bad aliased case - copyLongsDown(src, srcPos * 8L, dest, destPos * 8L, length); + for (long i = byteLength - VECTOR_SIZE; i >= 0; i -= VECTOR_SIZE) { + Long a = UnsafeLoadNode.load(src, header, i + srcOffset, VECTOR_KIND); + UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), VECTOR_KIND); + } } else { - copyLongsUp(src, srcPos * 8L, dest, destPos * 8L, length); + for (long i = 0; i < byteLength; i += VECTOR_SIZE) { + Long a = UnsafeLoadNode.load(src, header, i + srcOffset, VECTOR_KIND); + UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), VECTOR_KIND); + } } } @@ -241,42 +327,6 @@ } } - @Snippet - public static void copyBytesDown(Object src, int srcPos, Object dest, int destPos, int length) { - int header = arrayBaseOffset(Kind.Byte); - for (long i = length - 1; i >= 0; i--) { - Byte a = UnsafeLoadNode.load(src, header, i + srcPos, Kind.Byte); - UnsafeStoreNode.store(dest, header, i + destPos, a.byteValue(), Kind.Byte); - } - } - - @Snippet - public static void copyShortsDown(Object src, long srcOffset, Object dest, long destOffset, int length) { - int header = arrayBaseOffset(Kind.Short); - for (long i = (length - 1) * 2; i >= 0; i -= 2) { - Character a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Short); - UnsafeStoreNode.store(dest, header, i + destOffset, a.charValue(), Kind.Short); - } - } - - @Snippet - public static void copyIntsDown(Object src, long srcOffset, Object dest, long destOffset, int length) { - int header = arrayBaseOffset(Kind.Int); - for (long i = (length - 1) * 4; i >= 0; i -= 4) { - Integer a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Int); - UnsafeStoreNode.store(dest, header, i + destOffset, a.intValue(), Kind.Int); - } - } - - @Snippet - public static void copyLongsDown(Object src, long srcOffset, Object dest, long destOffset, int length) { - int header = arrayBaseOffset(Kind.Long); - for (long i = (length - 1) * 8; i >= 0; i -= 8) { - Long a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Long); - UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), Kind.Long); - } - } - // Does NOT perform store checks @Snippet public static void copyObjectsDown(Object src, long srcOffset, Object dest, long destOffset, int length) { @@ -287,57 +337,6 @@ DirectObjectStoreNode.store(dest, header, i + destOffset, a); } } - /** - * Copies {@code length} bytes from {@code src} starting at {@code srcPos} to {@code dest} starting at {@code destPos}. - * @param src source object - * @param srcPos source offset - * @param dest destination object - * @param destPos destination offset - * @param length number of bytes to copy - */ - @Snippet - public static void copyBytesUp(Object src, int srcPos, Object dest, int destPos, int length) { - int header = arrayBaseOffset(Kind.Byte); - for (long i = 0; i < length; i++) { - Byte a = UnsafeLoadNode.load(src, header, i + srcPos, Kind.Byte); - UnsafeStoreNode.store(dest, header, i + destPos, a.byteValue(), Kind.Byte); - } - } - - /** - * Copies {@code length} shorts from {@code src} starting at offset {@code srcOffset} (in bytes) to {@code dest} starting at offset {@code destOffset} (in bytes). - * @param src - * @param srcOffset (in bytes) - * @param dest - * @param destOffset (in bytes) - * @param length (in shorts) - */ - @Snippet - public static void copyShortsUp(Object src, long srcOffset, Object dest, long destOffset, int length) { - int header = arrayBaseOffset(Kind.Short); - for (long i = 0; i < length * 2L; i += 2) { - Character a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Short); - UnsafeStoreNode.store(dest, header, i + destOffset, a.charValue(), Kind.Short); - } - } - - @Snippet - public static void copyIntsUp(Object src, long srcOffset, Object dest, long destOffset, int length) { - int header = arrayBaseOffset(Kind.Int); - for (long i = 0; i < length * 4L; i += 4) { - Integer a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Int); - UnsafeStoreNode.store(dest, header, i + destOffset, a.intValue(), Kind.Int); - } - } - - @Snippet - public static void copyLongsUp(Object src, long srcOffset, Object dest, long destOffset, int length) { - int header = arrayBaseOffset(Kind.Long); - for (long i = 0; i < length * 8L; i += 8) { - Long a = UnsafeLoadNode.load(src, header, i + srcOffset, Kind.Long); - UnsafeStoreNode.store(dest, header, i + destOffset, a.longValue(), Kind.Long); - } - } // Does NOT perform store checks @Snippet diff -r 8d420cfd2a6f -r d05664608cb7 graal/com.oracle.graal.java/src/com/oracle/graal/java/FrameStateBuilder.java --- a/graal/com.oracle.graal.java/src/com/oracle/graal/java/FrameStateBuilder.java Tue Jun 19 11:37:39 2012 +0200 +++ b/graal/com.oracle.graal.java/src/com/oracle/graal/java/FrameStateBuilder.java Tue Jun 19 11:38:30 2012 +0200 @@ -116,7 +116,7 @@ } public FrameState create(int bci) { - return graph.add(new FrameState(method, bci, locals, stack, stackSize, rethrowException, false)); + return graph.add(new FrameState(method, bci, locals, stack, stackSize, rethrowException, false, null)); } public FrameStateBuilder copy() { diff -r 8d420cfd2a6f -r d05664608cb7 graal/com.oracle.graal.jtt/src/com/oracle/graal/jtt/optimize/ArrayCopy04.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.jtt/src/com/oracle/graal/jtt/optimize/ArrayCopy04.java Tue Jun 19 11:38:30 2012 +0200 @@ -0,0 +1,137 @@ +/* + * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package com.oracle.graal.jtt.optimize; + +import org.junit.*; + +/* + * Tests calls to the array copy method. + */ +public class ArrayCopy04 { + + public static byte[] array = new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + public static byte[] array0 = new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + + @Before + public void setUp() { + System.currentTimeMillis(); + for (int i = 0; i < array.length; i++) { + array[i] = array0[i]; + } + } + + public static byte[] test(int srcPos, int destPos, int length) { + System.arraycopy(array, srcPos, array, destPos, length); + return array; + } + + @Test + public void run0() throws Throwable { + Assert.assertArrayEquals(new byte[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, test(0, 0, 0)); + } + + @Test(expected = java.lang.IndexOutOfBoundsException.class) + public void run1() throws Throwable { + test(0, 0, -1); + } + + @Test(expected = java.lang.IndexOutOfBoundsException.class) + public void run2() throws Throwable { + test(-1, 0, 0); + } + + @Test(expected = java.lang.IndexOutOfBoundsException.class) + public void run3() throws Throwable { + test(0, -1, 0); + } + + @Test + public void run4() throws Throwable { + Assert.assertArrayEquals(new byte[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, test(0, 0, 2)); + } + + @Test(expected = java.lang.IndexOutOfBoundsException.class) + public void run5() throws Throwable { + test(0, 1, 11); + } + + @Test(expected = java.lang.IndexOutOfBoundsException.class) + public void run6() throws Throwable { + test(1, 0, 11); + } + + @Test(expected = java.lang.IndexOutOfBoundsException.class) + public void run7() throws Throwable { + test(1, 1, -1); + } + + @Test + public void run8() throws Throwable { + Assert.assertArrayEquals(new byte[] {0, 0, 1, 3, 4, 5, 6, 7, 8, 9, 10}, test(0, 1, 2)); + } + + @Test + public void run9() throws Throwable { + Assert.assertArrayEquals(new byte[] {1, 2, 2, 3, 4, 5, 6, 7, 8, 9, 10}, test(1, 0, 2)); + } + + @Test + public void run10() throws Throwable { + Assert.assertArrayEquals(new byte[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, test(1, 1, 2)); + } + + @Test + public void run11() throws Throwable { + Assert.assertArrayEquals(new byte[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, test(0, 0, 6)); + } + + @Test + public void run12() throws Throwable { + Assert.assertArrayEquals(new byte[] {0, 0, 1, 2, 3, 4, 6, 7, 8, 9, 10}, test(0, 1, 5)); + } + + @Test + public void run13() throws Throwable { + Assert.assertArrayEquals(new byte[] {1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 10}, test(1, 0, 5)); + } + + @Test + public void run14() throws Throwable { + Assert.assertArrayEquals(new byte[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, test(1, 1, 5)); + } + + @Test + public void run15() throws Throwable { + Assert.assertArrayEquals(new byte[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, test(0, 0, 11)); + } + + @Test + public void run16() throws Throwable { + Assert.assertArrayEquals(new byte[] {0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, test(0, 1, 10)); + } + + @Test + public void run17() throws Throwable { + Assert.assertArrayEquals(new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10}, test(1, 0, 10)); + } +} diff -r 8d420cfd2a6f -r d05664608cb7 graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/AnchorNode.java --- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/AnchorNode.java Tue Jun 19 11:37:39 2012 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,50 +0,0 @@ -/* - * Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package com.oracle.graal.nodes; - -import com.oracle.graal.nodes.spi.*; -import com.oracle.graal.nodes.type.*; - -/** - * The {@code AnchorNode} can be used a lower bound for a guard. It can also be used as an upper bound if no other FixedNode can be used for that purpose. - * The guards that should be kept above this node need to be added to the {@link #dependencies()} collection. - */ -public final class AnchorNode extends FixedWithNextNode implements LIRLowerable, Canonicalizable { - - public AnchorNode() { - super(StampFactory.dependency()); - } - - @Override - public ValueNode canonical(CanonicalizerTool tool) { - if (this.usages().size() == 0 && dependencies().isEmpty()) { - return null; - } - return this; - } - - @Override - public void generate(LIRGeneratorTool gen) { - // Currently, there is nothing to emit since anchors are only a structural element with no execution semantics. - } -} diff -r 8d420cfd2a6f -r d05664608cb7 graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/FixedGuardNode.java --- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/FixedGuardNode.java Tue Jun 19 11:37:39 2012 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/FixedGuardNode.java Tue Jun 19 11:38:30 2012 +0200 @@ -93,8 +93,7 @@ @Override public void lower(CiLoweringTool tool) { - ValueAnchorNode newAnchor = graph().add(new ValueAnchorNode()); - newAnchor.addAnchoredNode(tool.createGuard(condition, deoptReason, action, negated, leafGraphId)); + ValueAnchorNode newAnchor = graph().add(new ValueAnchorNode(tool.createGuard(condition, deoptReason, action, negated, leafGraphId))); ((StructuredGraph) graph()).replaceFixedWithFixed(this, newAnchor); } diff -r 8d420cfd2a6f -r d05664608cb7 graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/FrameState.java --- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/FrameState.java Tue Jun 19 11:37:39 2012 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/FrameState.java Tue Jun 19 11:38:30 2012 +0200 @@ -37,6 +37,25 @@ */ public final class FrameState extends VirtualState implements Node.IterableNodeType, LIRLowerable { + /** + * An instance of this class is an identifier for all nodes that were generated by one specific inlining operation. + * It is used to generate the correct debug information for nested locks. + */ + public static final class InliningIdentifier { + private final ResolvedJavaMethod method; + private final String context; + + public InliningIdentifier(ResolvedJavaMethod method, String context) { + this.method = method; + this.context = context; + } + + @Override + public String toString() { + return method + "@" + context; + } + } + protected final int localsSize; protected final int stackSize; @@ -46,6 +65,12 @@ private boolean duringCall; /** + * This object identifies the concrete inlining operation that produced this frame state. + * It is set during inlining, therefore for the outermost frame states of a graph this field is null. + */ + private InliningIdentifier inliningIdentifier; + + /** * This BCI should be used for frame states that are built for code with no meaningful BCI. */ public static final int UNKNOWN_BCI = -4; @@ -92,7 +117,7 @@ * @param stackSize size of the stack * @param rethrowException if true the VM should re-throw the exception on top of the stack when deopt'ing using this framestate */ - public FrameState(ResolvedJavaMethod method, int bci, List values, int stackSize, boolean rethrowException, boolean duringCall, List virtualObjectMappings) { + public FrameState(ResolvedJavaMethod method, int bci, List values, int stackSize, boolean rethrowException, boolean duringCall, InliningIdentifier inliningIdentifier, List virtualObjectMappings) { assert stackSize >= 0; assert (bci >= 0 && method != null) || (bci < 0 && method == null && values.isEmpty()); this.method = method; @@ -103,6 +128,7 @@ this.virtualObjectMappings = new NodeInputList<>(this, virtualObjectMappings); this.rethrowException = rethrowException; this.duringCall = duringCall; + this.inliningIdentifier = inliningIdentifier; assert !rethrowException || stackSize == 1 : "must have exception on top of the stack"; } @@ -111,10 +137,10 @@ * @param bci marker bci, needs to be < 0 */ public FrameState(int bci) { - this(null, bci, Collections.emptyList(), 0, false, false, Collections.emptyList()); + this(null, bci, Collections.emptyList(), 0, false, false, null, Collections.emptyList()); } - public FrameState(ResolvedJavaMethod method, int bci, ValueNode[] locals, ValueNode[] stack, int stackSize, boolean rethrowException, boolean duringCall) { + public FrameState(ResolvedJavaMethod method, int bci, ValueNode[] locals, ValueNode[] stack, int stackSize, boolean rethrowException, boolean duringCall, InliningIdentifier inliningIdentifier) { this.method = method; this.bci = bci; this.localsSize = locals.length; @@ -132,6 +158,7 @@ this.virtualObjectMappings = new NodeInputList<>(this); this.rethrowException = rethrowException; this.duringCall = duringCall; + this.inliningIdentifier = inliningIdentifier; assert !rethrowException || stackSize == 1 : "must have exception on top of the stack"; } @@ -148,6 +175,14 @@ this.outerFrameState = x; } + public InliningIdentifier inliningIdentifier() { + return inliningIdentifier; + } + + public void setInliningIdentifier(InliningIdentifier inliningIdentifier) { + this.inliningIdentifier = inliningIdentifier; + } + public boolean rethrowException() { return rethrowException; } @@ -176,7 +211,7 @@ return virtualObjectMappings.get(i); } - public Iterable virtualObjectMappings() { + public NodeInputList virtualObjectMappings() { return virtualObjectMappings; } @@ -184,7 +219,9 @@ * Gets a copy of this frame state. */ public FrameState duplicate(int newBci) { - return duplicate(newBci, false); + FrameState other = graph().add(new FrameState(method, newBci, values, stackSize, rethrowException, duringCall, inliningIdentifier, virtualObjectMappings)); + other.setOuterFrameState(outerFrameState()); + return other; } /** @@ -194,12 +231,21 @@ return duplicate(bci); } - public FrameState duplicate(int newBci, boolean duplicateOuter) { - FrameState other = graph().add(new FrameState(method, newBci, values, stackSize, rethrowException, duringCall, virtualObjectMappings)); + /** + * Duplicates a FrameState, along with a deep copy of all connected VirtualState (outer FrameStates, + * VirtualObjectStates, ...). + */ + @Override + public FrameState duplicateWithVirtualState() { FrameState newOuterFrameState = outerFrameState(); - if (duplicateOuter && newOuterFrameState != null) { - newOuterFrameState = newOuterFrameState.duplicate(newOuterFrameState.bci, duplicateOuter); + if (newOuterFrameState != null) { + newOuterFrameState = newOuterFrameState.duplicateWithVirtualState(); } + ArrayList newVirtualMappings = new ArrayList<>(virtualObjectMappings.size()); + for (VirtualObjectState state : virtualObjectMappings) { + newVirtualMappings.add(state.duplicateWithVirtualState()); + } + FrameState other = graph().add(new FrameState(method, bci, values, stackSize, rethrowException, duringCall, inliningIdentifier, newVirtualMappings)); other.setOuterFrameState(newOuterFrameState); return other; } @@ -221,7 +267,7 @@ } Collections.addAll(copy, pushedValues); - FrameState other = graph().add(new FrameState(method, newBci, copy, copy.size() - localsSize, newRethrowException, false, virtualObjectMappings)); + FrameState other = graph().add(new FrameState(method, newBci, copy, copy.size() - localsSize, newRethrowException, false, inliningIdentifier, virtualObjectMappings)); other.setOuterFrameState(outerFrameState()); return other; } @@ -342,4 +388,14 @@ } return super.verify(); } + + @Override + public void applyToNonVirtual(NodeClosure< ? super ValueNode> closure) { + for (ValueNode value : values.nonNull()) { + closure.apply(value); + } + for (VirtualObjectState state : virtualObjectMappings) { + state.applyToNonVirtual(closure); + } + } } diff -r 8d420cfd2a6f -r d05664608cb7 graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/VirtualState.java --- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/VirtualState.java Tue Jun 19 11:37:39 2012 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/VirtualState.java Tue Jun 19 11:38:30 2012 +0200 @@ -30,4 +30,12 @@ */ public abstract class VirtualState extends Node { + public interface NodeClosure { + void apply(T node); + } + + public abstract VirtualState duplicateWithVirtualState(); + + public abstract void applyToNonVirtual(NodeClosure closure); + } diff -r 8d420cfd2a6f -r d05664608cb7 graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ValueAnchorNode.java --- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ValueAnchorNode.java Tue Jun 19 11:37:39 2012 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ValueAnchorNode.java Tue Jun 19 11:38:30 2012 +0200 @@ -52,20 +52,16 @@ } @Override - public boolean verify() { - assertTrue(usages().isEmpty(), "upwards dependencies should target BeginNodes only"); - return super.verify(); - } - - @Override public ValueNode canonical(CanonicalizerTool tool) { if (this.predecessor() instanceof ValueAnchorNode) { - // transfer values and remove ValueAnchorNode previousAnchor = (ValueAnchorNode) this.predecessor(); - for (ValueNode node : dependencies().nonNull().distinct()) { - previousAnchor.addAnchoredNode(node); + if (previousAnchor.usages().isEmpty()) { // avoid creating cycles + // transfer values and remove + for (ValueNode node : dependencies().nonNull().distinct()) { + previousAnchor.addAnchoredNode(node); + } + return previousAnchor; } - return null; } for (Node node : dependencies().nonNull().and(isNotA(BeginNode.class))) { if (node instanceof ConstantNode) { @@ -83,6 +79,9 @@ } return this; // still necessary } - return null; // no node which require an anchor found + if (usages().isEmpty()) { + return null; // no node which require an anchor found + } + return this; } } diff -r 8d420cfd2a6f -r d05664608cb7 graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/NewArrayNode.java --- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/NewArrayNode.java Tue Jun 19 11:37:39 2012 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/NewArrayNode.java Tue Jun 19 11:38:30 2012 +0200 @@ -102,7 +102,7 @@ EscapeField[] fields = new EscapeField[length]; for (int i = 0; i < length; i++) { Integer representation = i; - fields[i] = new EscapeField("[" + i + "]", representation, ((NewArrayNode) node).elementType()); + fields[i] = new EscapeField(Integer.toString(i), representation, ((NewArrayNode) node).elementType()); } return fields; } diff -r 8d420cfd2a6f -r d05664608cb7 graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/virtual/VirtualObjectState.java --- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/virtual/VirtualObjectState.java Tue Jun 19 11:37:39 2012 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/virtual/VirtualObjectState.java Tue Jun 19 11:38:30 2012 +0200 @@ -22,6 +22,8 @@ */ package com.oracle.graal.nodes.virtual; +import java.util.*; + import com.oracle.graal.graph.*; import com.oracle.graal.nodes.*; import com.oracle.graal.nodes.spi.*; @@ -32,24 +34,42 @@ public final class VirtualObjectState extends VirtualState implements Node.IterableNodeType, LIRLowerable { @Input private VirtualObjectNode object; - @Input private NodeInputList fields; + @Input private NodeInputList fieldValues; public VirtualObjectNode object() { return object; } - public NodeInputList fields() { - return fields; + public NodeInputList fieldValues() { + return fieldValues; } - public VirtualObjectState(VirtualObjectNode object, ValueNode[] fields) { + public VirtualObjectState(VirtualObjectNode object, ValueNode[] fieldValues) { + assert object.fieldsCount() == fieldValues.length; this.object = object; - assert object.fields().length == fields.length; - this.fields = new NodeInputList<>(this, fields); + this.fieldValues = new NodeInputList<>(this, fieldValues); + } + + private VirtualObjectState(VirtualObjectNode object, List fieldValues) { + assert object.fieldsCount() == fieldValues.size(); + this.object = object; + this.fieldValues = new NodeInputList<>(this, fieldValues); } @Override public void generate(LIRGeneratorTool generator) { // Nothing to do, virtual object states are processed as part of the handling of StateSplit nodes. } + + @Override + public VirtualObjectState duplicateWithVirtualState() { + return graph().add(new VirtualObjectState(object, fieldValues)); + } + + @Override + public void applyToNonVirtual(NodeClosure< ? super ValueNode> closure) { + for (ValueNode value : fieldValues) { + closure.apply(value); + } + } }