truffle: truffle/com.oracle.truffle.api.dsl/src/com/oracle/truffle/api/dsl/internal/SpecializationNode.java annotate

annotate truffle/com.oracle.truffle.api.dsl/src/com/oracle/truffle/api/dsl/internal/SpecializationNode.java @ 22509:53d05fc21834

SpecializationNode cleanup

author	Andreas Woess <andreas.woess@oracle.com>
date	Thu, 17 Dec 2015 16:37:45 +0100
parents	a619835e6709
children	6fe6d2cb7cc1

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) {
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	272 return removeSameImpl(SpecializationNode.this, reason);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	273 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	274
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	275 /** Find the topmost of the specialization chain. */
18766 a720bf2e2f43 Truffle-DSL: checkstyle fixes. Christian Humer <christian.humer@gmail.com> parents: 18761 diff changeset	276 private SpecializationNode findStart() {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	277 SpecializationNode node = this;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	278 Node parent = this.getParent();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	279 while (parent instanceof SpecializationNode) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	280 SpecializationNode parentCast = ((SpecializationNode) parent);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	281 if (parentCast.next != node) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	282 break;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	283 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	284 node = parentCast;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	285 parent = node.getParent();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	286 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	287 return node;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	288 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	289
19289 62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax. Christian Humer <christian.humer@gmail.com> parents: 19281 diff changeset	290 private Node findRoot() {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	291 return findStart().getParent();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	292 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	293
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	294 private static SpecializationNode removeSameImpl(SpecializationNode toRemove, CharSequence reason) {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	295 SpecializationNode start = toRemove.findStart();
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	296 SpecializationNode current = start;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	297 while (current != null) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	298 if (current.isSame(toRemove)) {
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	299 NodeUtil.nonAtomicReplace(current, current.next, reason);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	300 if (current == start) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	301 start = start.next;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	302 }
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 current = current.next;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	305 }
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	306 return toRemove.findEnd().findStart();
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	307 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	308
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	309 @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	310 public Object acceptAndExecute(Frame frame) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	311 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	312 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	313
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	314 @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	315 public Object acceptAndExecute(Frame frame, Object o1) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	316 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	317 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	318
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	319 @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	320 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	321 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	322 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	323
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	324 @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	325 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	326 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	327 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	328
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	329 @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	330 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	331 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	332 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	333
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	334 @SuppressWarnings("unused")
18802 71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	335 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	336 throw new UnsupportedOperationException();
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	337 }
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	338
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	339 @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	340 public Object acceptAndExecute(Frame frame, Object... args) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	341 throw new UnsupportedOperationException();
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 createFallback() {
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
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	348 protected SpecializationNode createPolymorphic() {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	349 return null;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	350 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	351
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	352 @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	353 protected SpecializationNode createNext(Frame frame) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	354 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	355 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	356
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	357 @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	358 protected SpecializationNode createNext(Frame frame, Object o1) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	359 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	360 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	361
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	362 @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	363 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	364 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	365 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	366
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	367 @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	368 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	369 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	370 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	371
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	372 @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	373 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	374 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	375 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	376
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	377 @SuppressWarnings("unused")
18802 71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	378 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	379 throw new UnsupportedOperationException();
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	380 }
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	381
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	382 @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	383 protected SpecializationNode createNext(Frame frame, Object... args) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	384 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	385 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	386
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	387 protected final Object uninitialized(Frame frame) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	388 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	389 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	390 if (newNode == null) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	391 return unsupported(frame);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	392 }
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	393 return newNode.acceptAndExecute(frame);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	394 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	395
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	396 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	397 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	398 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	399 if (newNode == null) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	400 return unsupported(frame, o1);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	401 }
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	402 return newNode.acceptAndExecute(frame, o1);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	403 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	404
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	405 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	406 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	407 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	408 if (newNode == null) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	409 return unsupported(frame, o1, o2);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	410 }
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	411 return newNode.acceptAndExecute(frame, o1, o2);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	412 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	413
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	414 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	415 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	416 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	417 if (newNode == null) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	418 return unsupported(frame, o1, o2, o3);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	419 }
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	420 return newNode.acceptAndExecute(frame, o1, o2, o3);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	421 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	422
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	423 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	424 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	425 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	426 if (newNode == null) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	427 return unsupported(frame, o1, o2, o3, o4);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	428 }
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	429 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	430 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	431
18802 71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	432 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	433 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	434 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	435 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	436 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	437 }
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	438 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	439 }
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	440
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	441 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	442 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	443 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	444 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	445 return unsupported(frame, args);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	446 }
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	447 return newNode.acceptAndExecute(frame, args);
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) {
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 RemoveEvent0(this, reason, frame)).acceptAndExecute(frame);
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) {
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 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	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) {
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 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	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) {
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 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	464 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	465
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	466 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	467 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	468 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	469
18802 71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	470 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	471 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	472 }
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	473
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	474 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	475 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	476 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	477
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	478 @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	479 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	480 throw new UnsupportedSpecializationException(findRoot(), getSuppliedChildren());
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	481 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	482
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	483 @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	484 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	485 throw new UnsupportedSpecializationException(findRoot(), getSuppliedChildren(), o1);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	486 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	487
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	488 @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	489 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	490 throw new UnsupportedSpecializationException(findRoot(), getSuppliedChildren(), o1, o2);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	491 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	492
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	493 @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	494 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	495 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	496 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	497
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	498 @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	499 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	500 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	501 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	502
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	503 @SuppressWarnings("unused")
18802 71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	504 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	505 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	506 }
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	507
22509 53d05fc21834 SpecializationNode cleanup Andreas Woess <andreas.woess@oracle.com> parents: 22508 diff changeset	508 @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	509 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	510 throw new UnsupportedSpecializationException(findRoot(), getSuppliedChildren(), args);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	511 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	512
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	513 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	514 if (merged == generated) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	515 // new node
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	516 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	517 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	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 * 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	520 * 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	521 * 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	522 */
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	523 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	524 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	525 }
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	526 }
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	527 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	528 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	529 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	530 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	531 return insertAt(current, generated, message);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	532 } else {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	533 // 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	534 return start;
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	535 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	536 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	537
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	538 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	539 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	540 // 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	541 return NodeUtil.nonAtomicReplace(node, insertBefore, reason);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	542 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	543
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	544 @Override
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	545 public final String toString() {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	546 Class<?> clazz = getClass();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	547 StringBuilder b = new StringBuilder();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	548 b.append(clazz.getSimpleName());
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 appendFields(b, clazz);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	551 if (next != null) {
19291 f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	552 b.append("\n -> ").append(next.toString());
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	553 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	554 return b.toString();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	555 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	556
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	557 private void appendFields(StringBuilder b, Class<?> clazz) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	558 Field[] fields = clazz.getDeclaredFields();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	559 if (fields.length == 0) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	560 return;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	561 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	562 b.append("(");
19291 f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	563 String sep = "";
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	564 for (Field field : fields) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	565 if (Modifier.isStatic(field.getModifiers())) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	566 continue;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	567 }
19291 f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	568 b.append(sep);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	569 String name = field.getName();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	570 if (name.equals("root")) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	571 continue;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	572 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	573 b.append(field.getName());
19291 f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	574 b.append(" = ");
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	575 try {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	576 field.setAccessible(true);
19291 f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	577 Object value = field.get(this);
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	578 if (value instanceof Object[]) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	579 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	580 } else {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	581 b.append(field.get(this));
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	582 }
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	583 } catch (IllegalArgumentException e) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	584 b.append(e.toString());
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	585 } catch (IllegalAccessException e) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	586 b.append(e.toString());
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	587 }
19291 f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	588 sep = ", ";
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	589 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	590 b.append(")");
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	591 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	592
19291 f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	593 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	594 if (assumption != null) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	595 assumption.check();
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	596 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	597 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	598
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	599 @ExplodeLoop
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	600 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	601 if (assumptions != null) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	602 CompilerAsserts.compilationConstant(assumptions.length);
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	603 for (Assumption assumption : assumptions) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	604 check(assumption);
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	605 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	606 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	607 }
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 protected static boolean isValid(Assumption assumption) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	610 if (assumption != null) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	611 return assumption.isValid();
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	612 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	613 return true;
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	614 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	615
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	616 protected static boolean isValid(Assumption[] assumptions) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	617 if (assumptions != null) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	618 for (Assumption assumption : assumptions) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	619 if (!isValid(assumption)) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	620 return false;
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 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	623 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	624 return true;
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	625 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	626
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	627 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	628
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	629 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	630 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	631 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	632
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	633 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	634 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	635 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	636 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	637 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations. Christian Humer <christian.humer@gmail.com> parents: 19768 diff changeset	638 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	639 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	640 }
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	641 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	642 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	643 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	644 } 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	645 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	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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	649 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: 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 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	652
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	653 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	654 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	655 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	656
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	657 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	658 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	659 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	660 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	661 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations. Christian Humer <christian.humer@gmail.com> parents: 19768 diff changeset	662 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	663 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	664 }
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	665 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	666 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	667 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	668 } 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	669 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	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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	673 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: 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 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	676
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	677 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	678 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	679 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	680
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	681 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	682 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	683 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	684 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	685 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations. Christian Humer <christian.humer@gmail.com> parents: 19768 diff changeset	686 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	687 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	688 }
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	689 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	690 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	691 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	692 } 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	693 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	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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	697 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: 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 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	700
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	701 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	702 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	703 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	704
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	705 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	706 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	707 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	708 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	709 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations. Christian Humer <christian.humer@gmail.com> parents: 19768 diff changeset	710 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	711 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	712 }
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	713 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	714 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	715 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	716 } 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	717 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	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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	721 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: 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 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	724
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	725 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	726 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	727 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	728
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	729 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	730 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	731 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	732 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	733 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations. Christian Humer <christian.humer@gmail.com> parents: 19768 diff changeset	734 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	735 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	736 }
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	737 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	738 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	739 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	740 } 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	741 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	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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	745 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: 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 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	748
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	749 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	750 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	751 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	752
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	753 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	754 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	755 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	756 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	757 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations. Christian Humer <christian.humer@gmail.com> parents: 19768 diff changeset	758 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	759 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	760 }
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	761 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	762 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	763 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	764 } 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	765 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	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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	769 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: 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 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	772
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	773 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	774 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	775 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	776
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	777 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	778 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	779 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	780 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	781 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations. Christian Humer <christian.humer@gmail.com> parents: 19768 diff changeset	782 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	783 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	784 }
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	785 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	786 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	787 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	788 } 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	789 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	790 }
e8d2f3f95dcd Truffle-DSL: 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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: 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 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	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 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	797 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	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 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	801 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	802 }
e8d2f3f95dcd Truffle-DSL: 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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: 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 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	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 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	809 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	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 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	813 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	814 }
e8d2f3f95dcd Truffle-DSL: 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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: 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 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	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 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	821 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	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 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	825 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	826 }
e8d2f3f95dcd Truffle-DSL: 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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: 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 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	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 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	833 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	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 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	837 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	838 }
e8d2f3f95dcd Truffle-DSL: 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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: 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 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	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 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	845 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	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 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	849 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	850 }
e8d2f3f95dcd Truffle-DSL: 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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: 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 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	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 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	857 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	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 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	861 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	862 }
e8d2f3f95dcd Truffle-DSL: 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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: 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 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	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 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	869 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	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 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	873 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	874 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	875 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	876
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	877 }

Mercurial > hg > truffle

annotate truffle/com.oracle.truffle.api.dsl/src/com/oracle/truffle/api/dsl/internal/SpecializationNode.java @ 22509:53d05fc21834