Mercurial > hg > truffle
changeset 15156:8fc3ca046532
Merged
| author | Christian Wirth <christian.wirth@oracle.com> |
|---|---|
| date | Wed, 16 Apr 2014 17:26:58 +0200 |
| parents | 370cb412d027 (current diff) d708c2fc5cba (diff) |
| children | f4e31f06b019 0ba58961ba14 |
| files | graal/com.oracle.graal.graph/src/com/oracle/graal/graph/iterators/AbstractNodeIterable.java graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/AbstractBeginNode.java |
| diffstat | 92 files changed, 1466 insertions(+), 816 deletions(-) [+] |
line wrap: on
line diff
--- a/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/SimpleCFGTest.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/SimpleCFGTest.java Wed Apr 16 17:26:58 2014 +0200 @@ -41,9 +41,9 @@ AbstractEndNode trueEnd = graph.add(new EndNode()); AbstractEndNode falseEnd = graph.add(new EndNode()); - AbstractBeginNode trueBegin = graph.add(new BeginNode()); + BeginNode trueBegin = graph.add(new BeginNode()); trueBegin.setNext(trueEnd); - AbstractBeginNode falseBegin = graph.add(new BeginNode()); + BeginNode falseBegin = graph.add(new BeginNode()); falseBegin.setNext(falseEnd); IfNode ifNode = graph.add(new IfNode(null, trueBegin, falseBegin, 0.5));
--- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/NodeLIRBuilder.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/NodeLIRBuilder.java Wed Apr 16 17:26:58 2014 +0200 @@ -659,7 +659,7 @@ return debugInfoBuilder; } - public void emitOverflowCheckBranch(AbstractBeginNode overflowSuccessor, AbstractBeginNode next, double probability) { + public void emitOverflowCheckBranch(BeginNode overflowSuccessor, BeginNode next, double probability) { gen.emitOverflowCheckBranch(getLIRBlock(overflowSuccessor), getLIRBlock(next), probability); }
--- a/graal/com.oracle.graal.debug/src/com/oracle/graal/debug/Debug.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.debug/src/com/oracle/graal/debug/Debug.java Wed Apr 16 17:26:58 2014 +0200 @@ -188,6 +188,19 @@ /** * @see #scope(Object) + * @param contextObjects an array of object to be appended to the {@linkplain #context() + * current} debug context + */ + public static Scope scope(Object name, Object[] contextObjects) { + if (ENABLED) { + return DebugScope.getInstance().scope(convertFormatArg(name).toString(), null, contextObjects); + } else { + return null; + } + } + + /** + * @see #scope(Object) * @param context an object to be appended to the {@linkplain #context() current} debug context */ public static Scope scope(Object name, Object context) {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.graph.test/src/com/oracle/graal/graph/test/NodeUsagesTests.java Wed Apr 16 17:26:58 2014 +0200 @@ -0,0 +1,425 @@ +/* + * Copyright (c) 2014, 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.graph.test; + +import static com.oracle.graal.graph.test.matchers.NodeIterableContains.*; +import static com.oracle.graal.graph.test.matchers.NodeIterableIsEmpty.*; +import static org.junit.Assert.*; + +import org.junit.*; + +import com.oracle.graal.graph.*; + +public class NodeUsagesTests { + + private static class Def extends Node { + + } + + private static class Use extends Node { + private @Input Def in0; + private @Input Def in1; + private @Input Def in2; + + public Use(Def in0, Def in1, Def in2) { + this.in0 = in0; + this.in1 = in1; + this.in2 = in2; + } + } + + @Test + public void testReplaceAtUsages() { + Graph graph = new Graph(); + Def def0 = graph.add(new Def()); + Def def1 = graph.add(new Def()); + Use use0 = graph.add(new Use(def0, null, null)); + Use use1 = graph.add(new Use(null, def0, null)); + Use use2 = graph.add(new Use(null, null, def0)); + + assertEquals(3, def0.usages().count()); + assertThat(def0.usages(), contains(use0)); + assertThat(def0.usages(), contains(use1)); + assertThat(def0.usages(), contains(use2)); + + assertThat(def0.usages(), isNotEmpty()); + assertThat(def1.usages(), isEmpty()); + + def0.replaceAtUsages(def1); + + assertThat(def0.usages(), isEmpty()); + + assertEquals(3, def1.usages().count()); + assertThat(def1.usages(), contains(use0)); + assertThat(def1.usages(), contains(use1)); + assertThat(def1.usages(), contains(use2)); + + assertThat(def1.usages(), isNotEmpty()); + } + + @Test + public void testReplaceAtUsagesWithPredicateAll() { + Graph graph = new Graph(); + Def def0 = graph.add(new Def()); + Def def1 = graph.add(new Def()); + Use use0 = graph.add(new Use(def0, null, null)); + Use use1 = graph.add(new Use(null, def0, null)); + Use use2 = graph.add(new Use(null, null, def0)); + + assertEquals(3, def0.usages().count()); + assertThat(def0.usages(), contains(use0)); + assertThat(def0.usages(), contains(use1)); + assertThat(def0.usages(), contains(use2)); + + assertThat(def0.usages(), isNotEmpty()); + assertThat(def1.usages(), isEmpty()); + + def0.replaceAtMatchingUsages(def1, u -> true); + + assertThat(def0.usages(), isEmpty()); + + assertEquals(3, def1.usages().count()); + assertThat(def1.usages(), contains(use0)); + assertThat(def1.usages(), contains(use1)); + assertThat(def1.usages(), contains(use2)); + + assertThat(def1.usages(), isNotEmpty()); + } + + @Test + public void testReplaceAtUsagesWithPredicateNone() { + Graph graph = new Graph(); + Def def0 = graph.add(new Def()); + Def def1 = graph.add(new Def()); + Use use0 = graph.add(new Use(def0, null, null)); + Use use1 = graph.add(new Use(null, def0, null)); + Use use2 = graph.add(new Use(null, null, def0)); + + assertEquals(3, def0.usages().count()); + assertThat(def0.usages(), contains(use0)); + assertThat(def0.usages(), contains(use1)); + assertThat(def0.usages(), contains(use2)); + + assertThat(def0.usages(), isNotEmpty()); + assertThat(def1.usages(), isEmpty()); + + def0.replaceAtMatchingUsages(def1, u -> false); + + assertThat(def1.usages(), isEmpty()); + + assertEquals(3, def0.usages().count()); + assertThat(def0.usages(), contains(use0)); + assertThat(def0.usages(), contains(use1)); + assertThat(def0.usages(), contains(use2)); + + assertThat(def0.usages(), isNotEmpty()); + } + + @Test + public void testReplaceAtUsagesWithPredicate1() { + Graph graph = new Graph(); + Def def0 = graph.add(new Def()); + Def def1 = graph.add(new Def()); + Use use0 = graph.add(new Use(def0, null, null)); + Use use1 = graph.add(new Use(null, def0, null)); + Use use2 = graph.add(new Use(null, null, def0)); + + assertEquals(3, def0.usages().count()); + assertThat(def0.usages(), contains(use0)); + assertThat(def0.usages(), contains(use1)); + assertThat(def0.usages(), contains(use2)); + + assertThat(def0.usages(), isNotEmpty()); + assertThat(def1.usages(), isEmpty()); + + def0.replaceAtMatchingUsages(def1, u -> u == use1); + + assertEquals(1, def1.usages().count()); + assertThat(def1.usages(), contains(use1)); + + assertThat(def1.usages(), isNotEmpty()); + + assertEquals(2, def0.usages().count()); + assertThat(def0.usages(), contains(use0)); + assertThat(def0.usages(), contains(use2)); + + assertThat(def0.usages(), isNotEmpty()); + } + + @Test + public void testReplaceAtUsagesWithPredicate2() { + Graph graph = new Graph(); + Def def0 = graph.add(new Def()); + Def def1 = graph.add(new Def()); + Use use0 = graph.add(new Use(def0, null, null)); + Use use1 = graph.add(new Use(null, def0, null)); + Use use2 = graph.add(new Use(null, null, def0)); + + assertEquals(3, def0.usages().count()); + assertThat(def0.usages(), contains(use0)); + assertThat(def0.usages(), contains(use1)); + assertThat(def0.usages(), contains(use2)); + + assertThat(def0.usages(), isNotEmpty()); + assertThat(def1.usages(), isEmpty()); + + def0.replaceAtMatchingUsages(def1, u -> u == use2); + + assertEquals(1, def1.usages().count()); + assertThat(def1.usages(), contains(use2)); + + assertThat(def1.usages(), isNotEmpty()); + + assertEquals(2, def0.usages().count()); + assertThat(def0.usages(), contains(use0)); + assertThat(def0.usages(), contains(use1)); + + assertThat(def0.usages(), isNotEmpty()); + } + + @Test + public void testReplaceAtUsagesWithPredicate0() { + Graph graph = new Graph(); + Def def0 = graph.add(new Def()); + Def def1 = graph.add(new Def()); + Use use0 = graph.add(new Use(def0, null, null)); + Use use1 = graph.add(new Use(null, def0, null)); + Use use2 = graph.add(new Use(null, null, def0)); + + assertEquals(3, def0.usages().count()); + assertThat(def0.usages(), contains(use0)); + assertThat(def0.usages(), contains(use1)); + assertThat(def0.usages(), contains(use2)); + + assertThat(def0.usages(), isNotEmpty()); + assertThat(def1.usages(), isEmpty()); + + def0.replaceAtMatchingUsages(def1, u -> u == use0); + + assertEquals(1, def1.usages().count()); + assertThat(def1.usages(), contains(use0)); + + assertThat(def1.usages(), isNotEmpty()); + + assertEquals(2, def0.usages().count()); + assertThat(def0.usages(), contains(use1)); + assertThat(def0.usages(), contains(use2)); + + assertThat(def0.usages(), isNotEmpty()); + } + + @Test + public void testReplaceAtUsagesWithPredicate02() { + Graph graph = new Graph(); + Def def0 = graph.add(new Def()); + Def def1 = graph.add(new Def()); + Use use0 = graph.add(new Use(def0, null, null)); + Use use1 = graph.add(new Use(null, def0, null)); + Use use2 = graph.add(new Use(null, null, def0)); + + assertEquals(3, def0.usages().count()); + assertThat(def0.usages(), contains(use0)); + assertThat(def0.usages(), contains(use1)); + assertThat(def0.usages(), contains(use2)); + + assertThat(def0.usages(), isNotEmpty()); + assertThat(def1.usages(), isEmpty()); + + def0.replaceAtMatchingUsages(def1, u -> u != use1); + + assertEquals(1, def0.usages().count()); + assertThat(def0.usages(), contains(use1)); + + assertThat(def0.usages(), isNotEmpty()); + + assertEquals(2, def1.usages().count()); + assertThat(def1.usages(), contains(use0)); + assertThat(def1.usages(), contains(use2)); + + assertThat(def1.usages(), isNotEmpty()); + } + + @Test + public void testReplaceAtUsagesWithPredicate023() { + Graph graph = new Graph(); + Def def0 = graph.add(new Def()); + Def def1 = graph.add(new Def()); + Use use0 = graph.add(new Use(def0, null, null)); + Use use1 = graph.add(new Use(null, def0, null)); + Use use2 = graph.add(new Use(null, null, def0)); + Use use3 = graph.add(new Use(null, null, def0)); + + assertEquals(4, def0.usages().count()); + assertThat(def0.usages(), contains(use0)); + assertThat(def0.usages(), contains(use1)); + assertThat(def0.usages(), contains(use2)); + assertThat(def0.usages(), contains(use3)); + + assertThat(def0.usages(), isNotEmpty()); + assertThat(def1.usages(), isEmpty()); + + def0.replaceAtMatchingUsages(def1, u -> u != use1); + + assertEquals(1, def0.usages().count()); + assertThat(def0.usages(), contains(use1)); + + assertThat(def0.usages(), isNotEmpty()); + + assertEquals(3, def1.usages().count()); + assertThat(def1.usages(), contains(use0)); + assertThat(def1.usages(), contains(use2)); + assertThat(def1.usages(), contains(use3)); + + assertThat(def1.usages(), isNotEmpty()); + } + + @Test + public void testReplaceAtUsagesWithPredicate013() { + Graph graph = new Graph(); + Def def0 = graph.add(new Def()); + Def def1 = graph.add(new Def()); + Use use0 = graph.add(new Use(def0, null, null)); + Use use1 = graph.add(new Use(null, def0, null)); + Use use2 = graph.add(new Use(null, null, def0)); + Use use3 = graph.add(new Use(null, null, def0)); + + assertEquals(4, def0.usages().count()); + assertThat(def0.usages(), contains(use0)); + assertThat(def0.usages(), contains(use1)); + assertThat(def0.usages(), contains(use2)); + assertThat(def0.usages(), contains(use3)); + + assertThat(def0.usages(), isNotEmpty()); + assertThat(def1.usages(), isEmpty()); + + def0.replaceAtMatchingUsages(def1, u -> u != use2); + + assertEquals(1, def0.usages().count()); + assertThat(def0.usages(), contains(use2)); + + assertThat(def0.usages(), isNotEmpty()); + + assertEquals(3, def1.usages().count()); + assertThat(def1.usages(), contains(use0)); + assertThat(def1.usages(), contains(use1)); + assertThat(def1.usages(), contains(use3)); + + assertThat(def1.usages(), isNotEmpty()); + } + + @Test + public void testReplaceAtUsagesWithPredicate2_3() { + Graph graph = new Graph(); + Def def0 = graph.add(new Def()); + Def def1 = graph.add(new Def()); + Use use0 = graph.add(new Use(def0, null, null)); + Use use1 = graph.add(new Use(null, def0, null)); + Use use2 = graph.add(new Use(null, null, def0)); + Use use3 = graph.add(new Use(null, null, def0)); + + assertEquals(4, def0.usages().count()); + assertThat(def0.usages(), contains(use0)); + assertThat(def0.usages(), contains(use1)); + assertThat(def0.usages(), contains(use2)); + assertThat(def0.usages(), contains(use3)); + + assertThat(def0.usages(), isNotEmpty()); + assertThat(def1.usages(), isEmpty()); + + def0.replaceAtMatchingUsages(def1, u -> u == use2); + + assertEquals(1, def1.usages().count()); + assertThat(def1.usages(), contains(use2)); + + assertThat(def1.usages(), isNotEmpty()); + + assertEquals(3, def0.usages().count()); + assertThat(def0.usages(), contains(use0)); + assertThat(def0.usages(), contains(use1)); + assertThat(def0.usages(), contains(use3)); + + assertThat(def0.usages(), isNotEmpty()); + } + + @Test + public void testReplaceAtUsagesWithPredicate01() { + Graph graph = new Graph(); + Def def0 = graph.add(new Def()); + Def def1 = graph.add(new Def()); + Use use0 = graph.add(new Use(def0, null, null)); + Use use1 = graph.add(new Use(null, def0, null)); + Use use2 = graph.add(new Use(null, null, def0)); + + assertEquals(3, def0.usages().count()); + assertThat(def0.usages(), contains(use0)); + assertThat(def0.usages(), contains(use1)); + assertThat(def0.usages(), contains(use2)); + + assertThat(def0.usages(), isNotEmpty()); + assertThat(def1.usages(), isEmpty()); + + def0.replaceAtMatchingUsages(def1, u -> u != use2); + + assertEquals(1, def0.usages().count()); + assertThat(def0.usages(), contains(use2)); + + assertThat(def0.usages(), isNotEmpty()); + + assertEquals(2, def1.usages().count()); + assertThat(def1.usages(), contains(use0)); + assertThat(def1.usages(), contains(use1)); + + assertThat(def1.usages(), isNotEmpty()); + } + + @Test + public void testReplaceAtUsagesWithPredicate12() { + Graph graph = new Graph(); + Def def0 = graph.add(new Def()); + Def def1 = graph.add(new Def()); + Use use0 = graph.add(new Use(def0, null, null)); + Use use1 = graph.add(new Use(null, def0, null)); + Use use2 = graph.add(new Use(null, null, def0)); + + assertEquals(3, def0.usages().count()); + assertThat(def0.usages(), contains(use0)); + assertThat(def0.usages(), contains(use1)); + assertThat(def0.usages(), contains(use2)); + + assertThat(def0.usages(), isNotEmpty()); + assertThat(def1.usages(), isEmpty()); + + def0.replaceAtMatchingUsages(def1, u -> u != use0); + + assertEquals(1, def0.usages().count()); + assertThat(def0.usages(), contains(use0)); + + assertThat(def0.usages(), isNotEmpty()); + + assertEquals(2, def1.usages().count()); + assertThat(def1.usages(), contains(use1)); + assertThat(def1.usages(), contains(use2)); + + assertThat(def1.usages(), isNotEmpty()); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.graph.test/src/com/oracle/graal/graph/test/matchers/NodeIterableContains.java Wed Apr 16 17:26:58 2014 +0200 @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2014, 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.graph.test.matchers; + +import org.hamcrest.*; + +import com.oracle.graal.graph.*; +import com.oracle.graal.graph.iterators.*; + +public class NodeIterableContains<T extends Node> extends TypeSafeDiagnosingMatcher<NodeIterable<T>> { + private T node; + + public NodeIterableContains(T node) { + this.node = node; + } + + public void describeTo(Description description) { + description.appendText("is a NodeIterable containing").appendValue(node); + } + + public static <T extends Node> NodeIterableContains<T> contains(T node) { + return new NodeIterableContains<>(node); + } + + public static <T extends Node> NodeIterableContains<T> d(T node) { + return new NodeIterableContains<>(node); + } + + @Override + protected boolean matchesSafely(NodeIterable<T> iterable, Description description) { + return iterable.contains(node); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.graph.test/src/com/oracle/graal/graph/test/matchers/NodeIterableIsEmpty.java Wed Apr 16 17:26:58 2014 +0200 @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2014, 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.graph.test.matchers; + +import org.hamcrest.*; +import org.hamcrest.core.*; + +import com.oracle.graal.graph.iterators.*; + +public class NodeIterableIsEmpty extends BaseMatcher<NodeIterable<?>> { + + private static final NodeIterableIsEmpty INSTANCE = new NodeIterableIsEmpty(); + + public boolean matches(Object iterable) { + return iterable instanceof NodeIterable<?> && ((NodeIterable<?>) iterable).isEmpty(); + } + + public void describeTo(Description description) { + description.appendText("is an empty NodeIterable"); + } + + public static Matcher<NodeIterable<?>> isEmpty() { + return INSTANCE; + } + + public static Matcher<NodeIterable<?>> isNotEmpty() { + return IsNot.not(INSTANCE); + } +}
--- a/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/Graph.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/Graph.java Wed Apr 16 17:26:58 2014 +0200 @@ -525,7 +525,7 @@ */ public NodeIterable<Node> getNewNodes(Mark mark) { final int index = mark.getValue(); - return new AbstractNodeIterable<Node>() { + return new NodeIterable<Node>() { @Override public Iterator<Node> iterator() { @@ -540,7 +540,7 @@ * @return an {@link Iterable} providing all the live nodes. */ public NodeIterable<Node> getNodes() { - return new AbstractNodeIterable<Node>() { + return new NodeIterable<Node>() { @Override public Iterator<Node> iterator() { @@ -714,7 +714,7 @@ */ public <T extends Node & IterableNodeType> NodeIterable<T> getNodes(final Class<T> type) { final NodeClass nodeClass = NodeClass.get(type); - return new AbstractNodeIterable<T>() { + return new NodeIterable<T>() { @Override public Iterator<T> iterator() {
--- a/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/Node.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/Node.java Wed Apr 16 17:26:58 2014 +0200 @@ -189,7 +189,6 @@ Node current; private void advance() { - assert index == -1 || current != null; current = null; index++; if (index == 0) { @@ -228,7 +227,7 @@ } } - class NodeUsageIterable extends AbstractNodeIterable<Node> { + class NodeUsageIterable implements NodeIterable<Node> { public NodeUsageIterator iterator() { return new NodeUsageIterator(); @@ -246,13 +245,7 @@ @Override public int count() { - if (usage0 == null) { - return 0; - } - if (usage1 == null) { - return 1; - } - return 2 + indexOfLastNonNull(extraUsages) + 1; + return usageCount(); } } @@ -349,6 +342,81 @@ } } + private int usageCount() { + if (usage0 == null) { + return 0; + } + if (usage1 == null) { + return 1; + } + return 2 + indexOfLastNonNull(extraUsages) + 1; + } + + /** + * Remove all usages between {@code fromIndex} and {@code toIndex} (exclusive), also, if + * {@code toIndex} is a valid usage, it is moved to {@code fromIndex}. + * + * <p> + * Visually, + * + * <pre> + * {@code + * [1, 2, 3, 4, 5, 6, 7].removeUsagesAndShiftFirst(1, 2) == [1, 4, 6, 7, 5, null, null]} + * </pre> + * + * + * @param fromIndex the index of the first element to be removed + * @param toIndex the index after the last element to be removed + */ + private void removeUsagesAndShiftFirst(int fromIndex, int toIndex) { + assert fromIndex < toIndex; + int firstNullIndex = usageCount(); + assert toIndex <= firstNullIndex; + int i = fromIndex; + int limit = toIndex; + if (toIndex < firstNullIndex) { + // move usage at toIndex to fromIndex(!) + movUsageTo(toIndex, fromIndex); + limit++; + i++; + } + while (i < limit && firstNullIndex > limit) { + movUsageTo(firstNullIndex - 1, i); + firstNullIndex--; + i++; + } + while (i < limit) { + if (i == 0) { + usage0 = null; + } else if (i == 1) { + usage1 = null; + } else { + extraUsages[i - INLINE_USAGE_COUNT] = null; + } + i++; + } + + } + + private void movUsageTo(int usageIndex, int toIndex) { + assert usageIndex > toIndex; + if (toIndex == 0) { + if (usageIndex == 1) { + usage0 = usage1; + usage1 = null; + } else { + usage0 = extraUsages[usageIndex - INLINE_USAGE_COUNT]; + extraUsages[usageIndex - INLINE_USAGE_COUNT] = null; + } + } else if (toIndex == 1) { + usage1 = extraUsages[usageIndex - INLINE_USAGE_COUNT]; + extraUsages[usageIndex - INLINE_USAGE_COUNT] = null; + } else { + extraUsages[toIndex - INLINE_USAGE_COUNT] = extraUsages[usageIndex - INLINE_USAGE_COUNT]; + extraUsages[usageIndex - INLINE_USAGE_COUNT] = null; + } + } + /** * Removes a given node from this node's {@linkplain #usages() usages}. * @@ -357,6 +425,7 @@ */ private boolean removeUsage(Node node) { assert recordsUsages(); + assert node != null; // It is critical that this method maintains the invariant that // the usage list has no null element preceding a non-null element incUsageModCount(); @@ -388,20 +457,19 @@ } return true; } - int lastNonNull = indexOfLastNonNull(extraUsages); - if (lastNonNull >= 0) { - for (int i = 0; i <= lastNonNull; ++i) { - Node n = extraUsages[i]; - if (n == node) { - if (i < lastNonNull) { - extraUsages[i] = extraUsages[lastNonNull]; - extraUsages[lastNonNull] = null; - } else { - extraUsages[i] = null; - } - return true; - } + int matchIndex = -1; + int i = 0; + Node n; + while (i < extraUsages.length && (n = extraUsages[i]) != null) { + if (n == node) { + matchIndex = i; } + i++; + } + if (matchIndex >= 0) { + extraUsages[matchIndex] = extraUsages[i - 1]; + extraUsages[i - 1] = null; + return true; } return false; } @@ -543,6 +611,40 @@ clearUsages(); } + public void replaceAtMatchingUsages(Node other, NodePredicate usagePredicate) { + assert checkReplaceWith(other); + NodeUsageIterator it = (NodeUsageIterator) usages().iterator(); + int removeStart = -1; + while (it.hasNext()) { + Node usage = it.next(); + if (usagePredicate.apply(usage)) { + if (removeStart < 0) { + removeStart = it.index - 1; + } + boolean result = usage.getNodeClass().replaceFirstInput(usage, this, other); + assert assertTrue(result, "not found in inputs, usage: %s", usage); + if (other != null) { + maybeNotifyChanged(usage); + if (other.recordsUsages()) { + other.addUsage(usage); + } + } + } else { + if (removeStart >= 0) { + int removeEndIndex = it.index - 1; + removeUsagesAndShiftFirst(removeStart, removeEndIndex); + it.index = removeStart; + it.advance(); + removeStart = -1; + } + } + } + if (removeStart >= 0) { + int removeEndIndex = it.index; + removeUsagesAndShiftFirst(removeStart, removeEndIndex); + } + } + public void replaceAtUsages(InputType type, Node other) { assert checkReplaceWith(other); for (Node usage : usages().snapshot()) {
--- a/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/NodeBitMap.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/NodeBitMap.java Wed Apr 16 17:26:58 2014 +0200 @@ -26,7 +26,7 @@ import com.oracle.graal.graph.iterators.*; -public final class NodeBitMap extends AbstractNodeIterable<Node> { +public final class NodeBitMap implements NodeIterable<Node> { private final boolean autoGrow; private final BitSet bitMap;
--- a/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/NodeClassIterable.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/NodeClassIterable.java Wed Apr 16 17:26:58 2014 +0200 @@ -30,7 +30,7 @@ * The iterator returned by this iterable can be used to access {@link Position Positions} during * iteration using {@link NodeClassIterator#nextPosition()}. */ -public abstract class NodeClassIterable extends AbstractNodeIterable<Node> { +public interface NodeClassIterable extends NodeIterable<Node> { @Override public abstract NodeClassIterator iterator();
--- a/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/NodeList.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/NodeList.java Wed Apr 16 17:26:58 2014 +0200 @@ -348,42 +348,6 @@ } @Override - public NodeIterable<T> until(final T u) { - return new FilteredNodeIterable<>(this).until(u); - } - - @Override - public NodeIterable<T> until(final Class<? extends T> clazz) { - return new FilteredNodeIterable<>(this).until(clazz); - } - - @Override - @SuppressWarnings("unchecked") - public <F extends T> NodeIterable<F> filter(Class<F> clazz) { - return (NodeIterable<F>) new FilteredNodeIterable<>(this).and(NodePredicates.isA(clazz)); - } - - @Override - public NodeIterable<T> filterInterface(Class<?> iface) { - return new FilteredNodeIterable<>(this).and(NodePredicates.isAInterface(iface)); - } - - @Override - public FilteredNodeIterable<T> filter(NodePredicate predicate) { - return new FilteredNodeIterable<>(this).and(predicate); - } - - @Override - public FilteredNodeIterable<T> nonNull() { - return new FilteredNodeIterable<>(this).and(NodePredicates.isNotNull()); - } - - @Override - public NodeIterable<T> distinct() { - return new FilteredNodeIterable<>(this).distinct(); - } - - @Override public T first() { if (size() > 0) { return get(0);
--- a/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/iterators/AbstractNodeIterable.java Wed Apr 16 16:54:15 2014 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,117 +0,0 @@ -/* - * 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.graph.iterators; - -import java.util.*; - -import com.oracle.graal.graph.*; - -public abstract class AbstractNodeIterable<T extends Node> implements NodeIterable<T> { - - @Override - public NodeIterable<T> until(final T u) { - return new FilteredNodeIterable<>(this).until(u); - } - - @Override - public NodeIterable<T> until(final Class<? extends T> clazz) { - return new FilteredNodeIterable<>(this).until(clazz); - } - - @Override - @SuppressWarnings("unchecked") - public <F extends T> NodeIterable<F> filter(Class<F> clazz) { - return (NodeIterable<F>) new FilteredNodeIterable<>(this).and(NodePredicates.isA(clazz)); - } - - @Override - public NodeIterable<T> filterInterface(Class<?> iface) { - return new FilteredNodeIterable<>(this).and(NodePredicates.isAInterface(iface)); - } - - @Override - public FilteredNodeIterable<T> filter(NodePredicate predicate) { - return new FilteredNodeIterable<>(this).and(predicate); - } - - @Override - public FilteredNodeIterable<T> nonNull() { - return new FilteredNodeIterable<>(this).and(NodePredicates.isNotNull()); - } - - @Override - public NodeIterable<T> distinct() { - return new FilteredNodeIterable<>(this).distinct(); - } - - @Override - public List<T> snapshot() { - ArrayList<T> list = new ArrayList<>(); - for (T n : this) { - list.add(n); - } - return list; - } - - @Override - public void snapshotTo(Collection<T> to) { - for (T n : this) { - to.add(n); - } - } - - @Override - public T first() { - Iterator<T> iterator = iterator(); - if (iterator.hasNext()) { - return iterator.next(); - } - return null; - } - - @Override - public int count() { - int count = 0; - Iterator<T> iterator = iterator(); - while (iterator.hasNext()) { - iterator.next(); - count++; - } - return count; - } - - @Override - public boolean isEmpty() { - return !iterator().hasNext(); - } - - @Override - public boolean isNotEmpty() { - return iterator().hasNext(); - } - - @Override - public boolean contains(T node) { - return this.filter(NodePredicates.equals(node)).isNotEmpty(); - } -}
--- a/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/iterators/FilteredNodeIterable.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/iterators/FilteredNodeIterable.java Wed Apr 16 17:26:58 2014 +0200 @@ -26,7 +26,7 @@ import com.oracle.graal.graph.*; -public class FilteredNodeIterable<T extends Node> extends AbstractNodeIterable<T> { +public class FilteredNodeIterable<T extends Node> implements NodeIterable<T> { protected final NodeIterable<T> nodeIterable; protected NodePredicate predicate = NodePredicates.alwaysTrue();
--- a/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/iterators/NodeIterable.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/iterators/NodeIterable.java Wed Apr 16 17:26:58 2014 +0200 @@ -28,32 +28,74 @@ public interface NodeIterable<T extends Node> extends Iterable<T> { - NodeIterable<T> until(T u); + default NodeIterable<T> until(final T u) { + return new FilteredNodeIterable<>(this).until(u); + } + + default NodeIterable<T> until(final Class<? extends T> clazz) { + return new FilteredNodeIterable<>(this).until(clazz); + } - NodeIterable<T> until(Class<? extends T> clazz); + @SuppressWarnings("unchecked") + default <F extends T> NodeIterable<F> filter(Class<F> clazz) { + return (NodeIterable<F>) new FilteredNodeIterable<>(this).and(NodePredicates.isA(clazz)); + } - <F extends T> NodeIterable<F> filter(Class<F> clazz); + default NodeIterable<T> filterInterface(Class<?> iface) { + return new FilteredNodeIterable<>(this).and(NodePredicates.isAInterface(iface)); + } - NodeIterable<T> filterInterface(Class<?> iface); + default FilteredNodeIterable<T> filter(NodePredicate predicate) { + return new FilteredNodeIterable<>(this).and(predicate); + } - FilteredNodeIterable<T> filter(NodePredicate predicate); + default FilteredNodeIterable<T> nonNull() { + return new FilteredNodeIterable<>(this).and(NodePredicates.isNotNull()); + } - FilteredNodeIterable<T> nonNull(); + default NodeIterable<T> distinct() { + return new FilteredNodeIterable<>(this).distinct(); + } - NodeIterable<T> distinct(); + default List<T> snapshot() { + ArrayList<T> list = new ArrayList<>(); + snapshotTo(list); + return list; + } - List<T> snapshot(); - - void snapshotTo(Collection<T> to); + default void snapshotTo(Collection<T> to) { + for (T n : this) { + to.add(n); + } + } - T first(); - - int count(); + default T first() { + Iterator<T> iterator = iterator(); + if (iterator.hasNext()) { + return iterator.next(); + } + return null; + } - boolean isEmpty(); - - boolean isNotEmpty(); + default int count() { + int count = 0; + Iterator<T> iterator = iterator(); + while (iterator.hasNext()) { + iterator.next(); + count++; + } + return count; + } - boolean contains(T node); + default boolean isEmpty() { + return !iterator().hasNext(); + } + default boolean isNotEmpty() { + return iterator().hasNext(); + } + + default boolean contains(T node) { + return this.filter(NodePredicates.equals(node)).isNotEmpty(); + } }
--- a/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/iterators/NodePredicate.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/iterators/NodePredicate.java Wed Apr 16 17:26:58 2014 +0200 @@ -23,20 +23,21 @@ package com.oracle.graal.graph.iterators; import com.oracle.graal.graph.*; +import com.oracle.graal.graph.iterators.NodePredicates.*; -public abstract class NodePredicate { +public interface NodePredicate { - public abstract boolean apply(Node n); + boolean apply(Node n); - public NodePredicate and(NodePredicate np) { - return NodePredicates.and(this, np); + default NodePredicate and(NodePredicate np) { + return new AndPredicate(this, np); } - public NodePredicate or(NodePredicate np) { - return NodePredicates.or(this, np); + default NodePredicate or(NodePredicate np) { + return new OrPredicate(this, np); } - public NodePredicate negate() { - return NodePredicates.not(this); + default NodePredicate negate() { + return new NotPredicate(this); } }
--- a/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/iterators/NodePredicates.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/iterators/NodePredicates.java Wed Apr 16 17:26:58 2014 +0200 @@ -27,7 +27,7 @@ public abstract class NodePredicates { private static final TautologyPredicate TAUTOLOGY = new TautologyPredicate(); - private static final FalsePredicate FALSE = new FalsePredicate(); + private static final ContradictionPredicate CONTRADICTION = new ContradictionPredicate(); private static final IsNullPredicate IS_NULL = new IsNullPredicate(); private static final IsNotNullPredicate IS_NOT_NULL = new IsNotNullPredicate(); @@ -36,7 +36,7 @@ } public static NodePredicate alwaysFalse() { - return FALSE; + return CONTRADICTION; } public static NodePredicate isNull() { @@ -52,60 +52,7 @@ } public static NodePredicate not(NodePredicate a) { - if (a == TAUTOLOGY) { - return FALSE; - } - if (a == FALSE) { - return TAUTOLOGY; - } - if (a == IS_NULL) { - return IS_NOT_NULL; - } - if (a == IS_NOT_NULL) { - return IS_NULL; - } - if (a instanceof NotPredicate) { - return ((NotPredicate) a).a; - } - if (a instanceof PositiveTypePredicate) { - return new NegativeTypePredicate((PositiveTypePredicate) a); - } - if (a instanceof NegativeTypePredicate) { - return new PositiveTypePredicate((NegativeTypePredicate) a); - } - if (a instanceof EqualsPredicate) { - return new NotEqualsPredicate(((EqualsPredicate) a).u); - } - if (a instanceof NotEqualsPredicate) { - return new EqualsPredicate(((NotEqualsPredicate) a).u); - } - return new NotPredicate(a); - } - - public static NodePredicate and(NodePredicate a, NodePredicate b) { - if (a == TAUTOLOGY) { - return b; - } - if (b == TAUTOLOGY) { - return a; - } - if (a == FALSE || b == FALSE) { - return FALSE; - } - return new AndPredicate(a, b); - } - - public static NodePredicate or(NodePredicate a, NodePredicate b) { - if (a == FALSE) { - return b; - } - if (b == FALSE) { - return a; - } - if (a == TAUTOLOGY || b == TAUTOLOGY) { - return TAUTOLOGY; - } - return new OrPredicate(a, b); + return a.negate(); } public static NegativeTypePredicate isNotA(Class<? extends Node> clazz) { @@ -126,28 +73,52 @@ return new NegativeTypePredicate(iface); } - private static final class TautologyPredicate extends NodePredicate { + static final class TautologyPredicate implements NodePredicate { @Override public boolean apply(Node n) { return true; } + + public NodePredicate and(NodePredicate np) { + return np; + } + + public NodePredicate negate() { + return CONTRADICTION; + } + + public NodePredicate or(NodePredicate np) { + return this; + } } - private static final class FalsePredicate extends NodePredicate { + static final class ContradictionPredicate implements NodePredicate { @Override public boolean apply(Node n) { return false; } + + public NodePredicate and(NodePredicate np) { + return this; + } + + public NodePredicate negate() { + return TAUTOLOGY; + } + + public NodePredicate or(NodePredicate np) { + return np; + } } - private static final class AndPredicate extends NodePredicate { + static final class AndPredicate implements NodePredicate { private final NodePredicate a; private final NodePredicate b; - private AndPredicate(NodePredicate a, NodePredicate b) { + AndPredicate(NodePredicate a, NodePredicate b) { this.a = a; this.b = b; } @@ -158,11 +129,11 @@ } } - private static final class NotPredicate extends NodePredicate { + static final class NotPredicate implements NodePredicate { private final NodePredicate a; - private NotPredicate(NodePredicate n) { + NotPredicate(NodePredicate n) { this.a = n; } @@ -170,14 +141,18 @@ public boolean apply(Node n) { return !a.apply(n); } + + public NodePredicate negate() { + return a; + } } - private static final class OrPredicate extends NodePredicate { + static final class OrPredicate implements NodePredicate { private final NodePredicate a; private final NodePredicate b; - private OrPredicate(NodePredicate a, NodePredicate b) { + OrPredicate(NodePredicate a, NodePredicate b) { this.a = a; this.b = b; } @@ -188,27 +163,35 @@ } } - private static final class IsNullPredicate extends NodePredicate { + static final class IsNullPredicate implements NodePredicate { @Override public boolean apply(Node n) { return n == null; } + + public NodePredicate negate() { + return IS_NOT_NULL; + } } - private static final class IsNotNullPredicate extends NodePredicate { + static final class IsNotNullPredicate implements NodePredicate { @Override public boolean apply(Node n) { return n != null; } + + public NodePredicate negate() { + return IS_NULL; + } } - private static final class EqualsPredicate extends NodePredicate { + static final class EqualsPredicate implements NodePredicate { private final Node u; - public EqualsPredicate(Node u) { + EqualsPredicate(Node u) { this.u = u; } @@ -216,13 +199,17 @@ public boolean apply(Node n) { return u == n; } + + public NodePredicate negate() { + return new NotEqualsPredicate(u); + } } - private static final class NotEqualsPredicate extends NodePredicate { + static final class NotEqualsPredicate implements NodePredicate { private final Node u; - public NotEqualsPredicate(Node u) { + NotEqualsPredicate(Node u) { this.u = u; } @@ -230,14 +217,18 @@ public boolean apply(Node n) { return u != n; } + + public NodePredicate negate() { + return new EqualsPredicate(u); + } } - public static final class PositiveTypePredicate extends NodePredicate { + public static final class PositiveTypePredicate implements NodePredicate { private final Class<?> type; private PositiveTypePredicate or; - public PositiveTypePredicate(Class<?> type) { + PositiveTypePredicate(Class<?> type) { this.type = type; } @@ -261,14 +252,18 @@ } return this; } + + public NodePredicate negate() { + return new NegativeTypePredicate(this); + } } - public static final class NegativeTypePredicate extends NodePredicate { + public static final class NegativeTypePredicate implements NodePredicate { private final Class<?> type; private NegativeTypePredicate nor; - public NegativeTypePredicate(Class<?> type) { + NegativeTypePredicate(Class<?> type) { this.type = type; } @@ -292,5 +287,9 @@ } return this; } + + public NodePredicate negate() { + return new PositiveTypePredicate(this); + } } }
--- a/graal/com.oracle.graal.hotspot.hsail/src/com/oracle/graal/hotspot/hsail/HSAILHotSpotBackend.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.hotspot.hsail/src/com/oracle/graal/hotspot/hsail/HSAILHotSpotBackend.java Wed Apr 16 17:26:58 2014 +0200 @@ -843,7 +843,7 @@ ParameterNode hsailFrame = hostGraph.unique(new ParameterNode(1, StampFactory.forKind(providers.getCodeCache().getTarget().wordKind))); ParameterNode reasonAndAction = hostGraph.unique(new ParameterNode(2, StampFactory.intValue())); ParameterNode speculation = hostGraph.unique(new ParameterNode(3, StampFactory.object())); - AbstractBeginNode[] branches = new AbstractBeginNode[deopts.size() + 1]; + BeginNode[] branches = new BeginNode[deopts.size() + 1]; int[] keys = new int[deopts.size()]; int[] keySuccessors = new int[deopts.size() + 1]; double[] keyProbabilities = new double[deopts.size() + 1]; @@ -875,15 +875,14 @@ return hostGraph; } - private static AbstractBeginNode createHostCrashBranch(StructuredGraph hostGraph, ValueNode deoptId) { + private static BeginNode createHostCrashBranch(StructuredGraph hostGraph, ValueNode deoptId) { VMErrorNode vmError = hostGraph.add(new VMErrorNode("Error in HSAIL deopt. DeoptId=%d", deoptId)); // ConvertNode.convert(hostGraph, Kind.Long, deoptId))); vmError.setNext(hostGraph.add(new ReturnNode(ConstantNode.defaultForKind(hostGraph.method().getSignature().getReturnKind(), hostGraph)))); return BeginNode.begin(vmError); } - private static AbstractBeginNode createHostDeoptBranch(DeoptimizeOp deopt, ParameterNode hsailFrame, ValueNode reasonAndAction, ValueNode speculation, HotSpotProviders providers, - HotSpotVMConfig config) { + private static BeginNode createHostDeoptBranch(DeoptimizeOp deopt, ParameterNode hsailFrame, ValueNode reasonAndAction, ValueNode speculation, HotSpotProviders providers, HotSpotVMConfig config) { BeginNode branch = hsailFrame.graph().add(new BeginNode()); DynamicDeoptimizeNode deoptimization = hsailFrame.graph().add(new DynamicDeoptimizeNode(reasonAndAction, speculation)); deoptimization.setStateBefore(createFrameState(deopt.getFrameState().topFrame, hsailFrame, providers, config));
--- a/graal/com.oracle.graal.hotspot.test/src/com/oracle/graal/hotspot/test/WriteBarrierVerificationTest.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.hotspot.test/src/com/oracle/graal/hotspot/test/WriteBarrierVerificationTest.java Wed Apr 16 17:26:58 2014 +0200 @@ -685,7 +685,7 @@ } @Override - protected Boolean afterSplit(AbstractBeginNode node, Boolean oldState) { + protected Boolean afterSplit(BeginNode node, Boolean oldState) { return false; } };
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotLoweringProvider.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotLoweringProvider.java Wed Apr 16 17:26:58 2014 +0200 @@ -474,7 +474,7 @@ ReadNode memoryRead = createUnsafeRead(graph, load, null); // An unsafe read must not float outside its block otherwise // it may float above an explicit null check on its object. - memoryRead.setGuard(AbstractBeginNode.prevBegin(load)); + memoryRead.setGuard(BeginNode.prevBegin(load)); graph.replaceFixedWithFixed(load, memoryRead); } }
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/SnippetAnchorNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/SnippetAnchorNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -37,7 +37,7 @@ @Override public void simplify(SimplifierTool tool) { - AbstractBeginNode prevBegin = BeginNode.prevBegin(this); + BeginNode prevBegin = BeginNode.prevBegin(this); replaceAtUsages(InputType.Anchor, prevBegin); replaceAtUsages(InputType.Guard, prevBegin); if (usages().isEmpty()) {
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/phases/AheadOfTimeVerificationPhase.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/phases/AheadOfTimeVerificationPhase.java Wed Apr 16 17:26:58 2014 +0200 @@ -27,6 +27,7 @@ import com.oracle.graal.api.meta.*; import com.oracle.graal.hotspot.meta.*; import com.oracle.graal.nodes.*; +import com.oracle.graal.nodes.type.*; import com.oracle.graal.phases.*; import com.oracle.graal.phases.tiers.*; @@ -45,7 +46,7 @@ protected boolean verify(StructuredGraph graph, PhaseContext context) { for (ConstantNode node : getConstantNodes(graph)) { if (node.recordsUsages() || !node.gatherUsages(graph).isEmpty()) { - if (isObject(node) && !isNullReference(node) && !isInternedString(node)) { + if (isObject(node) && !isNullReference(node) && !isInternedString(node) && !isDirectMethodHandle(node)) { throw new VerificationError("illegal object constant: " + node); } } @@ -61,6 +62,13 @@ return isObject(node) && node.asConstant().isNull(); } + private static boolean isDirectMethodHandle(ConstantNode node) { + if (!isObject(node)) { + return false; + } + return "Ljava/lang/invoke/DirectMethodHandle;".equals(ObjectStamp.typeOrNull(node).getName()); + } + @SuppressFBWarnings(value = "ES_COMPARING_STRINGS_WITH_EQ", justification = "reference equality is what we want") private static boolean isInternedString(ConstantNode node) { if (!isObject(node)) {
--- a/graal/com.oracle.graal.java/src/com/oracle/graal/java/GraphBuilderPhase.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.java/src/com/oracle/graal/java/GraphBuilderPhase.java Wed Apr 16 17:26:58 2014 +0200 @@ -1077,11 +1077,11 @@ * Returns a block begin node with the specified state. If the specified probability is * 0, the block deoptimizes immediately. */ - private AbstractBeginNode createBlockTarget(double probability, BciBlock block, HIRFrameStateBuilder stateAfter) { + private BeginNode createBlockTarget(double probability, BciBlock block, HIRFrameStateBuilder stateAfter) { FixedNode target = createTarget(probability, block, stateAfter); - AbstractBeginNode begin = AbstractBeginNode.begin(target); + BeginNode begin = BeginNode.begin(target); - assert !(target instanceof DeoptimizeNode && begin.stateAfter() != null) : "We are not allowed to set the stateAfter of the begin node, because we have to deoptimize " + assert !(target instanceof DeoptimizeNode && begin instanceof BeginStateSplitNode && ((BeginStateSplitNode) begin).stateAfter() != null) : "We are not allowed to set the stateAfter of the begin node, because we have to deoptimize " + "to a bci _before_ the actual if, so that the interpreter can update the profiling information."; return begin; } @@ -1299,7 +1299,7 @@ frameState.clearNonLiveLocals(currentBlock, liveness, false); } if (lastInstr instanceof StateSplit) { - if (lastInstr.getClass() == AbstractBeginNode.class) { + if (lastInstr.getClass() == BeginNode.class) { // BeginNodes do not need a frame state } else { StateSplit stateSplit = (StateSplit) lastInstr;
--- a/graal/com.oracle.graal.java/src/com/oracle/graal/java/HIRFrameStateBuilder.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.java/src/com/oracle/graal/java/HIRFrameStateBuilder.java Wed Apr 16 17:26:58 2014 +0200 @@ -259,7 +259,7 @@ } } - public void insertProxies(AbstractBeginNode begin) { + public void insertProxies(BeginNode begin) { for (int i = 0; i < localsSize(); i++) { ValueNode value = localAt(i); if (value != null) {
--- a/graal/com.oracle.graal.jtt/src/com/oracle/graal/jtt/loop/Loop07.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.jtt/src/com/oracle/graal/jtt/loop/Loop07.java Wed Apr 16 17:26:58 2014 +0200 @@ -26,8 +26,6 @@ import com.oracle.graal.jtt.*; -/* - */ public class Loop07 extends JTTTest { public static String test(int arg) {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.jtt/src/com/oracle/graal/jtt/loop/Loop07_2.java Wed Apr 16 17:26:58 2014 +0200 @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2014, 2014, 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.loop; + +import org.junit.*; + +import com.oracle.graal.jtt.*; + +public class Loop07_2 extends JTTTest { + + public static int test(int arg) { + int count = arg; + for (int i = 0; i < arg; i++) { + count++; + } + return count; + } + + @Test + public void run0() throws Throwable { + runTest("test", 0); + } + + @Test + public void run1() throws Throwable { + runTest("test", 10); + } + + @Test + public void run2() throws Throwable { + runTest("test", 25); + } + +}
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/CountedLoopInfo.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/CountedLoopInfo.java Wed Apr 16 17:26:58 2014 +0200 @@ -37,9 +37,9 @@ private InductionVariable iv; private ValueNode end; private boolean oneOff; - private AbstractBeginNode body; + private BeginNode body; - CountedLoopInfo(LoopEx loop, InductionVariable iv, ValueNode end, boolean oneOff, AbstractBeginNode body) { + CountedLoopInfo(LoopEx loop, InductionVariable iv, ValueNode end, boolean oneOff, BeginNode body) { this.loop = loop; this.iv = iv; this.end = end; @@ -117,7 +117,7 @@ return oneOff; } - public AbstractBeginNode getBody() { + public BeginNode getBody() { return body; }
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopEx.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopEx.java Wed Apr 16 17:26:58 2014 +0200 @@ -123,7 +123,7 @@ return (isCounted() ? "CountedLoop [" + counted() + "] " : "Loop ") + "(depth=" + lirLoop().depth + ") " + loopBegin(); } - private class InvariantPredicate extends NodePredicate { + private class InvariantPredicate implements NodePredicate { @Override public boolean apply(Node n) { @@ -222,9 +222,9 @@ return data; } - public NodeBitMap nodesInLoopFrom(AbstractBeginNode point, AbstractBeginNode until) { - Collection<AbstractBeginNode> blocks = new LinkedList<>(); - Collection<AbstractBeginNode> exits = new LinkedList<>(); + public NodeBitMap nodesInLoopFrom(BeginNode point, BeginNode until) { + Collection<BeginNode> blocks = new LinkedList<>(); + Collection<LoopExitNode> exits = new LinkedList<>(); Queue<Block> work = new LinkedList<>(); ControlFlowGraph cfg = loopsData().controlFlowGraph(); work.add(cfg.blockFor(point)); @@ -235,7 +235,7 @@ continue; } if (lirLoop().exits.contains(b)) { - exits.add(b.getBeginNode()); + exits.add((LoopExitNode) b.getBeginNode()); } else if (lirLoop().blocks.contains(b)) { blocks.add(b.getBeginNode()); work.addAll(b.getDominated());
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragment.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragment.java Wed Apr 16 17:26:58 2014 +0200 @@ -31,7 +31,6 @@ import com.oracle.graal.nodes.VirtualState.VirtualClosure; import com.oracle.graal.nodes.cfg.*; import com.oracle.graal.nodes.java.*; -import com.oracle.graal.nodes.util.*; import com.oracle.graal.nodes.virtual.*; public abstract class LoopFragment { @@ -79,6 +78,15 @@ duplicationMap.put(oldNode, newNode); } + /** + * Gets the corresponding value in this fragment. Should be called on duplicate fragments with a + * node from the original fragment as argument. + * + * @param b original value + * @return corresponding value in the peel + */ + protected abstract ValueNode prim(ValueNode b); + public boolean isDuplicate() { return original != null; } @@ -141,13 +149,13 @@ } } - protected static NodeBitMap computeNodes(Graph graph, Iterable<AbstractBeginNode> blocks) { - return computeNodes(graph, blocks, Collections.<AbstractBeginNode> emptyList()); + protected static NodeBitMap computeNodes(Graph graph, Iterable<BeginNode> blocks) { + return computeNodes(graph, blocks, Collections.emptyList()); } - protected static NodeBitMap computeNodes(Graph graph, Iterable<AbstractBeginNode> blocks, Iterable<AbstractBeginNode> earlyExits) { + protected static NodeBitMap computeNodes(Graph graph, Iterable<BeginNode> blocks, Iterable<LoopExitNode> earlyExits) { final NodeBitMap nodes = graph.createNodeBitMap(true); - for (AbstractBeginNode b : blocks) { + for (BeginNode b : blocks) { if (b.isDeleted()) { continue; } @@ -165,7 +173,7 @@ nodes.mark(n); } } - for (AbstractBeginNode earlyExit : earlyExits) { + for (LoopExitNode earlyExit : earlyExits) { if (earlyExit.isDeleted()) { continue; } @@ -188,7 +196,7 @@ } final NodeBitMap notloopNodes = graph.createNodeBitMap(true); - for (AbstractBeginNode b : blocks) { + for (BeginNode b : blocks) { if (b.isDeleted()) { continue; } @@ -245,19 +253,19 @@ return false; } - public static NodeIterable<AbstractBeginNode> toHirBlocks(final Iterable<Block> blocks) { - return new AbstractNodeIterable<AbstractBeginNode>() { + public static NodeIterable<BeginNode> toHirBlocks(final Iterable<Block> blocks) { + return new NodeIterable<BeginNode>() { - public Iterator<AbstractBeginNode> iterator() { + public Iterator<BeginNode> iterator() { final Iterator<Block> it = blocks.iterator(); - return new Iterator<AbstractBeginNode>() { + return new Iterator<BeginNode>() { @Override public void remove() { throw new UnsupportedOperationException(); } - public AbstractBeginNode next() { + public BeginNode next() { return it.next().getBeginNode(); } @@ -270,6 +278,31 @@ }; } + public static NodeIterable<LoopExitNode> toHirExits(final Iterable<Block> blocks) { + return new NodeIterable<LoopExitNode>() { + + public Iterator<LoopExitNode> iterator() { + final Iterator<Block> it = blocks.iterator(); + return new Iterator<LoopExitNode>() { + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + public LoopExitNode next() { + return (LoopExitNode) it.next().getBeginNode(); + } + + public boolean hasNext() { + return it.hasNext(); + } + }; + } + + }; + } + /** * Merges the early exits (i.e. loop exits) that were duplicated as part of this fragment, with * the original fragment's exits. @@ -277,38 +310,38 @@ protected void mergeEarlyExits() { assert isDuplicate(); StructuredGraph graph = graph(); - for (AbstractBeginNode earlyExit : LoopFragment.toHirBlocks(original().loop().lirLoop().exits)) { - FixedNode next = earlyExit.next(); - if (earlyExit.isDeleted() || !this.original().contains(earlyExit)) { + for (BeginNode earlyExit : LoopFragment.toHirBlocks(original().loop().lirLoop().exits)) { + LoopExitNode loopEarlyExit = (LoopExitNode) earlyExit; + FixedNode next = loopEarlyExit.next(); + if (loopEarlyExit.isDeleted() || !this.original().contains(loopEarlyExit)) { continue; } - AbstractBeginNode newEarlyExit = getDuplicatedNode(earlyExit); + BeginNode newEarlyExit = getDuplicatedNode(loopEarlyExit); if (newEarlyExit == null) { continue; } - boolean newEarlyExitIsBegin = newEarlyExit instanceof BeginNode; MergeNode merge = graph.add(new MergeNode()); AbstractEndNode originalEnd = graph.add(new EndNode()); AbstractEndNode newEnd = graph.add(new EndNode()); merge.addForwardEnd(originalEnd); merge.addForwardEnd(newEnd); - earlyExit.setNext(originalEnd); + loopEarlyExit.setNext(originalEnd); newEarlyExit.setNext(newEnd); merge.setNext(next); - FrameState exitState = earlyExit.stateAfter(); + FrameState exitState = loopEarlyExit.stateAfter(); FrameState state = null; if (exitState != null) { state = exitState; exitState = exitState.duplicateWithVirtualState(); - earlyExit.setStateAfter(exitState); + loopEarlyExit.setStateAfter(exitState); merge.setStateAfter(state); /* * Using the old exit's state as the merge's state is necessary because some of the * VirtualState nodes contained in the old exit's state may be shared by other * dominated VirtualStates. Those dominated virtual states need to see the * proxy->phi update that are applied below. - * + * * We now update the original fragment's nodes accordingly: */ state.applyToVirtual(new VirtualClosure() { @@ -322,14 +355,19 @@ } }); } + FrameState finalExitState = exitState; - for (Node anchored : earlyExit.anchored().snapshot()) { - anchored.replaceFirstInput(earlyExit, merge); + for (Node anchored : loopEarlyExit.anchored().snapshot()) { + anchored.replaceFirstInput(loopEarlyExit, merge); } - for (final ProxyNode vpn : earlyExit.proxies().snapshot()) { + boolean newEarlyExitIsLoopExit = newEarlyExit instanceof LoopExitNode; + for (final ProxyNode vpn : loopEarlyExit.proxies().snapshot()) { + if (vpn.usages().isEmpty()) { + continue; + } final ValueNode replaceWith; - ProxyNode newVpn = getDuplicatedNode(vpn); + ValueNode newVpn = prim(newEarlyExitIsLoopExit ? vpn : vpn.value()); if (newVpn != null) { PhiNode phi; if (vpn instanceof ValueProxyNode) { @@ -342,32 +380,23 @@ throw GraalInternalError.shouldNotReachHere(); } phi.addInput(vpn); - phi.addInput(newEarlyExitIsBegin ? newVpn.value() : newVpn); + phi.addInput(newVpn); replaceWith = phi; } else { replaceWith = vpn.value(); } - for (Node usage : vpn.usages().snapshot()) { - if (!merge.isPhiAtMerge(usage)) { - if (usage instanceof VirtualState) { - VirtualState stateUsage = (VirtualState) usage; - if (exitState.isPartOfThisState(stateUsage)) { - continue; - } - } - usage.replaceFirstInput(vpn, replaceWith); + vpn.replaceAtMatchingUsages(replaceWith, usage -> { + if (merge.isPhiAtMerge(usage)) { + return false; } - } - } - if (newEarlyExitIsBegin) { - FrameState stateAtNewEarlyExit = newEarlyExit.stateAfter(); - if (stateAtNewEarlyExit != null) { - newEarlyExit.setStateAfter(null); - GraphUtil.killWithUnusedFloatingInputs(stateAtNewEarlyExit); - } - for (ProxyNode proxy : newEarlyExit.proxies().snapshot()) { - GraphUtil.killWithUnusedFloatingInputs(proxy); - } + if (usage instanceof VirtualState) { + VirtualState stateUsage = (VirtualState) usage; + if (finalExitState.isPartOfThisState(stateUsage)) { + return false; + } + } + return true; + }); } } }
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragmentInside.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragmentInside.java Wed Apr 16 17:26:58 2014 +0200 @@ -29,7 +29,6 @@ import com.oracle.graal.graph.iterators.*; import com.oracle.graal.nodes.*; import com.oracle.graal.nodes.VirtualState.NodeClosure; -import com.oracle.graal.nodes.util.*; public class LoopFragmentInside extends LoopFragment { @@ -88,18 +87,13 @@ patchNodes(dataFixBefore); - AbstractBeginNode end = mergeEnds(); - - original().patchPeeling(this); + BeginNode end = mergeEnds(); mergeEarlyExits(); - AbstractBeginNode entry = getDuplicatedNode(loop.loopBegin()); - FrameState state = entry.stateAfter(); - if (state != null) { - entry.setStateAfter(null); - GraphUtil.killWithUnusedFloatingInputs(state); - } + original().patchPeeling(this); + + BeginNode entry = getDuplicatedNode(loop.loopBegin()); loop.entryPoint().replaceAtPredecessor(entry); end.setNext(loop.entryPoint()); } @@ -111,13 +105,27 @@ whole.nodes(); // init nodes bitmap in whole nodes = whole.nodes.copy(); // remove the phis - for (PhiNode phi : loop().loopBegin().phis()) { + LoopBeginNode loopBegin = loop().loopBegin(); + for (PhiNode phi : loopBegin.phis()) { nodes.clear(phi); } + for (LoopExitNode exit : exits()) { + FrameState exitState = exit.stateAfter(); + if (exitState != null) { + exitState.applyToVirtual(v -> nodes.clear(v)); + } + for (ProxyNode proxy : exit.proxies()) { + nodes.clear(proxy); + } + } } return nodes; } + public NodeIterable<LoopExitNode> exits() { + return loop().loopBegin().loopExits(); + } + @Override protected DuplicationReplacement getDuplicationReplacement() { final LoopBeginNode loopBegin = loop().loopBegin(); @@ -183,7 +191,22 @@ LoopBeginNode loopBegin = loop().loopBegin(); StructuredGraph graph = loopBegin.graph(); List<PhiNode> newPhis = new LinkedList<>(); + + NodeBitMap usagesToPatch = nodes.copy(); + for (LoopExitNode exit : exits()) { + FrameState exitState = exit.stateAfter(); + if (exitState != null) { + exitState.applyToVirtual(v -> usagesToPatch.mark(v)); + } + for (ProxyNode proxy : exit.proxies()) { + usagesToPatch.mark(proxy); + } + } + for (PhiNode phi : loopBegin.phis().snapshot()) { + if (phi.usages().isEmpty()) { + continue; + } ValueNode first; if (loopBegin.loopEnds().count() == 1) { ValueNode b = phi.valueAt(loopBegin.loopEnds().first()); // back edge value @@ -201,9 +224,8 @@ peel.putDuplicatedNode(phi, newPhi); newPhis.add(newPhi); for (Node usage : phi.usages().snapshot()) { - if (peel.getDuplicatedNode(usage) != null) { // patch only usages that should use - // the new phi ie usages that were - // peeled + // patch only usages that should use the new phi ie usages that were peeled + if (usagesToPatch.isMarked(usage)) { usage.replaceFirstInput(phi, newPhi); } } @@ -229,7 +251,8 @@ * @param b original value * @return corresponding value in the peel */ - private ValueNode prim(ValueNode b) { + @Override + protected ValueNode prim(ValueNode b) { assert isDuplicate(); LoopBeginNode loopBegin = original().loop().loopBegin(); if (loopBegin.isPhiAtMerge(b)) { @@ -246,7 +269,7 @@ } } - private AbstractBeginNode mergeEnds() { + private BeginNode mergeEnds() { assert isDuplicate(); List<AbstractEndNode> endsToMerge = new LinkedList<>(); Map<AbstractEndNode, LoopEndNode> reverseEnds = new HashMap<>(); // map peel's exit to the @@ -260,7 +283,7 @@ } } mergedInitializers = new IdentityHashMap<>(); - AbstractBeginNode newExit; + BeginNode newExit; StructuredGraph graph = graph(); if (endsToMerge.size() == 1) { AbstractEndNode end = endsToMerge.get(0); @@ -283,6 +306,9 @@ } for (final PhiNode phi : loopBegin.phis().snapshot()) { + if (phi.usages().isEmpty()) { + continue; + } final PhiNode firstPhi = patchPhi(graph, phi, newExitMerge); for (AbstractEndNode end : newExitMerge.forwardEnds()) { LoopEndNode loopEnd = reverseEnds.get(end);
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragmentWhole.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragmentWhole.java Wed Apr 16 17:26:58 2014 +0200 @@ -57,12 +57,17 @@ public NodeIterable<Node> nodes() { if (nodes == null) { Loop<Block> lirLoop = loop().lirLoop(); - nodes = LoopFragment.computeNodes(graph(), LoopFragment.toHirBlocks(lirLoop.blocks), LoopFragment.toHirBlocks(lirLoop.exits)); + nodes = LoopFragment.computeNodes(graph(), LoopFragment.toHirBlocks(lirLoop.blocks), LoopFragment.toHirExits(lirLoop.exits)); } return nodes; } @Override + protected ValueNode prim(ValueNode b) { + return getDuplicatedNode(b); + } + + @Override protected DuplicationReplacement getDuplicationReplacement() { final FixedNode entry = loop().entryPoint(); final Graph graph = this.graph();
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopPolicies.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopPolicies.java Wed Apr 16 17:26:58 2014 +0200 @@ -64,12 +64,12 @@ public static boolean shouldUnswitch(LoopEx loop, ControlSplitNode controlSplit) { Block postDomBlock = loop.loopsData().controlFlowGraph().blockFor(controlSplit).getPostdominator(); - AbstractBeginNode postDom = postDomBlock != null ? postDomBlock.getBeginNode() : null; + BeginNode postDom = postDomBlock != null ? postDomBlock.getBeginNode() : null; int loopTotal = loop.size(); int inBranchTotal = 0; double maxProbability = 0; for (Node successor : controlSplit.successors()) { - AbstractBeginNode branch = (AbstractBeginNode) successor; + BeginNode branch = (BeginNode) successor; inBranchTotal += loop.nodesInLoopFrom(branch, postDom).cardinality(); // this may count // twice because // of fall-through
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopTransformations.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopTransformations.java Wed Apr 16 17:26:58 2014 +0200 @@ -63,6 +63,7 @@ Mark mark = graph.getMark(); peel(loop); canonicalizer.applyIncremental(graph, context, mark); + loopBegin.removeDeadPhis(); loop.invalidateFragments(); if (iterations++ > UNROLL_LIMIT || graph.getNodeCount() > MaximumDesiredSize.getValue() * 3) { throw new BailoutException("FullUnroll : Graph seems to grow out of proportion"); @@ -81,19 +82,19 @@ // original loop is used as first successor Position firstPosition = successors.nextPosition(); NodeClass controlSplitClass = controlSplitNode.getNodeClass(); - controlSplitClass.set(newControlSplit, firstPosition, AbstractBeginNode.begin(originalLoop.entryPoint())); + controlSplitClass.set(newControlSplit, firstPosition, BeginNode.begin(originalLoop.entryPoint())); StructuredGraph graph = controlSplitNode.graph(); while (successors.hasNext()) { Position position = successors.nextPosition(); // create a new loop duplicate, connect it and simplify it LoopFragmentWhole duplicateLoop = originalLoop.duplicate(); - controlSplitClass.set(newControlSplit, position, AbstractBeginNode.begin(duplicateLoop.entryPoint())); + controlSplitClass.set(newControlSplit, position, BeginNode.begin(duplicateLoop.entryPoint())); ControlSplitNode duplicatedControlSplit = duplicateLoop.getDuplicatedNode(controlSplitNode); - graph.removeSplitPropagate(duplicatedControlSplit, (AbstractBeginNode) controlSplitClass.get(duplicatedControlSplit, position)); + graph.removeSplitPropagate(duplicatedControlSplit, (BeginNode) controlSplitClass.get(duplicatedControlSplit, position)); } // original loop is simplified last to avoid deleting controlSplitNode too early - graph.removeSplitPropagate(controlSplitNode, (AbstractBeginNode) controlSplitClass.get(controlSplitNode, firstPosition)); + graph.removeSplitPropagate(controlSplitNode, (BeginNode) controlSplitClass.get(controlSplitNode, firstPosition)); // TODO (gd) probabilities need some amount of fixup.. (probably also in other transforms) }
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/phases/LoopTransformLowPhase.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/phases/LoopTransformLowPhase.java Wed Apr 16 17:26:58 2014 +0200 @@ -78,7 +78,7 @@ sb.append(loop).append(" at ").append(controlSplit).append(" ["); NodeClassIterator it = controlSplit.successors().iterator(); while (it.hasNext()) { - sb.append(controlSplit.probability((AbstractBeginNode) it.next())); + sb.append(controlSplit.probability((BeginNode) it.next())); if (it.hasNext()) { sb.append(", "); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/AbstractBeginNode.java Wed Apr 16 16:54:15 2014 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,194 +0,0 @@ -/* - * Copyright (c) 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 static com.oracle.graal.graph.iterators.NodePredicates.*; - -import java.util.*; - -import com.oracle.graal.graph.*; -import com.oracle.graal.graph.iterators.*; -import com.oracle.graal.graph.spi.*; -import com.oracle.graal.nodes.extended.*; -import com.oracle.graal.nodes.spi.*; -import com.oracle.graal.nodes.type.*; - -@NodeInfo(allowedUsageTypes = {InputType.Guard, InputType.Anchor}) -public abstract class AbstractBeginNode extends FixedWithNextNode implements StateSplit, LIRLowerable, Simplifiable, GuardingNode, AnchoringNode, IterableNodeType { - - @Input(InputType.State) private FrameState stateAfter; - - public FrameState stateAfter() { - return stateAfter; - } - - public void setStateAfter(FrameState x) { - assert x == null || x.isAlive() : "frame state must be in a graph"; - updateUsages(stateAfter, x); - stateAfter = x; - } - - public boolean hasSideEffect() { - return false; - } - - protected AbstractBeginNode() { - super(StampFactory.forVoid()); - } - - protected AbstractBeginNode(Stamp stamp) { - super(stamp); - } - - public static AbstractBeginNode begin(FixedNode with) { - if (with instanceof AbstractBeginNode) { - return (AbstractBeginNode) with; - } - AbstractBeginNode begin = with.graph().add(new BeginNode()); - begin.setNext(with); - return begin; - } - - @Override - public void simplify(SimplifierTool tool) { - FixedNode prev = (FixedNode) this.predecessor(); - if (prev == null) { - // This is the start node. - } else if (prev instanceof ControlSplitNode) { - // This begin node is necessary. - } else { - // This begin node can be removed and all guards moved up to the preceding begin node. - prepareDelete(); - tool.addToWorkList(next()); - graph().removeFixed(this); - } - } - - public static AbstractBeginNode prevBegin(FixedNode from) { - Node prevBegin = from; - while (prevBegin != null) { - if (prevBegin instanceof AbstractBeginNode) { - return (AbstractBeginNode) prevBegin; - } - prevBegin = prevBegin.predecessor(); - } - return null; - } - - private void evacuateGuards(FixedNode evacuateFrom) { - if (!usages().isEmpty()) { - AbstractBeginNode prevBegin = prevBegin(evacuateFrom); - assert prevBegin != null; - for (Node anchored : anchored().snapshot()) { - anchored.replaceFirstInput(this, prevBegin); - } - } - } - - public void prepareDelete() { - prepareDelete((FixedNode) predecessor()); - } - - public void prepareDelete(FixedNode evacuateFrom) { - removeProxies(); - evacuateGuards(evacuateFrom); - } - - public void removeProxies() { - for (ProxyNode vpn : proxies().snapshot()) { - // can not use graph.replaceFloating because vpn.value may be null during killCFG - vpn.replaceAtUsages(vpn.value()); - vpn.safeDelete(); - } - } - - @Override - public boolean verify() { - assertTrue(predecessor() != null || this == graph().start() || this instanceof MergeNode, "begin nodes must be connected"); - return super.verify(); - } - - @Override - public void generate(NodeLIRBuilderTool gen) { - // nop - } - - public NodeIterable<GuardNode> guards() { - return usages().filter(GuardNode.class); - } - - public NodeIterable<Node> anchored() { - return usages().filter(isNotA(ProxyNode.class)); - } - - public NodeIterable<ProxyNode> proxies() { - return usages().filter(ProxyNode.class); - } - - public NodeIterable<FixedNode> getBlockNodes() { - return new AbstractNodeIterable<FixedNode>() { - - @Override - public Iterator<FixedNode> iterator() { - return new BlockNodeIterator(AbstractBeginNode.this); - } - }; - } - - private class BlockNodeIterator implements Iterator<FixedNode> { - - private FixedNode current; - - public BlockNodeIterator(FixedNode next) { - this.current = next; - } - - @Override - public boolean hasNext() { - return current != null; - } - - @Override - public FixedNode next() { - FixedNode ret = current; - if (ret == null) { - throw new NoSuchElementException(); - } - if (!(current instanceof FixedWithNextNode) || (current instanceof AbstractBeginNode && current != AbstractBeginNode.this)) { - current = null; - } else { - current = ((FixedWithNextNode) current).next(); - } - return ret; - } - - @Override - public void remove() { - throw new UnsupportedOperationException(); - } - } - - public FrameState getState() { - return stateAfter(); - } -}
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/AbstractFixedGuardNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/AbstractFixedGuardNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -89,7 +89,7 @@ DeoptimizeNode deopt = graph().add(new DeoptimizeNode(action, reason)); deopt.setStateBefore(stateBefore()); IfNode ifNode; - AbstractBeginNode noDeoptSuccessor; + BeginNode noDeoptSuccessor; if (negated) { ifNode = graph().add(new IfNode(condition, deopt, next, 0)); noDeoptSuccessor = ifNode.falseSuccessor();
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/BeginNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/BeginNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 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 @@ -22,11 +22,153 @@ */ package com.oracle.graal.nodes; +import static com.oracle.graal.graph.iterators.NodePredicates.*; + +import java.util.*; + +import com.oracle.graal.graph.*; +import com.oracle.graal.graph.iterators.*; +import com.oracle.graal.graph.spi.*; +import com.oracle.graal.nodes.extended.*; +import com.oracle.graal.nodes.spi.*; import com.oracle.graal.nodes.type.*; -public final class BeginNode extends AbstractBeginNode { +@NodeInfo(allowedUsageTypes = {InputType.Guard, InputType.Anchor}) +public class BeginNode extends FixedWithNextNode implements LIRLowerable, Simplifiable, GuardingNode, AnchoringNode, IterableNodeType { public BeginNode() { super(StampFactory.forVoid()); } + + public BeginNode(Stamp stamp) { + super(stamp); + } + + public static BeginNode begin(FixedNode with) { + if (with instanceof BeginNode) { + return (BeginNode) with; + } + BeginNode begin = with.graph().add(new BeginNode()); + begin.setNext(with); + return begin; + } + + @Override + public void simplify(SimplifierTool tool) { + FixedNode prev = (FixedNode) this.predecessor(); + if (prev == null) { + // This is the start node. + } else if (prev instanceof ControlSplitNode) { + // This begin node is necessary. + } else { + // This begin node can be removed and all guards moved up to the preceding begin node. + prepareDelete(); + tool.addToWorkList(next()); + graph().removeFixed(this); + } + } + + public static BeginNode prevBegin(FixedNode from) { + Node prevBegin = from; + while (prevBegin != null) { + if (prevBegin instanceof BeginNode) { + return (BeginNode) prevBegin; + } + prevBegin = prevBegin.predecessor(); + } + return null; + } + + private void evacuateGuards(FixedNode evacuateFrom) { + if (!usages().isEmpty()) { + BeginNode prevBegin = prevBegin(evacuateFrom); + assert prevBegin != null; + for (Node anchored : anchored().snapshot()) { + anchored.replaceFirstInput(this, prevBegin); + } + } + } + + public void prepareDelete() { + prepareDelete((FixedNode) predecessor()); + } + + public void prepareDelete(FixedNode evacuateFrom) { + removeProxies(); + evacuateGuards(evacuateFrom); + } + + public void removeProxies() { + for (ProxyNode vpn : proxies().snapshot()) { + // can not use graph.replaceFloating because vpn.value may be null during killCFG + vpn.replaceAtUsages(vpn.value()); + vpn.safeDelete(); + } + } + + @Override + public boolean verify() { + assertTrue(predecessor() != null || this == graph().start() || this instanceof MergeNode, "begin nodes must be connected"); + return super.verify(); + } + + @Override + public void generate(NodeLIRBuilderTool gen) { + // nop + } + + public NodeIterable<GuardNode> guards() { + return usages().filter(GuardNode.class); + } + + public NodeIterable<Node> anchored() { + return usages().filter(isNotA(ProxyNode.class)); + } + + public NodeIterable<ProxyNode> proxies() { + return usages().filter(ProxyNode.class); + } + + public NodeIterable<FixedNode> getBlockNodes() { + return new NodeIterable<FixedNode>() { + + @Override + public Iterator<FixedNode> iterator() { + return new BlockNodeIterator(BeginNode.this); + } + }; + } + + private class BlockNodeIterator implements Iterator<FixedNode> { + + private FixedNode current; + + public BlockNodeIterator(FixedNode next) { + this.current = next; + } + + @Override + public boolean hasNext() { + return current != null; + } + + @Override + public FixedNode next() { + FixedNode ret = current; + if (ret == null) { + throw new NoSuchElementException(); + } + if (!(current instanceof FixedWithNextNode) || (current instanceof BeginNode && current != BeginNode.this)) { + current = null; + } else { + current = ((FixedWithNextNode) current).next(); + } + return ret; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/BeginStateSplitNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/BeginStateSplitNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -22,16 +22,19 @@ */ package com.oracle.graal.nodes; +import com.oracle.graal.graph.*; import com.oracle.graal.nodes.type.*; /** - * Base class for {@link AbstractBeginNode}s that are associated with a frame state. - * - * TODO (dnsimon) this not needed until {@link AbstractBeginNode} no longer implements - * {@link StateSplit} which is not possible until loop peeling works without requiring begin nodes - * to have frames states. + * Base class for {@link BeginNode}s that are associated with a frame state. + * + * TODO (dnsimon) this not needed until {@link BeginNode} no longer implements {@link StateSplit} + * which is not possible until loop peeling works without requiring begin nodes to have frames + * states. */ -public abstract class BeginStateSplitNode extends AbstractBeginNode implements StateSplit { +public abstract class BeginStateSplitNode extends BeginNode implements StateSplit { + + @Input(InputType.State) private FrameState stateAfter; public BeginStateSplitNode() { } @@ -40,6 +43,16 @@ super(stamp); } + public FrameState stateAfter() { + return stateAfter; + } + + public void setStateAfter(FrameState x) { + assert x == null || x.isAlive() : "frame state must be in a graph"; + updateUsages(stateAfter, x); + stateAfter = x; + } + /** * A begin node has no side effect. */
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ControlSplitNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ControlSplitNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -35,7 +35,7 @@ super(stamp); } - public abstract double probability(AbstractBeginNode successor); + public abstract double probability(BeginNode successor); - public abstract void setProbability(AbstractBeginNode successor, double value); + public abstract void setProbability(BeginNode successor, double value); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/EntryMarkerNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/EntryMarkerNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -31,7 +31,7 @@ * by the graph builder. */ @NodeInfo(allowedUsageTypes = {InputType.Association}) -public class EntryMarkerNode extends AbstractBeginNode implements IterableNodeType, Simplifiable, LIRLowerable { +public class EntryMarkerNode extends BeginStateSplitNode implements IterableNodeType, Simplifiable, LIRLowerable { @Override public void simplify(SimplifierTool tool) {
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/GuardProxyNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/GuardProxyNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -32,7 +32,7 @@ @Input(InputType.Guard) private GuardingNode value; - public GuardProxyNode(GuardingNode value, AbstractBeginNode proxyPoint) { + public GuardProxyNode(GuardingNode value, BeginNode proxyPoint) { super(StampFactory.forVoid(), proxyPoint); this.value = value; }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/IfNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/IfNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -44,8 +44,8 @@ */ public final class IfNode extends ControlSplitNode implements Simplifiable, LIRLowerable, MemoryArithmeticLIRLowerable { - @Successor private AbstractBeginNode trueSuccessor; - @Successor private AbstractBeginNode falseSuccessor; + @Successor private BeginNode trueSuccessor; + @Successor private BeginNode falseSuccessor; @Input(InputType.Condition) private LogicNode condition; private double trueSuccessorProbability; @@ -59,10 +59,10 @@ } public IfNode(LogicNode condition, FixedNode trueSuccessor, FixedNode falseSuccessor, double trueSuccessorProbability) { - this(condition, AbstractBeginNode.begin(trueSuccessor), AbstractBeginNode.begin(falseSuccessor), trueSuccessorProbability); + this(condition, BeginNode.begin(trueSuccessor), BeginNode.begin(falseSuccessor), trueSuccessorProbability); } - public IfNode(LogicNode condition, AbstractBeginNode trueSuccessor, AbstractBeginNode falseSuccessor, double trueSuccessorProbability) { + public IfNode(LogicNode condition, BeginNode trueSuccessor, BeginNode falseSuccessor, double trueSuccessorProbability) { super(StampFactory.forVoid()); this.condition = condition; this.falseSuccessor = falseSuccessor; @@ -76,7 +76,7 @@ * * @return the true successor */ - public AbstractBeginNode trueSuccessor() { + public BeginNode trueSuccessor() { return trueSuccessor; } @@ -85,16 +85,16 @@ * * @return the false successor */ - public AbstractBeginNode falseSuccessor() { + public BeginNode falseSuccessor() { return falseSuccessor; } - public void setTrueSuccessor(AbstractBeginNode node) { + public void setTrueSuccessor(BeginNode node) { updatePredecessor(trueSuccessor, node); trueSuccessor = node; } - public void setFalseSuccessor(AbstractBeginNode node) { + public void setFalseSuccessor(BeginNode node) { updatePredecessor(falseSuccessor, node); falseSuccessor = node; } @@ -105,7 +105,7 @@ * @param istrue {@code true} if the true successor is requested, {@code false} otherwise * @return the corresponding successor */ - public AbstractBeginNode successor(boolean istrue) { + public BeginNode successor(boolean istrue) { return istrue ? trueSuccessor : falseSuccessor; } @@ -115,12 +115,12 @@ } @Override - public double probability(AbstractBeginNode successor) { + public double probability(BeginNode successor) { return successor == trueSuccessor ? trueSuccessorProbability : 1 - trueSuccessorProbability; } @Override - public void setProbability(AbstractBeginNode successor, double value) { + public void setProbability(BeginNode successor, double value) { assert successor == trueSuccessor || successor == falseSuccessor; setTrueSuccessorProbability(successor == trueSuccessor ? value : 1 - value); } @@ -146,8 +146,8 @@ @Override public void simplify(SimplifierTool tool) { if (condition() instanceof LogicNegationNode) { - AbstractBeginNode trueSucc = trueSuccessor(); - AbstractBeginNode falseSucc = falseSuccessor(); + BeginNode trueSucc = trueSuccessor(); + BeginNode falseSucc = falseSuccessor(); setTrueSuccessor(null); setFalseSuccessor(null); LogicNegationNode negation = (LogicNegationNode) condition(); @@ -182,7 +182,7 @@ } if (falseSuccessor().usages().isEmpty() && (!(falseSuccessor() instanceof LoopExitNode)) && falseSuccessor().next() instanceof IfNode) { - AbstractBeginNode intermediateBegin = falseSuccessor(); + BeginNode intermediateBegin = falseSuccessor(); IfNode nextIf = (IfNode) intermediateBegin.next(); double probabilityB = (1.0 - this.trueSuccessorProbability) * nextIf.trueSuccessorProbability; if (this.trueSuccessorProbability < probabilityB) { @@ -191,7 +191,7 @@ if (prepareForSwap(tool.getConstantReflection(), condition(), nextIf.condition(), this.trueSuccessorProbability, probabilityB)) { // Reording is allowed from (if1 => begin => if2) to (if2 => begin => if1). assert intermediateBegin.next() == nextIf; - AbstractBeginNode bothFalseBegin = nextIf.falseSuccessor(); + BeginNode bothFalseBegin = nextIf.falseSuccessor(); nextIf.setFalseSuccessor(null); intermediateBegin.setNext(null); this.setFalseSuccessor(null); @@ -547,8 +547,8 @@ List<AbstractEndNode> trueEnds = new ArrayList<>(mergePredecessors.size()); Map<AbstractEndNode, ValueNode> phiValues = new HashMap<>(mergePredecessors.size()); - AbstractBeginNode oldFalseSuccessor = falseSuccessor(); - AbstractBeginNode oldTrueSuccessor = trueSuccessor(); + BeginNode oldFalseSuccessor = falseSuccessor(); + BeginNode oldTrueSuccessor = trueSuccessor(); setFalseSuccessor(null); setTrueSuccessor(null); @@ -637,7 +637,7 @@ * @param oldMerge the merge being removed * @param phiValues the values of the phi at the merge, keyed by the merge ends */ - private void connectEnds(List<AbstractEndNode> ends, Map<AbstractEndNode, ValueNode> phiValues, AbstractBeginNode successor, MergeNode oldMerge, SimplifierTool tool) { + private void connectEnds(List<AbstractEndNode> ends, Map<AbstractEndNode, ValueNode> phiValues, BeginNode successor, MergeNode oldMerge, SimplifierTool tool) { if (!ends.isEmpty()) { if (ends.size() == 1) { AbstractEndNode end = ends.get(0); @@ -703,8 +703,8 @@ } private void removeEmptyIf(SimplifierTool tool) { - AbstractBeginNode originalTrueSuccessor = trueSuccessor(); - AbstractBeginNode originalFalseSuccessor = falseSuccessor(); + BeginNode originalTrueSuccessor = trueSuccessor(); + BeginNode originalFalseSuccessor = falseSuccessor(); assert originalTrueSuccessor.next() instanceof AbstractEndNode && originalFalseSuccessor.next() instanceof AbstractEndNode; AbstractEndNode trueEnd = (AbstractEndNode) originalTrueSuccessor.next();
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/InvokeWithExceptionNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/InvokeWithExceptionNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -36,7 +36,7 @@ private static final double EXCEPTION_PROBA = 1e-5; - @Successor private AbstractBeginNode next; + @Successor private BeginNode next; @Successor private DispatchBeginNode exceptionEdge; @Input(InputType.Extension) private CallTargetNode callTarget; @Input(InputType.State) private FrameState stateDuring; @@ -66,11 +66,11 @@ exceptionEdge = x; } - public AbstractBeginNode next() { + public BeginNode next() { return next; } - public void setNext(AbstractBeginNode x) { + public void setNext(BeginNode x) { updatePredecessor(next, x); next = x; } @@ -163,7 +163,7 @@ } public void killExceptionEdge() { - AbstractBeginNode edge = exceptionEdge(); + BeginNode edge = exceptionEdge(); setExceptionEdge(null); GraphUtil.killCFG(edge); } @@ -196,12 +196,12 @@ } @Override - public double probability(AbstractBeginNode successor) { + public double probability(BeginNode successor) { return successor == next ? 1 - exceptionProbability : exceptionProbability; } @Override - public void setProbability(AbstractBeginNode successor, double value) { + public void setProbability(BeginNode successor, double value) { assert successor == next || successor == exceptionEdge; this.exceptionProbability = successor == next ? 1 - value : value; }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/KillingBeginNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/KillingBeginNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -27,7 +27,7 @@ import com.oracle.graal.nodes.extended.*; @NodeInfo(allowedUsageTypes = {InputType.Memory}) -public class KillingBeginNode extends AbstractBeginNode implements MemoryCheckpoint.Single { +public class KillingBeginNode extends BeginNode implements MemoryCheckpoint.Single { private LocationIdentity locationIdentity;
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/LoopBeginNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/LoopBeginNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -178,7 +178,7 @@ // nothing yet } - public boolean isLoopExit(AbstractBeginNode begin) { + public boolean isLoopExit(BeginNode begin) { return begin instanceof LoopExitNode && ((LoopExitNode) begin).loopBegin() == this; } @@ -201,4 +201,27 @@ updateUsagesInterface(this.overflowGuard, overflowGuard); this.overflowGuard = overflowGuard; } + + /** + * Removes dead {@linkplain PhiNode phi nodes} hanging from this node. + * + * This method uses the heuristic that any node which not a phi node of this LoopBeginNode is + * alive. This allows the removal of dead phi loops. + */ + public void removeDeadPhis() { + Set<PhiNode> alive = new HashSet<>(); + for (PhiNode phi : phis()) { + NodePredicate isAlive = u -> !isPhiAtMerge(u) || alive.contains(u); + if (phi.usages().filter(isAlive).isNotEmpty()) { + alive.add(phi); + for (PhiNode keptAlive : phi.values().filter(PhiNode.class).filter(isAlive.negate())) { + alive.add(keptAlive); + } + } + } + for (PhiNode phi : phis().filter(((NodePredicate) alive::contains).negate()).snapshot()) { + phi.replaceAtUsages(null); + phi.safeDelete(); + } + } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/MemoryProxyNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/MemoryProxyNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -34,7 +34,7 @@ @Input(InputType.Memory) private MemoryNode value; private final LocationIdentity identity; - public MemoryProxyNode(MemoryNode value, AbstractBeginNode exit, LocationIdentity identity) { + public MemoryProxyNode(MemoryNode value, BeginNode exit, LocationIdentity identity) { super(StampFactory.forVoid(), exit); this.value = value; this.identity = identity;
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/MergeNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/MergeNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -124,24 +124,12 @@ } public NodeIterable<PhiNode> phis() { - return this.usages().filter(PhiNode.class).filter(new NodePredicate() { - - @Override - public boolean apply(Node n) { - return ((PhiNode) n).merge() == MergeNode.this; - } - }); + return this.usages().filter(PhiNode.class).filter(this::isPhiAtMerge); } @Override public NodeIterable<Node> anchored() { - return super.anchored().filter(isNotA(PhiNode.class).or(new NodePredicate() { - - @Override - public boolean apply(Node n) { - return ((PhiNode) n).merge() != MergeNode.this; - } - })); + return super.anchored().filter(n -> !isPhiAtMerge(n)); } @Override @@ -163,10 +151,8 @@ return; } for (PhiNode phi : phis()) { - for (Node usage : phi.usages().filter(isNotA(FrameState.class))) { - if (!merge.isPhiAtMerge(usage)) { - return; - } + if (phi.usages().filter(isNotA(FrameState.class)).and(node -> !merge.isPhiAtMerge(node)).isNotEmpty()) { + return; } } Debug.log("Split %s into ends for %s.", this, merge);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ProxyNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ProxyNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -35,9 +35,9 @@ */ public abstract class ProxyNode extends FloatingNode implements IterableNodeType, ValueNumberable { - @Input(InputType.Association) private AbstractBeginNode proxyPoint; + @Input(InputType.Association) private BeginNode proxyPoint; - public ProxyNode(Stamp stamp, AbstractBeginNode proxyPoint) { + public ProxyNode(Stamp stamp, BeginNode proxyPoint) { super(stamp); assert proxyPoint != null; this.proxyPoint = proxyPoint; @@ -45,7 +45,7 @@ public abstract ValueNode value(); - public AbstractBeginNode proxyPoint() { + public BeginNode proxyPoint() { return proxyPoint; } @@ -57,15 +57,15 @@ return super.verify(); } - public static MemoryProxyNode forMemory(MemoryNode value, AbstractBeginNode exit, LocationIdentity location, StructuredGraph graph) { + public static MemoryProxyNode forMemory(MemoryNode value, BeginNode exit, LocationIdentity location, StructuredGraph graph) { return graph.unique(new MemoryProxyNode(value, exit, location)); } - public static ValueProxyNode forValue(ValueNode value, AbstractBeginNode exit, StructuredGraph graph) { + public static ValueProxyNode forValue(ValueNode value, BeginNode exit, StructuredGraph graph) { return graph.unique(new ValueProxyNode(value, exit)); } - public static GuardProxyNode forGuard(GuardingNode value, AbstractBeginNode exit, StructuredGraph graph) { + public static GuardProxyNode forGuard(GuardingNode value, BeginNode exit, StructuredGraph graph) { return graph.unique(new GuardProxyNode(value, exit)); } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/StructuredGraph.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/StructuredGraph.java Wed Apr 16 17:26:58 2014 +0200 @@ -79,16 +79,14 @@ private boolean isAfterFloatingReadPhase = false; /** - * Creates a new Graph containing a single {@link AbstractBeginNode} as the {@link #start() - * start} node. + * Creates a new Graph containing a single {@link BeginNode} as the {@link #start() start} node. */ public StructuredGraph() { this(null, null); } /** - * Creates a new Graph containing a single {@link AbstractBeginNode} as the {@link #start() - * start} node. + * Creates a new Graph containing a single {@link BeginNode} as the {@link #start() start} node. */ public StructuredGraph(String name, ResolvedJavaMethod method) { this(name, method, uniqueGraphIds.incrementAndGet(), INVOCATION_ENTRY_BCI); @@ -255,8 +253,8 @@ */ public void removeFixed(FixedWithNextNode node) { assert node != null; - if (node instanceof AbstractBeginNode) { - ((AbstractBeginNode) node).prepareDelete(); + if (node instanceof BeginNode) { + ((BeginNode) node).prepareDelete(); } assert node.usages().isEmpty() : node + " " + node.usages(); FixedNode next = node.next(); @@ -295,7 +293,7 @@ node.safeDelete(); } - public void removeSplit(ControlSplitNode node, AbstractBeginNode survivingSuccessor) { + public void removeSplit(ControlSplitNode node, BeginNode survivingSuccessor) { assert node != null; assert node.usages().isEmpty(); assert survivingSuccessor != null; @@ -304,7 +302,7 @@ node.safeDelete(); } - public void removeSplitPropagate(ControlSplitNode node, AbstractBeginNode survivingSuccessor) { + public void removeSplitPropagate(ControlSplitNode node, BeginNode survivingSuccessor) { assert node != null; assert node.usages().isEmpty(); assert survivingSuccessor != null; @@ -321,7 +319,7 @@ } } - public void replaceSplit(ControlSplitNode node, Node replacement, AbstractBeginNode survivingSuccessor) { + public void replaceSplit(ControlSplitNode node, Node replacement, BeginNode survivingSuccessor) { if (replacement instanceof FixedWithNextNode) { replaceSplitWithFixed(node, (FixedWithNextNode) replacement, survivingSuccessor); } else { @@ -331,7 +329,7 @@ } } - public void replaceSplitWithFixed(ControlSplitNode node, FixedWithNextNode replacement, AbstractBeginNode survivingSuccessor) { + public void replaceSplitWithFixed(ControlSplitNode node, FixedWithNextNode replacement, BeginNode survivingSuccessor) { assert node != null && replacement != null && node.isAlive() && replacement.isAlive() : "cannot replace " + node + " with " + replacement; assert survivingSuccessor != null; node.clearSuccessors(); @@ -339,7 +337,7 @@ node.replaceAndDelete(replacement); } - public void replaceSplitWithFloating(ControlSplitNode node, FloatingNode replacement, AbstractBeginNode survivingSuccessor) { + public void replaceSplitWithFloating(ControlSplitNode node, FloatingNode replacement, BeginNode survivingSuccessor) { assert node != null && replacement != null && node.isAlive() && replacement.isAlive() : "cannot replace " + node + " with " + replacement; assert survivingSuccessor != null; node.clearSuccessors();
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ValueNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ValueNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -92,13 +92,7 @@ return this instanceof ConstantNode; } - private static final NodePredicate IS_CONSTANT = new NodePredicate() { - - @Override - public boolean apply(Node n) { - return n instanceof ValueNode && ((ValueNode) n).isConstant(); - } - }; + private static final NodePredicate IS_CONSTANT = node -> node instanceof ConstantNode; public static NodePredicate isConstantPredicate() { return IS_CONSTANT;
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ValueProxyNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ValueProxyNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -30,7 +30,7 @@ @Input private ValueNode value; - public ValueProxyNode(ValueNode value, AbstractBeginNode proxyPoint) { + public ValueProxyNode(ValueNode value, BeginNode proxyPoint) { super(value.stamp(), proxyPoint); this.value = value; }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/cfg/Block.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/cfg/Block.java Wed Apr 16 17:26:58 2014 +0200 @@ -29,7 +29,7 @@ public final class Block extends AbstractBlockBase<Block> { - protected final AbstractBeginNode beginNode; + protected final BeginNode beginNode; protected FixedNode endNode; protected Loop<Block> loop; @@ -37,11 +37,11 @@ protected List<Block> dominated; protected Block postdominator; - protected Block(AbstractBeginNode node) { + protected Block(BeginNode node) { this.beginNode = node; } - public AbstractBeginNode getBeginNode() { + public BeginNode getBeginNode() { return beginNode; } @@ -122,7 +122,7 @@ } else { cur = ((FixedWithNextNode) cur).next(); } - assert !(cur instanceof AbstractBeginNode); + assert !(cur instanceof BeginNode); return result; }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/cfg/ControlFlowGraph.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/cfg/ControlFlowGraph.java Wed Apr 16 17:26:58 2014 +0200 @@ -125,7 +125,7 @@ Node last; // assign proxies of a loop exit to this block - if (cur instanceof AbstractBeginNode) { + if (cur instanceof BeginNode) { for (Node usage : cur.usages()) { if (usage instanceof ProxyNode) { nodeToBlock.set(usage, block); @@ -146,7 +146,7 @@ last = cur; cur = cur.successors().first(); - } while (cur != null && !(cur instanceof AbstractBeginNode)); + } while (cur != null && !(cur instanceof BeginNode)); block.endNode = (FixedNode) last; } @@ -154,7 +154,7 @@ private void identifyBlocks() { // Find all block headers int numBlocks = 0; - for (AbstractBeginNode begin : graph.getNodes(AbstractBeginNode.class)) { + for (BeginNode begin : graph.getNodes(BeginNode.class)) { Block block = new Block(begin); numBlocks++; identifyBlock(block); @@ -256,7 +256,7 @@ for (Block b : loop.blocks) { for (Block sux : b.getSuccessors()) { if (sux.loop != loop) { - AbstractBeginNode begin = sux.getBeginNode(); + BeginNode begin = sux.getBeginNode(); if (!(begin instanceof LoopExitNode && ((LoopExitNode) begin).loopBegin() == loopBegin)) { Debug.log("Unexpected loop exit with %s, including whole branch in the loop", sux); unexpected.add(sux);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/IntegerSwitchNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/IntegerSwitchNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -49,7 +49,7 @@ * @param keyProbabilities the probabilities of the keys * @param keySuccessors the successor index for each key */ - public IntegerSwitchNode(ValueNode value, AbstractBeginNode[] successors, int[] keys, double[] keyProbabilities, int[] keySuccessors) { + public IntegerSwitchNode(ValueNode value, BeginNode[] successors, int[] keys, double[] keyProbabilities, int[] keySuccessors) { super(value, successors, keySuccessors, keyProbabilities); assert keySuccessors.length == keys.length + 1; assert keySuccessors.length == keyProbabilities.length; @@ -76,7 +76,7 @@ * @param keySuccessors the successor index for each key */ public IntegerSwitchNode(ValueNode value, int successorCount, int[] keys, double[] keyProbabilities, int[] keySuccessors) { - this(value, new AbstractBeginNode[successorCount], keys, keyProbabilities, keySuccessors); + this(value, new BeginNode[successorCount], keys, keyProbabilities, keySuccessors); } @Override @@ -139,7 +139,7 @@ tool.addToWorkList(defaultSuccessor()); graph().removeSplitPropagate(this, defaultSuccessor()); } else if (validKeys != keys.length) { - ArrayList<AbstractBeginNode> newSuccessors = new ArrayList<>(blockSuccessorCount()); + ArrayList<BeginNode> newSuccessors = new ArrayList<>(blockSuccessorCount()); int[] newKeys = new int[validKeys]; int[] newKeySuccessors = new int[validKeys + 1]; double[] newKeyProbabilities = new double[validKeys + 1]; @@ -172,14 +172,14 @@ } for (int i = 0; i < blockSuccessorCount(); i++) { - AbstractBeginNode successor = blockSuccessor(i); + BeginNode successor = blockSuccessor(i); if (!newSuccessors.contains(successor)) { tool.deleteBranch(successor); } setBlockSuccessor(i, null); } - AbstractBeginNode[] successorsArray = newSuccessors.toArray(new AbstractBeginNode[newSuccessors.size()]); + BeginNode[] successorsArray = newSuccessors.toArray(new BeginNode[newSuccessors.size()]); IntegerSwitchNode newSwitch = graph().add(new IntegerSwitchNode(value(), successorsArray, newKeys, newKeyProbabilities, newKeySuccessors)); ((FixedWithNextNode) predecessor()).setNext(newSwitch); GraphUtil.killWithUnusedFloatingInputs(this);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/SwitchNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/SwitchNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -34,7 +34,7 @@ */ public abstract class SwitchNode extends ControlSplitNode { - @Successor private final NodeSuccessorList<AbstractBeginNode> successors; + @Successor private final NodeSuccessorList<BeginNode> successors; @Input private ValueNode value; private double[] keyProbabilities; private int[] keySuccessors; @@ -45,7 +45,7 @@ * @param value the instruction that provides the value to be switched over * @param successors the list of successors of this switch */ - public SwitchNode(ValueNode value, AbstractBeginNode[] successors, int[] keySuccessors, double[] keyProbabilities) { + public SwitchNode(ValueNode value, BeginNode[] successors, int[] keySuccessors, double[] keyProbabilities) { super(StampFactory.forVoid()); assert value.getKind() == Kind.Int || value.getKind() == Kind.Long || value.getKind() == Kind.Object : value.getKind() + " key not supported by SwitchNode"; assert keySuccessors.length == keyProbabilities.length; @@ -76,7 +76,7 @@ } @Override - public double probability(AbstractBeginNode successor) { + public double probability(BeginNode successor) { double sum = 0; for (int i = 0; i < keySuccessors.length; i++) { if (successors.get(keySuccessors[i]) == successor) { @@ -87,7 +87,7 @@ } @Override - public void setProbability(AbstractBeginNode successor, double value) { + public void setProbability(BeginNode successor, double value) { double changeInProbability = 0; int nonZeroProbabilityCases = 0; for (int i = 0; i < keySuccessors.length; i++) { @@ -139,7 +139,7 @@ /** * Returns the successor for the key at the given index. */ - public AbstractBeginNode keySuccessor(int i) { + public BeginNode keySuccessor(int i) { return successors.get(keySuccessors[i]); } @@ -157,11 +157,11 @@ return keySuccessors[keySuccessors.length - 1]; } - public AbstractBeginNode blockSuccessor(int i) { + public BeginNode blockSuccessor(int i) { return successors.get(i); } - public void setBlockSuccessor(int i, AbstractBeginNode s) { + public void setBlockSuccessor(int i, BeginNode s) { successors.set(i, s); } @@ -174,7 +174,7 @@ * * @return the default successor */ - public AbstractBeginNode defaultSuccessor() { + public BeginNode defaultSuccessor() { if (defaultSuccessorIndex() == -1) { throw new GraalInternalError("unexpected"); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ValueAnchorNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ValueAnchorNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -91,7 +91,7 @@ @Override public void virtualize(VirtualizerTool tool) { - if (anchored != null && !(anchored instanceof AbstractBeginNode)) { + if (anchored != null && !(anchored instanceof BeginNode)) { State state = tool.getObjectState(anchored); if (state == null || state.getState() != EscapeState.Virtual) { return;
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/LoadFieldNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/LoadFieldNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -22,11 +22,12 @@ */ package com.oracle.graal.nodes.java; +import static com.oracle.graal.graph.iterators.NodePredicates.*; + import java.lang.reflect.*; import com.oracle.graal.api.meta.*; import com.oracle.graal.graph.*; -import com.oracle.graal.graph.iterators.*; import com.oracle.graal.graph.spi.*; import com.oracle.graal.nodes.*; import com.oracle.graal.nodes.spi.*; @@ -97,7 +98,7 @@ } private PhiNode asPhi(MetaAccessProvider metaAccess) { - if (!isStatic() && Modifier.isFinal(field.getModifiers()) && object() instanceof ValuePhiNode && ((ValuePhiNode) object()).values().filter(NodePredicates.isNotA(ConstantNode.class)).isEmpty()) { + if (!isStatic() && Modifier.isFinal(field.getModifiers()) && object() instanceof ValuePhiNode && ((ValuePhiNode) object()).values().filter(isNotA(ConstantNode.class)).isEmpty()) { PhiNode phi = (PhiNode) object(); Constant[] constants = new Constant[phi.valueCount()]; for (int i = 0; i < phi.valueCount(); i++) {
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/TypeSwitchNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/TypeSwitchNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -51,7 +51,7 @@ * @param keyProbabilities the probabilities of the keys * @param keySuccessors the successor index for each key */ - public TypeSwitchNode(ValueNode value, AbstractBeginNode[] successors, ResolvedJavaType[] keys, double[] keyProbabilities, int[] keySuccessors) { + public TypeSwitchNode(ValueNode value, BeginNode[] successors, ResolvedJavaType[] keys, double[] keyProbabilities, int[] keySuccessors) { super(value, successors, keySuccessors, keyProbabilities); assert successors.length <= keys.length + 1; assert keySuccessors.length == keyProbabilities.length; @@ -134,7 +134,7 @@ tool.addToWorkList(defaultSuccessor()); graph().removeSplitPropagate(this, defaultSuccessor()); } else if (validKeys != keys.length) { - ArrayList<AbstractBeginNode> newSuccessors = new ArrayList<>(blockSuccessorCount()); + ArrayList<BeginNode> newSuccessors = new ArrayList<>(blockSuccessorCount()); ResolvedJavaType[] newKeys = new ResolvedJavaType[validKeys]; int[] newKeySuccessors = new int[validKeys + 1]; double[] newKeyProbabilities = new double[validKeys + 1]; @@ -167,14 +167,14 @@ } for (int i = 0; i < blockSuccessorCount(); i++) { - AbstractBeginNode successor = blockSuccessor(i); + BeginNode successor = blockSuccessor(i); if (!newSuccessors.contains(successor)) { tool.deleteBranch(successor); } setBlockSuccessor(i, null); } - AbstractBeginNode[] successorsArray = newSuccessors.toArray(new AbstractBeginNode[newSuccessors.size()]); + BeginNode[] successorsArray = newSuccessors.toArray(new BeginNode[newSuccessors.size()]); TypeSwitchNode newSwitch = graph().add(new TypeSwitchNode(value(), successorsArray, newKeys, newKeyProbabilities, newKeySuccessors)); ((FixedWithNextNode) predecessor()).setNext(newSwitch); GraphUtil.killWithUnusedFloatingInputs(this);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/NodeLIRBuilderTool.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/NodeLIRBuilderTool.java Wed Apr 16 17:26:58 2014 +0200 @@ -59,7 +59,7 @@ LIRGeneratorTool getLIRGeneratorTool(); - void emitOverflowCheckBranch(AbstractBeginNode overflowSuccessor, AbstractBeginNode next, double probability); + void emitOverflowCheckBranch(BeginNode overflowSuccessor, BeginNode next, double probability); Value[] visitInvokeArguments(CallingConvention cc, Collection<ValueNode> arguments);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/util/GraphUtil.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/util/GraphUtil.java Wed Apr 16 17:26:58 2014 +0200 @@ -38,7 +38,6 @@ @Override public final boolean apply(Node n) { - // isA(FloatingNode.class).or(VirtualState.class).or(CallTargetNode.class) return n instanceof FloatingNode || n instanceof VirtualState || n instanceof CallTargetNode; } }; @@ -164,7 +163,7 @@ } public static void checkRedundantProxy(ProxyNode vpn) { - AbstractBeginNode proxyPoint = vpn.proxyPoint(); + BeginNode proxyPoint = vpn.proxyPoint(); if (proxyPoint instanceof LoopExitNode) { LoopExitNode exit = (LoopExitNode) proxyPoint; LoopBeginNode loopBegin = exit.loopBegin();
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/util/NodeIterators.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/util/NodeIterators.java Wed Apr 16 17:26:58 2014 +0200 @@ -30,7 +30,7 @@ public class NodeIterators { public static NodeIterable<FixedNode> dominators(final FixedNode n) { - return new AbstractNodeIterable<FixedNode>() { + return new NodeIterable<FixedNode>() { @Override public Iterator<FixedNode> iterator() {
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConditionalEliminationPhase.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConditionalEliminationPhase.java Wed Apr 16 17:26:58 2014 +0200 @@ -407,7 +407,7 @@ } } - private void registerControlSplitInfo(Node pred, AbstractBeginNode begin) { + private void registerControlSplitInfo(Node pred, BeginNode begin) { assert pred != null && begin != null; if (begin instanceof LoopExitNode) { state.clear(); @@ -656,8 +656,8 @@ @Override protected void node(FixedNode node) { - if (node instanceof AbstractBeginNode) { - AbstractBeginNode begin = (AbstractBeginNode) node; + if (node instanceof BeginNode) { + BeginNode begin = (BeginNode) node; Node pred = node.predecessor(); if (pred != null) { @@ -742,7 +742,7 @@ LogicNode replacement = null; ValueNode replacementAnchor = null; - AbstractBeginNode survivingSuccessor = null; + BeginNode survivingSuccessor = null; if (state.trueConditions.containsKey(compare)) { replacement = trueConstant; replacementAnchor = state.trueConditions.get(compare); @@ -764,7 +764,7 @@ } if (replacement != null) { - if (!(replacementAnchor instanceof AbstractBeginNode)) { + if (!(replacementAnchor instanceof BeginNode)) { ValueAnchorNode anchor = graph.add(new ValueAnchorNode(replacementAnchor)); graph.addBeforeFixed(ifNode, anchor); }
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConvertDeoptimizeToGuardPhase.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConvertDeoptimizeToGuardPhase.java Wed Apr 16 17:26:58 2014 +0200 @@ -47,11 +47,11 @@ */ public class ConvertDeoptimizeToGuardPhase extends Phase { - private static AbstractBeginNode findBeginNode(FixedNode startNode) { + private static BeginNode findBeginNode(FixedNode startNode) { Node n = startNode; while (true) { - if (n instanceof AbstractBeginNode) { - return (AbstractBeginNode) n; + if (n instanceof BeginNode) { + return (BeginNode) n; } else { n = n.predecessor(); } @@ -71,7 +71,7 @@ for (FixedGuardNode fixedGuard : graph.getNodes(FixedGuardNode.class)) { - AbstractBeginNode pred = BeginNode.prevBegin(fixedGuard); + BeginNode pred = BeginNode.prevBegin(fixedGuard); if (pred instanceof MergeNode) { MergeNode merge = (MergeNode) pred; if (fixedGuard.condition() instanceof CompareNode) { @@ -109,17 +109,17 @@ new DeadCodeEliminationPhase().apply(graph); } - private void visitDeoptBegin(AbstractBeginNode deoptBegin, DeoptimizationAction deoptAction, DeoptimizationReason deoptReason, StructuredGraph graph) { + private void visitDeoptBegin(BeginNode deoptBegin, DeoptimizationAction deoptAction, DeoptimizationReason deoptReason, StructuredGraph graph) { if (deoptBegin instanceof MergeNode) { MergeNode mergeNode = (MergeNode) deoptBegin; Debug.log("Visiting %s", mergeNode); - List<AbstractBeginNode> begins = new ArrayList<>(); + List<BeginNode> begins = new ArrayList<>(); for (AbstractEndNode end : mergeNode.forwardEnds()) { - AbstractBeginNode newBeginNode = findBeginNode(end); + BeginNode newBeginNode = findBeginNode(end); assert !begins.contains(newBeginNode); begins.add(newBeginNode); } - for (AbstractBeginNode begin : begins) { + for (BeginNode begin : begins) { assert !begin.isDeleted(); visitDeoptBegin(begin, deoptAction, deoptReason, graph); } @@ -127,11 +127,11 @@ return; } else if (deoptBegin.predecessor() instanceof IfNode) { IfNode ifNode = (IfNode) deoptBegin.predecessor(); - AbstractBeginNode otherBegin = ifNode.trueSuccessor(); + BeginNode otherBegin = ifNode.trueSuccessor(); LogicNode conditionNode = ifNode.condition(); FixedGuardNode guard = graph.add(new FixedGuardNode(conditionNode, deoptReason, deoptAction, deoptBegin == ifNode.trueSuccessor())); FixedWithNextNode pred = (FixedWithNextNode) ifNode.predecessor(); - AbstractBeginNode survivingSuccessor; + BeginNode survivingSuccessor; if (deoptBegin == ifNode.trueSuccessor()) { survivingSuccessor = ifNode.falseSuccessor(); } else {
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ExpandLogicPhase.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ExpandLogicPhase.java Wed Apr 16 17:26:58 2014 +0200 @@ -54,8 +54,8 @@ } private static void processIf(LogicNode x, boolean xNegated, LogicNode y, boolean yNegated, IfNode ifNode, double shortCircuitProbability) { - AbstractBeginNode trueTarget = ifNode.trueSuccessor(); - AbstractBeginNode falseTarget = ifNode.falseSuccessor(); + BeginNode trueTarget = ifNode.trueSuccessor(); + BeginNode falseTarget = ifNode.falseSuccessor(); double firstIfProbability = shortCircuitProbability; /* * P(Y | not(X)) = P(Y inter not(X)) / P(not(X)) = (P(X union Y) - P(X)) / (1 - P(X)) @@ -77,9 +77,9 @@ EndNode secondTrueEnd = graph.add(new EndNode()); trueTargetMerge.addForwardEnd(firstTrueEnd); trueTargetMerge.addForwardEnd(secondTrueEnd); - AbstractBeginNode firstTrueTarget = AbstractBeginNode.begin(firstTrueEnd); - AbstractBeginNode secondTrueTarget = AbstractBeginNode.begin(secondTrueEnd); - AbstractBeginNode secondIf = AbstractBeginNode.begin(graph.add(new IfNode(y, yNegated ? falseTarget : secondTrueTarget, yNegated ? secondTrueTarget : falseTarget, secondIfProbability))); + BeginNode firstTrueTarget = BeginNode.begin(firstTrueEnd); + BeginNode secondTrueTarget = BeginNode.begin(secondTrueEnd); + BeginNode secondIf = BeginNode.begin(graph.add(new IfNode(y, yNegated ? falseTarget : secondTrueTarget, yNegated ? secondTrueTarget : falseTarget, secondIfProbability))); IfNode firstIf = graph.add(new IfNode(x, xNegated ? secondIf : firstTrueTarget, xNegated ? firstTrueTarget : secondIf, firstIfProbability)); ifNode.replaceAtPredecessor(firstIf); ifNode.safeDelete();
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/FloatingReadPhase.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/FloatingReadPhase.java Wed Apr 16 17:26:58 2014 +0200 @@ -191,7 +191,7 @@ } @Override - protected Set<LocationIdentity> afterSplit(AbstractBeginNode node, Set<LocationIdentity> oldState) { + protected Set<LocationIdentity> afterSplit(BeginNode node, Set<LocationIdentity> oldState) { return new HashSet<>(oldState); } @@ -292,7 +292,7 @@ } @Override - protected MemoryMapImpl afterSplit(AbstractBeginNode node, MemoryMapImpl oldState) { + protected MemoryMapImpl afterSplit(BeginNode node, MemoryMapImpl oldState) { MemoryMapImpl result = new MemoryMapImpl(oldState); if (node.predecessor() instanceof InvokeWithExceptionNode) { /*
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/FrameStateAssignmentPhase.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/FrameStateAssignmentPhase.java Wed Apr 16 17:26:58 2014 +0200 @@ -92,7 +92,7 @@ } @Override - protected FrameState afterSplit(AbstractBeginNode node, FrameState oldState) { + protected FrameState afterSplit(BeginNode node, FrameState oldState) { return oldState; }
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/GuardLoweringPhase.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/GuardLoweringPhase.java Wed Apr 16 17:26:58 2014 +0200 @@ -154,12 +154,12 @@ private void lowerToIf(GuardNode guard) { StructuredGraph graph = guard.graph(); - AbstractBeginNode fastPath = graph.add(new BeginNode()); + BeginNode fastPath = graph.add(new BeginNode()); @SuppressWarnings("deprecation") DeoptimizeNode deopt = graph.add(new DeoptimizeNode(guard.action(), guard.reason(), useGuardIdAsDebugId ? guard.getId() : 0, guard.getSpeculation())); - AbstractBeginNode deoptBranch = AbstractBeginNode.begin(deopt); - AbstractBeginNode trueSuccessor; - AbstractBeginNode falseSuccessor; + BeginNode deoptBranch = BeginNode.begin(deopt); + BeginNode trueSuccessor; + BeginNode falseSuccessor; insertLoopExits(deopt); if (guard.negated()) { trueSuccessor = deoptBranch;
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/InliningUtil.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/InliningUtil.java Wed Apr 16 17:26:58 2014 +0200 @@ -646,7 +646,7 @@ } // create one separate block for each invoked method - AbstractBeginNode[] successors = new AbstractBeginNode[numberOfMethods + 1]; + BeginNode[] successors = new BeginNode[numberOfMethods + 1]; for (int i = 0; i < numberOfMethods; i++) { successors[i] = createInvocationBlock(graph, invoke, returnMerge, returnValuePhi, exceptionMerge, exceptionObjectPhi, true); } @@ -658,7 +658,7 @@ } else { unknownTypeSux = graph.add(new DeoptimizeNode(DeoptimizationAction.InvalidateReprofile, DeoptimizationReason.TypeCheckedInliningViolated)); } - successors[successors.length - 1] = AbstractBeginNode.begin(unknownTypeSux); + successors[successors.length - 1] = BeginNode.begin(unknownTypeSux); // replace the invoke exception edge if (invoke instanceof InvokeWithExceptionNode) { @@ -684,7 +684,7 @@ // do the actual inlining for every invoke for (int i = 0; i < numberOfMethods; i++) { - AbstractBeginNode node = successors[i]; + BeginNode node = successors[i]; Invoke invokeForInlining = (Invoke) node.next(); ResolvedJavaType commonType; @@ -770,10 +770,10 @@ private void inlineSingleMethod(StructuredGraph graph, MetaAccessProvider metaAccess, Assumptions assumptions) { assert concretes.size() == 1 && inlineableElements.length == 1 && ptypes.size() > 1 && !shouldFallbackToInvoke() && notRecordedTypeProbability == 0; - AbstractBeginNode calleeEntryNode = graph.add(new BeginNode()); + BeginNode calleeEntryNode = graph.add(new BeginNode()); - AbstractBeginNode unknownTypeSux = createUnknownTypeSuccessor(graph); - AbstractBeginNode[] successors = new AbstractBeginNode[]{calleeEntryNode, unknownTypeSux}; + BeginNode unknownTypeSux = createUnknownTypeSuccessor(graph); + BeginNode[] successors = new BeginNode[]{calleeEntryNode, unknownTypeSux}; createDispatchOnTypeBeforeInvoke(graph, successors, false, metaAccess); calleeEntryNode.setNext(invoke.asNode()); @@ -781,7 +781,7 @@ inline(invoke, methodAt(0), inlineableElementAt(0), assumptions, false); } - private boolean createDispatchOnTypeBeforeInvoke(StructuredGraph graph, AbstractBeginNode[] successors, boolean invokeIsOnlySuccessor, MetaAccessProvider metaAccess) { + private boolean createDispatchOnTypeBeforeInvoke(StructuredGraph graph, BeginNode[] successors, boolean invokeIsOnlySuccessor, MetaAccessProvider metaAccess) { assert ptypes.size() >= 1; ValueNode nonNullReceiver = nonNullReceiver(invoke); Kind hubKind = ((MethodCallTargetNode) invoke.callTarget()).targetMethod().getDeclaringClass().getEncoding(Representation.ObjectHub).getKind(); @@ -891,10 +891,10 @@ return costEstimateMethodDispatch < costEstimateTypeDispatch; } - private static AbstractBeginNode createInvocationBlock(StructuredGraph graph, Invoke invoke, MergeNode returnMerge, PhiNode returnValuePhi, MergeNode exceptionMerge, - PhiNode exceptionObjectPhi, boolean useForInlining) { + private static BeginNode createInvocationBlock(StructuredGraph graph, Invoke invoke, MergeNode returnMerge, PhiNode returnValuePhi, MergeNode exceptionMerge, PhiNode exceptionObjectPhi, + boolean useForInlining) { Invoke duplicatedInvoke = duplicateInvokeForInlining(graph, invoke, exceptionMerge, exceptionObjectPhi, useForInlining); - AbstractBeginNode calleeEntryNode = graph.add(new BeginNode()); + BeginNode calleeEntryNode = graph.add(new BeginNode()); calleeEntryNode.setNext(duplicatedInvoke.asNode()); AbstractEndNode endNode = graph.add(new EndNode()); @@ -969,9 +969,9 @@ } private void devirtualizeWithTypeSwitch(StructuredGraph graph, InvokeKind kind, ResolvedJavaMethod target, MetaAccessProvider metaAccess) { - AbstractBeginNode invocationEntry = graph.add(new BeginNode()); - AbstractBeginNode unknownTypeSux = createUnknownTypeSuccessor(graph); - AbstractBeginNode[] successors = new AbstractBeginNode[]{invocationEntry, unknownTypeSux}; + BeginNode invocationEntry = graph.add(new BeginNode()); + BeginNode unknownTypeSux = createUnknownTypeSuccessor(graph); + BeginNode[] successors = new BeginNode[]{invocationEntry, unknownTypeSux}; createDispatchOnTypeBeforeInvoke(graph, successors, true, metaAccess); invocationEntry.setNext(invoke.asNode()); @@ -981,8 +981,8 @@ replaceInvokeCallTarget(invoke, graph, kind, target); } - private static AbstractBeginNode createUnknownTypeSuccessor(StructuredGraph graph) { - return AbstractBeginNode.begin(graph.add(new DeoptimizeNode(DeoptimizationAction.InvalidateReprofile, DeoptimizationReason.TypeCheckedInliningViolated))); + private static BeginNode createUnknownTypeSuccessor(StructuredGraph graph) { + return BeginNode.begin(graph.add(new DeoptimizeNode(DeoptimizationAction.InvalidateReprofile, DeoptimizationReason.TypeCheckedInliningViolated))); } @Override @@ -1347,7 +1347,7 @@ } } - final AbstractBeginNode prevBegin = AbstractBeginNode.prevBegin(invokeNode); + final BeginNode prevBegin = BeginNode.prevBegin(invokeNode); DuplicationReplacement localReplacement = new DuplicationReplacement() { public Node replacement(Node node) { @@ -1386,7 +1386,7 @@ } // get rid of memory kill - AbstractBeginNode begin = invokeWithException.next(); + BeginNode begin = invokeWithException.next(); if (begin instanceof KillingBeginNode) { BeginNode newBegin = new BeginNode(); graph.addAfterFixed(begin, graph.add(newBegin));
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/OptimizeGuardAnchorsPhase.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/OptimizeGuardAnchorsPhase.java Wed Apr 16 17:26:58 2014 +0200 @@ -55,11 +55,11 @@ @Override protected void run(StructuredGraph graph) { LazyCFG cfg = new LazyCFG(graph); - for (AbstractBeginNode begin : graph.getNodes(AbstractBeginNode.class)) { + for (BeginNode begin : graph.getNodes(BeginNode.class)) { if (!(begin instanceof StartNode || begin.predecessor() instanceof ControlSplitNode)) { NodeIterable<GuardNode> guards = begin.guards(); if (guards.isNotEmpty()) { - AbstractBeginNode newAnchor = computeOptimalAnchor(cfg.get(), begin); + BeginNode newAnchor = computeOptimalAnchor(cfg.get(), begin); // newAnchor == begin is possible because postdominator computation assumes that // loops never end if (newAnchor != begin) { @@ -76,14 +76,14 @@ } } - public static AbstractBeginNode getOptimalAnchor(LazyCFG cfg, AbstractBeginNode begin) { + public static BeginNode getOptimalAnchor(LazyCFG cfg, BeginNode begin) { if (begin instanceof StartNode || begin.predecessor() instanceof ControlSplitNode) { return begin; } return computeOptimalAnchor(cfg.get(), begin); } - private static AbstractBeginNode computeOptimalAnchor(ControlFlowGraph cfg, AbstractBeginNode begin) { + private static BeginNode computeOptimalAnchor(ControlFlowGraph cfg, BeginNode begin) { Block anchor = cfg.blockFor(begin); while (anchor.getDominator() != null && anchor.getDominator().getPostdominator() == anchor) { anchor = anchor.getDominator(); @@ -92,7 +92,7 @@ } private static void optimizeAtControlSplit(ControlSplitNode controlSplit, LazyCFG cfg) { - AbstractBeginNode successor = findMinimumUsagesSuccessor(controlSplit); + BeginNode successor = findMinimumUsagesSuccessor(controlSplit); int successorCount = controlSplit.successors().count(); List<GuardNode> otherGuards = new ArrayList<>(successorCount - 1); for (GuardNode guard : successor.guards().snapshot()) { @@ -109,7 +109,7 @@ } if (otherGuards.size() == successorCount - 1) { - AbstractBeginNode anchor = computeOptimalAnchor(cfg.get(), AbstractBeginNode.prevBegin(controlSplit)); + BeginNode anchor = computeOptimalAnchor(cfg.get(), BeginNode.prevBegin(controlSplit)); GuardNode newGuard = controlSplit.graph().unique(new GuardNode(guard.condition(), anchor, guard.reason(), guard.action(), guard.negated(), guard.getSpeculation())); for (GuardNode otherGuard : otherGuards) { otherGuard.replaceAndDelete(newGuard); @@ -126,12 +126,12 @@ conditonGuard.getSpeculation().equals(guard.getSpeculation()); } - private static AbstractBeginNode findMinimumUsagesSuccessor(ControlSplitNode controlSplit) { + private static BeginNode findMinimumUsagesSuccessor(ControlSplitNode controlSplit) { NodeClassIterator successors = controlSplit.successors().iterator(); - AbstractBeginNode min = (AbstractBeginNode) successors.next(); + BeginNode min = (BeginNode) successors.next(); int minUsages = min.usages().count(); while (successors.hasNext()) { - AbstractBeginNode successor = (AbstractBeginNode) successors.next(); + BeginNode successor = (BeginNode) successors.next(); int count = successor.usages().count(); if (count < minUsages) { minUsages = count;
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ProfileCompiledMethodsPhase.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ProfileCompiledMethodsPhase.java Wed Apr 16 17:26:58 2014 +0200 @@ -108,7 +108,7 @@ private static double getNodeWeight(ScheduledNode node) { if (node instanceof MergeNode) { return ((MergeNode) node).phiPredecessorCount(); - } else if (node instanceof AbstractBeginNode || node instanceof AbstractEndNode || node instanceof MonitorIdNode || node instanceof ConstantNode || node instanceof ParameterNode || + } else if (node instanceof BeginNode || node instanceof AbstractEndNode || node instanceof MonitorIdNode || node instanceof ConstantNode || node instanceof ParameterNode || node instanceof CallTargetNode || node instanceof ValueProxy || node instanceof VirtualObjectNode || node instanceof ReinterpretNode) { return 0; } else if (node instanceof AccessMonitorNode) {
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/TailDuplicationPhase.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/TailDuplicationPhase.java Wed Apr 16 17:26:58 2014 +0200 @@ -293,7 +293,7 @@ // EndNode FixedWithNextNode anchorDuplicate = (FixedWithNextNode) duplicates.get(anchor); // move dependencies on the ValueAnchorNode to the previous BeginNode - AbstractBeginNode prevBegin = AbstractBeginNode.prevBegin(forwardEnd); + BeginNode prevBegin = BeginNode.prevBegin(forwardEnd); anchorDuplicate.replaceAtUsages(InputType.Guard, prevBegin); anchorDuplicate.replaceAtUsages(InputType.Anchor, prevBegin); assert anchorDuplicate.usages().isEmpty();
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/UseTrappingNullChecksPhase.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/UseTrappingNullChecksPhase.java Wed Apr 16 17:26:58 2014 +0200 @@ -55,7 +55,7 @@ } Node predecessor = deopt.predecessor(); Node branch = null; - while (predecessor instanceof AbstractBeginNode) { + while (predecessor instanceof BeginNode) { branch = predecessor; predecessor = predecessor.predecessor(); } @@ -73,8 +73,8 @@ private static void replaceWithTrappingNullCheck(DeoptimizeNode deopt, IfNode ifNode, LogicNode condition) { IsNullNode isNullNode = (IsNullNode) condition; - AbstractBeginNode nonTrappingContinuation = ifNode.falseSuccessor(); - AbstractBeginNode trappingContinuation = ifNode.trueSuccessor(); + BeginNode nonTrappingContinuation = ifNode.falseSuccessor(); + BeginNode trappingContinuation = ifNode.trueSuccessor(); NullCheckNode trappingNullCheck = deopt.graph().add(new NullCheckNode(isNullNode.object())); trappingNullCheck.setStateBefore(deopt.stateBefore()); deopt.graph().replaceSplit(ifNode, trappingNullCheck, nonTrappingContinuation);
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ComputeInliningRelevanceClosure.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ComputeInliningRelevanceClosure.java Wed Apr 16 17:26:58 2014 +0200 @@ -171,7 +171,7 @@ int pathBeginCount = pathBeginNodes.size(); for (Node sux : controlSplit.successors()) { - double probability = controlSplit.probability((AbstractBeginNode) sux); + double probability = controlSplit.probability((BeginNode) sux); if (probability > maxProbability) { maxProbability = probability; maxSux = sux;
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ComputeProbabilityClosure.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ComputeProbabilityClosure.java Wed Apr 16 17:26:58 2014 +0200 @@ -223,7 +223,7 @@ } @Override - public void afterSplit(AbstractBeginNode node) { + public void afterSplit(BeginNode node) { assert node.predecessor() != null; Node pred = node.predecessor(); ControlSplitNode x = (ControlSplitNode) pred;
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/MergeableState.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/MergeableState.java Wed Apr 16 17:26:58 2014 +0200 @@ -58,7 +58,7 @@ * * @param node the successor of the control split that is about to be visited */ - public void afterSplit(AbstractBeginNode node) { + public void afterSplit(BeginNode node) { // empty default implementation } }
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/PostOrderNodeIterator.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/PostOrderNodeIterator.java Wed Apr 16 17:26:58 2014 +0200 @@ -43,7 +43,7 @@ public abstract class PostOrderNodeIterator<T extends MergeableState<T>> { private final NodeBitMap visitedEnds; - private final Deque<AbstractBeginNode> nodeQueue; + private final Deque<BeginNode> nodeQueue; private final IdentityHashMap<FixedNode, T> nodeStates; private final FixedNode start; @@ -109,13 +109,13 @@ for (Node node : successors) { if (node != null) { nodeStates.put((FixedNode) node.predecessor(), state); - nodeQueue.addFirst((AbstractBeginNode) node); + nodeQueue.addFirst((BeginNode) node); } } } else { for (Node node : x.successors()) { if (node != null) { - nodeQueue.addFirst((AbstractBeginNode) node); + nodeQueue.addFirst((BeginNode) node); } } } @@ -124,7 +124,7 @@ private FixedNode nextQueuedNode() { int maxIterations = nodeQueue.size(); while (maxIterations-- > 0) { - AbstractBeginNode node = nodeQueue.removeFirst(); + BeginNode node = nodeQueue.removeFirst(); if (node instanceof MergeNode) { MergeNode merge = (MergeNode) node; state = nodeStates.get(merge.forwardEndAt(0)).clone();
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ReentrantNodeIterator.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ReentrantNodeIterator.java Wed Apr 16 17:26:58 2014 +0200 @@ -41,7 +41,7 @@ protected abstract StateT merge(MergeNode merge, List<StateT> states); - protected abstract StateT afterSplit(AbstractBeginNode node, StateT oldState); + protected abstract StateT afterSplit(BeginNode node, StateT oldState); protected abstract Map<LoopExitNode, StateT> processLoop(LoopBeginNode loop, StateT initialState); @@ -81,7 +81,7 @@ } public static <StateT> Map<FixedNode, StateT> apply(NodeIteratorClosure<StateT> closure, FixedNode start, StateT initialState, Set<FixedNode> boundary) { - Deque<AbstractBeginNode> nodeQueue = new ArrayDeque<>(); + Deque<BeginNode> nodeQueue = new ArrayDeque<>(); IdentityHashMap<FixedNode, StateT> blockEndStates = new IdentityHashMap<>(); StateT state = initialState; @@ -146,14 +146,14 @@ continue; } else { while (successors.hasNext()) { - AbstractBeginNode successor = (AbstractBeginNode) successors.next(); + BeginNode successor = (BeginNode) successors.next(); StateT successorState = closure.afterSplit(successor, state); if (closure.continueIteration(successorState)) { blockEndStates.put(successor, successorState); nodeQueue.add(successor); } } - state = closure.afterSplit((AbstractBeginNode) firstSuccessor, state); + state = closure.afterSplit((BeginNode) firstSuccessor, state); current = closure.continueIteration(state) ? firstSuccessor : null; continue; } @@ -167,7 +167,7 @@ } else { current = nodeQueue.removeFirst(); state = blockEndStates.get(current); - assert !(current instanceof MergeNode) && current instanceof AbstractBeginNode; + assert !(current instanceof MergeNode) && current instanceof BeginNode; } } while (true); }
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/StatelessPostOrderNodeIterator.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/StatelessPostOrderNodeIterator.java Wed Apr 16 17:26:58 2014 +0200 @@ -36,7 +36,7 @@ public abstract class StatelessPostOrderNodeIterator { private final NodeBitMap visitedEnds; - private final Deque<AbstractBeginNode> nodeQueue; + private final Deque<BeginNode> nodeQueue; private final FixedNode start; public StatelessPostOrderNodeIterator(FixedNode start) { @@ -76,7 +76,7 @@ controlSplit((ControlSplitNode) current); for (Node node : current.successors()) { if (node != null) { - nodeQueue.addFirst((AbstractBeginNode) node); + nodeQueue.addFirst((BeginNode) node); } } current = nodeQueue.pollFirst();
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/schedule/SchedulePhase.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/schedule/SchedulePhase.java Wed Apr 16 17:26:58 2014 +0200 @@ -201,7 +201,7 @@ } } - AbstractBeginNode startNode = cfg.getStartBlock().getBeginNode(); + BeginNode startNode = cfg.getStartBlock().getBeginNode(); assert startNode instanceof StartNode; KillSet accm = foundExcludeNode ? set : excludedLocations; @@ -753,7 +753,7 @@ // If a FrameState is an outer FrameState this method behaves as if the inner // FrameState was the actual usage, by recursing. blocksForUsage(node, unscheduledUsage, closure, strategy); - } else if (unscheduledUsage instanceof AbstractBeginNode) { + } else if (unscheduledUsage instanceof BeginNode) { // Only FrameStates can be connected to BeginNodes. if (!(usage instanceof FrameState)) { throw new SchedulingError(usage.toString()); @@ -1047,7 +1047,7 @@ } } - if (instruction instanceof AbstractBeginNode) { + if (instruction instanceof BeginNode) { ArrayList<ProxyNode> proxies = (instruction instanceof LoopExitNode) ? new ArrayList<>() : null; for (ScheduledNode inBlock : blockToNodesMap.get(b)) { if (!visited.isMarked(inBlock)) {
--- a/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/CFGPrinter.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/CFGPrinter.java Wed Apr 16 17:26:58 2014 +0200 @@ -488,7 +488,7 @@ return "-"; } String prefix; - if (node instanceof AbstractBeginNode && (lir == null && schedule == null)) { + if (node instanceof BeginNode && (lir == null && schedule == null)) { prefix = "B"; } else if (node instanceof ValueNode) { ValueNode value = (ValueNode) node;
--- a/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/IdealGraphPrinter.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/IdealGraphPrinter.java Wed Apr 16 17:26:58 2014 +0200 @@ -171,7 +171,7 @@ printProperty(bit, "true"); } } - if (node.getClass() == AbstractBeginNode.class) { + if (node.getClass() == BeginNode.class) { printProperty("shortName", "B"); } else if (node.getClass() == AbstractEndNode.class) { printProperty("shortName", "E");
--- a/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/CollapseFrameForSingleSideEffectPhase.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/CollapseFrameForSingleSideEffectPhase.java Wed Apr 16 17:26:58 2014 +0200 @@ -65,7 +65,7 @@ return new IterationState(this, sideEffect.asNode(), null, true); } - public IterationState addBranch(AbstractBeginNode begin) { + public IterationState addBranch(BeginNode begin) { return new IterationState(this, begin, null, this.invalid); } @@ -192,7 +192,7 @@ } @Override - protected IterationState afterSplit(AbstractBeginNode node, IterationState oldState) { + protected IterationState afterSplit(BeginNode node, IterationState oldState) { return oldState.addBranch(node); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerAddExactNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerAddExactNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -77,7 +77,7 @@ } @Override - public IntegerExactArithmeticSplitNode createSplit(AbstractBeginNode next, AbstractBeginNode deopt) { + public IntegerExactArithmeticSplitNode createSplit(BeginNode next, BeginNode deopt) { return graph().add(new IntegerAddExactSplitNode(stamp(), x(), y(), next, deopt)); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerAddExactSplitNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerAddExactSplitNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -29,7 +29,7 @@ public class IntegerAddExactSplitNode extends IntegerExactArithmeticSplitNode { - public IntegerAddExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, AbstractBeginNode next, AbstractBeginNode overflowSuccessor) { + public IntegerAddExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, BeginNode next, BeginNode overflowSuccessor) { super(stamp, x, y, next, overflowSuccessor); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerExactArithmeticNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerExactArithmeticNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -28,5 +28,5 @@ interface IntegerExactArithmeticNode extends Lowerable, IterableNodeType { - IntegerExactArithmeticSplitNode createSplit(AbstractBeginNode next, AbstractBeginNode deopt); + IntegerExactArithmeticSplitNode createSplit(BeginNode next, BeginNode deopt); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerExactArithmeticSplitNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerExactArithmeticSplitNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -30,12 +30,12 @@ public abstract class IntegerExactArithmeticSplitNode extends ControlSplitNode implements LIRLowerable { - @Successor private AbstractBeginNode overflowSuccessor; - @Successor private AbstractBeginNode next; + @Successor private BeginNode overflowSuccessor; + @Successor private BeginNode next; @Input private ValueNode x; @Input private ValueNode y; - public IntegerExactArithmeticSplitNode(Stamp stamp, ValueNode x, ValueNode y, AbstractBeginNode next, AbstractBeginNode overflowSuccessor) { + public IntegerExactArithmeticSplitNode(Stamp stamp, ValueNode x, ValueNode y, BeginNode next, BeginNode overflowSuccessor) { super(stamp); this.x = x; this.y = y; @@ -44,20 +44,20 @@ } @Override - public double probability(AbstractBeginNode successor) { + public double probability(BeginNode successor) { return successor == next ? 1 : 0; } @Override - public void setProbability(AbstractBeginNode successor, double value) { + public void setProbability(BeginNode successor, double value) { assert probability(successor) == value; } - public AbstractBeginNode getNext() { + public BeginNode getNext() { return next; } - public AbstractBeginNode getOverflowSuccessor() { + public BeginNode getOverflowSuccessor() { return overflowSuccessor; }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerMulExactNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerMulExactNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -74,7 +74,7 @@ } @Override - public IntegerExactArithmeticSplitNode createSplit(AbstractBeginNode next, AbstractBeginNode deopt) { + public IntegerExactArithmeticSplitNode createSplit(BeginNode next, BeginNode deopt) { return graph().add(new IntegerMulExactSplitNode(stamp(), x(), y(), next, deopt)); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerMulExactSplitNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerMulExactSplitNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -29,7 +29,7 @@ public class IntegerMulExactSplitNode extends IntegerExactArithmeticSplitNode { - public IntegerMulExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, AbstractBeginNode next, AbstractBeginNode overflowSuccessor) { + public IntegerMulExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, BeginNode next, BeginNode overflowSuccessor) { super(stamp, x, y, next, overflowSuccessor); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerSubExactNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerSubExactNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -77,7 +77,7 @@ } @Override - public IntegerExactArithmeticSplitNode createSplit(AbstractBeginNode next, AbstractBeginNode deopt) { + public IntegerExactArithmeticSplitNode createSplit(BeginNode next, BeginNode deopt) { return graph().add(new IntegerSubExactSplitNode(stamp(), x(), y(), next, deopt)); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerSubExactSplitNode.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerSubExactSplitNode.java Wed Apr 16 17:26:58 2014 +0200 @@ -29,7 +29,7 @@ public class IntegerSubExactSplitNode extends IntegerExactArithmeticSplitNode { - public IntegerSubExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, AbstractBeginNode next, AbstractBeginNode overflowSuccessor) { + public IntegerSubExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, BeginNode next, BeginNode overflowSuccessor) { super(stamp, x, y, next, overflowSuccessor); }
--- a/graal/com.oracle.graal.word/src/com/oracle/graal/word/phases/WordTypeRewriterPhase.java Wed Apr 16 16:54:15 2014 +0200 +++ b/graal/com.oracle.graal.word/src/com/oracle/graal/word/phases/WordTypeRewriterPhase.java Wed Apr 16 17:26:58 2014 +0200 @@ -379,7 +379,7 @@ * The read must not float outside its block otherwise it may float above an explicit zero * check on its base address. */ - read.setGuard(AbstractBeginNode.prevBegin(invoke.asNode())); + read.setGuard(BeginNode.prevBegin(invoke.asNode())); return read; }
--- a/mx/projects Wed Apr 16 16:54:15 2014 +0200 +++ b/mx/projects Wed Apr 16 17:26:58 2014 +0200 @@ -5,10 +5,21 @@ library@JDK_TOOLS@path=${JAVA_HOME}/lib/tools.jar library@JDK_TOOLS@optional=true -library@JUNIT@path=lib/junit-4.8.jar -library@JUNIT@urls=http://repo1.maven.org/maven2/junit/junit/4.8/junit-4.8.jar -library@JUNIT@sha1=4150c00c5706306ef0f8f1410e70c8ff12757922 +library@JUNIT@path=lib/junit-4.11.jar +library@JUNIT@urls=http://repo1.maven.org/maven2/junit/junit/4.11/junit-4.11.jar +library@JUNIT@sha1=4e031bb61df09069aeb2bffb4019e7a5034a4ee0 library@JUNIT@eclipse.container=org.eclipse.jdt.junit.JUNIT_CONTAINER/4 +library@JUNIT@sourcePath=lib/junit-4.11-sources.jar +library@JUNIT@sourceUrls=http://repo1.maven.org/maven2/junit/junit/4.11/junit-4.11-sources.jar +library@JUNIT@sourceSha1=28e0ad201304e4a4abf999ca0570b7cffc352c3c +library@JUNIT@dependencies=HAMCREST + +library@HAMCREST@path=lib/hamcrest-core-1.3.jar +library@HAMCREST@urls=http://repo1.maven.org/maven2/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar +library@HAMCREST@sha1=42a25dc3219429f0e5d060061f71acb49bf010a0 +library@HAMCREST@sourcePath=lib/hamcrest-core-1.3-sources.jar +library@HAMCREST@sourceUrls=http://repo1.maven.org/maven2/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3-sources.jar +library@HAMCREST@sourceSha1=1dc37250fbc78e23a65a67fbbaf71d2e9cbc3c0b library@CHECKSTYLE@path=lib/checkstyle-5.5-all.jar library@CHECKSTYLE@urls=jar:http://sourceforge.net/projects/checkstyle/files/checkstyle/5.5/checkstyle-5.5-bin.zip/download!/checkstyle-5.5/checkstyle-5.5-all.jar
--- a/mxtool/mx.py Wed Apr 16 16:54:15 2014 +0200 +++ b/mxtool/mx.py Wed Apr 16 17:26:58 2014 +0200 @@ -406,7 +406,7 @@ return path class Library(Dependency): - def __init__(self, suite, name, path, mustExist, urls, sha1, sourcePath, sourceUrls, sourceSha1): + def __init__(self, suite, name, path, mustExist, urls, sha1, sourcePath, sourceUrls, sourceSha1, deps): Dependency.__init__(self, suite, name) self.path = path.replace('/', os.sep) self.urls = urls @@ -415,6 +415,7 @@ self.sourcePath = sourcePath self.sourceUrls = sourceUrls self.sourceSha1 = sourceSha1 + self.deps = deps for url in urls: if url.endswith('/') != self.path.endswith(os.sep): abort('Path for dependency directory must have a URL ending with "/": path=' + self.path + ' url=' + url) @@ -448,9 +449,9 @@ def get_source_path(self, resolve): - if self.path is None: + if self.sourcePath is None: return None - path = _make_absolute(self.path, self.suite.dir) + path = _make_absolute(self.sourcePath, self.suite.dir) sha1path = path + '.sha1' return _download_file_with_sha1(self.name, path, self.sourceUrls, self.sourceSha1, sha1path, resolve, len(self.sourceUrls) != 0, sources=True) @@ -461,9 +462,21 @@ cp.append(path) def all_deps(self, deps, includeLibs, includeSelf=True, includeAnnotationProcessors=False): - if not includeLibs or not includeSelf: + """ + Add the transitive set of dependencies for this library to the 'deps' list. + """ + if not includeLibs: + return deps + childDeps = list(self.deps) + if self in deps: return deps - deps.append(self) + for name in childDeps: + assert name != self.name + dep = library(name) + if not dep in deps: + dep.all_deps(deps, includeLibs=includeLibs, includeAnnotationProcessors=includeAnnotationProcessors) + if not self in deps and includeSelf: + deps.append(self) return deps class HgConfig: @@ -620,7 +633,8 @@ sourcePath = attrs.pop('sourcePath', None) sourceUrls = pop_list(attrs, 'sourceUrls') sourceSha1 = attrs.pop('sourceSha1', None) - l = Library(self, name, path, mustExist, urls, sha1, sourcePath, sourceUrls, sourceSha1) + deps = pop_list(attrs, 'dependencies') + l = Library(self, name, path, mustExist, urls, sha1, sourcePath, sourceUrls, sourceSha1, deps) l.__dict__.update(attrs) self.libs.append(l) @@ -2859,35 +2873,47 @@ if exists(join(p.dir, 'plugin.xml')): # eclipse plugin project out.element('classpathentry', {'kind' : 'con', 'path' : 'org.eclipse.pde.core.requiredPlugins'}) + containerDeps = set() + libraryDeps = set() + projectDeps = set() + for dep in p.all_deps([], True): if dep == p: continue - if dep.isLibrary(): if hasattr(dep, 'eclipse.container'): - out.element('classpathentry', {'exported' : 'true', 'kind' : 'con', 'path' : getattr(dep, 'eclipse.container')}) - elif hasattr(dep, 'eclipse.project'): - out.element('classpathentry', {'combineaccessrules' : 'false', 'exported' : 'true', 'kind' : 'src', 'path' : '/' + getattr(dep, 'eclipse.project')}) + container = getattr(dep, 'eclipse.container') + containerDeps.add(container) + libraryDeps -= set(dep.all_deps([], True)) else: - path = dep.path - dep.get_path(resolve=True) - if not path or (not exists(path) and not dep.mustExist): - continue - - # Relative paths for "lib" class path entries have various semantics depending on the Eclipse - # version being used (e.g. see https://bugs.eclipse.org/bugs/show_bug.cgi?id=274737) so it's - # safest to simply use absolute paths. - path = _make_absolute(path, p.suite.dir) - - attributes = {'exported' : 'true', 'kind' : 'lib', 'path' : path} - - sourcePath = dep.get_source_path(resolve=True) - if sourcePath is not None: - attributes['sourcepath'] = sourcePath - out.element('classpathentry', attributes) - libFiles.append(path) + libraryDeps.add(dep) else: - out.element('classpathentry', {'combineaccessrules' : 'false', 'exported' : 'true', 'kind' : 'src', 'path' : '/' + dep.name}) + projectDeps.add(dep) + + for dep in containerDeps: + out.element('classpathentry', {'exported' : 'true', 'kind' : 'con', 'path' : dep}) + + for dep in libraryDeps: + path = dep.path + dep.get_path(resolve=True) + if not path or (not exists(path) and not dep.mustExist): + continue + + # Relative paths for "lib" class path entries have various semantics depending on the Eclipse + # version being used (e.g. see https://bugs.eclipse.org/bugs/show_bug.cgi?id=274737) so it's + # safest to simply use absolute paths. + path = _make_absolute(path, p.suite.dir) + + attributes = {'exported' : 'true', 'kind' : 'lib', 'path' : path} + + sourcePath = dep.get_source_path(resolve=True) + if sourcePath is not None: + attributes['sourcepath'] = sourcePath + out.element('classpathentry', attributes) + libFiles.append(path) + + for dep in projectDeps: + out.element('classpathentry', {'combineaccessrules' : 'false', 'exported' : 'true', 'kind' : 'src', 'path' : '/' + dep.name}) out.element('classpathentry', {'kind' : 'output', 'path' : getattr(p, 'eclipse.output', 'bin')}) out.close('classpath') @@ -3681,12 +3707,12 @@ libraryXml.open('component', attributes={'name': 'libraryTable'}) libraryXml.open('library', attributes={'name': library.name}) libraryXml.open('CLASSES') - libraryXml.element('root', attributes={'url': 'jar://$PROJECT_DIR$/' + os.path.relpath(library.path, suite.dir) + '!/'}) + libraryXml.element('root', attributes={'url': 'jar://$PROJECT_DIR$/' + os.path.relpath(library.get_path(True), suite.dir) + '!/'}) libraryXml.close('CLASSES') libraryXml.element('JAVADOC') if library.sourcePath: libraryXml.open('SOURCES') - libraryXml.element('root', attributes={'url': 'jar://$PROJECT_DIR$/' + os.path.relpath(library.sourcePath, suite.dir) + '!/'}) + libraryXml.element('root', attributes={'url': 'jar://$PROJECT_DIR$/' + os.path.relpath(library.get_source_path(True), suite.dir) + '!/'}) libraryXml.close('SOURCES') else: libraryXml.element('SOURCES') @@ -3738,7 +3764,7 @@ # Wite misc.xml for global JDK config miscXml = XMLDoc() miscXml.open('project', attributes={'version': '4'}) - miscXml.element('component', attributes={'name': 'ProjectRootManager', 'version': '2', 'languagelevel': _complianceToIntellijLanguageLevel(java().javaCompliance), 'project-jdk-name': str(java().javaCompliance), 'project-jdk-type': 'JavaSDK'}) + miscXml.element('component', attributes={'name': 'ProjectRootManager', 'version': '2', 'languageLevel': _complianceToIntellijLanguageLevel(java().javaCompliance), 'project-jdk-name': str(java().javaCompliance), 'project-jdk-type': 'JavaSDK'}) miscXml.close('project') miscFile = join(ideaProjectDirectory, 'misc.xml') update_file(miscFile, miscXml.xml(indent=' ', newl='\n'))