Mercurial > hg > truffle
annotate graal/com.oracle.graal.graph/src/com/oracle/graal/graph/NodeClass.java @ 17188:55a924683e72
removed generated inputs/successors iterators and Position related methods
author | Doug Simon <doug.simon@oracle.com> |
---|---|
date | Tue, 23 Sep 2014 13:40:00 +0200 |
parents | bd760d193008 |
children | ef64e2682bb6 |
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.*; |
17147
7a3f6543d383
added timer for NodeClass initializer (-Dgraal.debug.timer.NodeClassCreation=true)
Doug Simon <doug.simon@oracle.com>
parents:
17128
diff
changeset
|
35 import com.oracle.graal.debug.internal.*; |
5478
4a99bfc329f0
Add posibility to provide a replacement function instead of map for duplication.
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5361
diff
changeset
|
36 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
|
37 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
|
38 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
|
39 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
|
40 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
|
41 |
11431
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
42 /** |
15106
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
43 * 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
|
44 * <ul> |
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
45 * <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
|
46 * 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
|
47 * <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
|
48 * </ul> |
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
49 */ |
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
50 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
|
51 |
15106
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
52 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
|
53 |
17175
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
54 // Timers for creation of a NodeClass instance |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
55 private static final DebugTimer Init = Debug.timer("NodeClass.Init"); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
56 private static final DebugTimer Init_FieldScanning = Debug.timer("NodeClass.Init.FieldScanning"); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
57 private static final DebugTimer Init_Offsets = Debug.timer("NodeClass.Init.Offsets"); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
58 private static final DebugTimer Init_Naming = Debug.timer("NodeClass.Init.Naming"); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
59 private static final DebugTimer Init_AllowedUsages = Debug.timer("NodeClass.Init.AllowedUsages"); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
60 private static final DebugTimer Init_IterableIds = Debug.timer("NodeClass.Init.IterableIds"); |
17147
7a3f6543d383
added timer for NodeClass initializer (-Dgraal.debug.timer.NodeClassCreation=true)
Doug Simon <doug.simon@oracle.com>
parents:
17128
diff
changeset
|
61 |
11431
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
62 /** |
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
63 * 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
|
64 */ |
11434
0d9fe4e80ab8
moved warning suppression annotation to placate JDT
Doug Simon <doug.simon@oracle.com>
parents:
11431
diff
changeset
|
65 @SuppressWarnings("unchecked") |
11431
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
66 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
|
67 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
|
68 |
15106
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
69 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
|
70 // 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
|
71 // 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
|
72 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
|
73 // 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
|
74 // 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
|
75 synchronized (GetNodeClassLock) { |
17175
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
76 try (TimerCloseable t = Init.start()) { |
17147
7a3f6543d383
added timer for NodeClass initializer (-Dgraal.debug.timer.NodeClassCreation=true)
Doug Simon <doug.simon@oracle.com>
parents:
17128
diff
changeset
|
77 value = (NodeClass) allClasses.get(key); |
7a3f6543d383
added timer for NodeClass initializer (-Dgraal.debug.timer.NodeClassCreation=true)
Doug Simon <doug.simon@oracle.com>
parents:
17128
diff
changeset
|
78 if (value == null) { |
7a3f6543d383
added timer for NodeClass initializer (-Dgraal.debug.timer.NodeClassCreation=true)
Doug Simon <doug.simon@oracle.com>
parents:
17128
diff
changeset
|
79 GeneratedNode gen = c.getAnnotation(GeneratedNode.class); |
7a3f6543d383
added timer for NodeClass initializer (-Dgraal.debug.timer.NodeClassCreation=true)
Doug Simon <doug.simon@oracle.com>
parents:
17128
diff
changeset
|
80 if (gen != null) { |
7a3f6543d383
added timer for NodeClass initializer (-Dgraal.debug.timer.NodeClassCreation=true)
Doug Simon <doug.simon@oracle.com>
parents:
17128
diff
changeset
|
81 Class<? extends Node> originalNodeClass = (Class<? extends Node>) gen.value(); |
7a3f6543d383
added timer for NodeClass initializer (-Dgraal.debug.timer.NodeClassCreation=true)
Doug Simon <doug.simon@oracle.com>
parents:
17128
diff
changeset
|
82 value = (NodeClass) allClasses.get(originalNodeClass); |
7a3f6543d383
added timer for NodeClass initializer (-Dgraal.debug.timer.NodeClassCreation=true)
Doug Simon <doug.simon@oracle.com>
parents:
17128
diff
changeset
|
83 assert value != null; |
7a3f6543d383
added timer for NodeClass initializer (-Dgraal.debug.timer.NodeClassCreation=true)
Doug Simon <doug.simon@oracle.com>
parents:
17128
diff
changeset
|
84 if (value.genClass == null) { |
7a3f6543d383
added timer for NodeClass initializer (-Dgraal.debug.timer.NodeClassCreation=true)
Doug Simon <doug.simon@oracle.com>
parents:
17128
diff
changeset
|
85 value.genClass = (Class<? extends Node>) c; |
7a3f6543d383
added timer for NodeClass initializer (-Dgraal.debug.timer.NodeClassCreation=true)
Doug Simon <doug.simon@oracle.com>
parents:
17128
diff
changeset
|
86 } else { |
7a3f6543d383
added timer for NodeClass initializer (-Dgraal.debug.timer.NodeClassCreation=true)
Doug Simon <doug.simon@oracle.com>
parents:
17128
diff
changeset
|
87 assert value.genClass == c; |
7a3f6543d383
added timer for NodeClass initializer (-Dgraal.debug.timer.NodeClassCreation=true)
Doug Simon <doug.simon@oracle.com>
parents:
17128
diff
changeset
|
88 } |
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
|
89 } else { |
17148
3837c6aa9fd0
ensure NodeClass initialization follows class hierarchy order
Doug Simon <doug.simon@oracle.com>
parents:
17147
diff
changeset
|
90 Class<?> superclass = c.getSuperclass(); |
3837c6aa9fd0
ensure NodeClass initialization follows class hierarchy order
Doug Simon <doug.simon@oracle.com>
parents:
17147
diff
changeset
|
91 if (superclass != NODE_CLASS) { |
3837c6aa9fd0
ensure NodeClass initialization follows class hierarchy order
Doug Simon <doug.simon@oracle.com>
parents:
17147
diff
changeset
|
92 // Ensure NodeClass for superclass exists |
3837c6aa9fd0
ensure NodeClass initialization follows class hierarchy order
Doug Simon <doug.simon@oracle.com>
parents:
17147
diff
changeset
|
93 get(superclass); |
3837c6aa9fd0
ensure NodeClass initialization follows class hierarchy order
Doug Simon <doug.simon@oracle.com>
parents:
17147
diff
changeset
|
94 } |
17147
7a3f6543d383
added timer for NodeClass initializer (-Dgraal.debug.timer.NodeClassCreation=true)
Doug Simon <doug.simon@oracle.com>
parents:
17128
diff
changeset
|
95 value = new NodeClass(key); |
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
|
96 } |
17147
7a3f6543d383
added timer for NodeClass initializer (-Dgraal.debug.timer.NodeClassCreation=true)
Doug Simon <doug.simon@oracle.com>
parents:
17128
diff
changeset
|
97 Object old = allClasses.putIfAbsent(key, value); |
7a3f6543d383
added timer for NodeClass initializer (-Dgraal.debug.timer.NodeClassCreation=true)
Doug Simon <doug.simon@oracle.com>
parents:
17128
diff
changeset
|
98 assert old == null : old + " " + key; |
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
|
99 } |
15106
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
100 } |
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
101 } |
11431
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
102 } |
15106
6876a4599b7e
create NodeClass for each Node subclass during class initialization of the latter
Doug Simon <doug.simon@oracle.com>
parents:
15040
diff
changeset
|
103 return value; |
11431
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
104 } |
ca53d08b8ef9
removed Node.nodeClass field (GRAAL-359)
Doug Simon <doug.simon@oracle.com>
parents:
10785
diff
changeset
|
105 |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
106 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
|
107 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
|
108 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
|
109 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
110 private static int nextIterableId = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
111 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
112 private final int directInputCount; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
113 private final long[] inputOffsets; |
15001 | 114 private final InputType[] inputTypes; |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
115 private final boolean[] inputOptional; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
116 private final int directSuccessorCount; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
117 private final long[] successorOffsets; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
118 private final Class<?>[] dataTypes; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
119 private final boolean canGVN; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
120 private final int startGVNNumber; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
121 private final String shortName; |
5813
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
122 private final String nameTemplate; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
123 private final int iterableId; |
15002
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
124 private final EnumSet<InputType> allowedUsageTypes; |
7332
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
125 private int[] iterableIds; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
126 |
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
|
127 /** |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
128 * 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
|
129 * 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
|
130 * {@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
|
131 */ |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
132 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
|
133 |
11642
5507e2824bc6
added metric to count IterableNodeTypes (GRAAL-471)
Doug Simon <doug.simon@oracle.com>
parents:
11631
diff
changeset
|
134 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
|
135 private final DebugMetric nodeIterableCount; |
11642
5507e2824bc6
added metric to count IterableNodeTypes (GRAAL-471)
Doug Simon <doug.simon@oracle.com>
parents:
11631
diff
changeset
|
136 |
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
|
137 /** |
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
|
138 * 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
|
139 */ |
16239
de84713267fa
use default methods to select Canonicalizable behavior
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16206
diff
changeset
|
140 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
|
141 |
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
|
142 /** |
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
|
143 * 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
|
144 */ |
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
|
145 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
|
146 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
|
147 |
13127
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
148 public NodeClass(Class<?> clazz) { |
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
149 this(clazz, new DefaultCalcOffset(), null, 0); |
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
150 } |
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
151 |
17188
55a924683e72
removed generated inputs/successors iterators and Position related methods
Doug Simon <doug.simon@oracle.com>
parents:
17187
diff
changeset
|
152 private static long[] sortedOffsets(ArrayList<Long> list1, ArrayList<Long> list2) { |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
153 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
|
154 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
|
155 } |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
156 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
|
157 } |
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
158 |
13127
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
159 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
|
160 super(clazz); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
161 assert NODE_CLASS.isAssignableFrom(clazz); |
16239
de84713267fa
use default methods to select Canonicalizable behavior
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16206
diff
changeset
|
162 |
de84713267fa
use default methods to select Canonicalizable behavior
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16206
diff
changeset
|
163 this.isCanonicalizable = Canonicalizable.class.isAssignableFrom(clazz); |
de84713267fa
use default methods to select Canonicalizable behavior
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16206
diff
changeset
|
164 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
|
165 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
|
166 } |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
167 |
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
|
168 this.isSimplifiable = Simplifiable.class.isAssignableFrom(clazz); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
169 |
13127
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
170 FieldScanner scanner = new FieldScanner(calcOffset); |
17175
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
171 try (TimerCloseable t = Init_FieldScanning.start()) { |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
172 scanner.scan(clazz); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
173 } |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
174 |
17175
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
175 try (TimerCloseable t1 = Init_Offsets.start()) { |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
176 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
|
177 |
17175
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
178 isLeafNode = scanner.inputOffsets.isEmpty() && scanner.inputListOffsets.isEmpty() && scanner.successorOffsets.isEmpty() && scanner.successorListOffsets.isEmpty(); |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
179 |
17188
55a924683e72
removed generated inputs/successors iterators and Position related methods
Doug Simon <doug.simon@oracle.com>
parents:
17187
diff
changeset
|
180 inputOffsets = sortedOffsets(scanner.inputOffsets, scanner.inputListOffsets); |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
181 |
17175
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
182 inputTypes = new InputType[inputOffsets.length]; |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
183 inputOptional = new boolean[inputOffsets.length]; |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
184 for (int i = 0; i < inputOffsets.length; i++) { |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
185 inputTypes[i] = scanner.types.get(inputOffsets[i]); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
186 assert inputTypes[i] != null; |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
187 inputOptional[i] = scanner.optionalInputs.contains(inputOffsets[i]); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
188 } |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
189 directSuccessorCount = scanner.successorOffsets.size(); |
17188
55a924683e72
removed generated inputs/successors iterators and Position related methods
Doug Simon <doug.simon@oracle.com>
parents:
17187
diff
changeset
|
190 successorOffsets = sortedOffsets(scanner.successorOffsets, scanner.successorListOffsets); |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
191 |
17175
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
192 dataOffsets = sortedLongCopy(scanner.dataOffsets); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
193 dataTypes = new Class[dataOffsets.length]; |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
194 for (int i = 0; i < dataOffsets.length; i++) { |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
195 dataTypes[i] = scanner.fieldTypes.get(dataOffsets[i]); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
196 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
197 } |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
198 |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
199 fieldNames = scanner.fieldNames; |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
200 fieldTypes = scanner.fieldTypes; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
201 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
202 canGVN = Node.ValueNumberable.class.isAssignableFrom(clazz); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
203 startGVNNumber = clazz.hashCode(); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
204 |
5813
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
205 String newNameTemplate = null; |
17175
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
206 String newShortName; |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
207 try (TimerCloseable t1 = Init_Naming.start()) { |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
208 newShortName = clazz.getSimpleName(); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
209 if (newShortName.endsWith("Node") && !newShortName.equals("StartNode") && !newShortName.equals("EndNode")) { |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
210 newShortName = newShortName.substring(0, newShortName.length() - 4); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
211 } |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
212 NodeInfo info = clazz.getAnnotation(NodeInfo.class); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
213 assert info != null : "missing " + NodeInfo.class.getSimpleName() + " annotation on " + clazz; |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
214 if (!info.shortName().isEmpty()) { |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
215 newShortName = info.shortName(); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
216 } |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
217 if (!info.nameTemplate().isEmpty()) { |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
218 newNameTemplate = info.nameTemplate(); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
219 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
220 } |
15002
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
221 EnumSet<InputType> newAllowedUsageTypes = EnumSet.noneOf(InputType.class); |
17175
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
222 try (TimerCloseable t1 = Init_AllowedUsages.start()) { |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
223 Class<?> current = clazz; |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
224 do { |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
225 NodeInfo currentInfo = current.getAnnotation(NodeInfo.class); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
226 if (currentInfo != null) { |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
227 if (currentInfo.allowedUsageTypes().length > 0) { |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
228 newAllowedUsageTypes.addAll(Arrays.asList(currentInfo.allowedUsageTypes())); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
229 } |
15002
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
230 } |
17175
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
231 current = current.getSuperclass(); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
232 } while (current != Node.class); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
233 } |
5813
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
234 this.nameTemplate = newNameTemplate == null ? newShortName : newNameTemplate; |
15002
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
235 this.allowedUsageTypes = newAllowedUsageTypes; |
4142
bc8527f3071c
Adjust code base to new level of warnings.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
3733
diff
changeset
|
236 this.shortName = newShortName; |
13127
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
237 if (presetIterableIds != null) { |
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
238 this.iterableIds = presetIterableIds; |
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
239 this.iterableId = presetIterableId; |
f42f1f5d5ce0
Allow custom field offset providers
Christian Wimmer <christian.wimmer@oracle.com>
parents:
12701
diff
changeset
|
240 } 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
|
241 ITERABLE_NODE_TYPES.increment(); |
17175
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
242 try (TimerCloseable t1 = Init_IterableIds.start()) { |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
243 this.iterableId = nextIterableId++; |
17148
3837c6aa9fd0
ensure NodeClass initialization follows class hierarchy order
Doug Simon <doug.simon@oracle.com>
parents:
17147
diff
changeset
|
244 |
17175
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
245 Class<?> superclass = clazz.getSuperclass(); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
246 while (superclass != NODE_CLASS) { |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
247 if (IterableNodeType.class.isAssignableFrom(superclass)) { |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
248 NodeClass superNodeClass = NodeClass.get(superclass); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
249 assert !containsId(this.iterableId, superNodeClass.iterableIds); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
250 superNodeClass.iterableIds = Arrays.copyOf(superNodeClass.iterableIds, superNodeClass.iterableIds.length + 1); |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
251 superNodeClass.iterableIds[superNodeClass.iterableIds.length - 1] = this.iterableId; |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
252 } |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
253 superclass = superclass.getSuperclass(); |
7332
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
254 } |
17175
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
255 |
63870b298b39
added timers for NodeClass creation
Doug Simon <doug.simon@oracle.com>
parents:
17148
diff
changeset
|
256 this.iterableIds = new int[]{iterableId}; |
7332
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
257 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
258 } 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
|
259 this.iterableId = Node.NOT_ITERABLE; |
7332
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
260 this.iterableIds = null; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
261 } |
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
|
262 nodeIterableCount = Debug.metric("NodeIterable_%s", shortName); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
263 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
264 |
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
|
265 /** |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
266 * 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
|
267 */ |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
268 @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
|
269 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
|
270 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
|
271 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
|
272 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
|
273 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
|
274 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
|
275 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
|
276 } 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
|
277 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
|
278 } |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
279 } 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
|
280 // 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
|
281 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
|
282 } |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
283 } |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
284 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
|
285 } |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
286 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
|
287 } |
4a6d852dbb68
added support to get the generated Node class represented by a NodeClass instance
Doug Simon <doug.simon@oracle.com>
parents:
16987
diff
changeset
|
288 |
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
|
289 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
|
290 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
|
291 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
|
292 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
|
293 } |
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
294 } |
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
295 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
|
296 } |
39d979dae809
need extra logic when computing Node iterable ids and USE_GENERATED_NODES == true
Doug Simon <doug.simon@oracle.com>
parents:
16986
diff
changeset
|
297 |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
298 @Override |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
299 protected void rescanFieldOffsets(CalcOffset calc) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
300 FieldScanner scanner = new FieldScanner(calc); |
15295
21663230ba88
Move FieldIntrospection to graal.compiler.common.
Josef Eisl <josef.eisl@jku.at>
parents:
15241
diff
changeset
|
301 scanner.scan(getClazz()); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
302 assert directInputCount == scanner.inputOffsets.size(); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
303 copyInto(inputOffsets, sortedLongCopy(scanner.inputOffsets, scanner.inputListOffsets)); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
304 assert directSuccessorCount == scanner.successorOffsets.size(); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
305 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
|
306 copyInto(dataOffsets, sortedLongCopy(scanner.dataOffsets)); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
307 |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
308 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
|
309 dataTypes[i] = scanner.fieldTypes.get(dataOffsets[i]); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
310 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
311 |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
312 fieldNames.clear(); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
313 fieldNames.putAll(scanner.fieldNames); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
314 fieldTypes.clear(); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
315 fieldTypes.putAll(scanner.fieldTypes); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
316 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
317 |
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
|
318 /** |
17051
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
319 * 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
|
320 * 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
|
321 * example: |
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
322 * |
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
323 * <pre> |
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
324 * if (node.getNodeClass().is(BeginNode.class)) { ... } |
17187 | 325 * |
17051
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
326 * // Due to generated Node classes, the test below |
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
327 * // is *not* the same as the test above: |
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
328 * if (node.getClass() == BeginNode.class) { ... } |
c25fcf343b4f
improved javadoc for NodeClass.is()
Doug Simon <doug.simon@oracle.com>
parents:
17044
diff
changeset
|
329 * </pre> |
16986
f7359a0ce946
tweaked comparison of a Node against a node class
Doug Simon <doug.simon@oracle.com>
parents:
16982
diff
changeset
|
330 * |
f7359a0ce946
tweaked comparison of a Node against a node class
Doug Simon <doug.simon@oracle.com>
parents:
16982
diff
changeset
|
331 * @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
|
332 */ |
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
|
333 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
|
334 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
|
335 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
|
336 } |
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
|
337 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
338 public String shortName() { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
339 return shortName; |
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 |
7332
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
342 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
|
343 nodeIterableCount.increment(); |
7332
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
344 return iterableIds; |
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
345 } |
c5a9bcd9493d
Support sub-types for typed node iterators
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7283
diff
changeset
|
346 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
347 public int iterableId() { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
348 return iterableId; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
349 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
350 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
351 public boolean valueNumberable() { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
352 return canGVN; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
353 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
354 |
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
|
355 /** |
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
|
356 * 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
|
357 */ |
16239
de84713267fa
use default methods to select Canonicalizable behavior
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16206
diff
changeset
|
358 public boolean isCanonicalizable() { |
de84713267fa
use default methods to select Canonicalizable behavior
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16206
diff
changeset
|
359 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
|
360 } |
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
|
361 |
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
|
362 /** |
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
|
363 * 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
|
364 */ |
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
|
365 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
|
366 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
|
367 } |
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
|
368 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
369 public static int cacheSize() { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
370 return nextIterableId; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
371 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
372 |
15002
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
373 public EnumSet<InputType> getAllowedUsageTypes() { |
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
374 return allowedUsageTypes; |
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
375 } |
06e50d290784
isAllowedUsageType on Nodes
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15001
diff
changeset
|
376 |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
377 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
|
378 |
4142
bc8527f3071c
Adjust code base to new level of warnings.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
3733
diff
changeset
|
379 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
|
380 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
|
381 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
|
382 public final ArrayList<Long> successorListOffsets = new ArrayList<>(); |
15001 | 383 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
|
384 public final HashSet<Long> optionalInputs = new HashSet<>(); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
385 |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
386 protected FieldScanner(CalcOffset calc) { |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
387 super(calc); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
388 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
389 |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
390 @Override |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
391 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
|
392 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
|
393 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
|
394 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
|
395 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
|
396 // 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
|
397 // 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
|
398 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
|
399 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
|
400 inputListOffsets.add(offset); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
401 } else { |
9808
12fdb8fe0a35
turn assertions in NodeClass.FieldScanner into guarantees
Lukas Stadler <lukas.stadler@jku.at>
parents:
9720
diff
changeset
|
402 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
|
403 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
|
404 inputOffsets.add(offset); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
405 } |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
406 if (field.isAnnotationPresent(Node.Input.class)) { |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
407 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
|
408 } else { |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
409 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
|
410 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
411 if (field.isAnnotationPresent(Node.OptionalInput.class)) { |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
412 optionalInputs.add(offset); |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
413 } |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
414 } 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
|
415 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
|
416 // 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
|
417 // 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
|
418 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
|
419 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
|
420 successorListOffsets.add(offset); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
421 } else { |
9808
12fdb8fe0a35
turn assertions in NodeClass.FieldScanner into guarantees
Lukas Stadler <lukas.stadler@jku.at>
parents:
9720
diff
changeset
|
422 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
|
423 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
|
424 successorOffsets.add(offset); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
425 } |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
426 } else { |
9808
12fdb8fe0a35
turn assertions in NodeClass.FieldScanner into guarantees
Lukas Stadler <lukas.stadler@jku.at>
parents:
9720
diff
changeset
|
427 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
|
428 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
|
429 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
|
430 dataOffsets.add(offset); |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
431 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
432 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
433 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
434 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
435 @Override |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
436 public String toString() { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
437 StringBuilder str = new StringBuilder(); |
15295
21663230ba88
Move FieldIntrospection to graal.compiler.common.
Josef Eisl <josef.eisl@jku.at>
parents:
15241
diff
changeset
|
438 str.append("NodeClass ").append(getClazz().getSimpleName()).append(" ["); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
439 for (int i = 0; i < inputOffsets.length; i++) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
440 str.append(i == 0 ? "" : ", ").append(inputOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
441 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
442 str.append("] ["); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
443 for (int i = 0; i < successorOffsets.length; i++) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
444 str.append(i == 0 ? "" : ", ").append(successorOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
445 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
446 str.append("] ["); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
447 for (int i = 0; i < dataOffsets.length; i++) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
448 str.append(i == 0 ? "" : ", ").append(dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
449 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
450 str.append("]"); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
451 return str.toString(); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
452 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
453 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
454 private static Node getNode(Node node, long offset) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
455 return (Node) unsafe.getObject(node, offset); |
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 @SuppressWarnings("unchecked") |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
459 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
|
460 return (NodeList<Node>) unsafe.getObject(node, offset); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
461 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
462 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
463 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
|
464 unsafe.putObject(node, offset, value); |
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 |
15040
288c23143d47
Fix most raw type references.
Josef Eisl <josef.eisl@jku.at>
parents:
15002
diff
changeset
|
467 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
|
468 unsafe.putObject(node, offset, value); |
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 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
471 /** |
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
|
472 * 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
|
473 * {@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
|
474 * 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
|
475 * 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
|
476 * successors of a node. |
15001 | 477 * |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
478 * 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
|
479 * 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
|
480 */ |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
481 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
|
482 protected final Node node; |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
483 protected int index; |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
484 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
|
485 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
|
486 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
|
487 protected Node nextElement; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
488 |
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 * Creates an iterator that will iterate over fields in the given node. |
15001 | 491 * |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
492 * @param node the node which contains the fields. |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
493 */ |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
494 NodeClassIterator(Node node) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
495 this.node = node; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
496 index = NOT_ITERABLE; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
497 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
|
498 needsForward = true; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
499 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
500 |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
501 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
|
502 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
|
503 if (index < getDirectCount()) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
504 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
|
505 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
|
506 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
|
507 if (nextElement != null) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
508 return; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
509 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
510 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
511 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
512 } else { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
513 subIndex++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
514 } |
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
|
515 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
|
516 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
|
517 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
|
518 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
519 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
|
520 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
|
521 if (nextElement != null) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
522 return; |
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 subIndex++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
525 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
526 subIndex = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
527 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
528 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
529 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
530 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
531 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
|
532 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
|
533 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
|
534 } |
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
|
535 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
|
536 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
|
537 return nextElement; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
538 } |
7258
9bee93f61522
Cleanups: remove unused NodeUsagesList.replaceFirst and FrameState.block
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7123
diff
changeset
|
539 throw new NoSuchElementException(); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
540 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
541 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
542 @Override |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
543 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
|
544 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
|
545 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
|
546 } |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
547 return index < getOffsets().length; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
548 } |
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 @Override |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
551 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
|
552 return nextElement(); |
3733
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 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
|
556 if (needsForward) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
557 forward(); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
558 } |
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
|
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 < 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
|
561 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
|
562 } 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
|
563 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
|
564 } |
3733
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 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
567 @Override |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
568 public void remove() { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
569 throw new UnsupportedOperationException(); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
570 } |
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
|
571 |
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
|
572 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
|
573 |
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
|
574 protected abstract long[] getOffsets(); |
12378
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
575 |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
576 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
|
577 } |
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
|
578 |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
579 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
|
580 |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
581 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
|
582 super(node); |
12378
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
583 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
|
584 } |
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
|
585 |
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
|
586 @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
|
587 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
|
588 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
|
589 } |
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
|
590 |
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
|
591 @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
|
592 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
|
593 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
|
594 } |
12378
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
595 |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
596 @Override |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
597 protected NodeClass getNodeClass() { |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
598 return NodeClass.this; |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
599 } |
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
|
600 } |
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 |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
602 private class NodeClassAllInputsIterator extends NodeClassInputsIterator { |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
603 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
|
604 super(node); |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
605 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
606 |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
607 @Override |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
608 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
|
609 needsForward = false; |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
610 if (index < getDirectCount()) { |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
611 index++; |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
612 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
|
613 nextElement = getNode(node, getOffsets()[index]); |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
614 return; |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
615 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
616 } else { |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
617 subIndex++; |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
618 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
619 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
|
620 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
|
621 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
|
622 } |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
623 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
|
624 nextElement = list.get(subIndex); |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
625 return; |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
626 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
627 subIndex = 0; |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
628 index++; |
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 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
632 |
16337
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
633 private class NodeClassAllSuccessorsIterator extends NodeClassSuccessorsIterator { |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
634 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
|
635 super(node); |
16337
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
636 } |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
637 |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
638 @Override |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
639 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
|
640 needsForward = false; |
16337
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
641 if (index < getDirectCount()) { |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
642 index++; |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
643 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
|
644 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
|
645 return; |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
646 } |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
647 } else { |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
648 subIndex++; |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
649 } |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
650 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
|
651 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
|
652 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
|
653 } |
16337
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
654 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
|
655 nextElement = list.get(subIndex); |
16337
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
656 return; |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
657 } |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
658 subIndex = 0; |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
659 index++; |
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 } |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
663 |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
664 private final class NodeClassInputsWithModCountIterator extends NodeClassInputsIterator { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
665 private final int modCount; |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
666 |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
667 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
|
668 super(node); |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
669 assert MODIFICATION_COUNTS_ENABLED; |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
670 this.modCount = node.modCount(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
671 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
672 |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
673 @Override |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
674 public boolean hasNext() { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
675 try { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
676 return super.hasNext(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
677 } finally { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
678 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
|
679 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
680 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
681 |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
682 @Override |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
683 public Node next() { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
684 try { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
685 return super.next(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
686 } finally { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
687 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
|
688 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
689 } |
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 @Override |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
692 public Position nextPosition() { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
693 try { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
694 return super.nextPosition(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
695 } finally { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
696 assert modCount == node.modCount(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
697 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
698 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
699 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
700 |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
701 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
|
702 |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
703 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
|
704 super(node); |
12378
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
705 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
|
706 } |
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
|
707 |
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
|
708 @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
|
709 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
|
710 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
|
711 } |
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
|
712 |
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
|
713 @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
|
714 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
|
715 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
|
716 } |
12378
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
717 |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
718 @Override |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
719 protected NodeClass getNodeClass() { |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
720 return NodeClass.this; |
1e76b14e1b3a
NodeClassIterator: remove reference to NodeClass
Bernhard Urban <bernhard.urban@jku.at>
parents:
12047
diff
changeset
|
721 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
722 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
723 |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
724 private final class NodeClassSuccessorsWithModCountIterator extends NodeClassSuccessorsIterator { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
725 private final int modCount; |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
726 |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
727 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
|
728 super(node); |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
729 assert MODIFICATION_COUNTS_ENABLED; |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
730 this.modCount = node.modCount(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
731 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
732 |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
733 @Override |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
734 public boolean hasNext() { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
735 try { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
736 return super.hasNext(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
737 } finally { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
738 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
|
739 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
740 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
741 |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
742 @Override |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
743 public Node next() { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
744 try { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
745 return super.next(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
746 } finally { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
747 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
|
748 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
749 } |
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 @Override |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
752 public Position nextPosition() { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
753 try { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
754 return super.nextPosition(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
755 } finally { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
756 assert modCount == node.modCount(); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
757 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
758 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
759 } |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
760 |
12696
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
761 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
|
762 if (o instanceof Object[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
763 return Arrays.deepHashCode((Object[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
764 } else if (o instanceof byte[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
765 return Arrays.hashCode((byte[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
766 } else if (o instanceof short[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
767 return Arrays.hashCode((short[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
768 } else if (o instanceof int[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
769 return Arrays.hashCode((int[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
770 } else if (o instanceof long[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
771 return Arrays.hashCode((long[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
772 } else if (o instanceof char[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
773 return Arrays.hashCode((char[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
774 } else if (o instanceof float[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
775 return Arrays.hashCode((float[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
776 } else if (o instanceof double[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
777 return Arrays.hashCode((double[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
778 } else if (o instanceof boolean[]) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
779 return Arrays.hashCode((boolean[]) o); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
780 } else if (o != null) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
781 return o.hashCode(); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
782 } else { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
783 return 0; |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
784 } |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
785 } |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
786 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
787 public int valueNumber(Node n) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
788 int number = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
789 if (canGVN) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
790 number = startGVNNumber; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
791 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
|
792 Class<?> type = dataTypes[i]; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
793 if (type.isPrimitive()) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
794 if (type == Integer.TYPE) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
795 int intValue = unsafe.getInt(n, dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
796 number += intValue; |
6657
768793150bcd
more PEA refactoring, multiple iterations
Lukas Stadler <lukas.stadler@jku.at>
parents:
6414
diff
changeset
|
797 } else if (type == Long.TYPE) { |
768793150bcd
more PEA refactoring, multiple iterations
Lukas Stadler <lukas.stadler@jku.at>
parents:
6414
diff
changeset
|
798 long longValue = unsafe.getLong(n, dataOffsets[i]); |
768793150bcd
more PEA refactoring, multiple iterations
Lukas Stadler <lukas.stadler@jku.at>
parents:
6414
diff
changeset
|
799 number += longValue ^ (longValue >>> 32); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
800 } else if (type == Boolean.TYPE) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
801 boolean booleanValue = unsafe.getBoolean(n, dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
802 if (booleanValue) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
803 number += 7; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
804 } |
12701
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
805 } 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
|
806 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
|
807 number += Float.floatToRawIntBits(floatValue); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
808 } 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
|
809 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
|
810 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
|
811 number += longValue ^ (longValue >>> 32); |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
812 } 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
|
813 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
|
814 number += shortValue; |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
815 } 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
|
816 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
|
817 number += charValue; |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
818 } 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
|
819 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
|
820 number += byteValue; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
821 } else { |
12701
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
822 assert false : "unhandled property type: " + type; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
823 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
824 } else { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
825 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
|
826 number += deepHashCode0(o); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
827 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
828 number *= 13; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
829 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
830 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
831 return number; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
832 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
833 |
12696
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
834 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
|
835 assert e1 != null; |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
836 boolean eq; |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
837 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
|
838 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
|
839 } 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
|
840 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
|
841 } 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
|
842 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
|
843 } 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
|
844 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
|
845 } 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
|
846 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
|
847 } 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
|
848 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
|
849 } 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
|
850 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
|
851 } 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
|
852 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
|
853 } 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
|
854 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
|
855 } else { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
856 eq = e1.equals(e2); |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
857 } |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
858 return eq; |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
859 } |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
860 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
861 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
|
862 if (a.getClass() != b.getClass()) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
863 return a == b; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
864 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
865 for (int i = 0; i < dataOffsets.length; ++i) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
866 Class<?> type = dataTypes[i]; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
867 if (type.isPrimitive()) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
868 if (type == Integer.TYPE) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
869 int aInt = unsafe.getInt(a, dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
870 int bInt = unsafe.getInt(b, dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
871 if (aInt != bInt) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
872 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
873 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
874 } else if (type == Boolean.TYPE) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
875 boolean aBoolean = unsafe.getBoolean(a, dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
876 boolean bBoolean = unsafe.getBoolean(b, dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
877 if (aBoolean != bBoolean) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
878 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
879 } |
5301
23ea81293bd5
let NodeClass.valueEqual handle long fields
Lukas Stadler <lukas.stadler@jku.at>
parents:
5299
diff
changeset
|
880 } else if (type == Long.TYPE) { |
23ea81293bd5
let NodeClass.valueEqual handle long fields
Lukas Stadler <lukas.stadler@jku.at>
parents:
5299
diff
changeset
|
881 long aLong = unsafe.getLong(a, dataOffsets[i]); |
23ea81293bd5
let NodeClass.valueEqual handle long fields
Lukas Stadler <lukas.stadler@jku.at>
parents:
5299
diff
changeset
|
882 long bLong = unsafe.getLong(b, dataOffsets[i]); |
23ea81293bd5
let NodeClass.valueEqual handle long fields
Lukas Stadler <lukas.stadler@jku.at>
parents:
5299
diff
changeset
|
883 if (aLong != bLong) { |
23ea81293bd5
let NodeClass.valueEqual handle long fields
Lukas Stadler <lukas.stadler@jku.at>
parents:
5299
diff
changeset
|
884 return false; |
23ea81293bd5
let NodeClass.valueEqual handle long fields
Lukas Stadler <lukas.stadler@jku.at>
parents:
5299
diff
changeset
|
885 } |
12701
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
886 } 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
|
887 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
|
888 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
|
889 if (aFloat != bFloat) { |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
890 return false; |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
891 } |
10785
debb9d8e0282
allow double fields in value number computation and thus, in floating nodes
Doug Simon <doug.simon@oracle.com>
parents:
10424
diff
changeset
|
892 } 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
|
893 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
|
894 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
|
895 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
|
896 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
|
897 } |
12701
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
898 } 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
|
899 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
|
900 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
|
901 if (aShort != bShort) { |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
902 return false; |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
903 } |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
904 } 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
|
905 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
|
906 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
|
907 if (aChar != bChar) { |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
908 return false; |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
909 } |
42a60780c2c9
Add some missing cases for NodeClass.(getDebugProperties|valueEqual|valueNumber)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12696
diff
changeset
|
910 } 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
|
911 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
|
912 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
|
913 if (aByte != bByte) { |
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 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
916 } else { |
5301
23ea81293bd5
let NodeClass.valueEqual handle long fields
Lukas Stadler <lukas.stadler@jku.at>
parents:
5299
diff
changeset
|
917 assert false : "unhandled type: " + type; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
918 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
919 } else { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
920 Object objectA = unsafe.getObject(a, dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
921 Object objectB = unsafe.getObject(b, dataOffsets[i]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
922 if (objectA != objectB) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
923 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
|
924 if (!deepEquals0(objectA, objectB)) { |
22780dc399da
Support arbitrary array types in global value numbering.
Roland Schatz <roland.schatz@oracle.com>
parents:
12687
diff
changeset
|
925 return false; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
926 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
927 } else { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
928 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
929 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
930 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
931 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
932 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
933 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
934 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
935 |
5214 | 936 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
|
937 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
|
938 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
|
939 } |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
940 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
|
941 if (pos.getIndex() >= offsets.length) { |
5214 | 942 return false; |
943 } | |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
944 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
|
945 if (pos.getIndex() >= fromOffsets.length) { |
5214 | 946 return false; |
947 } | |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
948 return offsets[pos.getIndex()] == fromOffsets[pos.getIndex()]; |
5214 | 949 } |
950 | |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
951 public Node get(Node node, Position pos) { |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
952 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
|
953 if (pos.getSubIndex() == NOT_ITERABLE) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
954 return getNode(node, offset); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
955 } else { |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
956 return getNodeList(node, offset).get(pos.getSubIndex()); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
957 } |
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 |
15001 | 960 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
|
961 assert pos.isInput(); |
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
962 return inputTypes[pos.getIndex()]; |
15001 | 963 } |
964 | |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
965 public boolean isInputOptional(Position pos) { |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
966 assert pos.isInput(); |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
967 return inputOptional[pos.getIndex()]; |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
968 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
969 |
12483
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
970 public NodeList<?> getNodeList(Node node, Position pos) { |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
971 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
|
972 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
|
973 return getNodeList(node, offset); |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
974 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
975 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
976 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
|
977 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
|
978 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
979 |
15827
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
980 public String getPropertyName(int pos) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
981 return fieldNames.get(dataOffsets[pos]); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
982 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
983 |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
984 public Class<?> getPropertyType(int pos) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
985 return fieldTypes.get(dataOffsets[pos]); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
986 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
987 |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
988 public Object getProperty(Node node, int pos) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
989 long dataOffset = dataOffsets[pos]; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
990 Class<?> type = fieldTypes.get(dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
991 Object value = null; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
992 if (type.isPrimitive()) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
993 if (type == Integer.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
994 value = unsafe.getInt(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
995 } else if (type == Long.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
996 value = unsafe.getLong(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
997 } else if (type == Boolean.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
998 value = unsafe.getBoolean(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
999 } else if (type == Float.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1000 value = unsafe.getFloat(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1001 } else if (type == Double.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1002 value = unsafe.getDouble(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1003 } else if (type == Short.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1004 value = unsafe.getShort(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1005 } else if (type == Character.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1006 value = unsafe.getChar(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1007 } else if (type == Byte.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1008 value = unsafe.getByte(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1009 } else { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1010 assert false : "unhandled property type: " + type; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1011 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1012 } else { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1013 value = unsafe.getObject(node, dataOffset); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1014 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1015 return value; |
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 void setProperty(Node node, int pos, Object value) { |
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 if (type.isPrimitive()) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1022 if (type == Integer.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1023 unsafe.putInt(node, dataOffset, (Integer) value); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1024 } else if (type == Long.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1025 unsafe.putLong(node, dataOffset, (Long) value); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1026 } else if (type == Boolean.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1027 unsafe.putBoolean(node, dataOffset, (Boolean) value); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1028 } else if (type == Float.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1029 unsafe.putFloat(node, dataOffset, (Float) value); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1030 } else if (type == Double.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1031 unsafe.putDouble(node, dataOffset, (Double) value); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1032 } else if (type == Short.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1033 unsafe.putShort(node, dataOffset, (Short) value); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1034 } else if (type == Character.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1035 unsafe.putChar(node, dataOffset, (Character) value); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1036 } else if (type == Byte.TYPE) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1037 unsafe.putByte(node, dataOffset, (Byte) value); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1038 } else { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1039 assert false : "unhandled property type: " + type; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1040 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1041 } else { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1042 assert value == null || !value.getClass().isPrimitive(); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1043 unsafe.putObject(node, dataOffset, value); |
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 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1046 |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1047 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
|
1048 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
|
1049 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
|
1050 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
|
1051 if (input != null) { |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1052 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
|
1053 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
|
1054 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
|
1055 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
|
1056 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
|
1057 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1058 index++; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1059 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1060 |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1061 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
|
1062 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
|
1063 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1064 |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1065 index = 0; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1066 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
|
1067 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
|
1068 if (successor != null) { |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1069 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
|
1070 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
|
1071 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
|
1072 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
|
1073 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
|
1074 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1075 index++; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1076 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1077 |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1078 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
|
1079 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
|
1080 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1081 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1082 |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1083 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
|
1084 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
|
1085 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
|
1086 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
|
1087 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
|
1088 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
|
1089 index++; |
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 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1092 |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1093 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
|
1094 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
|
1095 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
|
1096 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
|
1097 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
|
1098 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
|
1099 index++; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1100 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1101 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1102 |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1103 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
|
1104 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
|
1105 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
|
1106 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
|
1107 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
|
1108 if (oldNode != null) { |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1109 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
|
1110 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
|
1111 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1112 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1113 return result; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1114 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1115 |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1116 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
|
1117 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
|
1118 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
|
1119 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
|
1120 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
|
1121 if (oldNode != null) { |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1122 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
|
1123 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
|
1124 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1125 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1126 return result; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1127 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1128 |
7283
3964f3d4eb18
Extend loop unswicthing to Switch nodes (integer or type)
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7258
diff
changeset
|
1129 public void set(Node node, Position pos, Node x) { |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
1130 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
|
1131 if (pos.getSubIndex() == NOT_ITERABLE) { |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1132 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
|
1133 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
|
1134 putNode(node, offset, x); |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
1135 if (pos.isInput()) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1136 node.updateUsages(old, x); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1137 } else { |
5487
9743ae819f73
Move virtual chain help methods from SuperBlock to GraphUtil
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5486
diff
changeset
|
1138 node.updatePredecessor(old, x); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1139 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1140 } else { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1141 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
|
1142 if (pos.getSubIndex() < list.size()) { |
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
1143 list.set(pos.getSubIndex(), x); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1144 } else { |
15827
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1145 while (list.size() < pos.getSubIndex()) { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1146 list.add(null); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1147 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1148 list.add(x); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1149 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1150 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1151 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1152 |
16206
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1153 public void initializePosition(Node node, Position pos, Node x) { |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1154 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
|
1155 if (pos.getSubIndex() == NOT_ITERABLE) { |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1156 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
|
1157 putNode(node, offset, x); |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1158 } else { |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1159 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
|
1160 while (list.size() <= pos.getSubIndex()) { |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1161 list.add(null); |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1162 } |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1163 list.initialize(pos.getSubIndex(), x); |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1164 } |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1165 } |
2a1f3a8f76f1
handle Canonicalizable.Unary/Binary in CanonicalizerPhase and EquationalReasoner
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16154
diff
changeset
|
1166 |
7123
b914b9b4c578
graal.graph refactorings
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
6657
diff
changeset
|
1167 public NodeClassIterable getInputIterable(final Node node) { |
15295
21663230ba88
Move FieldIntrospection to graal.compiler.common.
Josef Eisl <josef.eisl@jku.at>
parents:
15241
diff
changeset
|
1168 assert getClazz().isInstance(node); |
7123
b914b9b4c578
graal.graph refactorings
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
6657
diff
changeset
|
1169 return new NodeClassIterable() { |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1170 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1171 @Override |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1172 public NodeClassIterator iterator() { |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1173 if (MODIFICATION_COUNTS_ENABLED) { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1174 return new NodeClassInputsWithModCountIterator(node); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1175 } else { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1176 return new NodeClassInputsIterator(node); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1177 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1178 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1179 |
16332
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
1180 public NodeClassIterator withNullIterator() { |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
1181 return new NodeClassAllInputsIterator(node); |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
1182 } |
ddd68e267e34
explicitly define optional inputs in @Input
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16239
diff
changeset
|
1183 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1184 @Override |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1185 public boolean contains(Node other) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1186 return inputContains(node, other); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1187 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1188 }; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1189 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1190 |
7123
b914b9b4c578
graal.graph refactorings
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
6657
diff
changeset
|
1191 public NodeClassIterable getSuccessorIterable(final Node node) { |
15295
21663230ba88
Move FieldIntrospection to graal.compiler.common.
Josef Eisl <josef.eisl@jku.at>
parents:
15241
diff
changeset
|
1192 assert getClazz().isInstance(node); |
7123
b914b9b4c578
graal.graph refactorings
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
6657
diff
changeset
|
1193 return new NodeClassIterable() { |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1194 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1195 @Override |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1196 public NodeClassIterator iterator() { |
12047
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1197 if (MODIFICATION_COUNTS_ENABLED) { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1198 return new NodeClassSuccessorsWithModCountIterator(node); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1199 } else { |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1200 return new NodeClassSuccessorsIterator(node); |
dcd412a084a2
NodeClassIterator: seperate implementation for modCount check
Bernhard Urban <bernhard.urban@jku.at>
parents:
12046
diff
changeset
|
1201 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1202 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1203 |
16337
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
1204 public NodeClassIterator withNullIterator() { |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
1205 return new NodeClassAllSuccessorsIterator(node); |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
1206 } |
67f3267a8846
code and javadoc cleanups in Canonicalizable and NodeClassIterable
Lukas Stadler <lukas.stadler@oracle.com>
parents:
16332
diff
changeset
|
1207 |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1208 @Override |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1209 public boolean contains(Node other) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1210 return successorContains(node, other); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1211 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1212 }; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1213 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1214 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1215 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
|
1216 int index = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1217 while (index < directInputCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1218 Node input = getNode(node, inputOffsets[index]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1219 if (input == old) { |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1220 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
|
1221 " in " + node; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1222 putNode(node, inputOffsets[index], other); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1223 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1224 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1225 index++; |
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 while (index < inputOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1228 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
|
1229 assert list != null : getClazz(); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1230 if (list.replaceFirst(old, other)) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1231 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1232 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1233 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1234 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1235 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1236 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1237 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1238 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
|
1239 int index = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1240 while (index < directSuccessorCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1241 Node successor = getNode(node, successorOffsets[index]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1242 if (successor == old) { |
10424
e6cf435419b2
Fix after lowering phase refactoring.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
9808
diff
changeset
|
1243 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
|
1244 other.getClass(); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1245 putNode(node, successorOffsets[index], other); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1246 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1247 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1248 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1249 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1250 while (index < successorOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1251 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
|
1252 assert list != null : getClazz() + " " + successorOffsets[index] + " " + node; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1253 if (list.replaceFirst(old, other)) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1254 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1255 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1256 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1257 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1258 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1259 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1260 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1261 /** |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1262 * 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
|
1263 * 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
|
1264 * clear the inputs of cloned nodes.) |
15001 | 1265 * |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1266 * @param node the node to be cleared |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1267 */ |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1268 public void clearInputs(Node node) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1269 int index = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1270 while (index < directInputCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1271 putNode(node, inputOffsets[index++], null); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1272 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1273 while (index < inputOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1274 long curOffset = inputOffsets[index++]; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1275 int size = (getNodeList(node, curOffset)).initialSize; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1276 // 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
|
1277 putNodeList(node, curOffset, new NodeInputList<>(node, size)); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1278 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1279 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1280 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1281 /** |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1282 * 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
|
1283 * 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
|
1284 * can be used to clear the successors of cloned nodes.) |
15001 | 1285 * |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1286 * @param node the node to be cleared |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1287 */ |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1288 public void clearSuccessors(Node node) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1289 int index = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1290 while (index < directSuccessorCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1291 putNode(node, successorOffsets[index++], null); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1292 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1293 while (index < successorOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1294 long curOffset = successorOffsets[index++]; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1295 int size = getNodeList(node, curOffset).initialSize; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1296 // 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
|
1297 putNodeList(node, curOffset, new NodeSuccessorList<>(node, size)); |
3733
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 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1301 /** |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1302 * 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
|
1303 * NodeClass type. |
15001 | 1304 * |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1305 * @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
|
1306 * @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
|
1307 */ |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1308 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
|
1309 assert node.getNodeClass() == this && newNode.getNodeClass() == this; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1310 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1311 int index = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1312 while (index < directInputCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1313 putNode(newNode, inputOffsets[index], getNode(node, inputOffsets[index])); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1314 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1315 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1316 while (index < inputOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1317 NodeList<Node> list = getNodeList(newNode, inputOffsets[index]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1318 list.copy(getNodeList(node, inputOffsets[index])); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1319 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1320 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1321 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1322 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1323 /** |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1324 * 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
|
1325 * NodeClass type. |
15001 | 1326 * |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1327 * @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
|
1328 * @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
|
1329 */ |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1330 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
|
1331 assert node.getNodeClass() == this && newNode.getNodeClass() == this; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1332 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1333 int index = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1334 while (index < directSuccessorCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1335 putNode(newNode, successorOffsets[index], getNode(node, successorOffsets[index])); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1336 index++; |
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 while (index < successorOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1339 NodeList<Node> list = getNodeList(newNode, successorOffsets[index]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1340 list.copy(getNodeList(node, successorOffsets[index])); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1341 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1342 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1343 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1344 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1345 public boolean edgesEqual(Node node, Node other) { |
9450
ca34e36c53e8
Add loop safepoint elimination
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7530
diff
changeset
|
1346 return inputsEqual(node, other) && successorsEqual(node, other); |
ca34e36c53e8
Add loop safepoint elimination
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7530
diff
changeset
|
1347 } |
ca34e36c53e8
Add loop safepoint elimination
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7530
diff
changeset
|
1348 |
ca34e36c53e8
Add loop safepoint elimination
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7530
diff
changeset
|
1349 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
|
1350 assert node.getNodeClass() == this && other.getNodeClass() == this; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1351 int index = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1352 while (index < directInputCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1353 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
|
1354 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1355 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1356 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1357 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1358 while (index < inputOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1359 NodeList<Node> list = getNodeList(other, inputOffsets[index]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1360 if (!list.equals(getNodeList(node, inputOffsets[index]))) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1361 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1362 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1363 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1364 } |
9450
ca34e36c53e8
Add loop safepoint elimination
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7530
diff
changeset
|
1365 return true; |
ca34e36c53e8
Add loop safepoint elimination
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7530
diff
changeset
|
1366 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1367 |
9450
ca34e36c53e8
Add loop safepoint elimination
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7530
diff
changeset
|
1368 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
|
1369 assert node.getNodeClass() == this && other.getNodeClass() == this; |
9450
ca34e36c53e8
Add loop safepoint elimination
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
7530
diff
changeset
|
1370 int index = 0; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1371 while (index < directSuccessorCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1372 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
|
1373 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1374 } |
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(other, successorOffsets[index]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1379 if (!list.equals(getNodeList(node, successorOffsets[index]))) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1380 return false; |
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 index++; |
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 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1385 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1386 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1387 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
|
1388 assert node.getNodeClass() == this; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1389 |
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(node, inputOffsets[index]) == other) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1393 return true; |
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(node, inputOffsets[index]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1399 if (list.contains(other)) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1400 return true; |
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 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1404 return false; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1405 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1406 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1407 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
|
1408 assert node.getNodeClass() == this; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1409 |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1410 int index = 0; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1411 while (index < directSuccessorCount) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1412 if (getNode(node, successorOffsets[index]) == other) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1413 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1414 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1415 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1416 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1417 while (index < successorOffsets.length) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1418 NodeList<Node> list = getNodeList(node, successorOffsets[index]); |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1419 if (list.contains(other)) { |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1420 return true; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1421 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1422 index++; |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1423 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1424 return false; |
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 |
12483
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1427 public Collection<Position> getFirstLevelInputPositions() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1428 return new AbstractCollection<Position>() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1429 @Override |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1430 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
|
1431 return new Iterator<Position>() { |
12483
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1432 int i = 0; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1433 |
12558 | 1434 @Override |
12483
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1435 public void remove() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1436 throw new UnsupportedOperationException(); |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1437 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1438 |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1439 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
|
1440 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
|
1441 i++; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1442 return pos; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1443 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1444 |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1445 public boolean hasNext() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1446 return i < inputOffsets.length; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1447 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1448 }; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1449 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1450 |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1451 @Override |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1452 public int size() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1453 return inputOffsets.length; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1454 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1455 }; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1456 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1457 |
12483
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1458 public Collection<Position> getFirstLevelSuccessorPositions() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1459 return new AbstractCollection<Position>() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1460 @Override |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1461 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
|
1462 return new Iterator<Position>() { |
12483
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1463 int i = 0; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1464 |
12558 | 1465 @Override |
12483
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1466 public void remove() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1467 throw new UnsupportedOperationException(); |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1468 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1469 |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1470 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
|
1471 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
|
1472 i++; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1473 return pos; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1474 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1475 |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1476 public boolean hasNext() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1477 return i < successorOffsets.length; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1478 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1479 }; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1480 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1481 |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1482 @Override |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1483 public int size() { |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1484 return successorOffsets.length; |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1485 } |
134671fbf973
Optimize Binary Graph format for more compact size
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
12378
diff
changeset
|
1486 }; |
5813
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
1487 } |
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
1488 |
15827
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1489 public Collection<Integer> getPropertyPositions() { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1490 return new AbstractCollection<Integer>() { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1491 @Override |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1492 public Iterator<Integer> iterator() { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1493 return new Iterator<Integer>() { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1494 int i = 0; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1495 |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1496 @Override |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1497 public void remove() { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1498 throw new UnsupportedOperationException(); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1499 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1500 |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1501 public Integer next() { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1502 Integer pos = i++; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1503 return pos; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1504 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1505 |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1506 public boolean hasNext() { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1507 return i < dataOffsets.length; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1508 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1509 }; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1510 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1511 |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1512 @Override |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1513 public int size() { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1514 return dataOffsets.length; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1515 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1516 }; |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1517 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1518 |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1519 /** |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1520 * 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
|
1521 * implement node factories in svm. |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1522 */ |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1523 public void initRawNode(Node node) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1524 node.init(); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1525 for (int inputPos = directInputCount; inputPos < inputOffsets.length; inputPos++) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1526 if (getNodeList(node, inputOffsets[inputPos]) == null) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1527 putNodeList(node, inputOffsets[inputPos], new NodeInputList<>(node)); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1528 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1529 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1530 for (int successorPos = directSuccessorCount; successorPos < successorOffsets.length; successorPos++) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1531 if (getNodeList(node, successorOffsets[successorPos]) == null) { |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1532 putNodeList(node, successorOffsets[successorPos], new NodeSuccessorList<>(node)); |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1533 } |
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 } |
4e770fa50889
Make NodeClass more flexible
Christian Wimmer <christian.wimmer@oracle.com>
parents:
15551
diff
changeset
|
1536 |
5813
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
1537 public Class<?> getJavaClass() { |
15295
21663230ba88
Move FieldIntrospection to graal.compiler.common.
Josef Eisl <josef.eisl@jku.at>
parents:
15241
diff
changeset
|
1538 return getClazz(); |
5813
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
1539 } |
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
1540 |
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
1541 /** |
7530
5e3d1a68664e
applied mx eclipseformat to all Java files
Doug Simon <doug.simon@oracle.com>
parents:
7332
diff
changeset
|
1542 * 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
|
1543 * 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
|
1544 */ |
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
1545 public String getNameTemplate() { |
3b8bc07f8d17
Add ability to give an existing to getDebugProperties
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5810
diff
changeset
|
1546 return nameTemplate; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1547 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1548 |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1549 interface InplaceUpdateClosure { |
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1550 |
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1551 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
|
1552 } |
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1553 |
11675
77d9f12797c5
Use NodeMap in inlining utility when number of nodes is high.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11674
diff
changeset
|
1554 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
|
1555 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
|
1556 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
|
1557 if (estimatedNodeCount > denseThreshold) { |
12685
478c82dde838
commented choice of data structure in NodeClass.addGraphDuplicate()
Doug Simon <doug.simon@oracle.com>
parents:
12669
diff
changeset
|
1558 // Use dense map |
478c82dde838
commented choice of data structure in NodeClass.addGraphDuplicate()
Doug Simon <doug.simon@oracle.com>
parents:
12669
diff
changeset
|
1559 newNodes = new NodeNodeMap(oldGraph); |
478c82dde838
commented choice of data structure in NodeClass.addGraphDuplicate()
Doug Simon <doug.simon@oracle.com>
parents:
12669
diff
changeset
|
1560 } else { |
478c82dde838
commented choice of data structure in NodeClass.addGraphDuplicate()
Doug Simon <doug.simon@oracle.com>
parents:
12669
diff
changeset
|
1561 // 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
|
1562 newNodes = newIdentityMap(); |
12685
478c82dde838
commented choice of data structure in NodeClass.addGraphDuplicate()
Doug Simon <doug.simon@oracle.com>
parents:
12669
diff
changeset
|
1563 } |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1564 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
|
1565 |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1566 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
|
1567 |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1568 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
|
1569 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
|
1570 if (target == null) { |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1571 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
|
1572 if (replacements != null) { |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1573 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
|
1574 } |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1575 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
|
1576 target = replacement; |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1577 } 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
|
1578 // patch to the outer world |
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1579 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
|
1580 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1581 |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1582 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1583 return target; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1584 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1585 |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1586 }; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1587 |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1588 // 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
|
1589 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
|
1590 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
|
1591 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
|
1592 NodeClass nodeClass = node.getNodeClass(); |
11676
435c8b984680
Distinguish inputs and successors in in-place updates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11675
diff
changeset
|
1593 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
|
1594 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
|
1595 } else { |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1596 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
|
1597 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1598 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1599 |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1600 return newNodes; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1601 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1602 |
11675
77d9f12797c5
Use NodeMap in inlining utility when number of nodes is high.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11674
diff
changeset
|
1603 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
|
1604 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
|
1605 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
|
1606 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
|
1607 Node replacement = node; |
3522f7c99c5f
Allow null DuplicationReplacement in addDuplicates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11669
diff
changeset
|
1608 if (replacements != null) { |
3522f7c99c5f
Allow null DuplicationReplacement in addDuplicates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11669
diff
changeset
|
1609 replacement = replacements.replacement(node); |
3522f7c99c5f
Allow null DuplicationReplacement in addDuplicates.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11669
diff
changeset
|
1610 } |
5478
4a99bfc329f0
Add posibility to provide a replacement function instead of map for duplication.
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5361
diff
changeset
|
1611 if (replacement != node) { |
5519
cedae73d9c2a
Fix problem with jython and tmt
Gilles Duboscq <duboscq@ssw.jku.at>
parents:
5489
diff
changeset
|
1612 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
|
1613 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
|
1614 } else { |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1615 Node newNode = node.clone(graph, false); |
12612
42a2c235652f
replace ".count() == 0" with ".isEmpty()"
Doug Simon <doug.simon@oracle.com>
parents:
12574
diff
changeset
|
1616 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
|
1617 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
|
1618 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
|
1619 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1620 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1621 } |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1622 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1623 |
11675
77d9f12797c5
Use NodeMap in inlining utility when number of nodes is high.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11674
diff
changeset
|
1624 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
|
1625 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
|
1626 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
|
1627 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
|
1628 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
|
1629 continue; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1630 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1631 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
|
1632 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
|
1633 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
|
1634 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
|
1635 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
|
1636 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
|
1637 } |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1638 if (replacement != input) { |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
1639 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
|
1640 target = replacement; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1641 } 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
|
1642 target = input; |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1643 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1644 } |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1645 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
|
1646 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1647 |
17008
81c9a1fc9072
select generated input and successor iterators if Node.USE_GENERATED_NODES
Doug Simon <doug.simon@oracle.com>
parents:
16991
diff
changeset
|
1648 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
|
1649 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
|
1650 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
|
1651 continue; |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1652 } |
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1653 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
|
1654 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
|
1655 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
|
1656 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
|
1657 if (replacement != succ) { |
15241
c570c2fe9d2b
small refactoring of NodeClass.Position, remove duplicated functionality
Lukas Stadler <lukas.stadler@oracle.com>
parents:
15193
diff
changeset
|
1658 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
|
1659 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
|
1660 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1661 } |
11674
8505bcff4bdc
New graph duplication mechanism that allows in-place fixing of edges.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
11673
diff
changeset
|
1662 nodeClass.set(node, pos, target); |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1663 } |
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1664 } |
5858
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
1665 |
911315a3e642
Factor out common infrastructure from NodeClass and LIRInstructionClass
Christian Wimmer <christian.wimmer@oracle.com>
parents:
5813
diff
changeset
|
1666 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
|
1667 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
|
1668 } |
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
|
1669 |
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
|
1670 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
|
1671 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
|
1672 } |
3733
e233f5660da4
Added Java files from Maxine project.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents:
diff
changeset
|
1673 } |