Mercurial > hg > truffle
annotate graal/com.oracle.graal.graph/src/com/oracle/graal/graph/NodeClass.java @ 17128:8ec6deb7d2eb
Fix when not using generated node classes
author | Christian Wimmer <christian.wimmer@oracle.com> |
---|---|
date | Tue, 16 Sep 2014 18:41:44 -0700 |
parents | c25fcf343b4f |
children | 7a3f6543d383 |
rev | line source |
---|---|
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1 /* |
16154
f9f7bd1a6b2c
IGV: Support for InputType.
Roland Schatz <roland.schatz@oracle.com>
parents:
15827
diff
changeset
|
2 * Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved. |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
4 * |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
5 * This code is free software; you can redistribute it and/or modify it |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
6 * under the terms of the GNU General Public License version 2 only, as |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
7 * published by the Free Software Foundation. |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
8 * |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
9 * This code is distributed in the hope that it will be useful, but WITHOUT |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
12 * version 2 for more details (a copy is included in the LICENSE file that |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
13 * accompanied this code). |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
14 * |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
15 * You should have received a copy of the GNU General Public License version |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
16 * 2 along with this work; if not, write to the Free Software Foundation, |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
18 * |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
21 * questions. |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
22 */ |
5060
4ed4295ce15f
Update import statements.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
5059
diff
changeset
|
23 package com.oracle.graal.graph; |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
24 |
11524
dede53632f3e
removed Node.modCount field (GRAAL-452)
Doug Simon <doug.simon@oracle.com>
parents:
11434
diff
changeset
|
25 import static com.oracle.graal.graph.Graph.*; |
16897
f90dcdbbb75e
switched to using new NodeFieldIterator and NodeFieldIterable for traversing Node inputs and successors
Doug Simon <doug.simon@oracle.com>
parents:
16841
diff
changeset
|
26 import static com.oracle.graal.graph.Node.*; |
15551
33cedbce5b23
added CollectionsProvider and NodeCollectionsProvider and replaced (almost) all allocations of IdentityHashMaps to go through these providers
Doug Simon <doug.simon@oracle.com>
parents:
15295
diff
changeset
|
27 import static com.oracle.graal.graph.util.CollectionsAccess.*; |
16991
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
28 import static java.lang.reflect.Modifier.*; |
11524
dede53632f3e
removed Node.modCount field (GRAAL-452)
Doug Simon <doug.simon@oracle.com>
parents:
11434
diff
changeset
|
29 |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
30 import java.lang.reflect.*; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
31 import java.util.*; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
32 |
15193
96bb07a5d667
Spit up and move GraalInternalError.
Josef Eisl <josef.eisl@jku.at>
parents:
15186
diff
changeset
|
33 import com.oracle.graal.compiler.common.*; |
11642
5507e2824bc6
added metric to count IterableNodeTypes (GRAAL-471)
Doug Simon <doug.simon@oracle.com>
parents:
11631
diff
changeset
|
34 import com.oracle.graal.debug.*; |
5478
4a99bfc329f0
Add posibility to provide a replacement function instead of map for duplication.
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5361
diff
changeset
|
35 import com.oracle.graal.graph.Graph.DuplicationReplacement; |
14991
64dcb92ee75a
Truffle: Change signature for Truffle calls from (PackedFrame, Arguments) to (Object[]).
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
14616
diff
changeset
|
36 import com.oracle.graal.graph.Node.Input; |
64dcb92ee75a
Truffle: Change signature for Truffle calls from (PackedFrame, Arguments) to (Object[]).
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
14616
diff
changeset
|
37 import com.oracle.graal.graph.Node.Successor; |
11882
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
38 import com.oracle.graal.graph.spi.*; |
16841
cbd42807a31f
moved NodeInfo and friends into separate com.oracle.graal.nodeinfo project so that annotation processor can be applied to the base Node class
Doug Simon <doug.simon@oracle.com>
parents:
16554
diff
changeset
|
39 import com.oracle.graal.nodeinfo.*; |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
40 |
11431
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
41 /** |
15106
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
42 * Metadata for every {@link Node} type. The metadata includes: |
11431
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
43 * <ul> |
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
44 * <li>The offsets of fields annotated with {@link Input} and {@link Successor} as well as methods |
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
45 * for iterating over such fields.</li> |
11631
1aed684853f6
refactored IterableNodeType into a top level type to avoid problems it was causing for javac and JDT (CR-1408)
Doug Simon <doug.simon@oracle.com>
parents:
11556
diff
changeset
|
46 * <li>The identifier for an {@link IterableNodeType} class.</li> |
11431
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
47 * </ul> |
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
48 */ |
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
49 public final class NodeClass extends FieldIntrospection { |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
50 |
15106
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
51 private static final Object GetNodeClassLock = new Object(); |
11431
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
52 |
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
53 /** |
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
54 * Gets the {@link NodeClass} associated with a given {@link Class}. |
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
55 */ |
11434
0d9fe4e80ab8
moved warning suppression annotation to placate JDT
Doug Simon <doug.simon@oracle.com>
parents:
11431
diff
changeset
|
56 @SuppressWarnings("unchecked") |
11431
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
57 public static NodeClass get(Class<?> c) { |
16982
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
58 Class<? extends Node> key = (Class<? extends Node>) c; |
16903
3ca8ba1bfc21
bind a generated Node class to the NodeClass instance of the generated-from Node class
Doug Simon <doug.simon@oracle.com>
parents:
16897
diff
changeset
|
59 |
15106
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
60 NodeClass value = (NodeClass) allClasses.get(key); |
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
61 // The fact that {@link ConcurrentHashMap#put} and {@link ConcurrentHashMap#get} |
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
62 // are used makes the double-checked locking idiom work. |
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
63 if (value == null) { |
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
64 // The creation of a NodeClass must be serialized as the NodeClass constructor accesses |
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
65 // both FieldIntrospection.allClasses and NodeClass.nextIterableId. |
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
66 synchronized (GetNodeClassLock) { |
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
67 value = (NodeClass) allClasses.get(key); |
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
68 if (value == null) { |
16982
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
69 GeneratedNode gen = c.getAnnotation(GeneratedNode.class); |
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
70 if (gen != null) { |
16991
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
71 Class<? extends Node> originalNodeClass = (Class<? extends Node>) gen.value(); |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
72 value = (NodeClass) allClasses.get(originalNodeClass); |
16982
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
73 assert value != null; |
16991
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
74 if (value.genClass == null) { |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
75 value.genClass = (Class<? extends Node>) c; |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
76 } else { |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
77 assert value.genClass == c; |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
78 } |
16982
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
79 } else { |
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
80 value = new NodeClass(key); |
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
81 } |
15106
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
82 Object old = allClasses.putIfAbsent(key, value); |
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
83 assert old == null : old + " " + key; |
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
84 } |
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
85 } |
11431
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
86 } |
15106
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
87 return value; |
11431
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
88 } |
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
89 |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
90 private static final Class<?> NODE_CLASS = Node.class; |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
91 private static final Class<?> INPUT_LIST_CLASS = NodeInputList.class; |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
92 private static final Class<?> SUCCESSOR_LIST_CLASS = NodeSuccessorList.class; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
93 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
94 private static int nextIterableId = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
95 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
96 private final int directInputCount; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
97 private final long[] inputOffsets; |
15001 | 98 private final InputType[] inputTypes; |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
99 private final boolean[] inputOptional; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
100 private final int directSuccessorCount; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
101 private final long[] successorOffsets; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
102 private final Class<?>[] dataTypes; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
103 private final boolean canGVN; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
104 private final int startGVNNumber; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
105 private final String shortName; |
5813
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
106 private final String nameTemplate; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
107 private final int iterableId; |
15002
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
108 private final EnumSet<InputType> allowedUsageTypes; |
7332
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
109 private int[] iterableIds; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
110 |
16991
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
111 /** |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
112 * The {@linkplain GeneratedNode generated} node class denoted by this object. This value is |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
113 * lazily initialized to avoid class initialization circularity issues. A sentinel value of |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
114 * {@code Node.class} is used to denote absence of a generated class. |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
115 */ |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
116 private Class<? extends Node> genClass; |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
117 |
11642
5507e2824bc6
added metric to count IterableNodeTypes (GRAAL-471)
Doug Simon <doug.simon@oracle.com>
parents:
11631
diff
changeset
|
118 private static final DebugMetric ITERABLE_NODE_TYPES = Debug.metric("IterableNodeTypes"); |
11663
d213be26ffb4
added metric to count number of times a typed node iterator is used per IterableNodeType (GRAAL-471)
Doug Simon <doug.simon@oracle.com>
parents:
11653
diff
changeset
|
119 private final DebugMetric nodeIterableCount; |
11642
5507e2824bc6
added metric to count IterableNodeTypes (GRAAL-471)
Doug Simon <doug.simon@oracle.com>
parents:
11631
diff
changeset
|
120 |
11882
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
121 /** |
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
122 * Determines if this node type implements {@link Canonicalizable}. |
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
123 */ |
16239
de84713267fa
use default methods to select Canonicalizable behavior
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16206
diff
changeset
|
124 private final boolean isCanonicalizable; |
11882
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
125 |
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
126 /** |
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
127 * Determines if this node type implements {@link Simplifiable}. |
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
128 */ |
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
129 private final boolean isSimplifiable; |
16919
0fe4732e5181
made use of generated Node classes predicated on value of graal.useGeneratedNodes system property (default is false)
Doug Simon <doug.simon@oracle.com>
parents:
16903
diff
changeset
|
130 private final boolean isLeafNode; |
11882
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
131 |
13127
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
132 public NodeClass(Class<?> clazz) { |
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
133 this(clazz, new DefaultCalcOffset(), null, 0); |
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
134 } |
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
135 |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
136 /** |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
137 * Defines the order of fields in a node class that accessed via {@link Position}s. |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
138 */ |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
139 public interface PositionFieldOrder { |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
140 /** |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
141 * Gets a field ordering specified by an ordered field name list. The only guarantee |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
142 * provided by this method is that all {@link NodeList} fields are preceded by all non |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
143 * {@link NodeList} fields. |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
144 * |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
145 * @param input specified whether input or successor field order is being requested |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
146 */ |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
147 String[] getOrderedFieldNames(boolean input); |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
148 } |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
149 |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
150 private static long[] sortedOffsets(boolean input, PositionFieldOrder pfo, Map<Long, String> names, ArrayList<Long> list1, ArrayList<Long> list2) { |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
151 if (list1.isEmpty() && list2.isEmpty()) { |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
152 return new long[0]; |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
153 } |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
154 if (pfo != null) { |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
155 List<String> fields = Arrays.asList(pfo.getOrderedFieldNames(input)); |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
156 long[] offsets = new long[fields.size()]; |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
157 assert list1.size() + list2.size() == fields.size(); |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
158 for (Map.Entry<Long, String> e : names.entrySet()) { |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
159 int index = fields.indexOf(e.getValue()); |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
160 if (index != -1) { |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
161 offsets[index] = e.getKey(); |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
162 } |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
163 } |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
164 return offsets; |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
165 } |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
166 return sortedLongCopy(list1, list2); |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
167 } |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
168 |
13127
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
169 public NodeClass(Class<?> clazz, CalcOffset calcOffset, int[] presetIterableIds, int presetIterableId) { |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
170 super(clazz); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
171 assert NODE_CLASS.isAssignableFrom(clazz); |
16239
de84713267fa
use default methods to select Canonicalizable behavior
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16206
diff
changeset
|
172 |
de84713267fa
use default methods to select Canonicalizable behavior
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16206
diff
changeset
|
173 this.isCanonicalizable = Canonicalizable.class.isAssignableFrom(clazz); |
de84713267fa
use default methods to select Canonicalizable behavior
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16206
diff
changeset
|
174 if (Canonicalizable.Unary.class.isAssignableFrom(clazz) || Canonicalizable.Binary.class.isAssignableFrom(clazz)) { |
de84713267fa
use default methods to select Canonicalizable behavior
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16206
diff
changeset
|
175 assert Canonicalizable.Unary.class.isAssignableFrom(clazz) ^ Canonicalizable.Binary.class.isAssignableFrom(clazz) : clazz + " should implement either Unary or Binary, not both"; |
16206
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
176 } |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
177 |
11882
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
178 this.isSimplifiable = Simplifiable.class.isAssignableFrom(clazz); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
179 |
13127
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
180 FieldScanner scanner = new FieldScanner(calcOffset); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
181 scanner.scan(clazz); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
182 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
183 directInputCount = scanner.inputOffsets.size(); |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
184 |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
185 isLeafNode = scanner.inputOffsets.isEmpty() && scanner.inputListOffsets.isEmpty() && scanner.successorOffsets.isEmpty() && scanner.successorListOffsets.isEmpty(); |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
186 |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
187 PositionFieldOrder pfo = lookupPositionFieldOrder(clazz); |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
188 |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
189 inputOffsets = sortedOffsets(true, pfo, scanner.fieldNames, scanner.inputOffsets, scanner.inputListOffsets); |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
190 |
15001 | 191 inputTypes = new InputType[inputOffsets.length]; |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
192 inputOptional = new boolean[inputOffsets.length]; |
15001 | 193 for (int i = 0; i < inputOffsets.length; i++) { |
194 inputTypes[i] = scanner.types.get(inputOffsets[i]); | |
195 assert inputTypes[i] != null; | |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
196 inputOptional[i] = scanner.optionalInputs.contains(inputOffsets[i]); |
15001 | 197 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
198 directSuccessorCount = scanner.successorOffsets.size(); |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
199 successorOffsets = sortedOffsets(false, pfo, scanner.fieldNames, scanner.successorOffsets, scanner.successorListOffsets); |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
200 |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
201 dataOffsets = sortedLongCopy(scanner.dataOffsets); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
202 dataTypes = new Class[dataOffsets.length]; |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
203 for (int i = 0; i < dataOffsets.length; i++) { |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
204 dataTypes[i] = scanner.fieldTypes.get(dataOffsets[i]); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
205 } |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
206 |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
207 fieldNames = scanner.fieldNames; |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
208 fieldTypes = scanner.fieldTypes; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
209 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
210 canGVN = Node.ValueNumberable.class.isAssignableFrom(clazz); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
211 startGVNNumber = clazz.hashCode(); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
212 |
4142
bc8527f3071c
Adjust code base to new level of warnings.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
3733
diff
changeset
|
213 String newShortName = clazz.getSimpleName(); |
bc8527f3071c
Adjust code base to new level of warnings.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
3733
diff
changeset
|
214 if (newShortName.endsWith("Node") && !newShortName.equals("StartNode") && !newShortName.equals("EndNode")) { |
bc8527f3071c
Adjust code base to new level of warnings.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
3733
diff
changeset
|
215 newShortName = newShortName.substring(0, newShortName.length() - 4); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
216 } |
5813
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
217 String newNameTemplate = null; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
218 NodeInfo info = clazz.getAnnotation(NodeInfo.class); |
16982
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
219 assert info != null : "missing " + NodeInfo.class.getSimpleName() + " annotation on " + clazz; |
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
220 if (!info.shortName().isEmpty()) { |
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
221 newShortName = info.shortName(); |
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
222 } |
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
223 if (!info.nameTemplate().isEmpty()) { |
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
224 newNameTemplate = info.nameTemplate(); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
225 } |
15002
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
226 EnumSet<InputType> newAllowedUsageTypes = EnumSet.noneOf(InputType.class); |
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
227 Class<?> current = clazz; |
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
228 do { |
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
229 NodeInfo currentInfo = current.getAnnotation(NodeInfo.class); |
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
230 if (currentInfo != null) { |
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
231 if (currentInfo.allowedUsageTypes().length > 0) { |
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
232 newAllowedUsageTypes.addAll(Arrays.asList(currentInfo.allowedUsageTypes())); |
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
233 } |
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
234 } |
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
235 current = current.getSuperclass(); |
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
236 } while (current != Node.class); |
5813
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
237 this.nameTemplate = newNameTemplate == null ? newShortName : newNameTemplate; |
15002
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
238 this.allowedUsageTypes = newAllowedUsageTypes; |
4142
bc8527f3071c
Adjust code base to new level of warnings.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
3733
diff
changeset
|
239 this.shortName = newShortName; |
13127
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
240 if (presetIterableIds != null) { |
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
241 this.iterableIds = presetIterableIds; |
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
242 this.iterableId = presetIterableId; |
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
243 } else if (IterableNodeType.class.isAssignableFrom(clazz)) { |
11642
5507e2824bc6
added metric to count IterableNodeTypes (GRAAL-471)
Doug Simon <doug.simon@oracle.com>
parents:
11631
diff
changeset
|
244 ITERABLE_NODE_TYPES.increment(); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
245 this.iterableId = nextIterableId++; |
7332
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
246 List<NodeClass> existingClasses = new LinkedList<>(); |
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
247 for (FieldIntrospection nodeClass : allClasses.values()) { |
16987
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
248 // There are duplicate entries in allClasses when using generated nodes |
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
249 // hence the extra logic below guarded by USE_GENERATED_NODES |
15295
21663230ba88
Move FieldIntrospection to graal.compiler.common.
Josef Eisl <josef.eisl@jku.at>
parents:
15241
diff
changeset
|
250 if (clazz.isAssignableFrom(nodeClass.getClazz())) { |
16987
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
251 if (!USE_GENERATED_NODES || !existingClasses.contains(nodeClass)) { |
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
252 existingClasses.add((NodeClass) nodeClass); |
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
253 } |
7332
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
254 } |
15295
21663230ba88
Move FieldIntrospection to graal.compiler.common.
Josef Eisl <josef.eisl@jku.at>
parents:
15241
diff
changeset
|
255 if (nodeClass.getClazz().isAssignableFrom(clazz) && IterableNodeType.class.isAssignableFrom(nodeClass.getClazz())) { |
7332
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
256 NodeClass superNodeClass = (NodeClass) nodeClass; |
17128
8ec6deb7d2eb
Fix when not using generated node classes
Christian Wimmer <christian.wimmer@oracle.com>
parents:
17051
diff
changeset
|
257 if (!containsId(this.iterableId, superNodeClass.iterableIds)) { |
16987
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
258 superNodeClass.iterableIds = Arrays.copyOf(superNodeClass.iterableIds, superNodeClass.iterableIds.length + 1); |
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
259 superNodeClass.iterableIds[superNodeClass.iterableIds.length - 1] = this.iterableId; |
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
260 } |
7332
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
261 } |
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
262 } |
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
263 int[] ids = new int[existingClasses.size() + 1]; |
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
264 ids[0] = iterableId; |
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
265 int i = 1; |
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
266 for (NodeClass other : existingClasses) { |
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
267 ids[i++] = other.iterableId; |
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
268 } |
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
269 this.iterableIds = ids; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
270 } else { |
16897
f90dcdbbb75e
switched to using new NodeFieldIterator and NodeFieldIterable for traversing Node inputs and successors
Doug Simon <doug.simon@oracle.com>
parents:
16841
diff
changeset
|
271 this.iterableId = Node.NOT_ITERABLE; |
7332
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
272 this.iterableIds = null; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
273 } |
14616
aa7bcf1fa423
expanded Debug API to avoid any allocation for timer and metric creation if debugging is disabled
Doug Simon <doug.simon@oracle.com>
parents:
14157
diff
changeset
|
274 nodeIterableCount = Debug.metric("NodeIterable_%s", shortName); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
275 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
276 |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
277 private PositionFieldOrder lookupPositionFieldOrder(Class<?> clazz) throws GraalInternalError { |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
278 if (USE_GENERATED_NODES && !isAbstract(clazz.getModifiers()) && !isLeafNode) { |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
279 String name = clazz.getName().replace('$', '_') + "Gen$FieldOrder"; |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
280 try { |
17009
2c04d7665bf6
use the right class loader when loading generated PositionFieldOrder class
Doug Simon <doug.simon@oracle.com>
parents:
17008
diff
changeset
|
281 return (PositionFieldOrder) Class.forName(name, true, getClazz().getClassLoader()).newInstance(); |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
282 } catch (Exception e) { |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
283 throw new GraalInternalError("Could not find generated class " + name + " for " + getClazz()); |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
284 } |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
285 } |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
286 return null; |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
287 } |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
288 |
16991
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
289 /** |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
290 * Gets the {@linkplain GeneratedNode generated} node class (if any) described by the object. |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
291 */ |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
292 @SuppressWarnings("unchecked") |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
293 public Class<? extends Node> getGenClass() { |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
294 if (USE_GENERATED_NODES) { |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
295 if (genClass == null) { |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
296 if (!isAbstract(getClazz().getModifiers())) { |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
297 String genClassName = getClazz().getName().replace('$', '_') + "Gen"; |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
298 try { |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
299 genClass = (Class<? extends Node>) Class.forName(genClassName); |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
300 } catch (ClassNotFoundException e) { |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
301 throw new GraalInternalError("Could not find generated class " + genClassName + " for " + getClazz()); |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
302 } |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
303 } else { |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
304 // Sentinel value denoting no generated class |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
305 genClass = Node.class; |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
306 } |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
307 } |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
308 return genClass.equals(Node.class) ? null : genClass; |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
309 } |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
310 return null; |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
311 } |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
312 |
16987
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
313 private static boolean containsId(int iterableId, int[] iterableIds) { |
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
314 for (int i : iterableIds) { |
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
315 if (i == iterableId) { |
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
316 return true; |
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
317 } |
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
318 } |
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
319 return false; |
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
320 } |
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
321 |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
322 @Override |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
323 protected void rescanFieldOffsets(CalcOffset calc) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
324 FieldScanner scanner = new FieldScanner(calc); |
15295
21663230ba88
Move FieldIntrospection to graal.compiler.common.
Josef Eisl <josef.eisl@jku.at>
parents:
15241
diff
changeset
|
325 scanner.scan(getClazz()); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
326 assert directInputCount == scanner.inputOffsets.size(); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
327 copyInto(inputOffsets, sortedLongCopy(scanner.inputOffsets, scanner.inputListOffsets)); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
328 assert directSuccessorCount == scanner.successorOffsets.size(); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
329 copyInto(successorOffsets, sortedLongCopy(scanner.successorOffsets, scanner.successorListOffsets)); |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
330 copyInto(dataOffsets, sortedLongCopy(scanner.dataOffsets)); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
331 |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
332 for (int i = 0; i < dataOffsets.length; i++) { |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
333 dataTypes[i] = scanner.fieldTypes.get(dataOffsets[i]); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
334 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
335 |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
336 fieldNames.clear(); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
337 fieldNames.putAll(scanner.fieldNames); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
338 fieldTypes.clear(); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
339 fieldTypes.putAll(scanner.fieldTypes); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
340 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
341 |
16982
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
342 /** |
17051
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
343 * Determines if a given {@link Node} class is described by this {@link NodeClass} object. This |
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
344 * is useful for doing an exact type test (as opposed to an instanceof test) on a node. For |
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
345 * example: |
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
346 * |
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
347 * <pre> |
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
348 * if (node.getNodeClass().is(BeginNode.class)) { ... } |
17128
8ec6deb7d2eb
Fix when not using generated node classes
Christian Wimmer <christian.wimmer@oracle.com>
parents:
17051
diff
changeset
|
349 * |
17051
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
350 * // Due to generated Node classes, the test below |
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
351 * // is *not* the same as the test above: |
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
352 * if (node.getClass() == BeginNode.class) { ... } |
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
353 * </pre> |
16986
f7359a0ce946
tweaked comparison of a Node against a node class
Doug Simon <doug.simon@oracle.com>
parents:
16982
diff
changeset
|
354 * |
f7359a0ce946
tweaked comparison of a Node against a node class
Doug Simon <doug.simon@oracle.com>
parents:
16982
diff
changeset
|
355 * @param nodeClass a {@linkplain GeneratedNode non-generated} {@link Node} class |
16982
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
356 */ |
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
357 public boolean is(Class<? extends Node> nodeClass) { |
16986
f7359a0ce946
tweaked comparison of a Node against a node class
Doug Simon <doug.simon@oracle.com>
parents:
16982
diff
changeset
|
358 assert nodeClass.getAnnotation(GeneratedNode.class) == null : "cannot test NodeClas against generated " + nodeClass; |
f7359a0ce946
tweaked comparison of a Node against a node class
Doug Simon <doug.simon@oracle.com>
parents:
16982
diff
changeset
|
359 return nodeClass == getClazz(); |
16903
3ca8ba1bfc21
bind a generated Node class to the NodeClass instance of the generated-from Node class
Doug Simon <doug.simon@oracle.com>
parents:
16897
diff
changeset
|
360 } |
3ca8ba1bfc21
bind a generated Node class to the NodeClass instance of the generated-from Node class
Doug Simon <doug.simon@oracle.com>
parents:
16897
diff
changeset
|
361 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
362 public String shortName() { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
363 return shortName; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
364 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
365 |
7332
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
366 public int[] iterableIds() { |
11663
d213be26ffb4
added metric to count number of times a typed node iterator is used per IterableNodeType (GRAAL-471)
Doug Simon <doug.simon@oracle.com>
parents:
11653
diff
changeset
|
367 nodeIterableCount.increment(); |
7332
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
368 return iterableIds; |
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
369 } |
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
370 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
371 public int iterableId() { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
372 return iterableId; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
373 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
374 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
375 public boolean valueNumberable() { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
376 return canGVN; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
377 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
378 |
11882
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
379 /** |
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
380 * Determines if this node type implements {@link Canonicalizable}. |
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
381 */ |
16239
de84713267fa
use default methods to select Canonicalizable behavior
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16206
diff
changeset
|
382 public boolean isCanonicalizable() { |
de84713267fa
use default methods to select Canonicalizable behavior
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16206
diff
changeset
|
383 return isCanonicalizable; |
11882
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
384 } |
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
385 |
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
386 /** |
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
387 * Determines if this node type implements {@link Simplifiable}. |
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
388 */ |
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
389 public boolean isSimplifiable() { |
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
390 return isSimplifiable; |
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
391 } |
51059863da73
replace instanceof type tests for Canonicalizable and Simplifiable with extra boolean properties in NodeClass (GRAAL-506)
Doug Simon <doug.simon@oracle.com>
parents:
11676
diff
changeset
|
392 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
393 public static int cacheSize() { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
394 return nextIterableId; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
395 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
396 |
15002
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
397 public EnumSet<InputType> getAllowedUsageTypes() { |
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
398 return allowedUsageTypes; |
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
399 } |
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
400 |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
401 protected static class FieldScanner extends BaseFieldScanner { |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
402 |
4142
bc8527f3071c
Adjust code base to new level of warnings.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
3733
diff
changeset
|
403 public final ArrayList<Long> inputOffsets = new ArrayList<>(); |
bc8527f3071c
Adjust code base to new level of warnings.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
3733
diff
changeset
|
404 public final ArrayList<Long> inputListOffsets = new ArrayList<>(); |
bc8527f3071c
Adjust code base to new level of warnings.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
3733
diff
changeset
|
405 public final ArrayList<Long> successorOffsets = new ArrayList<>(); |
bc8527f3071c
Adjust code base to new level of warnings.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
3733
diff
changeset
|
406 public final ArrayList<Long> successorListOffsets = new ArrayList<>(); |
15001 | 407 public final HashMap<Long, InputType> types = new HashMap<>(); |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
408 public final HashSet<Long> optionalInputs = new HashSet<>(); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
409 |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
410 protected FieldScanner(CalcOffset calc) { |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
411 super(calc); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
412 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
413 |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
414 @Override |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
415 protected void scanField(Field field, Class<?> type, long offset) { |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
416 if (field.isAnnotationPresent(Node.Input.class) || field.isAnnotationPresent(Node.OptionalInput.class)) { |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
417 assert !field.isAnnotationPresent(Node.Successor.class) : "field cannot be both input and successor"; |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
418 assert field.isAnnotationPresent(Node.Input.class) ^ field.isAnnotationPresent(Node.OptionalInput.class) : "inputs can either be optional or non-optional"; |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
419 if (INPUT_LIST_CLASS.isAssignableFrom(type)) { |
16897
f90dcdbbb75e
switched to using new NodeFieldIterator and NodeFieldIterable for traversing Node inputs and successors
Doug Simon <doug.simon@oracle.com>
parents:
16841
diff
changeset
|
420 // NodeInputList fields should not be final since they are |
f90dcdbbb75e
switched to using new NodeFieldIterator and NodeFieldIterable for traversing Node inputs and successors
Doug Simon <doug.simon@oracle.com>
parents:
16841
diff
changeset
|
421 // written (via Unsafe) in clearInputs() |
f90dcdbbb75e
switched to using new NodeFieldIterator and NodeFieldIterable for traversing Node inputs and successors
Doug Simon <doug.simon@oracle.com>
parents:
16841
diff
changeset
|
422 GraalInternalError.guarantee(!Modifier.isFinal(field.getModifiers()), "NodeInputList input field %s should not be final", field); |
9808
12fdb8fe0a35
turn assertions in NodeClass.FieldScanner into guarantees
Lukas Stadler <lukas.stadler@jku.at>
parents:
9720
diff
changeset
|
423 GraalInternalError.guarantee(!Modifier.isPublic(field.getModifiers()), "NodeInputList input field %s should not be public", field); |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
424 inputListOffsets.add(offset); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
425 } else { |
9808
12fdb8fe0a35
turn assertions in NodeClass.FieldScanner into guarantees
Lukas Stadler <lukas.stadler@jku.at>
parents:
9720
diff
changeset
|
426 GraalInternalError.guarantee(NODE_CLASS.isAssignableFrom(type) || type.isInterface(), "invalid input type: %s", type); |
12fdb8fe0a35
turn assertions in NodeClass.FieldScanner into guarantees
Lukas Stadler <lukas.stadler@jku.at>
parents:
9720
diff
changeset
|
427 GraalInternalError.guarantee(!Modifier.isFinal(field.getModifiers()), "Node input field %s should not be final", field); |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
428 inputOffsets.add(offset); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
429 } |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
430 if (field.isAnnotationPresent(Node.Input.class)) { |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
431 types.put(offset, field.getAnnotation(Node.Input.class).value()); |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
432 } else { |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
433 types.put(offset, field.getAnnotation(Node.OptionalInput.class).value()); |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
434 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
435 if (field.isAnnotationPresent(Node.OptionalInput.class)) { |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
436 optionalInputs.add(offset); |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
437 } |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
438 } else if (field.isAnnotationPresent(Node.Successor.class)) { |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
439 if (SUCCESSOR_LIST_CLASS.isAssignableFrom(type)) { |
16897
f90dcdbbb75e
switched to using new NodeFieldIterator and NodeFieldIterable for traversing Node inputs and successors
Doug Simon <doug.simon@oracle.com>
parents:
16841
diff
changeset
|
440 // NodeSuccessorList fields should not be final since they are |
f90dcdbbb75e
switched to using new NodeFieldIterator and NodeFieldIterable for traversing Node inputs and successors
Doug Simon <doug.simon@oracle.com>
parents:
16841
diff
changeset
|
441 // written (via Unsafe) in clearSuccessors() |
f90dcdbbb75e
switched to using new NodeFieldIterator and NodeFieldIterable for traversing Node inputs and successors
Doug Simon <doug.simon@oracle.com>
parents:
16841
diff
changeset
|
442 GraalInternalError.guarantee(!Modifier.isFinal(field.getModifiers()), "NodeSuccessorList successor field % should not be final", field); |
9808
12fdb8fe0a35
turn assertions in NodeClass.FieldScanner into guarantees
Lukas Stadler <lukas.stadler@jku.at>
parents:
9720
diff
changeset
|
443 GraalInternalError.guarantee(!Modifier.isPublic(field.getModifiers()), "NodeSuccessorList successor field %s should not be public", field); |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
444 successorListOffsets.add(offset); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
445 } else { |
9808
12fdb8fe0a35
turn assertions in NodeClass.FieldScanner into guarantees
Lukas Stadler <lukas.stadler@jku.at>
parents:
9720
diff
changeset
|
446 GraalInternalError.guarantee(NODE_CLASS.isAssignableFrom(type), "invalid successor type: %s", type); |
12fdb8fe0a35
turn assertions in NodeClass.FieldScanner into guarantees
Lukas Stadler <lukas.stadler@jku.at>
parents:
9720
diff
changeset
|
447 GraalInternalError.guarantee(!Modifier.isFinal(field.getModifiers()), "Node successor field %s should not be final", field); |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
448 successorOffsets.add(offset); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
449 } |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
450 } else { |
9808
12fdb8fe0a35
turn assertions in NodeClass.FieldScanner into guarantees
Lukas Stadler <lukas.stadler@jku.at>
parents:
9720
diff
changeset
|
451 GraalInternalError.guarantee(!NODE_CLASS.isAssignableFrom(type) || field.getName().equals("Null"), "suspicious node field: %s", field); |
12fdb8fe0a35
turn assertions in NodeClass.FieldScanner into guarantees
Lukas Stadler <lukas.stadler@jku.at>
parents:
9720
diff
changeset
|
452 GraalInternalError.guarantee(!INPUT_LIST_CLASS.isAssignableFrom(type), "suspicious node input list field: %s", field); |
12fdb8fe0a35
turn assertions in NodeClass.FieldScanner into guarantees
Lukas Stadler <lukas.stadler@jku.at>
parents:
9720
diff
changeset
|
453 GraalInternalError.guarantee(!SUCCESSOR_LIST_CLASS.isAssignableFrom(type), "suspicious node successor list field: %s", field); |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
454 dataOffsets.add(offset); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
455 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
456 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
457 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
458 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
459 @Override |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
460 public String toString() { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
461 StringBuilder str = new StringBuilder(); |
15295
21663230ba88
Move FieldIntrospection to graal.compiler.common.
Josef Eisl <josef.eisl@jku.at>
parents:
15241
diff
changeset
|
462 str.append("NodeClass ").append(getClazz().getSimpleName()).append(" ["); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
463 for (int i = 0; i < inputOffsets.length; i++) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
464 str.append(i == 0 ? "" : ", ").append(inputOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
465 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
466 str.append("] ["); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
467 for (int i = 0; i < successorOffsets.length; i++) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
468 str.append(i == 0 ? "" : ", ").append(successorOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
469 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
470 str.append("] ["); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
471 for (int i = 0; i < dataOffsets.length; i++) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
472 str.append(i == 0 ? "" : ", ").append(dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
473 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
474 str.append("]"); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
475 return str.toString(); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
476 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
477 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
478 private static Node getNode(Node node, long offset) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
479 return (Node) unsafe.getObject(node, offset); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
480 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
481 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
482 @SuppressWarnings("unchecked") |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
483 private static NodeList<Node> getNodeList(Node node, long offset) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
484 return (NodeList<Node>) unsafe.getObject(node, offset); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
485 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
486 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
487 private static void putNode(Node node, long offset, Node value) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
488 unsafe.putObject(node, offset, value); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
489 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
490 |
15040
288c23143d47
Fix most raw type references.
Josef Eisl <josef.eisl@jku.at>
parents:
15002
diff
changeset
|
491 private static void putNodeList(Node node, long offset, NodeList<?> value) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
492 unsafe.putObject(node, offset, value); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
493 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
494 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
495 /** |
12046
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
496 * An iterator that will iterate over the fields given in {@link #getOffsets()}. The first |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
497 * {@link #getDirectCount()} offsets are treated as fields of type {@link Node}, while the rest |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
498 * of the fields are treated as {@link NodeList}s. All elements of these NodeLists will be |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
499 * visited by the iterator as well. This iterator can be used to iterate over the inputs or |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
500 * successors of a node. |
15001 | 501 * |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
502 * An iterator of this type will not return null values, unless the field values are modified |
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
503 * concurrently. Concurrent modifications are detected by an assertion on a best-effort basis. |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
504 */ |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
505 public abstract static class NodeClassIterator implements NodePosIterator { |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
506 protected final Node node; |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
507 protected int index; |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
508 protected int subIndex; |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
509 NodeList<Node> list; |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
510 protected boolean needsForward; |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
511 protected Node nextElement; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
512 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
513 /** |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
514 * Creates an iterator that will iterate over fields in the given node. |
15001 | 515 * |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
516 * @param node the node which contains the fields. |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
517 */ |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
518 NodeClassIterator(Node node) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
519 this.node = node; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
520 index = NOT_ITERABLE; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
521 subIndex = 0; |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
522 needsForward = true; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
523 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
524 |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
525 void forward() { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
526 needsForward = false; |
12046
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
527 if (index < getDirectCount()) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
528 index++; |
12046
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
529 while (index < getDirectCount()) { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
530 nextElement = getNode(node, getOffsets()[index]); |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
531 if (nextElement != null) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
532 return; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
533 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
534 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
535 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
536 } else { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
537 subIndex++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
538 } |
12046
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
539 while (index < getOffsets().length) { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
540 if (subIndex == 0) { |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
541 list = getNodeList(node, getOffsets()[index]); |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
542 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
543 while (subIndex < list.size()) { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
544 nextElement = list.get(subIndex); |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
545 if (nextElement != null) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
546 return; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
547 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
548 subIndex++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
549 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
550 subIndex = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
551 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
552 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
553 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
554 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
555 private Node nextElement() { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
556 if (needsForward) { |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
557 forward(); |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
558 } |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
559 needsForward = true; |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
560 if (index < getOffsets().length) { |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
561 return nextElement; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
562 } |
7258
9bee93f61522
Cleanups: remove unused NodeUsagesList.replaceFirst and FrameState.block
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7123
diff
changeset
|
563 throw new NoSuchElementException(); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
564 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
565 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
566 @Override |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
567 public boolean hasNext() { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
568 if (needsForward) { |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
569 forward(); |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
570 } |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
571 return index < getOffsets().length; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
572 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
573 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
574 @Override |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
575 public Node next() { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
576 return nextElement(); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
577 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
578 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
579 public Position nextPosition() { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
580 if (needsForward) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
581 forward(); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
582 } |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
583 needsForward = true; |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
584 if (index < getDirectCount()) { |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
585 return new Position(getOffsets() == getNodeClass().inputOffsets, index, NOT_ITERABLE); |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
586 } else { |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
587 return new Position(getOffsets() == getNodeClass().inputOffsets, index, subIndex); |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
588 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
589 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
590 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
591 @Override |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
592 public void remove() { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
593 throw new UnsupportedOperationException(); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
594 } |
12046
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
595 |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
596 protected abstract int getDirectCount(); |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
597 |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
598 protected abstract long[] getOffsets(); |
12378
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
599 |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
600 protected abstract NodeClass getNodeClass(); |
12046
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
601 } |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
602 |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
603 private class NodeClassInputsIterator extends NodeClassIterator { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
604 |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
605 NodeClassInputsIterator(Node node) { |
12046
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
606 super(node); |
12378
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
607 assert NodeClass.this == node.getNodeClass(); |
12046
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
608 } |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
609 |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
610 @Override |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
611 protected int getDirectCount() { |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
612 return directInputCount; |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
613 } |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
614 |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
615 @Override |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
616 protected long[] getOffsets() { |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
617 return inputOffsets; |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
618 } |
12378
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
619 |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
620 @Override |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
621 protected NodeClass getNodeClass() { |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
622 return NodeClass.this; |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
623 } |
12046
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
624 } |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
625 |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
626 private class NodeClassAllInputsIterator extends NodeClassInputsIterator { |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
627 NodeClassAllInputsIterator(Node node) { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
628 super(node); |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
629 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
630 |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
631 @Override |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
632 void forward() { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
633 needsForward = false; |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
634 if (index < getDirectCount()) { |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
635 index++; |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
636 if (index < getDirectCount()) { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
637 nextElement = getNode(node, getOffsets()[index]); |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
638 return; |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
639 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
640 } else { |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
641 subIndex++; |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
642 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
643 while (index < getOffsets().length) { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
644 if (subIndex == 0) { |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
645 list = getNodeList(node, getOffsets()[index]); |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
646 } |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
647 if (subIndex < list.size()) { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
648 nextElement = list.get(subIndex); |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
649 return; |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
650 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
651 subIndex = 0; |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
652 index++; |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
653 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
654 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
655 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
656 |
16337
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
657 private class NodeClassAllSuccessorsIterator extends NodeClassSuccessorsIterator { |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
658 NodeClassAllSuccessorsIterator(Node node) { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
659 super(node); |
16337
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
660 } |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
661 |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
662 @Override |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
663 void forward() { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
664 needsForward = false; |
16337
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
665 if (index < getDirectCount()) { |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
666 index++; |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
667 if (index < getDirectCount()) { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
668 nextElement = getNode(node, getOffsets()[index]); |
16337
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
669 return; |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
670 } |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
671 } else { |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
672 subIndex++; |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
673 } |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
674 while (index < getOffsets().length) { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
675 if (subIndex == 0) { |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
676 list = getNodeList(node, getOffsets()[index]); |
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
677 } |
16337
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
678 if (subIndex < list.size()) { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
679 nextElement = list.get(subIndex); |
16337
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
680 return; |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
681 } |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
682 subIndex = 0; |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
683 index++; |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
684 } |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
685 } |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
686 } |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
687 |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
688 private final class NodeClassInputsWithModCountIterator extends NodeClassInputsIterator { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
689 private final int modCount; |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
690 |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
691 private NodeClassInputsWithModCountIterator(Node node) { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
692 super(node); |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
693 assert MODIFICATION_COUNTS_ENABLED; |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
694 this.modCount = node.modCount(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
695 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
696 |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
697 @Override |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
698 public boolean hasNext() { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
699 try { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
700 return super.hasNext(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
701 } finally { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
702 assert modCount == node.modCount() : "must not be modified"; |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
703 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
704 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
705 |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
706 @Override |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
707 public Node next() { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
708 try { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
709 return super.next(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
710 } finally { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
711 assert modCount == node.modCount() : "must not be modified"; |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
712 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
713 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
714 |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
715 @Override |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
716 public Position nextPosition() { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
717 try { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
718 return super.nextPosition(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
719 } finally { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
720 assert modCount == node.modCount(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
721 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
722 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
723 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
724 |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
725 private class NodeClassSuccessorsIterator extends NodeClassIterator { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
726 |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
727 NodeClassSuccessorsIterator(Node node) { |
12046
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
728 super(node); |
12378
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
729 assert NodeClass.this == node.getNodeClass(); |
12046
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
730 } |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
731 |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
732 @Override |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
733 protected int getDirectCount() { |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
734 return directSuccessorCount; |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
735 } |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
736 |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
737 @Override |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
738 protected long[] getOffsets() { |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
739 return successorOffsets; |
c3a1d5bfc3ee
NodeClassIterator: specialize instance for each type of iterator (inputs/successors) in order to share directCount/offsets directly with NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
11882
diff
changeset
|
740 } |
12378
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
741 |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
742 @Override |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
743 protected NodeClass getNodeClass() { |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
744 return NodeClass.this; |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
745 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
746 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
747 |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
748 private final class NodeClassSuccessorsWithModCountIterator extends NodeClassSuccessorsIterator { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
749 private final int modCount; |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
750 |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
751 private NodeClassSuccessorsWithModCountIterator(Node node) { |
17044
d5289a18cf5d
NodeClassIterator advances lazily instead of eagerly, allowing the next element to be cached in the advance operation
Doug Simon <doug.simon@oracle.com>
parents:
17009
diff
changeset
|
752 super(node); |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
753 assert MODIFICATION_COUNTS_ENABLED; |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
754 this.modCount = node.modCount(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
755 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
756 |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
757 @Override |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
758 public boolean hasNext() { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
759 try { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
760 return super.hasNext(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
761 } finally { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
762 assert modCount == node.modCount() : "must not be modified"; |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
763 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
764 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
765 |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
766 @Override |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
767 public Node next() { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
768 try { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
769 return super.next(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
770 } finally { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
771 assert modCount == node.modCount() : "must not be modified"; |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
772 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
773 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
774 |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
775 @Override |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
776 public Position nextPosition() { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
777 try { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
778 return super.nextPosition(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
779 } finally { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
780 assert modCount == node.modCount(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
781 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
782 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
783 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
784 |
12696
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
785 private static int deepHashCode0(Object o) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
786 if (o instanceof Object[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
787 return Arrays.deepHashCode((Object[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
788 } else if (o instanceof byte[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
789 return Arrays.hashCode((byte[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
790 } else if (o instanceof short[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
791 return Arrays.hashCode((short[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
792 } else if (o instanceof int[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
793 return Arrays.hashCode((int[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
794 } else if (o instanceof long[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
795 return Arrays.hashCode((long[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
796 } else if (o instanceof char[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
797 return Arrays.hashCode((char[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
798 } else if (o instanceof float[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
799 return Arrays.hashCode((float[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
800 } else if (o instanceof double[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
801 return Arrays.hashCode((double[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
802 } else if (o instanceof boolean[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
803 return Arrays.hashCode((boolean[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
804 } else if (o != null) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
805 return o.hashCode(); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
806 } else { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
807 return 0; |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
808 } |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
809 } |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
810 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
811 public int valueNumber(Node n) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
812 int number = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
813 if (canGVN) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
814 number = startGVNNumber; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
815 for (int i = 0; i < dataOffsets.length; ++i) { |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
816 Class<?> type = dataTypes[i]; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
817 if (type.isPrimitive()) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
818 if (type == Integer.TYPE) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
819 int intValue = unsafe.getInt(n, dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
820 number += intValue; |
6657
768793150bcd
more PEA refactoring, multiple iterations
Lukas Stadler <lukas.stadler@jku.at>
parents:
6414
diff
changeset
|
821 } else if (type == Long.TYPE) { |
768793150bcd
more PEA refactoring, multiple iterations
Lukas Stadler <lukas.stadler@jku.at>
parents:
6414
diff
changeset
|
822 long longValue = unsafe.getLong(n, dataOffsets[i]); |
768793150bcd
more PEA refactoring, multiple iterations
Lukas Stadler <lukas.stadler@jku.at>
parents:
6414
diff
changeset
|
823 number += longValue ^ (longValue >>> 32); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
824 } else if (type == Boolean.TYPE) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
825 boolean booleanValue = unsafe.getBoolean(n, dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
826 if (booleanValue) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
827 number += 7; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
828 } |
12701
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
829 } else if (type == Float.TYPE) { |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
830 float floatValue = unsafe.getFloat(n, dataOffsets[i]); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
831 number += Float.floatToRawIntBits(floatValue); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
832 } else if (type == Double.TYPE) { |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
833 double doubleValue = unsafe.getDouble(n, dataOffsets[i]); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
834 long longValue = Double.doubleToRawLongBits(doubleValue); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
835 number += longValue ^ (longValue >>> 32); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
836 } else if (type == Short.TYPE) { |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
837 short shortValue = unsafe.getShort(n, dataOffsets[i]); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
838 number += shortValue; |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
839 } else if (type == Character.TYPE) { |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
840 char charValue = unsafe.getChar(n, dataOffsets[i]); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
841 number += charValue; |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
842 } else if (type == Byte.TYPE) { |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
843 byte byteValue = unsafe.getByte(n, dataOffsets[i]); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
844 number += byteValue; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
845 } else { |
12701
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
846 assert false : "unhandled property type: " + type; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
847 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
848 } else { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
849 Object o = unsafe.getObject(n, dataOffsets[i]); |
12696
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
850 number += deepHashCode0(o); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
851 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
852 number *= 13; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
853 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
854 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
855 return number; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
856 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
857 |
12696
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
858 private static boolean deepEquals0(Object e1, Object e2) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
859 assert e1 != null; |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
860 boolean eq; |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
861 if (e1 instanceof Object[] && e2 instanceof Object[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
862 eq = Arrays.deepEquals((Object[]) e1, (Object[]) e2); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
863 } else if (e1 instanceof byte[] && e2 instanceof byte[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
864 eq = Arrays.equals((byte[]) e1, (byte[]) e2); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
865 } else if (e1 instanceof short[] && e2 instanceof short[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
866 eq = Arrays.equals((short[]) e1, (short[]) e2); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
867 } else if (e1 instanceof int[] && e2 instanceof int[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
868 eq = Arrays.equals((int[]) e1, (int[]) e2); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
869 } else if (e1 instanceof long[] && e2 instanceof long[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
870 eq = Arrays.equals((long[]) e1, (long[]) e2); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
871 } else if (e1 instanceof char[] && e2 instanceof char[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
872 eq = Arrays.equals((char[]) e1, (char[]) e2); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
873 } else if (e1 instanceof float[] && e2 instanceof float[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
874 eq = Arrays.equals((float[]) e1, (float[]) e2); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
875 } else if (e1 instanceof double[] && e2 instanceof double[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
876 eq = Arrays.equals((double[]) e1, (double[]) e2); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
877 } else if (e1 instanceof boolean[] && e2 instanceof boolean[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
878 eq = Arrays.equals((boolean[]) e1, (boolean[]) e2); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
879 } else { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
880 eq = e1.equals(e2); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
881 } |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
882 return eq; |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
883 } |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
884 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
885 public boolean valueEqual(Node a, Node b) { |
15186
5e2cffe8b815
allow valueEqual for non-GVN node classes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15106
diff
changeset
|
886 if (a.getClass() != b.getClass()) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
887 return a == b; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
888 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
889 for (int i = 0; i < dataOffsets.length; ++i) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
890 Class<?> type = dataTypes[i]; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
891 if (type.isPrimitive()) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
892 if (type == Integer.TYPE) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
893 int aInt = unsafe.getInt(a, dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
894 int bInt = unsafe.getInt(b, dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
895 if (aInt != bInt) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
896 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
897 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
898 } else if (type == Boolean.TYPE) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
899 boolean aBoolean = unsafe.getBoolean(a, dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
900 boolean bBoolean = unsafe.getBoolean(b, dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
901 if (aBoolean != bBoolean) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
902 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
903 } |
5301
23ea81293bd5
let NodeClass.valueEqual handle long fields
Lukas Stadler <lukas.stadler@jku.at>
parents:
5299
diff
changeset
|
904 } else if (type == Long.TYPE) { |
23ea81293bd5
let NodeClass.valueEqual handle long fields
Lukas Stadler <lukas.stadler@jku.at>
parents:
5299
diff
changeset
|
905 long aLong = unsafe.getLong(a, dataOffsets[i]); |
23ea81293bd5
let NodeClass.valueEqual handle long fields
Lukas Stadler <lukas.stadler@jku.at>
parents:
5299
diff
changeset
|
906 long bLong = unsafe.getLong(b, dataOffsets[i]); |
23ea81293bd5
let NodeClass.valueEqual handle long fields
Lukas Stadler <lukas.stadler@jku.at>
parents:
5299
diff
changeset
|
907 if (aLong != bLong) { |
23ea81293bd5
let NodeClass.valueEqual handle long fields
Lukas Stadler <lukas.stadler@jku.at>
parents:
5299
diff
changeset
|
908 return false; |
23ea81293bd5
let NodeClass.valueEqual handle long fields
Lukas Stadler <lukas.stadler@jku.at>
parents:
5299
diff
changeset
|
909 } |
12701
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
910 } else if (type == Float.TYPE) { |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
911 float aFloat = unsafe.getFloat(a, dataOffsets[i]); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
912 float bFloat = unsafe.getFloat(b, dataOffsets[i]); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
913 if (aFloat != bFloat) { |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
914 return false; |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
915 } |
10785
debb9d8e0282
allow double fields in value number computation and thus, in floating nodes
Doug Simon <doug.simon@oracle.com>
parents:
10424
diff
changeset
|
916 } else if (type == Double.TYPE) { |
debb9d8e0282
allow double fields in value number computation and thus, in floating nodes
Doug Simon <doug.simon@oracle.com>
parents:
10424
diff
changeset
|
917 double aDouble = unsafe.getDouble(a, dataOffsets[i]); |
debb9d8e0282
allow double fields in value number computation and thus, in floating nodes
Doug Simon <doug.simon@oracle.com>
parents:
10424
diff
changeset
|
918 double bDouble = unsafe.getDouble(b, dataOffsets[i]); |
debb9d8e0282
allow double fields in value number computation and thus, in floating nodes
Doug Simon <doug.simon@oracle.com>
parents:
10424
diff
changeset
|
919 if (aDouble != bDouble) { |
debb9d8e0282
allow double fields in value number computation and thus, in floating nodes
Doug Simon <doug.simon@oracle.com>
parents:
10424
diff
changeset
|
920 return false; |
debb9d8e0282
allow double fields in value number computation and thus, in floating nodes
Doug Simon <doug.simon@oracle.com>
parents:
10424
diff
changeset
|
921 } |
12701
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
922 } else if (type == Short.TYPE) { |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
923 short aShort = unsafe.getShort(a, dataOffsets[i]); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
924 short bShort = unsafe.getShort(b, dataOffsets[i]); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
925 if (aShort != bShort) { |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
926 return false; |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
927 } |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
928 } else if (type == Character.TYPE) { |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
929 char aChar = unsafe.getChar(a, dataOffsets[i]); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
930 char bChar = unsafe.getChar(b, dataOffsets[i]); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
931 if (aChar != bChar) { |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
932 return false; |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
933 } |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
934 } else if (type == Byte.TYPE) { |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
935 byte aByte = unsafe.getByte(a, dataOffsets[i]); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
936 byte bByte = unsafe.getByte(b, dataOffsets[i]); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
937 if (aByte != bByte) { |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
938 return false; |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
939 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
940 } else { |
5301
23ea81293bd5
let NodeClass.valueEqual handle long fields
Lukas Stadler <lukas.stadler@jku.at>
parents:
5299
diff
changeset
|
941 assert false : "unhandled type: " + type; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
942 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
943 } else { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
944 Object objectA = unsafe.getObject(a, dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
945 Object objectB = unsafe.getObject(b, dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
946 if (objectA != objectB) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
947 if (objectA != null && objectB != null) { |
12696
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
948 if (!deepEquals0(objectA, objectB)) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
949 return false; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
950 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
951 } else { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
952 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
953 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
954 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
955 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
956 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
957 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
958 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
959 |
5214 | 960 public boolean isValid(Position pos, NodeClass from) { |
5489
5d0d72b37f88
Switch to new loop transformation framework, use it for peeling and full unrolling for snippets
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5487
diff
changeset
|
961 if (this == from) { |
5d0d72b37f88
Switch to new loop transformation framework, use it for peeling and full unrolling for snippets
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5487
diff
changeset
|
962 return true; |
5d0d72b37f88
Switch to new loop transformation framework, use it for peeling and full unrolling for snippets
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5487
diff
changeset
|
963 } |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
964 long[] offsets = pos.isInput() ? inputOffsets : successorOffsets; |
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
965 if (pos.getIndex() >= offsets.length) { |
5214 | 966 return false; |
967 } | |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
968 long[] fromOffsets = pos.isInput() ? from.inputOffsets : from.successorOffsets; |
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
969 if (pos.getIndex() >= fromOffsets.length) { |
5214 | 970 return false; |
971 } | |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
972 return offsets[pos.getIndex()] == fromOffsets[pos.getIndex()]; |
5214 | 973 } |
974 | |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
975 public Node get(Node node, Position pos) { |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
976 if (Node.USE_GENERATED_NODES) { |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
977 return node.getNodeAt(pos); |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
978 } |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
979 long offset = pos.isInput() ? inputOffsets[pos.getIndex()] : successorOffsets[pos.getIndex()]; |
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
980 if (pos.getSubIndex() == NOT_ITERABLE) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
981 return getNode(node, offset); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
982 } else { |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
983 return getNodeList(node, offset).get(pos.getSubIndex()); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
984 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
985 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
986 |
15001 | 987 public InputType getInputType(Position pos) { |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
988 assert pos.isInput(); |
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
989 return inputTypes[pos.getIndex()]; |
15001 | 990 } |
991 | |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
992 public boolean isInputOptional(Position pos) { |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
993 assert pos.isInput(); |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
994 return inputOptional[pos.getIndex()]; |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
995 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
996 |
12483
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
997 public NodeList<?> getNodeList(Node node, Position pos) { |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
998 if (Node.USE_GENERATED_NODES) { |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
999 return node.getNodeListAt(pos); |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
1000 } |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
1001 long offset = pos.isInput() ? inputOffsets[pos.getIndex()] : successorOffsets[pos.getIndex()]; |
16897
f90dcdbbb75e
switched to using new NodeFieldIterator and NodeFieldIterable for traversing Node inputs and successors
Doug Simon <doug.simon@oracle.com>
parents:
16841
diff
changeset
|
1002 assert pos.getSubIndex() == Node.NODE_LIST; |
12483
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1003 return getNodeList(node, offset); |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1004 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1005 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1006 public String getName(Position pos) { |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
1007 return fieldNames.get(pos.isInput() ? inputOffsets[pos.getIndex()] : successorOffsets[pos.getIndex()]); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1008 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1009 |
15827
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1010 public String getPropertyName(int pos) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1011 return fieldNames.get(dataOffsets[pos]); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1012 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1013 |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1014 public Class<?> getPropertyType(int pos) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1015 return fieldTypes.get(dataOffsets[pos]); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1016 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1017 |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1018 public Object getProperty(Node node, int pos) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1019 long dataOffset = dataOffsets[pos]; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1020 Class<?> type = fieldTypes.get(dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1021 Object value = null; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1022 if (type.isPrimitive()) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1023 if (type == Integer.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1024 value = unsafe.getInt(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1025 } else if (type == Long.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1026 value = unsafe.getLong(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1027 } else if (type == Boolean.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1028 value = unsafe.getBoolean(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1029 } else if (type == Float.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1030 value = unsafe.getFloat(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1031 } else if (type == Double.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1032 value = unsafe.getDouble(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1033 } else if (type == Short.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1034 value = unsafe.getShort(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1035 } else if (type == Character.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1036 value = unsafe.getChar(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1037 } else if (type == Byte.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1038 value = unsafe.getByte(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1039 } else { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1040 assert false : "unhandled property type: " + type; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1041 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1042 } else { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1043 value = unsafe.getObject(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1044 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1045 return value; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1046 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1047 |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1048 public void setProperty(Node node, int pos, Object value) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1049 long dataOffset = dataOffsets[pos]; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1050 Class<?> type = fieldTypes.get(dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1051 if (type.isPrimitive()) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1052 if (type == Integer.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1053 unsafe.putInt(node, dataOffset, (Integer) value); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1054 } else if (type == Long.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1055 unsafe.putLong(node, dataOffset, (Long) value); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1056 } else if (type == Boolean.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1057 unsafe.putBoolean(node, dataOffset, (Boolean) value); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1058 } else if (type == Float.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1059 unsafe.putFloat(node, dataOffset, (Float) value); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1060 } else if (type == Double.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1061 unsafe.putDouble(node, dataOffset, (Double) value); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1062 } else if (type == Short.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1063 unsafe.putShort(node, dataOffset, (Short) value); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1064 } else if (type == Character.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1065 unsafe.putChar(node, dataOffset, (Character) value); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1066 } else if (type == Byte.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1067 unsafe.putByte(node, dataOffset, (Byte) value); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1068 } else { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1069 assert false : "unhandled property type: " + type; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1070 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1071 } else { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1072 assert value == null || !value.getClass().isPrimitive(); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1073 unsafe.putObject(node, dataOffset, value); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1074 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1075 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1076 |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1077 void updateInputSuccInPlace(Node node, InplaceUpdateClosure duplicationReplacement) { |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1078 int index = 0; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1079 while (index < directInputCount) { |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1080 Node input = getNode(node, inputOffsets[index]); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1081 if (input != null) { |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1082 Node newInput = duplicationReplacement.replacement(input, true); |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1083 node.updateUsages(null, newInput); |
13151
5801a5e3e7e4
Assert for checking the input type in NodeClass.updateInputSuccInPlace.
Roland Schatz <roland.schatz@oracle.com>
parents:
13140
diff
changeset
|
1084 assert newInput == null || fieldTypes.get(inputOffsets[index]).isAssignableFrom(newInput.getClass()) : "Can not assign " + newInput.getClass() + " to " + |
5801a5e3e7e4
Assert for checking the input type in NodeClass.updateInputSuccInPlace.
Roland Schatz <roland.schatz@oracle.com>
parents:
13140
diff
changeset
|
1085 fieldTypes.get(inputOffsets[index]) + " in " + node; |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1086 putNode(node, inputOffsets[index], newInput); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1087 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1088 index++; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1089 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1090 |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1091 if (index < inputOffsets.length) { |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1092 updateInputLists(node, duplicationReplacement, index); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1093 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1094 |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1095 index = 0; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1096 while (index < directSuccessorCount) { |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1097 Node successor = getNode(node, successorOffsets[index]); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1098 if (successor != null) { |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1099 Node newSucc = duplicationReplacement.replacement(successor, false); |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1100 node.updatePredecessor(null, newSucc); |
13151
5801a5e3e7e4
Assert for checking the input type in NodeClass.updateInputSuccInPlace.
Roland Schatz <roland.schatz@oracle.com>
parents:
13140
diff
changeset
|
1101 assert newSucc == null || fieldTypes.get(successorOffsets[index]).isAssignableFrom(newSucc.getClass()) : fieldTypes.get(successorOffsets[index]) + " is not compatible with " + |
5801a5e3e7e4
Assert for checking the input type in NodeClass.updateInputSuccInPlace.
Roland Schatz <roland.schatz@oracle.com>
parents:
13140
diff
changeset
|
1102 newSucc.getClass(); |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1103 putNode(node, successorOffsets[index], newSucc); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1104 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1105 index++; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1106 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1107 |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1108 if (index < successorOffsets.length) { |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1109 updateSuccLists(node, duplicationReplacement, index); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1110 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1111 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1112 |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1113 private void updateInputLists(Node node, InplaceUpdateClosure duplicationReplacement, int startIndex) { |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1114 int index = startIndex; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1115 while (index < inputOffsets.length) { |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1116 NodeList<Node> list = getNodeList(node, inputOffsets[index]); |
15295
21663230ba88
Move FieldIntrospection to graal.compiler.common.
Josef Eisl <josef.eisl@jku.at>
parents:
15241
diff
changeset
|
1117 assert list != null : getClazz(); |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1118 putNodeList(node, inputOffsets[index], updateInputListCopy(list, node, duplicationReplacement)); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1119 index++; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1120 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1121 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1122 |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1123 private void updateSuccLists(Node node, InplaceUpdateClosure duplicationReplacement, int startIndex) { |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1124 int index = startIndex; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1125 while (index < successorOffsets.length) { |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1126 NodeList<Node> list = getNodeList(node, successorOffsets[index]); |
15295
21663230ba88
Move FieldIntrospection to graal.compiler.common.
Josef Eisl <josef.eisl@jku.at>
parents:
15241
diff
changeset
|
1127 assert list != null : getClazz(); |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1128 putNodeList(node, successorOffsets[index], updateSuccListCopy(list, node, duplicationReplacement)); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1129 index++; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1130 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1131 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1132 |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1133 private static NodeInputList<Node> updateInputListCopy(NodeList<Node> list, Node node, InplaceUpdateClosure duplicationReplacement) { |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1134 int size = list.size(); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1135 NodeInputList<Node> result = new NodeInputList<>(node, size); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1136 for (int i = 0; i < list.count(); ++i) { |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1137 Node oldNode = list.get(i); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1138 if (oldNode != null) { |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1139 Node newNode = duplicationReplacement.replacement(oldNode, true); |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1140 result.set(i, newNode); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1141 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1142 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1143 return result; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1144 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1145 |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1146 private static NodeSuccessorList<Node> updateSuccListCopy(NodeList<Node> list, Node node, InplaceUpdateClosure duplicationReplacement) { |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1147 int size = list.size(); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1148 NodeSuccessorList<Node> result = new NodeSuccessorList<>(node, size); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1149 for (int i = 0; i < list.count(); ++i) { |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1150 Node oldNode = list.get(i); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1151 if (oldNode != null) { |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1152 Node newNode = duplicationReplacement.replacement(oldNode, false); |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1153 result.set(i, newNode); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1154 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1155 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1156 return result; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1157 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1158 |
7283
3964f3d4eb18
Extend loop unswicthing to Switch nodes (integer or type)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7258
diff
changeset
|
1159 public void set(Node node, Position pos, Node x) { |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
1160 if (Node.USE_GENERATED_NODES) { |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
1161 node.updateNodeAt(pos, x); |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
1162 return; |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
1163 } |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
1164 |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
1165 long offset = pos.isInput() ? inputOffsets[pos.getIndex()] : successorOffsets[pos.getIndex()]; |
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
1166 if (pos.getSubIndex() == NOT_ITERABLE) { |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1167 Node old = getNode(node, offset); |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
1168 assert x == null || fieldTypes.get((pos.isInput() ? inputOffsets : successorOffsets)[pos.getIndex()]).isAssignableFrom(x.getClass()) : this + ".set(node, pos, " + x + ")"; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1169 putNode(node, offset, x); |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
1170 if (pos.isInput()) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1171 node.updateUsages(old, x); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1172 } else { |
5487
9743ae819f73
Move virtual chain help methods from SuperBlock to GraphUtil
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5486
diff
changeset
|
1173 node.updatePredecessor(old, x); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1174 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1175 } else { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1176 NodeList<Node> list = getNodeList(node, offset); |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
1177 if (pos.getSubIndex() < list.size()) { |
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
1178 list.set(pos.getSubIndex(), x); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1179 } else { |
15827
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1180 while (list.size() < pos.getSubIndex()) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1181 list.add(null); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1182 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1183 list.add(x); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1184 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1185 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1186 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1187 |
16206
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1188 public void initializePosition(Node node, Position pos, Node x) { |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
1189 if (Node.USE_GENERATED_NODES) { |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
1190 node.initializeNodeAt(pos, x); |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
1191 return; |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
1192 } |
16206
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1193 long offset = pos.isInput() ? inputOffsets[pos.getIndex()] : successorOffsets[pos.getIndex()]; |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1194 if (pos.getSubIndex() == NOT_ITERABLE) { |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1195 assert x == null || fieldTypes.get((pos.isInput() ? inputOffsets : successorOffsets)[pos.getIndex()]).isAssignableFrom(x.getClass()) : this + ".set(node, pos, " + x + ")"; |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1196 putNode(node, offset, x); |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1197 } else { |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1198 NodeList<Node> list = getNodeList(node, offset); |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1199 while (list.size() <= pos.getSubIndex()) { |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1200 list.add(null); |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1201 } |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1202 list.initialize(pos.getSubIndex(), x); |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1203 } |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1204 } |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1205 |
7123
b914b9b4c578
graal.graph refactorings
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
6657
diff
changeset
|
1206 public NodeClassIterable getInputIterable(final Node node) { |
15295
21663230ba88
Move FieldIntrospection to graal.compiler.common.
Josef Eisl <josef.eisl@jku.at>
parents:
15241
diff
changeset
|
1207 assert getClazz().isInstance(node); |
7123
b914b9b4c578
graal.graph refactorings
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
6657
diff
changeset
|
1208 return new NodeClassIterable() { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1209 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1210 @Override |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1211 public NodeClassIterator iterator() { |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1212 if (MODIFICATION_COUNTS_ENABLED) { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1213 return new NodeClassInputsWithModCountIterator(node); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1214 } else { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1215 return new NodeClassInputsIterator(node); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1216 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1217 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1218 |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
1219 public NodeClassIterator withNullIterator() { |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
1220 return new NodeClassAllInputsIterator(node); |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
1221 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
1222 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1223 @Override |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1224 public boolean contains(Node other) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1225 return inputContains(node, other); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1226 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1227 }; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1228 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1229 |
7123
b914b9b4c578
graal.graph refactorings
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
6657
diff
changeset
|
1230 public NodeClassIterable getSuccessorIterable(final Node node) { |
15295
21663230ba88
Move FieldIntrospection to graal.compiler.common.
Josef Eisl <josef.eisl@jku.at>
parents:
15241
diff
changeset
|
1231 assert getClazz().isInstance(node); |
7123
b914b9b4c578
graal.graph refactorings
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
6657
diff
changeset
|
1232 return new NodeClassIterable() { |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1233 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1234 @Override |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1235 public NodeClassIterator iterator() { |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1236 if (MODIFICATION_COUNTS_ENABLED) { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1237 return new NodeClassSuccessorsWithModCountIterator(node); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1238 } else { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1239 return new NodeClassSuccessorsIterator(node); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1240 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1241 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1242 |
16337
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
1243 public NodeClassIterator withNullIterator() { |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
1244 return new NodeClassAllSuccessorsIterator(node); |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
1245 } |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
1246 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1247 @Override |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1248 public boolean contains(Node other) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1249 return successorContains(node, other); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1250 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1251 }; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1252 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1253 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1254 public boolean replaceFirstInput(Node node, Node old, Node other) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1255 int index = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1256 while (index < directInputCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1257 Node input = getNode(node, inputOffsets[index]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1258 if (input == old) { |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1259 assert other == null || fieldTypes.get(inputOffsets[index]).isAssignableFrom(other.getClass()) : "Can not assign " + other.getClass() + " to " + fieldTypes.get(inputOffsets[index]) + |
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1260 " in " + node; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1261 putNode(node, inputOffsets[index], other); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1262 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1263 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1264 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1265 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1266 while (index < inputOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1267 NodeList<Node> list = getNodeList(node, inputOffsets[index]); |
15295
21663230ba88
Move FieldIntrospection to graal.compiler.common.
Josef Eisl <josef.eisl@jku.at>
parents:
15241
diff
changeset
|
1268 assert list != null : getClazz(); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1269 if (list.replaceFirst(old, other)) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1270 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1271 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1272 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1273 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1274 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1275 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1276 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1277 public boolean replaceFirstSuccessor(Node node, Node old, Node other) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1278 int index = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1279 while (index < directSuccessorCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1280 Node successor = getNode(node, successorOffsets[index]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1281 if (successor == old) { |
10424
e6cf435419b2
Fix after lowering phase refactoring.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
9808
diff
changeset
|
1282 assert other == null || fieldTypes.get(successorOffsets[index]).isAssignableFrom(other.getClass()) : fieldTypes.get(successorOffsets[index]) + " is not compatible with " + |
e6cf435419b2
Fix after lowering phase refactoring.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
9808
diff
changeset
|
1283 other.getClass(); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1284 putNode(node, successorOffsets[index], other); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1285 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1286 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1287 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1288 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1289 while (index < successorOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1290 NodeList<Node> list = getNodeList(node, successorOffsets[index]); |
15295
21663230ba88
Move FieldIntrospection to graal.compiler.common.
Josef Eisl <josef.eisl@jku.at>
parents:
15241
diff
changeset
|
1291 assert list != null : getClazz() + " " + successorOffsets[index] + " " + node; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1292 if (list.replaceFirst(old, other)) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1293 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1294 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1295 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1296 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1297 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1298 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1299 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1300 /** |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1301 * Clear all inputs in the given node. This is accomplished by setting input fields to null and |
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1302 * replacing input lists with new lists. (which is important so that this method can be used to |
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1303 * clear the inputs of cloned nodes.) |
15001 | 1304 * |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1305 * @param node the node to be cleared |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1306 */ |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1307 public void clearInputs(Node node) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1308 int index = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1309 while (index < directInputCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1310 putNode(node, inputOffsets[index++], null); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1311 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1312 while (index < inputOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1313 long curOffset = inputOffsets[index++]; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1314 int size = (getNodeList(node, curOffset)).initialSize; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1315 // replacing with a new list object is the expected behavior! |
4142
bc8527f3071c
Adjust code base to new level of warnings.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
3733
diff
changeset
|
1316 putNodeList(node, curOffset, new NodeInputList<>(node, size)); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1317 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1318 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1319 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1320 /** |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1321 * Clear all successors in the given node. This is accomplished by setting successor fields to |
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1322 * null and replacing successor lists with new lists. (which is important so that this method |
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1323 * can be used to clear the successors of cloned nodes.) |
15001 | 1324 * |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1325 * @param node the node to be cleared |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1326 */ |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1327 public void clearSuccessors(Node node) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1328 int index = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1329 while (index < directSuccessorCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1330 putNode(node, successorOffsets[index++], null); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1331 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1332 while (index < successorOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1333 long curOffset = successorOffsets[index++]; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1334 int size = getNodeList(node, curOffset).initialSize; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1335 // replacing with a new list object is the expected behavior! |
4142
bc8527f3071c
Adjust code base to new level of warnings.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
3733
diff
changeset
|
1336 putNodeList(node, curOffset, new NodeSuccessorList<>(node, size)); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1337 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1338 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1339 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1340 /** |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1341 * Copies the inputs from node to newNode. The nodes are expected to be of the exact same |
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1342 * NodeClass type. |
15001 | 1343 * |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1344 * @param node the node from which the inputs should be copied. |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1345 * @param newNode the node to which the inputs should be copied. |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1346 */ |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1347 public void copyInputs(Node node, Node newNode) { |
16982
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
1348 assert node.getNodeClass() == this && newNode.getNodeClass() == this; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1349 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1350 int index = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1351 while (index < directInputCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1352 putNode(newNode, inputOffsets[index], getNode(node, inputOffsets[index])); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1353 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1354 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1355 while (index < inputOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1356 NodeList<Node> list = getNodeList(newNode, inputOffsets[index]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1357 list.copy(getNodeList(node, inputOffsets[index])); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1358 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1359 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1360 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1361 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1362 /** |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1363 * Copies the successors from node to newNode. The nodes are expected to be of the exact same |
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1364 * NodeClass type. |
15001 | 1365 * |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1366 * @param node the node from which the successors should be copied. |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1367 * @param newNode the node to which the successors should be copied. |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1368 */ |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1369 public void copySuccessors(Node node, Node newNode) { |
16982
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
1370 assert node.getNodeClass() == this && newNode.getNodeClass() == this; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1371 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1372 int index = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1373 while (index < directSuccessorCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1374 putNode(newNode, successorOffsets[index], getNode(node, successorOffsets[index])); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1375 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1376 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1377 while (index < successorOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1378 NodeList<Node> list = getNodeList(newNode, successorOffsets[index]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1379 list.copy(getNodeList(node, successorOffsets[index])); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1380 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1381 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1382 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1383 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1384 public boolean edgesEqual(Node node, Node other) { |
9450
ca34e36c53e8
Add loop safepoint elimination
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7530
diff
changeset
|
1385 return inputsEqual(node, other) && successorsEqual(node, other); |
ca34e36c53e8
Add loop safepoint elimination
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7530
diff
changeset
|
1386 } |
ca34e36c53e8
Add loop safepoint elimination
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7530
diff
changeset
|
1387 |
ca34e36c53e8
Add loop safepoint elimination
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7530
diff
changeset
|
1388 public boolean inputsEqual(Node node, Node other) { |
16982
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
1389 assert node.getNodeClass() == this && other.getNodeClass() == this; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1390 int index = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1391 while (index < directInputCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1392 if (getNode(other, inputOffsets[index]) != getNode(node, inputOffsets[index])) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1393 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1394 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1395 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1396 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1397 while (index < inputOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1398 NodeList<Node> list = getNodeList(other, inputOffsets[index]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1399 if (!list.equals(getNodeList(node, inputOffsets[index]))) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1400 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1401 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1402 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1403 } |
9450
ca34e36c53e8
Add loop safepoint elimination
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7530
diff
changeset
|
1404 return true; |
ca34e36c53e8
Add loop safepoint elimination
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7530
diff
changeset
|
1405 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1406 |
9450
ca34e36c53e8
Add loop safepoint elimination
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7530
diff
changeset
|
1407 public boolean successorsEqual(Node node, Node other) { |
16982
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
1408 assert node.getNodeClass() == this && other.getNodeClass() == this; |
9450
ca34e36c53e8
Add loop safepoint elimination
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7530
diff
changeset
|
1409 int index = 0; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1410 while (index < directSuccessorCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1411 if (getNode(other, successorOffsets[index]) != getNode(node, successorOffsets[index])) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1412 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1413 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1414 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1415 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1416 while (index < successorOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1417 NodeList<Node> list = getNodeList(other, successorOffsets[index]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1418 if (!list.equals(getNodeList(node, successorOffsets[index]))) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1419 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1420 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1421 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1422 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1423 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1424 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1425 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1426 public boolean inputContains(Node node, Node other) { |
16982
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
1427 assert node.getNodeClass() == this; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1428 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1429 int index = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1430 while (index < directInputCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1431 if (getNode(node, inputOffsets[index]) == other) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1432 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1433 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1434 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1435 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1436 while (index < inputOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1437 NodeList<Node> list = getNodeList(node, inputOffsets[index]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1438 if (list.contains(other)) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1439 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1440 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1441 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1442 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1443 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1444 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1445 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1446 public boolean successorContains(Node node, Node other) { |
16982
5762848171e7
replaced 'node.getClass() == <literal>.getGenClass()' idiom with new 'NodeClass.is(Class<? extends Node.class> cls)' mechanism
Doug Simon <doug.simon@oracle.com>
parents:
16919
diff
changeset
|
1447 assert node.getNodeClass() == this; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1448 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1449 int index = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1450 while (index < directSuccessorCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1451 if (getNode(node, successorOffsets[index]) == other) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1452 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1453 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1454 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1455 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1456 while (index < successorOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1457 NodeList<Node> list = getNodeList(node, successorOffsets[index]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1458 if (list.contains(other)) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1459 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1460 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1461 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1462 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1463 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1464 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1465 |
12483
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1466 public Collection<Position> getFirstLevelInputPositions() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1467 return new AbstractCollection<Position>() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1468 @Override |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1469 public Iterator<Position> iterator() { |
16897
f90dcdbbb75e
switched to using new NodeFieldIterator and NodeFieldIterable for traversing Node inputs and successors
Doug Simon <doug.simon@oracle.com>
parents:
16841
diff
changeset
|
1470 return new Iterator<Position>() { |
12483
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1471 int i = 0; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1472 |
12558 | 1473 @Override |
12483
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1474 public void remove() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1475 throw new UnsupportedOperationException(); |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1476 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1477 |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1478 public Position next() { |
16897
f90dcdbbb75e
switched to using new NodeFieldIterator and NodeFieldIterable for traversing Node inputs and successors
Doug Simon <doug.simon@oracle.com>
parents:
16841
diff
changeset
|
1479 Position pos = new Position(true, i, i >= directInputCount ? Node.NODE_LIST : Node.NOT_ITERABLE); |
12483
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1480 i++; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1481 return pos; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1482 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1483 |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1484 public boolean hasNext() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1485 return i < inputOffsets.length; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1486 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1487 }; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1488 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1489 |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1490 @Override |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1491 public int size() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1492 return inputOffsets.length; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1493 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1494 }; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1495 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1496 |
12483
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1497 public Collection<Position> getFirstLevelSuccessorPositions() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1498 return new AbstractCollection<Position>() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1499 @Override |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1500 public Iterator<Position> iterator() { |
16897
f90dcdbbb75e
switched to using new NodeFieldIterator and NodeFieldIterable for traversing Node inputs and successors
Doug Simon <doug.simon@oracle.com>
parents:
16841
diff
changeset
|
1501 return new Iterator<Position>() { |
12483
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1502 int i = 0; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1503 |
12558 | 1504 @Override |
12483
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1505 public void remove() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1506 throw new UnsupportedOperationException(); |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1507 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1508 |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1509 public Position next() { |
16897
f90dcdbbb75e
switched to using new NodeFieldIterator and NodeFieldIterable for traversing Node inputs and successors
Doug Simon <doug.simon@oracle.com>
parents:
16841
diff
changeset
|
1510 Position pos = new Position(false, i, i >= directSuccessorCount ? Node.NODE_LIST : Node.NOT_ITERABLE); |
12483
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1511 i++; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1512 return pos; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1513 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1514 |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1515 public boolean hasNext() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1516 return i < successorOffsets.length; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1517 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1518 }; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1519 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1520 |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1521 @Override |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1522 public int size() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1523 return successorOffsets.length; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1524 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1525 }; |
5813
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
1526 } |
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
1527 |
15827
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1528 public Collection<Integer> getPropertyPositions() { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1529 return new AbstractCollection<Integer>() { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1530 @Override |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1531 public Iterator<Integer> iterator() { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1532 return new Iterator<Integer>() { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1533 int i = 0; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1534 |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1535 @Override |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1536 public void remove() { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1537 throw new UnsupportedOperationException(); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1538 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1539 |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1540 public Integer next() { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1541 Integer pos = i++; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1542 return pos; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1543 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1544 |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1545 public boolean hasNext() { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1546 return i < dataOffsets.length; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1547 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1548 }; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1549 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1550 |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1551 @Override |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1552 public int size() { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1553 return dataOffsets.length; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1554 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1555 }; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1556 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1557 |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1558 /** |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1559 * Initializes a fresh allocated node for which no constructor is called yet. Needed to |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1560 * implement node factories in svm. |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1561 */ |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1562 public void initRawNode(Node node) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1563 node.init(); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1564 for (int inputPos = directInputCount; inputPos < inputOffsets.length; inputPos++) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1565 if (getNodeList(node, inputOffsets[inputPos]) == null) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1566 putNodeList(node, inputOffsets[inputPos], new NodeInputList<>(node)); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1567 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1568 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1569 for (int successorPos = directSuccessorCount; successorPos < successorOffsets.length; successorPos++) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1570 if (getNodeList(node, successorOffsets[successorPos]) == null) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1571 putNodeList(node, successorOffsets[successorPos], new NodeSuccessorList<>(node)); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1572 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1573 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1574 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1575 |
5813
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
1576 public Class<?> getJavaClass() { |
15295
21663230ba88
Move FieldIntrospection to graal.compiler.common.
Josef Eisl <josef.eisl@jku.at>
parents:
15241
diff
changeset
|
1577 return getClazz(); |
5813
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
1578 } |
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
1579 |
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
1580 /** |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1581 * The template used to build the {@link Verbosity#Name} version. Variable part are specified |
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1582 * using {i#inputName} or {p#propertyName}. |
5813
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
1583 */ |
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
1584 public String getNameTemplate() { |
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
1585 return nameTemplate; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1586 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1587 |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1588 interface InplaceUpdateClosure { |
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1589 |
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1590 Node replacement(Node node, boolean isInput); |
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1591 } |
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1592 |
11675
77d9f12797c5
Use NodeMap in inlining utility when number of nodes is high.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11674
diff
changeset
|
1593 static Map<Node, Node> addGraphDuplicate(final Graph graph, final Graph oldGraph, int estimatedNodeCount, Iterable<Node> nodes, final DuplicationReplacement replacements) { |
12685
478c82dde838
commented choice of data structure in NodeClass.addGraphDuplicate()
Doug Simon <doug.simon@oracle.com>
parents:
12669
diff
changeset
|
1594 final Map<Node, Node> newNodes; |
15551
33cedbce5b23
added CollectionsProvider and NodeCollectionsProvider and replaced (almost) all allocations of IdentityHashMaps to go through these providers
Doug Simon <doug.simon@oracle.com>
parents:
15295
diff
changeset
|
1595 int denseThreshold = oldGraph.getNodeCount() + oldGraph.getNodesDeletedSinceLastCompression() >> 4; |
33cedbce5b23
added CollectionsProvider and NodeCollectionsProvider and replaced (almost) all allocations of IdentityHashMaps to go through these providers
Doug Simon <doug.simon@oracle.com>
parents:
15295
diff
changeset
|
1596 if (estimatedNodeCount > denseThreshold) { |
12685
478c82dde838
commented choice of data structure in NodeClass.addGraphDuplicate()
Doug Simon <doug.simon@oracle.com>
parents:
12669
diff
changeset
|
1597 // Use dense map |
478c82dde838
commented choice of data structure in NodeClass.addGraphDuplicate()
Doug Simon <doug.simon@oracle.com>
parents:
12669
diff
changeset
|
1598 newNodes = new NodeNodeMap(oldGraph); |
478c82dde838
commented choice of data structure in NodeClass.addGraphDuplicate()
Doug Simon <doug.simon@oracle.com>
parents:
12669
diff
changeset
|
1599 } else { |
478c82dde838
commented choice of data structure in NodeClass.addGraphDuplicate()
Doug Simon <doug.simon@oracle.com>
parents:
12669
diff
changeset
|
1600 // Use sparse map |
15551
33cedbce5b23
added CollectionsProvider and NodeCollectionsProvider and replaced (almost) all allocations of IdentityHashMaps to go through these providers
Doug Simon <doug.simon@oracle.com>
parents:
15295
diff
changeset
|
1601 newNodes = newIdentityMap(); |
12685
478c82dde838
commented choice of data structure in NodeClass.addGraphDuplicate()
Doug Simon <doug.simon@oracle.com>
parents:
12669
diff
changeset
|
1602 } |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1603 createNodeDuplicates(graph, nodes, replacements, newNodes); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1604 |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1605 InplaceUpdateClosure replacementClosure = new InplaceUpdateClosure() { |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1606 |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1607 public Node replacement(Node node, boolean isInput) { |
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1608 Node target = newNodes.get(node); |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1609 if (target == null) { |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1610 Node replacement = node; |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1611 if (replacements != null) { |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1612 replacement = replacements.replacement(node); |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1613 } |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1614 if (replacement != node) { |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1615 target = replacement; |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1616 } else if (node.graph() == graph && isInput) { |
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1617 // patch to the outer world |
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1618 target = node; |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1619 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1620 |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1621 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1622 return target; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1623 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1624 |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1625 }; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1626 |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1627 // re-wire inputs |
11675
77d9f12797c5
Use NodeMap in inlining utility when number of nodes is high.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11674
diff
changeset
|
1628 for (Node oldNode : nodes) { |
77d9f12797c5
Use NodeMap in inlining utility when number of nodes is high.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11674
diff
changeset
|
1629 Node node = newNodes.get(oldNode); |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1630 NodeClass oldNodeClass = oldNode.getNodeClass(); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1631 NodeClass nodeClass = node.getNodeClass(); |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1632 if (replacements == null || replacements.replacement(oldNode) == oldNode) { |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1633 nodeClass.updateInputSuccInPlace(node, replacementClosure); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1634 } else { |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1635 transferValuesDifferentNodeClass(graph, replacements, newNodes, oldNode, node, oldNodeClass, nodeClass); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1636 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1637 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1638 |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1639 return newNodes; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1640 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1641 |
11675
77d9f12797c5
Use NodeMap in inlining utility when number of nodes is high.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11674
diff
changeset
|
1642 private static void createNodeDuplicates(final Graph graph, Iterable<Node> nodes, final DuplicationReplacement replacements, final Map<Node, Node> newNodes) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1643 for (Node node : nodes) { |
5478
4a99bfc329f0
Add posibility to provide a replacement function instead of map for duplication.
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5361
diff
changeset
|
1644 if (node != null) { |
6302
5d7d9a6953bd
added InstanceOfSnippets which passes InstanceOfTest but is not yet enabled for general lowering
Doug Simon <doug.simon@oracle.com>
parents:
5858
diff
changeset
|
1645 assert !node.isDeleted() : "trying to duplicate deleted node: " + node; |
11671
3522f7c99c5f
Allow null DuplicationReplacement in addDuplicates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11669
diff
changeset
|
1646 Node replacement = node; |
3522f7c99c5f
Allow null DuplicationReplacement in addDuplicates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11669
diff
changeset
|
1647 if (replacements != null) { |
3522f7c99c5f
Allow null DuplicationReplacement in addDuplicates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11669
diff
changeset
|
1648 replacement = replacements.replacement(node); |
3522f7c99c5f
Allow null DuplicationReplacement in addDuplicates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11669
diff
changeset
|
1649 } |
5478
4a99bfc329f0
Add posibility to provide a replacement function instead of map for duplication.
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5361
diff
changeset
|
1650 if (replacement != node) { |
5519
cedae73d9c2a
Fix problem with jython and tmt
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5489
diff
changeset
|
1651 assert replacement != null; |
5489
5d0d72b37f88
Switch to new loop transformation framework, use it for peeling and full unrolling for snippets
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5487
diff
changeset
|
1652 newNodes.put(node, replacement); |
5478
4a99bfc329f0
Add posibility to provide a replacement function instead of map for duplication.
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5361
diff
changeset
|
1653 } else { |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1654 Node newNode = node.clone(graph, false); |
12612
42a2c235652f
replace ".count() == 0" with ".isEmpty()"
Doug Simon <doug.simon@oracle.com>
parents:
12574
diff
changeset
|
1655 assert newNode.inputs().isEmpty() || newNode.usages().isEmpty(); |
5478
4a99bfc329f0
Add posibility to provide a replacement function instead of map for duplication.
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5361
diff
changeset
|
1656 assert newNode.getClass() == node.getClass(); |
4a99bfc329f0
Add posibility to provide a replacement function instead of map for duplication.
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5361
diff
changeset
|
1657 newNodes.put(node, newNode); |
4a99bfc329f0
Add posibility to provide a replacement function instead of map for duplication.
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5361
diff
changeset
|
1658 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1659 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1660 } |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1661 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1662 |
11675
77d9f12797c5
Use NodeMap in inlining utility when number of nodes is high.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11674
diff
changeset
|
1663 private static void transferValuesDifferentNodeClass(final Graph graph, final DuplicationReplacement replacements, final Map<Node, Node> newNodes, Node oldNode, Node node, NodeClass oldNodeClass, |
77d9f12797c5
Use NodeMap in inlining utility when number of nodes is high.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11674
diff
changeset
|
1664 NodeClass nodeClass) { |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
1665 for (NodePosIterator iter = oldNode.inputs().iterator(); iter.hasNext();) { |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1666 Position pos = iter.nextPosition(); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1667 if (!nodeClass.isValid(pos, oldNodeClass)) { |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1668 continue; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1669 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1670 Node input = oldNodeClass.get(oldNode, pos); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1671 Node target = newNodes.get(input); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1672 if (target == null) { |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1673 Node replacement = input; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1674 if (replacements != null) { |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1675 replacement = replacements.replacement(input); |
5489
5d0d72b37f88
Switch to new loop transformation framework, use it for peeling and full unrolling for snippets
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5487
diff
changeset
|
1676 } |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1677 if (replacement != input) { |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
1678 assert isAssignable(nodeClass.fieldTypes.get(nodeClass.inputOffsets[pos.getIndex()]), replacement); |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1679 target = replacement; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1680 } else if (input.graph() == graph) { // patch to the outer world |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1681 target = input; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1682 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1683 } |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1684 nodeClass.set(node, pos, target); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1685 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1686 |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
1687 for (NodePosIterator iter = oldNode.successors().iterator(); iter.hasNext();) { |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1688 Position pos = iter.nextPosition(); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1689 if (!nodeClass.isValid(pos, oldNodeClass)) { |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1690 continue; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1691 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1692 Node succ = oldNodeClass.get(oldNode, pos); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1693 Node target = newNodes.get(succ); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1694 if (target == null) { |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1695 Node replacement = replacements.replacement(succ); |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1696 if (replacement != succ) { |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
1697 assert isAssignable(nodeClass.fieldTypes.get(node.getNodeClass().successorOffsets[pos.getIndex()]), replacement); |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1698 target = replacement; |
5489
5d0d72b37f88
Switch to new loop transformation framework, use it for peeling and full unrolling for snippets
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5487
diff
changeset
|
1699 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1700 } |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1701 nodeClass.set(node, pos, target); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1702 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1703 } |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
1704 |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
1705 private static boolean isAssignable(Class<?> fieldType, Node replacement) { |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
1706 return replacement == null || !NODE_CLASS.isAssignableFrom(fieldType) || fieldType.isAssignableFrom(replacement.getClass()); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
1707 } |
16919
0fe4732e5181
made use of generated Node classes predicated on value of graal.useGeneratedNodes system property (default is false)
Doug Simon <doug.simon@oracle.com>
parents:
16903
diff
changeset
|
1708 |
0fe4732e5181
made use of generated Node classes predicated on value of graal.useGeneratedNodes system property (default is false)
Doug Simon <doug.simon@oracle.com>
parents:
16903
diff
changeset
|
1709 public boolean isLeafNode() { |
0fe4732e5181
made use of generated Node classes predicated on value of graal.useGeneratedNodes system property (default is false)
Doug Simon <doug.simon@oracle.com>
parents:
16903
diff
changeset
|
1710 return isLeafNode; |
0fe4732e5181
made use of generated Node classes predicated on value of graal.useGeneratedNodes system property (default is false)
Doug Simon <doug.simon@oracle.com>
parents:
16903
diff
changeset
|
1711 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1712 } |