Mercurial > hg > truffle

annotate truffle/com.oracle.truffle.api.dsl/src/com/oracle/truffle/api/dsl/internal/SpecializationNode.java @ 22514:6fe6d2cb7cc1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
SpecializationNode: inline method removeSameImpl
author Andreas Woess <andreas.woess@oracle.com>
date Fri, 18 Dec 2015 14:29:20 +0100
parents 53d05fc21834
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
1 /*
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
4 *
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
7 * published by the Free Software Foundation. Oracle designates this
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
8 * particular file as subject to the "Classpath" exception as provided
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
9 * by Oracle in the LICENSE file that accompanied this code.
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
10 *
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
11 * This code is distributed in the hope that it will be useful, but WITHOUT
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
14 * version 2 for more details (a copy is included in the LICENSE file that
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
15 * accompanied this code).
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
16 *
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
17 * You should have received a copy of the GNU General Public License version
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
18 * 2 along with this work; if not, write to the Free Software Foundation,
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
20 *
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
22 * or visit www.oracle.com if you need additional information or have any
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
23 * questions.
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
24 */
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
25 package com.oracle.truffle.api.dsl.internal;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
26
22508
a619835e6709 SpecializationNode refactoring: update root field through generated setter
Andreas Woess <andreas.woess@oracle.com>
parents: 22507
diff changeset
27 import java.lang.reflect.Field;
a619835e6709 SpecializationNode refactoring: update root field through generated setter
Andreas Woess <andreas.woess@oracle.com>
parents: 22507
diff changeset
28 import java.lang.reflect.Modifier;
a619835e6709 SpecializationNode refactoring: update root field through generated setter
Andreas Woess <andreas.woess@oracle.com>
parents: 22507
diff changeset
29 import java.util.Arrays;
a619835e6709 SpecializationNode refactoring: update root field through generated setter
Andreas Woess <andreas.woess@oracle.com>
parents: 22507
diff changeset
30 import java.util.concurrent.Callable;
a619835e6709 SpecializationNode refactoring: update root field through generated setter
Andreas Woess <andreas.woess@oracle.com>
parents: 22507
diff changeset
31
22157
dc83cc1f94f2 Using fully qualified imports
Jaroslav Tulach <jaroslav.tulach@oracle.com>
parents: 21951
diff changeset
32 import com.oracle.truffle.api.Assumption;
dc83cc1f94f2 Using fully qualified imports
Jaroslav Tulach <jaroslav.tulach@oracle.com>
parents: 21951
diff changeset
33 import com.oracle.truffle.api.CompilerAsserts;
dc83cc1f94f2 Using fully qualified imports
Jaroslav Tulach <jaroslav.tulach@oracle.com>
parents: 21951
diff changeset
34 import com.oracle.truffle.api.CompilerDirectives;
dc83cc1f94f2 Using fully qualified imports
Jaroslav Tulach <jaroslav.tulach@oracle.com>
parents: 21951
diff changeset
35 import com.oracle.truffle.api.dsl.UnsupportedSpecializationException;
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
36 import com.oracle.truffle.api.dsl.internal.SlowPathEvent.SlowPathEvent0;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
37 import com.oracle.truffle.api.dsl.internal.SlowPathEvent.SlowPathEvent1;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
38 import com.oracle.truffle.api.dsl.internal.SlowPathEvent.SlowPathEvent2;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
39 import com.oracle.truffle.api.dsl.internal.SlowPathEvent.SlowPathEvent3;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
40 import com.oracle.truffle.api.dsl.internal.SlowPathEvent.SlowPathEvent4;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
41 import com.oracle.truffle.api.dsl.internal.SlowPathEvent.SlowPathEvent5;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
42 import com.oracle.truffle.api.dsl.internal.SlowPathEvent.SlowPathEventN;
22157
dc83cc1f94f2 Using fully qualified imports
Jaroslav Tulach <jaroslav.tulach@oracle.com>
parents: 21951
diff changeset
43 import com.oracle.truffle.api.frame.Frame;
dc83cc1f94f2 Using fully qualified imports
Jaroslav Tulach <jaroslav.tulach@oracle.com>
parents: 21951
diff changeset
44 import com.oracle.truffle.api.nodes.ExplodeLoop;
dc83cc1f94f2 Using fully qualified imports
Jaroslav Tulach <jaroslav.tulach@oracle.com>
parents: 21951
diff changeset
45 import com.oracle.truffle.api.nodes.InvalidAssumptionException;
dc83cc1f94f2 Using fully qualified imports
Jaroslav Tulach <jaroslav.tulach@oracle.com>
parents: 21951
diff changeset
46 import com.oracle.truffle.api.nodes.Node;
dc83cc1f94f2 Using fully qualified imports
Jaroslav Tulach <jaroslav.tulach@oracle.com>
parents: 21951
diff changeset
47 import com.oracle.truffle.api.nodes.NodeCost;
dc83cc1f94f2 Using fully qualified imports
Jaroslav Tulach <jaroslav.tulach@oracle.com>
parents: 21951
diff changeset
48 import com.oracle.truffle.api.nodes.NodeInfo;
dc83cc1f94f2 Using fully qualified imports
Jaroslav Tulach <jaroslav.tulach@oracle.com>
parents: 21951
diff changeset
49 import com.oracle.truffle.api.nodes.NodeUtil;
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
50
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
51 /**
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
52 * Internal implementation dependent base class for generated specialized nodes.
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
53 */
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
54 @NodeInfo(cost = NodeCost.NONE)
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
55 public abstract class SpecializationNode extends Node {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
56
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
57 @Child protected SpecializationNode next;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
58
22393
ab33db2c148c SpecializationNode.index can be private
Andreas Woess <andreas.woess@oracle.com>
parents: 22372
diff changeset
59 private final int index;
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
60
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
61 public SpecializationNode(int index) {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
62 this.index = index;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
63 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
64
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
65 @Override
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
66 public final NodeCost getCost() {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
67 return NodeCost.NONE;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
68 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
69
19281
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain.
Christian Humer <christian.humer@gmail.com>
parents: 18802
diff changeset
70 public void reset() {
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain.
Christian Humer <christian.humer@gmail.com>
parents: 18802
diff changeset
71 SpecializationNode start = findStart();
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain.
Christian Humer <christian.humer@gmail.com>
parents: 18802
diff changeset
72 SpecializationNode end = findEnd();
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain.
Christian Humer <christian.humer@gmail.com>
parents: 18802
diff changeset
73 if (start != end) {
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain.
Christian Humer <christian.humer@gmail.com>
parents: 18802
diff changeset
74 start.replace(end, "reset specialization");
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain.
Christian Humer <christian.humer@gmail.com>
parents: 18802
diff changeset
75 }
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain.
Christian Humer <christian.humer@gmail.com>
parents: 18802
diff changeset
76 }
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain.
Christian Humer <christian.humer@gmail.com>
parents: 18802
diff changeset
77
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
78 public static Node updateRoot(Node node) {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
79 updateRootImpl(((SpecializedNode) node).getSpecializationNode(), node);
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
80 return node;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
81 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
82
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
83 private static void updateRootImpl(SpecializationNode start, Node node) {
22508
a619835e6709 SpecializationNode refactoring: update root field through generated setter
Andreas Woess <andreas.woess@oracle.com>
parents: 22507
diff changeset
84 start.setRoot(node);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
85 if (start.next != null) {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
86 updateRootImpl(start.next, node);
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
87 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
88 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
89
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
90 protected final SpecializationNode polymorphicMerge(SpecializationNode newNode, SpecializationNode merged) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
91 if (merged == newNode && count() <= 2) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
92 return removeSame(new SlowPathEvent0(this, "merged polymorphic to monomorphic", null));
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
93 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
94 return merged;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
95 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
96
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
97 public final NodeCost getNodeCost() {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
98 switch (count()) {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
99 case 0:
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
100 case 1:
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
101 return NodeCost.UNINITIALIZED;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
102 case 2:
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
103 return NodeCost.MONOMORPHIC;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
104 default:
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
105 return NodeCost.POLYMORPHIC;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
106 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
107 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
108
22508
a619835e6709 SpecializationNode refactoring: update root field through generated setter
Andreas Woess <andreas.woess@oracle.com>
parents: 22507
diff changeset
109 protected abstract void setRoot(Node root);
a619835e6709 SpecializationNode refactoring: update root field through generated setter
Andreas Woess <andreas.woess@oracle.com>
parents: 22507
diff changeset
110
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
111 protected abstract Node[] getSuppliedChildren();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
112
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
113 protected SpecializationNode merge(SpecializationNode newNode, Frame frame) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
114 if (isIdentical(newNode, frame)) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
115 return this;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
116 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
117 return next != null ? next.merge(newNode, frame) : newNode;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
118 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
119
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
120 protected SpecializationNode merge(SpecializationNode newNode, Frame frame, Object o1) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
121 if (isIdentical(newNode, frame, o1)) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
122 return this;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
123 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
124 return next != null ? next.merge(newNode, frame, o1) : newNode;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
125 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
126
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
127 protected SpecializationNode merge(SpecializationNode newNode, Frame frame, Object o1, Object o2) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
128 if (isIdentical(newNode, frame, o1, o2)) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
129 return this;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
130 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
131 return next != null ? next.merge(newNode, frame, o1, o2) : newNode;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
132 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
133
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
134 protected SpecializationNode merge(SpecializationNode newNode, Frame frame, Object o1, Object o2, Object o3) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
135 if (isIdentical(newNode, frame, o1, o2, o3)) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
136 return this;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
137 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
138 return next != null ? next.merge(newNode, frame, o1, o2, o3) : newNode;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
139 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
140
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
141 protected SpecializationNode merge(SpecializationNode newNode, Frame frame, Object o1, Object o2, Object o3, Object o4) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
142 if (isIdentical(newNode, frame, o1, o2, o3, o4)) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
143 return this;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
144 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
145 return next != null ? next.merge(newNode, frame, o1, o2, o3, o4) : newNode;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
146 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
147
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
148 protected SpecializationNode merge(SpecializationNode newNode, Frame frame, Object o1, Object o2, Object o3, Object o4, Object o5) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
149 if (isIdentical(newNode, frame, o1, o2, o3, o4, o5)) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
150 return this;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
151 }
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
152 return next != null ? next.merge(newNode, frame, o1, o2, o3, o4, o5) : newNode;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
153 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
154
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
155 protected SpecializationNode merge(SpecializationNode newNode, Frame frame, Object... args) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
156 if (isIdentical(newNode, frame, args)) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
157 return this;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
158 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
159 return next != null ? next.merge(newNode, frame, args) : newNode;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
160 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
161
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
162 protected boolean isSame(SpecializationNode other) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
163 return getClass() == other.getClass();
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
164 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
165
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
166 @SuppressWarnings("unused")
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
167 protected boolean isIdentical(SpecializationNode newNode, Frame frame) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
168 return isSame(newNode);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
169 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
170
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
171 @SuppressWarnings("unused")
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
172 protected boolean isIdentical(SpecializationNode newNode, Frame frame, Object o1) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
173 return isSame(newNode);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
174 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
175
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
176 @SuppressWarnings("unused")
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
177 protected boolean isIdentical(SpecializationNode newNode, Frame frame, Object o1, Object o2) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
178 return isSame(newNode);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
179 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
180
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
181 @SuppressWarnings("unused")
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
182 protected boolean isIdentical(SpecializationNode newNode, Frame frame, Object o1, Object o2, Object o3) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
183 return isSame(newNode);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
184 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
185
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
186 @SuppressWarnings("unused")
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
187 protected boolean isIdentical(SpecializationNode newNode, Frame frame, Object o1, Object o2, Object o3, Object o4) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
188 return isSame(newNode);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
189 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
190
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
191 @SuppressWarnings("unused")
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
192 protected boolean isIdentical(SpecializationNode newNode, Frame frame, Object o1, Object o2, Object o3, Object o4, Object o5) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
193 return isSame(newNode);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
194 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
195
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
196 @SuppressWarnings("unused")
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
197 protected boolean isIdentical(SpecializationNode newNode, Frame frame, Object... args) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
198 return isSame(newNode);
19289
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
199 }
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
200
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
201 protected final int countSame(SpecializationNode node) {
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
202 return findStart().countSameImpl(node);
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
203 }
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
204
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
205 private int countSameImpl(SpecializationNode node) {
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
206 if (next != null) {
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
207 return next.countSameImpl(node) + (isSame(node) ? 1 : 0);
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
208 } else {
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
209 return 0;
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
210 }
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
211 }
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
212
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
213 @Override
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
214 public final boolean equals(Object obj) {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
215 if (obj instanceof SpecializationNode) {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
216 return ((SpecializationNode) obj).isSame(this);
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
217 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
218 return super.equals(obj);
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
219 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
220
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
221 @Override
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
222 public final int hashCode() {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
223 return index;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
224 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
225
18766
a720bf2e2f43 Truffle-DSL: checkstyle fixes.
Christian Humer <christian.humer@gmail.com>
parents: 18761
diff changeset
226 private int count() {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
227 return next != null ? next.count() + 1 : 1;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
228 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
229
19281
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain.
Christian Humer <christian.humer@gmail.com>
parents: 18802
diff changeset
230 private SpecializationNode findEnd() {
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain.
Christian Humer <christian.humer@gmail.com>
parents: 18802
diff changeset
231 SpecializationNode node = this;
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain.
Christian Humer <christian.humer@gmail.com>
parents: 18802
diff changeset
232 while (node.next != null) {
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain.
Christian Humer <christian.humer@gmail.com>
parents: 18802
diff changeset
233 node = node.next;
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain.
Christian Humer <christian.humer@gmail.com>
parents: 18802
diff changeset
234 }
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain.
Christian Humer <christian.humer@gmail.com>
parents: 18802
diff changeset
235 return node;
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain.
Christian Humer <christian.humer@gmail.com>
parents: 18802
diff changeset
236 }
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain.
Christian Humer <christian.humer@gmail.com>
parents: 18802
diff changeset
237
19291
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
238 protected final Object removeThis(final CharSequence reason, Frame frame) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
239 return removeThisImpl(reason).acceptAndExecute(frame);
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
240 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
241
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
242 protected final Object removeThis(final CharSequence reason, Frame frame, Object o1) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
243 return removeThisImpl(reason).acceptAndExecute(frame, o1);
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
244 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
245
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
246 protected final Object removeThis(final CharSequence reason, Frame frame, Object o1, Object o2) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
247 return removeThisImpl(reason).acceptAndExecute(frame, o1, o2);
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
248 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
249
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
250 protected final Object removeThis(final CharSequence reason, Frame frame, Object o1, Object o2, Object o3) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
251 return removeThisImpl(reason).acceptAndExecute(frame, o1, o2, o3);
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
252 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
253
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
254 protected final Object removeThis(final CharSequence reason, Frame frame, Object o1, Object o2, Object o3, Object o4) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
255 return removeThisImpl(reason).acceptAndExecute(frame, o1, o2, o3, o4);
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
256 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
257
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
258 protected final Object removeThis(final CharSequence reason, Frame frame, Object o1, Object o2, Object o3, Object o4, Object o5) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
259 return removeThisImpl(reason).acceptAndExecute(frame, o1, o2, o3, o4, o5);
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
260 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
261
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
262 protected final Object removeThis(final CharSequence reason, Frame frame, Object... args) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
263 return removeThisImpl(reason).acceptAndExecute(frame, args);
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
264 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
265
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
266 private SpecializationNode removeThisImpl(final CharSequence reason) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
267 this.replace(this.next, reason);
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
268 return findEnd().findStart();
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
269 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
270
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
271 protected final SpecializationNode removeSame(final CharSequence reason) {
22514
6fe6d2cb7cc1 SpecializationNode: inline method removeSameImpl
Andreas Woess <andreas.woess@oracle.com>
parents: 22509
diff changeset
272 SpecializationNode start = SpecializationNode.this.findStart();
6fe6d2cb7cc1 SpecializationNode: inline method removeSameImpl
Andreas Woess <andreas.woess@oracle.com>
parents: 22509
diff changeset
273 SpecializationNode current = start;
6fe6d2cb7cc1 SpecializationNode: inline method removeSameImpl
Andreas Woess <andreas.woess@oracle.com>
parents: 22509
diff changeset
274 while (current != null) {
6fe6d2cb7cc1 SpecializationNode: inline method removeSameImpl
Andreas Woess <andreas.woess@oracle.com>
parents: 22509
diff changeset
275 if (current.isSame(SpecializationNode.this)) {
6fe6d2cb7cc1 SpecializationNode: inline method removeSameImpl
Andreas Woess <andreas.woess@oracle.com>
parents: 22509
diff changeset
276 NodeUtil.nonAtomicReplace(current, current.next, reason);
6fe6d2cb7cc1 SpecializationNode: inline method removeSameImpl
Andreas Woess <andreas.woess@oracle.com>
parents: 22509
diff changeset
277 if (current == start) {
6fe6d2cb7cc1 SpecializationNode: inline method removeSameImpl
Andreas Woess <andreas.woess@oracle.com>
parents: 22509
diff changeset
278 start = start.next;
6fe6d2cb7cc1 SpecializationNode: inline method removeSameImpl
Andreas Woess <andreas.woess@oracle.com>
parents: 22509
diff changeset
279 }
6fe6d2cb7cc1 SpecializationNode: inline method removeSameImpl
Andreas Woess <andreas.woess@oracle.com>
parents: 22509
diff changeset
280 }
6fe6d2cb7cc1 SpecializationNode: inline method removeSameImpl
Andreas Woess <andreas.woess@oracle.com>
parents: 22509
diff changeset
281 current = current.next;
6fe6d2cb7cc1 SpecializationNode: inline method removeSameImpl
Andreas Woess <andreas.woess@oracle.com>
parents: 22509
diff changeset
282 }
6fe6d2cb7cc1 SpecializationNode: inline method removeSameImpl
Andreas Woess <andreas.woess@oracle.com>
parents: 22509
diff changeset
283 return SpecializationNode.this.findEnd().findStart();
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
284 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
285
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
286 /** Find the topmost of the specialization chain. */
18766
a720bf2e2f43 Truffle-DSL: checkstyle fixes.
Christian Humer <christian.humer@gmail.com>
parents: 18761
diff changeset
287 private SpecializationNode findStart() {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
288 SpecializationNode node = this;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
289 Node parent = this.getParent();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
290 while (parent instanceof SpecializationNode) {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
291 SpecializationNode parentCast = ((SpecializationNode) parent);
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
292 if (parentCast.next != node) {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
293 break;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
294 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
295 node = parentCast;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
296 parent = node.getParent();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
297 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
298 return node;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
299 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
300
19289
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
301 private Node findRoot() {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
302 return findStart().getParent();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
303 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
304
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
305 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
306 public Object acceptAndExecute(Frame frame) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
307 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
308 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
309
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
310 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
311 public Object acceptAndExecute(Frame frame, Object o1) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
312 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
313 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
314
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
315 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
316 public Object acceptAndExecute(Frame frame, Object o1, Object o2) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
317 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
318 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
319
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
320 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
321 public Object acceptAndExecute(Frame frame, Object o1, Object o2, Object o3) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
322 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
323 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
324
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
325 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
326 public Object acceptAndExecute(Frame frame, Object o1, Object o2, Object o3, Object o4) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
327 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
328 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
329
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
330 @SuppressWarnings("unused")
18802
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
331 public Object acceptAndExecute(Frame frame, Object o1, Object o2, Object o3, Object o4, Object o5) {
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
332 throw new UnsupportedOperationException();
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
333 }
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
334
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
335 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
336 public Object acceptAndExecute(Frame frame, Object... args) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
337 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
338 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
339
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
340 protected SpecializationNode createFallback() {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
341 return null;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
342 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
343
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
344 protected SpecializationNode createPolymorphic() {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
345 return null;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
346 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
347
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
348 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
349 protected SpecializationNode createNext(Frame frame) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
350 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
351 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
352
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
353 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
354 protected SpecializationNode createNext(Frame frame, Object o1) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
355 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
356 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
357
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
358 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
359 protected SpecializationNode createNext(Frame frame, Object o1, Object o2) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
360 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
361 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
362
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
363 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
364 protected SpecializationNode createNext(Frame frame, Object o1, Object o2, Object o3) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
365 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
366 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
367
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
368 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
369 protected SpecializationNode createNext(Frame frame, Object o1, Object o2, Object o3, Object o4) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
370 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
371 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
372
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
373 @SuppressWarnings("unused")
18802
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
374 protected SpecializationNode createNext(Frame frame, Object o1, Object o2, Object o3, Object o4, Object o5) {
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
375 throw new UnsupportedOperationException();
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
376 }
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
377
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
378 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
379 protected SpecializationNode createNext(Frame frame, Object... args) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
380 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
381 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
382
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
383 protected final Object uninitialized(Frame frame) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
384 CompilerDirectives.transferToInterpreterAndInvalidate();
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
385 SpecializationNode newNode = atomic(new InsertionEvent0(this, "insert new specialization", frame));
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
386 if (newNode == null) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
387 return unsupported(frame);
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
388 }
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
389 return newNode.acceptAndExecute(frame);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
390 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
391
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
392 protected final Object uninitialized(Frame frame, Object o1) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
393 CompilerDirectives.transferToInterpreterAndInvalidate();
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
394 SpecializationNode newNode = atomic(new InsertionEvent1(this, "insert new specialization", frame, o1));
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
395 if (newNode == null) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
396 return unsupported(frame, o1);
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
397 }
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
398 return newNode.acceptAndExecute(frame, o1);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
399 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
400
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
401 protected final Object uninitialized(Frame frame, Object o1, Object o2) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
402 CompilerDirectives.transferToInterpreterAndInvalidate();
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
403 SpecializationNode newNode = atomic(new InsertionEvent2(this, "insert new specialization", frame, o1, o2));
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
404 if (newNode == null) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
405 return unsupported(frame, o1, o2);
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
406 }
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
407 return newNode.acceptAndExecute(frame, o1, o2);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
408 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
409
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
410 protected final Object uninitialized(Frame frame, Object o1, Object o2, Object o3) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
411 CompilerDirectives.transferToInterpreterAndInvalidate();
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
412 SpecializationNode newNode = atomic(new InsertionEvent3(this, "insert new specialization", frame, o1, o2, o3));
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
413 if (newNode == null) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
414 return unsupported(frame, o1, o2, o3);
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
415 }
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
416 return newNode.acceptAndExecute(frame, o1, o2, o3);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
417 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
418
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
419 protected final Object uninitialized(Frame frame, Object o1, Object o2, Object o3, Object o4) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
420 CompilerDirectives.transferToInterpreterAndInvalidate();
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
421 SpecializationNode newNode = atomic(new InsertionEvent4(this, "insert new specialization", frame, o1, o2, o3, o4));
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
422 if (newNode == null) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
423 return unsupported(frame, o1, o2, o3, o4);
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
424 }
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
425 return newNode.acceptAndExecute(frame, o1, o2, o3, o4);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
426 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
427
18802
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
428 protected final Object uninitialized(Frame frame, Object o1, Object o2, Object o3, Object o4, Object o5) {
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
429 CompilerDirectives.transferToInterpreterAndInvalidate();
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
430 SpecializationNode newNode = atomic(new InsertionEvent5(this, "insert new specialization", frame, o1, o2, o3, o4, o5));
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
431 if (newNode == null) {
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
432 return unsupported(frame, o1, o2, o3, o4, o5);
18802
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
433 }
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
434 return newNode.acceptAndExecute(frame, o1, o2, o3, o4, o5);
18802
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
435 }
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
436
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
437 protected final Object uninitialized(Frame frame, Object... args) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
438 CompilerDirectives.transferToInterpreterAndInvalidate();
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
439 SpecializationNode newNode = atomic(new InsertionEventN(this, "insert new specialization", frame, args));
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
440 if (newNode == null) {
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
441 return unsupported(frame, args);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
442 }
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
443 return newNode.acceptAndExecute(frame, args);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
444 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
445
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
446 protected final Object remove(String reason, Frame frame) {
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
447 return atomic(new RemoveEvent0(this, reason, frame)).acceptAndExecute(frame);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
448 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
449
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
450 protected final Object remove(String reason, Frame frame, Object o1) {
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
451 return atomic(new RemoveEvent1(this, reason, frame, o1)).acceptAndExecute(frame, o1);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
452 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
453
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
454 protected final Object remove(String reason, Frame frame, Object o1, Object o2) {
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
455 return atomic(new RemoveEvent2(this, reason, frame, o1, o2)).acceptAndExecute(frame, o1, o2);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
456 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
457
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
458 protected final Object remove(String reason, Frame frame, Object o1, Object o2, Object o3) {
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
459 return atomic(new RemoveEvent3(this, reason, frame, o1, o2, o3)).acceptAndExecute(frame, o1, o2, o3);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
460 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
461
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
462 protected final Object remove(String reason, Frame frame, Object o1, Object o2, Object o3, Object o4) {
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
463 return atomic(new RemoveEvent4(this, reason, frame, o1, o2, o3, o4)).acceptAndExecute(frame, o1, o2, o3, o4);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
464 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
465
18802
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
466 protected final Object remove(String reason, Frame frame, Object o1, Object o2, Object o3, Object o4, Object o5) {
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
467 return atomic(new RemoveEvent5(this, reason, frame, o1, o2, o3, o4, o5)).acceptAndExecute(frame, o1, o2, o3, o4, o5);
18802
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
468 }
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
469
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
470 protected final Object remove(String reason, Frame frame, Object... args) {
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
471 return atomic(new RemoveEventN(this, reason, frame, args)).acceptAndExecute(frame, args);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
472 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
473
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
474 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
475 protected Object unsupported(Frame frame) {
19289
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
476 throw new UnsupportedSpecializationException(findRoot(), getSuppliedChildren());
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
477 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
478
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
479 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
480 protected Object unsupported(Frame frame, Object o1) {
19289
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
481 throw new UnsupportedSpecializationException(findRoot(), getSuppliedChildren(), o1);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
482 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
483
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
484 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
485 protected Object unsupported(Frame frame, Object o1, Object o2) {
19289
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
486 throw new UnsupportedSpecializationException(findRoot(), getSuppliedChildren(), o1, o2);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
487 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
488
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
489 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
490 protected Object unsupported(Frame frame, Object o1, Object o2, Object o3) {
19289
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
491 throw new UnsupportedSpecializationException(findRoot(), getSuppliedChildren(), o1, o2, o3);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
492 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
493
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
494 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
495 protected Object unsupported(Frame frame, Object o1, Object o2, Object o3, Object o4) {
19289
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
496 throw new UnsupportedSpecializationException(findRoot(), getSuppliedChildren(), o1, o2, o3, o4);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
497 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
498
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
499 @SuppressWarnings("unused")
18802
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
500 protected Object unsupported(Frame frame, Object o1, Object o2, Object o3, Object o4, Object o5) {
19289
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
501 throw new UnsupportedSpecializationException(findRoot(), getSuppliedChildren(), o1, o2, o3, o4, o5);
18802
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
502 }
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5.
Christian Humer <christian.humer@gmail.com>
parents: 18776
diff changeset
503
22509
53d05fc21834 SpecializationNode cleanup
Andreas Woess <andreas.woess@oracle.com>
parents: 22508
diff changeset
504 @SuppressWarnings("unused")
18776
c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way.
Christian Humer <christian.humer@gmail.com>
parents: 18766
diff changeset
505 protected Object unsupported(Frame frame, Object... args) {
19289
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
506 throw new UnsupportedSpecializationException(findRoot(), getSuppliedChildren(), args);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
507 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
508
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
509 static SpecializationNode insertSorted(SpecializationNode start, final SpecializationNode generated, final CharSequence message, final SpecializationNode merged) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
510 if (merged == generated) {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
511 // new node
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
512 if (start.count() == 2) {
21065
986f1c0d6f55 Truffle-DSL: do not generate polymorphic nodes for nodes with all parameters evaluated in all execute methods.
Christian Humer <christian.humer@oracle.com>
parents: 20130
diff changeset
513 SpecializationNode polymorphic = start.createPolymorphic();
986f1c0d6f55 Truffle-DSL: do not generate polymorphic nodes for nodes with all parameters evaluated in all execute methods.
Christian Humer <christian.humer@oracle.com>
parents: 20130
diff changeset
514 /*
986f1c0d6f55 Truffle-DSL: do not generate polymorphic nodes for nodes with all parameters evaluated in all execute methods.
Christian Humer <christian.humer@oracle.com>
parents: 20130
diff changeset
515 * For nodes with all parameters evaluated in the execute method we do not need a
986f1c0d6f55 Truffle-DSL: do not generate polymorphic nodes for nodes with all parameters evaluated in all execute methods.
Christian Humer <christian.humer@oracle.com>
parents: 20130
diff changeset
516 * polymorphic node. the generated code returns null in createPolymorphic in this
986f1c0d6f55 Truffle-DSL: do not generate polymorphic nodes for nodes with all parameters evaluated in all execute methods.
Christian Humer <christian.humer@oracle.com>
parents: 20130
diff changeset
517 * case.
986f1c0d6f55 Truffle-DSL: do not generate polymorphic nodes for nodes with all parameters evaluated in all execute methods.
Christian Humer <christian.humer@oracle.com>
parents: 20130
diff changeset
518 */
986f1c0d6f55 Truffle-DSL: do not generate polymorphic nodes for nodes with all parameters evaluated in all execute methods.
Christian Humer <christian.humer@oracle.com>
parents: 20130
diff changeset
519 if (polymorphic != null) {
986f1c0d6f55 Truffle-DSL: do not generate polymorphic nodes for nodes with all parameters evaluated in all execute methods.
Christian Humer <christian.humer@oracle.com>
parents: 20130
diff changeset
520 insertAt(start, polymorphic, "insert polymorphic");
986f1c0d6f55 Truffle-DSL: do not generate polymorphic nodes for nodes with all parameters evaluated in all execute methods.
Christian Humer <christian.humer@oracle.com>
parents: 20130
diff changeset
521 }
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
522 }
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
523 SpecializationNode current = start;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
524 while (current != null && current.index < generated.index) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
525 current = current.next;
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
526 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
527 return insertAt(current, generated, message);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
528 } else {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
529 // existing node
19289
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax.
Christian Humer <christian.humer@gmail.com>
parents: 19281
diff changeset
530 return start;
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
531 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
532 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
533
19758
f682b9e6ca07 Truffle: expose non-atomic replace API to Truffle DSL to avoid multiple RootNode lookups for multiple replaces in one atomic block.
Christian Humer <christian.humer@gmail.com>
parents: 19757
diff changeset
534 static <T> SpecializationNode insertAt(SpecializationNode node, SpecializationNode insertBefore, CharSequence reason) {
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
535 insertBefore.next = node;
19758
f682b9e6ca07 Truffle: expose non-atomic replace API to Truffle DSL to avoid multiple RootNode lookups for multiple replaces in one atomic block.
Christian Humer <christian.humer@gmail.com>
parents: 19757
diff changeset
536 // always guaranteed to be executed inside of an atomic block
f682b9e6ca07 Truffle: expose non-atomic replace API to Truffle DSL to avoid multiple RootNode lookups for multiple replaces in one atomic block.
Christian Humer <christian.humer@gmail.com>
parents: 19757
diff changeset
537 return NodeUtil.nonAtomicReplace(node, insertBefore, reason);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
538 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
539
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
540 @Override
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
541 public final String toString() {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
542 Class<?> clazz = getClass();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
543 StringBuilder b = new StringBuilder();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
544 b.append(clazz.getSimpleName());
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
545
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
546 appendFields(b, clazz);
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
547 if (next != null) {
19291
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
548 b.append("\n -> ").append(next.toString());
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
549 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
550 return b.toString();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
551 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
552
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
553 private void appendFields(StringBuilder b, Class<?> clazz) {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
554 Field[] fields = clazz.getDeclaredFields();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
555 if (fields.length == 0) {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
556 return;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
557 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
558 b.append("(");
19291
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
559 String sep = "";
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
560 for (Field field : fields) {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
561 if (Modifier.isStatic(field.getModifiers())) {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
562 continue;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
563 }
19291
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
564 b.append(sep);
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
565 String name = field.getName();
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
566 if (name.equals("root")) {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
567 continue;
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
568 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
569 b.append(field.getName());
19291
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
570 b.append(" = ");
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
571 try {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
572 field.setAccessible(true);
19291
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
573 Object value = field.get(this);
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
574 if (value instanceof Object[]) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
575 b.append(Arrays.toString((Object[]) field.get(this)));
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
576 } else {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
577 b.append(field.get(this));
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
578 }
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
579 } catch (IllegalArgumentException e) {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
580 b.append(e.toString());
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
581 } catch (IllegalAccessException e) {
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
582 b.append(e.toString());
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
583 }
19291
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
584 sep = ", ";
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
585 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
586 b.append(")");
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
587 }
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
588
19291
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
589 protected static void check(Assumption assumption) throws InvalidAssumptionException {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
590 if (assumption != null) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
591 assumption.check();
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
592 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
593 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
594
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
595 @ExplodeLoop
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
596 protected static void check(Assumption[] assumptions) throws InvalidAssumptionException {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
597 if (assumptions != null) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
598 CompilerAsserts.compilationConstant(assumptions.length);
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
599 for (Assumption assumption : assumptions) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
600 check(assumption);
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
601 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
602 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
603 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
604
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
605 protected static boolean isValid(Assumption assumption) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
606 if (assumption != null) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
607 return assumption.isValid();
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
608 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
609 return true;
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
610 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
611
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
612 protected static boolean isValid(Assumption[] assumptions) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
613 if (assumptions != null) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
614 for (Assumption assumption : assumptions) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
615 if (!isValid(assumption)) {
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
616 return false;
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
617 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
618 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
619 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
620 return true;
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
621 }
f4792a544170 Truffle-DSL: implement new assumptions semantics.
Christian Humer <christian.humer@gmail.com>
parents: 19289
diff changeset
622
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
623 private static final class InsertionEvent0 extends SlowPathEvent0 implements Callable<SpecializationNode> {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
624
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
625 public InsertionEvent0(SpecializationNode source, String reason, Frame frame) {
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
626 super(source, reason, frame);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
627 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
628
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
629 public SpecializationNode call() throws Exception {
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
630 SpecializationNode next = source.createNext(frame);
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
631 if (next == null) {
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
632 next = source.createFallback();
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
633 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
634 if (next == null) {
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
635 return null;
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
636 }
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
637 SpecializationNode start = source.findStart();
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
638 if (start.index == Integer.MAX_VALUE) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
639 return insertAt(start, next, this);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
640 } else {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
641 return insertSorted(start, next, this, start.merge(next, frame));
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
642 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
643 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
644
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
645 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
646
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
647 private static final class InsertionEvent1 extends SlowPathEvent1 implements Callable<SpecializationNode> {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
648
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
649 public InsertionEvent1(SpecializationNode source, String reason, Frame frame, Object o1) {
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
650 super(source, reason, frame, o1);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
651 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
652
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
653 public SpecializationNode call() throws Exception {
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
654 SpecializationNode next = source.createNext(frame, o1);
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
655 if (next == null) {
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
656 next = source.createFallback();
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
657 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
658 if (next == null) {
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
659 return null;
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
660 }
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
661 SpecializationNode start = source.findStart();
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
662 if (start.index == Integer.MAX_VALUE) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
663 return insertAt(start, next, this);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
664 } else {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
665 return insertSorted(start, next, this, start.merge(next, frame, o1));
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
666 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
667 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
668
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
669 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
670
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
671 private static final class InsertionEvent2 extends SlowPathEvent2 implements Callable<SpecializationNode> {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
672
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
673 public InsertionEvent2(SpecializationNode source, String reason, Frame frame, Object o1, Object o2) {
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
674 super(source, reason, frame, o1, o2);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
675 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
676
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
677 public SpecializationNode call() throws Exception {
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
678 SpecializationNode next = source.createNext(frame, o1, o2);
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
679 if (next == null) {
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
680 next = source.createFallback();
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
681 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
682 if (next == null) {
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
683 return null;
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
684 }
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
685 SpecializationNode start = source.findStart();
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
686 if (start.index == Integer.MAX_VALUE) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
687 return insertAt(start, next, this);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
688 } else {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
689 return insertSorted(start, next, this, start.merge(next, frame, o1, o2));
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
690 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
691 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
692
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
693 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
694
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
695 private static final class InsertionEvent3 extends SlowPathEvent3 implements Callable<SpecializationNode> {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
696
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
697 public InsertionEvent3(SpecializationNode source, String reason, Frame frame, Object o1, Object o2, Object o3) {
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
698 super(source, reason, frame, o1, o2, o3);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
699 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
700
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
701 public SpecializationNode call() throws Exception {
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
702 SpecializationNode next = source.createNext(frame, o1, o2, o3);
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
703 if (next == null) {
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
704 next = source.createFallback();
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
705 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
706 if (next == null) {
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
707 return null;
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
708 }
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
709 SpecializationNode start = source.findStart();
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
710 if (start.index == Integer.MAX_VALUE) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
711 return insertAt(start, next, this);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
712 } else {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
713 return insertSorted(start, next, this, start.merge(next, frame, o1, o2, o3));
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
714 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
715 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
716
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
717 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
718
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
719 private static final class InsertionEvent4 extends SlowPathEvent4 implements Callable<SpecializationNode> {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
720
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
721 public InsertionEvent4(SpecializationNode source, String reason, Frame frame, Object o1, Object o2, Object o3, Object o4) {
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
722 super(source, reason, frame, o1, o2, o3, o4);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
723 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
724
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
725 public SpecializationNode call() throws Exception {
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
726 SpecializationNode next = source.createNext(frame, o1, o2, o3, o4);
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
727 if (next == null) {
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
728 next = source.createFallback();
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
729 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
730 if (next == null) {
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
731 return null;
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
732 }
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
733 SpecializationNode start = source.findStart();
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
734 if (start.index == Integer.MAX_VALUE) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
735 return insertAt(start, next, this);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
736 } else {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
737 return insertSorted(start, next, this, start.merge(next, frame, o1, o2, o3, o4));
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
738 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
739 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
740
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
741 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
742
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
743 private static final class InsertionEvent5 extends SlowPathEvent5 implements Callable<SpecializationNode> {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
744
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
745 public InsertionEvent5(SpecializationNode source, String reason, Frame frame, Object o1, Object o2, Object o3, Object o4, Object o5) {
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
746 super(source, reason, frame, o1, o2, o3, o4, o5);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
747 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
748
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
749 public SpecializationNode call() throws Exception {
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
750 SpecializationNode next = source.createNext(frame, o1, o2, o3, o4, o5);
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
751 if (next == null) {
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
752 next = source.createFallback();
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
753 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
754 if (next == null) {
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
755 return null;
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
756 }
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
757 SpecializationNode start = source.findStart();
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
758 if (start.index == Integer.MAX_VALUE) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
759 return insertAt(start, next, this);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
760 } else {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
761 return insertSorted(start, next, this, start.merge(next, frame, o1, o2, o3, o4, o5));
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
762 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
763 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
764
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
765 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
766
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
767 private static final class InsertionEventN extends SlowPathEventN implements Callable<SpecializationNode> {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
768
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
769 public InsertionEventN(SpecializationNode source, String reason, Frame frame, Object[] args) {
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
770 super(source, reason, frame, args);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
771 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
772
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
773 public SpecializationNode call() throws Exception {
19770
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
774 SpecializationNode next = source.createNext(frame, args);
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
775 if (next == null) {
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
776 next = source.createFallback();
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
777 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
778 if (next == null) {
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
779 return null;
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.
Christian Humer <christian.humer@gmail.com>
parents: 19768
diff changeset
780 }
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
781 SpecializationNode start = source.findStart();
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
782 if (start.index == Integer.MAX_VALUE) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
783 return insertAt(start, next, this);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
784 } else {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
785 return insertSorted(start, next, this, start.merge(next, frame, args));
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
786 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
787 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
788 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
789
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
790 private static final class RemoveEvent0 extends SlowPathEvent0 implements Callable<SpecializationNode> {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
791
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
792 public RemoveEvent0(SpecializationNode source, String reason, Frame frame) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
793 super(source, reason, frame);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
794 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
795
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
796 public SpecializationNode call() throws Exception {
19768
8caabd6cf363 Truffle-DSL: removeSame does not need to run using atomic. It is always used in an atomic block already.
Christian Humer <christian.humer@gmail.com>
parents: 19758
diff changeset
797 return source.removeSame(this);
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
798 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
799
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
800 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
801
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
802 private static final class RemoveEvent1 extends SlowPathEvent1 implements Callable<SpecializationNode> {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
803
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
804 public RemoveEvent1(SpecializationNode source, String reason, Frame frame, Object o1) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
805 super(source, reason, frame, o1);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
806 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
807
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
808 public SpecializationNode call() throws Exception {
19768
8caabd6cf363 Truffle-DSL: removeSame does not need to run using atomic. It is always used in an atomic block already.
Christian Humer <christian.humer@gmail.com>
parents: 19758
diff changeset
809 return source.removeSame(this);
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
810 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
811
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
812 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
813
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
814 private static final class RemoveEvent2 extends SlowPathEvent2 implements Callable<SpecializationNode> {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
815
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
816 public RemoveEvent2(SpecializationNode source, String reason, Frame frame, Object o1, Object o2) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
817 super(source, reason, frame, o1, o2);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
818 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
819
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
820 public SpecializationNode call() throws Exception {
19768
8caabd6cf363 Truffle-DSL: removeSame does not need to run using atomic. It is always used in an atomic block already.
Christian Humer <christian.humer@gmail.com>
parents: 19758
diff changeset
821 return source.removeSame(this);
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
822 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
823
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
824 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
825
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
826 private static final class RemoveEvent3 extends SlowPathEvent3 implements Callable<SpecializationNode> {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
827
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
828 public RemoveEvent3(SpecializationNode source, String reason, Frame frame, Object o1, Object o2, Object o3) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
829 super(source, reason, frame, o1, o2, o3);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
830 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
831
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
832 public SpecializationNode call() throws Exception {
19768
8caabd6cf363 Truffle-DSL: removeSame does not need to run using atomic. It is always used in an atomic block already.
Christian Humer <christian.humer@gmail.com>
parents: 19758
diff changeset
833 return source.removeSame(this);
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
834 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
835
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
836 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
837
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
838 private static final class RemoveEvent4 extends SlowPathEvent4 implements Callable<SpecializationNode> {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
839
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
840 public RemoveEvent4(SpecializationNode source, String reason, Frame frame, Object o1, Object o2, Object o3, Object o4) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
841 super(source, reason, frame, o1, o2, o3, o4);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
842 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
843
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
844 public SpecializationNode call() throws Exception {
19768
8caabd6cf363 Truffle-DSL: removeSame does not need to run using atomic. It is always used in an atomic block already.
Christian Humer <christian.humer@gmail.com>
parents: 19758
diff changeset
845 return source.removeSame(this);
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
846 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
847
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
848 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
849
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
850 private static final class RemoveEvent5 extends SlowPathEvent5 implements Callable<SpecializationNode> {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
851
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
852 public RemoveEvent5(SpecializationNode source, String reason, Frame frame, Object o1, Object o2, Object o3, Object o4, Object o5) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
853 super(source, reason, frame, o1, o2, o3, o4, o5);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
854 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
855
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
856 public SpecializationNode call() throws Exception {
19768
8caabd6cf363 Truffle-DSL: removeSame does not need to run using atomic. It is always used in an atomic block already.
Christian Humer <christian.humer@gmail.com>
parents: 19758
diff changeset
857 return source.removeSame(this);
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
858 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
859
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
860 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
861
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
862 private static final class RemoveEventN extends SlowPathEventN implements Callable<SpecializationNode> {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
863
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
864 public RemoveEventN(SpecializationNode source, String reason, Frame frame, Object[] args) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
865 super(source, reason, frame, args);
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
866 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
867
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
868 public SpecializationNode call() throws Exception {
19768
8caabd6cf363 Truffle-DSL: removeSame does not need to run using atomic. It is always used in an atomic block already.
Christian Humer <christian.humer@gmail.com>
parents: 19758
diff changeset
869 return source.removeSame(this);
19757
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
870 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
871 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution.
Christian Humer <christian.humer@gmail.com>
parents: 19291
diff changeset
872
18761
a665483c3881 Truffle-DSL: new node layout implementation.
Christian Humer <christian.humer@gmail.com>
parents:
diff changeset
873 }