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

annotate graal/com.oracle.truffle.api.dsl/src/com/oracle/truffle/api/dsl/internal/SpecializationNode.java @ 19770:7108d2319169

Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations.

author	Christian Humer <christian.humer@gmail.com>
date	Wed, 11 Mar 2015 11:32:13 +0100
parents	8caabd6cf363
children	5b7db8941fd7

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
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	27 import java.lang.reflect.*;
19291 f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	28 import java.util.*;
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	29 import java.util.concurrent.*;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	30
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	31 import com.oracle.truffle.api.*;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	32 import com.oracle.truffle.api.dsl.*;
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	33 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	34 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	35 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	36 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	37 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	38 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	39 import com.oracle.truffle.api.dsl.internal.SlowPathEvent.SlowPathEventN;
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	40 import com.oracle.truffle.api.frame.*;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	41 import com.oracle.truffle.api.nodes.*;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	42 import com.oracle.truffle.api.nodes.NodeUtil.NodeClass;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	43 import com.oracle.truffle.api.nodes.NodeUtil.NodeField;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	44
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	45 /**
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	46 * 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	47 */
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	48 @NodeInfo(cost = NodeCost.NONE)
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	49 @SuppressWarnings("unused")
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	50 public abstract class SpecializationNode extends Node {
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 @Child protected SpecializationNode next;
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 final int index;
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	55
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	56 public SpecializationNode() {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	57 this(-1);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	58 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	59
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	60 public SpecializationNode(int index) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	61 this.index = index;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	62 }
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 @Override
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	65 public final NodeCost getCost() {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	66 return NodeCost.NONE;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	67 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	68
19281 92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain. Christian Humer <christian.humer@gmail.com> parents: 18802 diff changeset	69 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	70 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	71 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	72 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	73 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	74 }
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
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	77 public static Node updateRoot(Node node) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	78 updateRootImpl(((SpecializedNode) node).getSpecializationNode(), node);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	79 return node;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	80 }
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 private static void updateRootImpl(SpecializationNode start, Node node) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	83 NodeField[] fields = NodeClass.get(start.getClass()).getFields();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	84 for (int i = fields.length - 1; i >= 0; i--) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	85 NodeField f = fields[i];
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	86 if (f.getName().equals("root")) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	87 f.putObject(start, node);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	88 break;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	89 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	90 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	91 if (start.next != null) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	92 updateRootImpl(start.next, node);
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 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	95
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	96 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	97 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	98 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	99 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	100 return merged;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	101 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	102
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	103 public final NodeCost getNodeCost() {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	104 switch (count()) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	105 case 0:
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	106 case 1:
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	107 return NodeCost.UNINITIALIZED;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	108 case 2:
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	109 return NodeCost.MONOMORPHIC;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	110 default:
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	111 return NodeCost.POLYMORPHIC;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	112 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	113 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	114
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	115 protected abstract Node[] getSuppliedChildren();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	116
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	117 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	118 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	119 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	120 }
e8d2f3f95dcd Truffle-DSL: 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 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	122 }
e8d2f3f95dcd Truffle-DSL: 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 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	125 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	126 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	127 }
e8d2f3f95dcd Truffle-DSL: 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 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	129 }
e8d2f3f95dcd Truffle-DSL: 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 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	132 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	133 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	134 }
e8d2f3f95dcd Truffle-DSL: 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 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	136 }
e8d2f3f95dcd Truffle-DSL: 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 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	139 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	140 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	141 }
e8d2f3f95dcd Truffle-DSL: 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 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	143 }
e8d2f3f95dcd Truffle-DSL: 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 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	146 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	147 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	148 }
e8d2f3f95dcd Truffle-DSL: 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 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	150 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	151
e8d2f3f95dcd Truffle-DSL: 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 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	153 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	154 return this;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	155 }
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	156 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	157 }
e8d2f3f95dcd Truffle-DSL: 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 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	160 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	161 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	162 }
e8d2f3f95dcd Truffle-DSL: 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 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	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
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	166 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	167 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	168 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	169
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	170 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	171 return isSame(newNode);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	172 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	173
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	174 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	175 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	176 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: 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 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	179 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	180 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	181
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	186 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	187 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	188 }
e8d2f3f95dcd Truffle-DSL: 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 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	191 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	192 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: 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 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	195 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	196 }
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax. Christian Humer <christian.humer@gmail.com> parents: 19281 diff changeset	197
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax. Christian Humer <christian.humer@gmail.com> parents: 19281 diff changeset	198 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	199 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	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
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax. Christian Humer <christian.humer@gmail.com> parents: 19281 diff changeset	202 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	203 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	204 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	205 } else {
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax. Christian Humer <christian.humer@gmail.com> parents: 19281 diff changeset	206 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	207 }
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax. Christian Humer <christian.humer@gmail.com> parents: 19281 diff changeset	208 }
62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax. Christian Humer <christian.humer@gmail.com> parents: 19281 diff changeset	209
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	210 @Override
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	211 public final boolean equals(Object obj) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	212 if (obj instanceof SpecializationNode) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	213 return ((SpecializationNode) obj).isSame(this);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	214 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	215 return super.equals(obj);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	216 }
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 @Override
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	219 public final int hashCode() {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	220 return index;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	221 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	222
18766 a720bf2e2f43 Truffle-DSL: checkstyle fixes. Christian Humer <christian.humer@gmail.com> parents: 18761 diff changeset	223 private int count() {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	224 return next != null ? next.count() + 1 : 1;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	225 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	226
19281 92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain. Christian Humer <christian.humer@gmail.com> parents: 18802 diff changeset	227 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	228 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	229 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	230 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	231 }
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain. Christian Humer <christian.humer@gmail.com> parents: 18802 diff changeset	232 return node;
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain. Christian Humer <christian.humer@gmail.com> parents: 18802 diff changeset	233 }
92880b0f7fed Truffle-DSL: add internal API support to reset the specialization chain. Christian Humer <christian.humer@gmail.com> parents: 18802 diff changeset	234
19291 f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	235 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	236 return removeThisImpl(reason).acceptAndExecute(frame);
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	237 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	238
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	239 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	240 return removeThisImpl(reason).acceptAndExecute(frame, o1);
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
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	243 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	244 return removeThisImpl(reason).acceptAndExecute(frame, o1, o2);
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
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	247 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	248 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	249 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	250
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	251 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	252 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	253 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	254
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	255 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	256 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	257 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	258
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	259 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	260 return removeThisImpl(reason).acceptAndExecute(frame, args);
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
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	263 private SpecializationNode removeThisImpl(final CharSequence reason) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	264 this.replace(this.next, reason);
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	265 return findEnd().findStart();
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	266 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	267
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	268 protected final SpecializationNode removeSame(final CharSequence reason) {
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	269 SpecializationNode start = SpecializationNode.this.findStart();
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	270 SpecializationNode current = start;
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	271 while (current != null) {
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	272 if (current.isSame(SpecializationNode.this)) {
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	273 NodeUtil.nonAtomicReplace(current, current.next, reason);
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	274 if (current == start) {
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	275 start = start.next;
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	276 }
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	277 }
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	278 current = current.next;
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	279 }
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	280 return SpecializationNode.this.findEnd().findStart();
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	281 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	282
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	283 /** Find the topmost of the specialization chain. */
18766 a720bf2e2f43 Truffle-DSL: checkstyle fixes. Christian Humer <christian.humer@gmail.com> parents: 18761 diff changeset	284 private SpecializationNode findStart() {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	285 SpecializationNode node = this;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	286 Node parent = this.getParent();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	287 while (parent instanceof SpecializationNode) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	288 SpecializationNode parentCast = ((SpecializationNode) parent);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	289 if (parentCast.next != node) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	290 break;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	291 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	292 node = parentCast;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	293 parent = node.getParent();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	294 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	295 return node;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	296 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	297
19289 62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax. Christian Humer <christian.humer@gmail.com> parents: 19281 diff changeset	298 private Node findRoot() {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	299 return findStart().getParent();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	300 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	301
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	302 private SpecializedNode findSpecializedNode() {
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	303 return (SpecializedNode) findEnd().findStart().getParent();
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	304 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	305
e8d2f3f95dcd Truffle-DSL: 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 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	307 SpecializationNode start = toRemove.findStart();
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	308 SpecializationNode current = start;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	309 while (current != null) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	310 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	311 NodeUtil.nonAtomicReplace(current, current.next, reason);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	312 if (current == start) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	313 start = start.next;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	314 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	315 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	316 current = current.next;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	317 }
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	318 return toRemove.findEnd().findStart();
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	319 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	320
18776 c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way. Christian Humer <christian.humer@gmail.com> parents: 18766 diff changeset	321 public Object acceptAndExecute(Frame frame) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	322 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	323 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	324
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) {
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
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	329 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	330 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	331 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	332
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	333 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	334 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	335 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	336
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	337 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	338 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	339 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	340
18802 71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	341 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	342 throw new UnsupportedOperationException();
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	343 }
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	344
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	345 public Object acceptAndExecute(Frame frame, Object... args) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	346 throw new UnsupportedOperationException();
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
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	349 protected SpecializationNode createFallback() {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	350 return null;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	351 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	352
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	353 protected SpecializationNode createPolymorphic() {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	354 return null;
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
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	357 protected SpecializationNode createNext(Frame frame) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	358 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	359 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	360
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	361 protected SpecializationNode createNext(Frame frame, Object o1) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	362 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	363 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	364
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	365 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	366 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	367 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	368
18776 c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way. Christian Humer <christian.humer@gmail.com> parents: 18766 diff changeset	369 protected SpecializationNode createNext(Frame frame, Object o1, Object o2, Object o3) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	370 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	371 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	372
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
18802 71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	377 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	378 throw new UnsupportedOperationException();
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	379 }
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	380
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	381 protected SpecializationNode createNext(Frame frame, Object... args) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	382 throw new UnsupportedOperationException();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	383 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	384
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	385 protected final Object uninitialized(Frame frame) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	386 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	387 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	388 if (newNode == null) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	389 return unsupported(frame);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	390 }
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	391 return newNode.acceptAndExecute(frame);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	392 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	393
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	394 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	395 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	396 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	397 if (newNode == null) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	398 return unsupported(frame, o1);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	399 }
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	400 return newNode.acceptAndExecute(frame, o1);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	401 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	402
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	403 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	404 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	405 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	406 if (newNode == null) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	407 return unsupported(frame, o1, o2);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	408 }
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	409 return newNode.acceptAndExecute(frame, o1, o2);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	410 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	411
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	412 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	413 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	414 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	415 if (newNode == null) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	416 return unsupported(frame, o1, o2, o3);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	417 }
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	418 return newNode.acceptAndExecute(frame, o1, o2, o3);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	419 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	420
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	421 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	422 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	423 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	424 if (newNode == null) {
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	425 return unsupported(frame, o1, o2, o3, o4);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	426 }
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	427 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	428 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	429
18802 71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	430 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	431 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	432 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	433 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	434 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	435 }
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	436 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	437 }
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	438
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	439 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	440 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	441 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	442 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	443 return unsupported(frame, args);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	444 }
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	445 return newNode.acceptAndExecute(frame, args);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	446 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	447
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	448 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	449 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	450 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	451
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	452 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	453 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	454 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	455
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	456 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	457 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	458 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	459
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	460 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	461 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	462 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	463
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	464 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	465 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	466 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	467
18802 71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	468 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	469 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	470 }
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	471
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	472 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	473 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	474 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	475
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	476 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	477 throw new UnsupportedSpecializationException(findRoot(), getSuppliedChildren());
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	478 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	479
18776 c0fb70634640 Truffle-DSL: support for frame types Frame, MaterializedFrame. Added validation for frame type consistency. Some refactorings along the way. Christian Humer <christian.humer@gmail.com> parents: 18766 diff changeset	480 protected Object unsupported(Frame frame, Object o1) {
19289 62c43fcf5be2 Truffle-DSL: implement @Cached and fixes for the new guard expression syntax. Christian Humer <christian.humer@gmail.com> parents: 19281 diff changeset	481 throw new UnsupportedSpecializationException(findRoot(), getSuppliedChildren(), o1);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	482 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	483
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, 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	485 throw new UnsupportedSpecializationException(findRoot(), getSuppliedChildren(), o1, o2);
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
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	488 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	489 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	490 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	491
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	492 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	493 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	494 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	495
18802 71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	496 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	497 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	498 }
71e372cae32e Truffle-DSL: increase maximum number of acceptAndExecute arguments to 5. Christian Humer <christian.humer@gmail.com> parents: 18776 diff changeset	499
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	500 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	501 throw new UnsupportedSpecializationException(findRoot(), getSuppliedChildren(), args);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	502 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	503
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	504 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	505 if (merged == generated) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	506 // new node
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	507 if (start.count() == 2) {
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	508 insertAt(start, start.createPolymorphic(), "insert polymorphic");
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	509 }
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	510 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	511 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	512 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	513 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	514 return insertAt(current, generated, message);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	515 } else {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	516 // 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	517 return start;
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	518 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	519 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	520
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	521 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	522 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	523 // 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	524 return NodeUtil.nonAtomicReplace(node, insertBefore, reason);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	525 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	526
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	527 @Override
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	528 public final String toString() {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	529 Class<?> clazz = getClass();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	530 StringBuilder b = new StringBuilder();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	531 b.append(clazz.getSimpleName());
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	532
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	533 appendFields(b, clazz);
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	534 if (next != null) {
19291 f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	535 b.append("\n -> ").append(next.toString());
18761 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 return b.toString();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	538 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	539
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	540 private void appendFields(StringBuilder b, Class<?> clazz) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	541 Field[] fields = clazz.getDeclaredFields();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	542 if (fields.length == 0) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	543 return;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	544 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	545 b.append("(");
19291 f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	546 String sep = "";
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	547 for (Field field : fields) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	548 if (Modifier.isStatic(field.getModifiers())) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	549 continue;
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	550 }
19291 f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	551 b.append(sep);
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	552 String name = field.getName();
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	553 if (name.equals("root")) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	554 continue;
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 b.append(field.getName());
19291 f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	557 b.append(" = ");
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	558 try {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	559 field.setAccessible(true);
19291 f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	560 Object value = field.get(this);
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	561 if (value instanceof Object[]) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	562 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	563 } else {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	564 b.append(field.get(this));
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	565 }
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	566 } catch (IllegalArgumentException e) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	567 b.append(e.toString());
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	568 } catch (IllegalAccessException e) {
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	569 b.append(e.toString());
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	570 }
19291 f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	571 sep = ", ";
18761 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(")");
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	574 }
a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	575
19291 f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	576 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	577 if (assumption != null) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	578 assumption.check();
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	579 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	580 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	581
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	582 @ExplodeLoop
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	583 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	584 if (assumptions != null) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	585 CompilerAsserts.compilationConstant(assumptions.length);
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	586 for (Assumption assumption : assumptions) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	587 check(assumption);
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	588 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	589 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	590 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	591
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	592 protected static boolean isValid(Assumption assumption) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	593 if (assumption != null) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	594 return assumption.isValid();
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	595 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	596 return true;
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 protected static boolean isValid(Assumption[] assumptions) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	600 if (assumptions != null) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	601 for (Assumption assumption : assumptions) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	602 if (!isValid(assumption)) {
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	603 return false;
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	604 }
f4792a544170 Truffle-DSL: implement new assumptions semantics. Christian Humer <christian.humer@gmail.com> parents: 19289 diff changeset	605 }
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 return true;
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
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	610 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	611
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	612 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	613 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	614 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	615
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	616 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	617 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	618 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	619 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	620 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations. Christian Humer <christian.humer@gmail.com> parents: 19768 diff changeset	621 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	622 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	623 }
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	624 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	625 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	626 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	627 } 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	628 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	629 }
e8d2f3f95dcd Truffle-DSL: 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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	634 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	635
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	636 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	637 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	638 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	639
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	640 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	641 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	642 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	643 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	644 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations. Christian Humer <christian.humer@gmail.com> parents: 19768 diff changeset	645 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	646 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	647 }
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	648 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	649 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	650 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	651 } 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	652 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	653 }
e8d2f3f95dcd Truffle-DSL: 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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	658 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	659
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	660 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	661 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	662 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	663
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	664 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	665 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	666 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	667 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	668 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations. Christian Humer <christian.humer@gmail.com> parents: 19768 diff changeset	669 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	670 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	671 }
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	672 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	673 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	674 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	675 } 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	676 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	677 }
e8d2f3f95dcd Truffle-DSL: 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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	682 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	683
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	684 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	685 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	686 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	687
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	688 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	689 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	690 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	691 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	692 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations. Christian Humer <christian.humer@gmail.com> parents: 19768 diff changeset	693 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	694 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	695 }
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	696 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	697 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	698 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	699 } 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	700 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	701 }
e8d2f3f95dcd Truffle-DSL: 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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	706 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	707
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	708 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	709 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	710 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	711
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	712 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	713 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	714 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	715 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	716 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations. Christian Humer <christian.humer@gmail.com> parents: 19768 diff changeset	717 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	718 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	719 }
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	720 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	721 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	722 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	723 } 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	724 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	725 }
e8d2f3f95dcd Truffle-DSL: 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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	730 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	731
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	732 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	733 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	734 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	735
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	736 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	737 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	738 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	739 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	740 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations. Christian Humer <christian.humer@gmail.com> parents: 19768 diff changeset	741 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	742 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	743 }
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	744 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	745 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	746 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	747 } 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	748 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	749 }
e8d2f3f95dcd Truffle-DSL: 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 }
e8d2f3f95dcd Truffle-DSL: 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
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	754 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	755
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	756 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	757 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	758 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	759
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	760 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	761 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	762 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	763 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	764 }
7108d2319169 Truffle-DSL: make the whole specialization block atomic to avoid unnecessary node allocations. Christian Humer <christian.humer@gmail.com> parents: 19768 diff changeset	765 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	766 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	767 }
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	768 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	769 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	770 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	771 } 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	772 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	773 }
e8d2f3f95dcd Truffle-DSL: 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 }
e8d2f3f95dcd Truffle-DSL: 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 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	778
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	779 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	780 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	781 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	782
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	783 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	784 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	785 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	786
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	787 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	788
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	789 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	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 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	792 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	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
e8d2f3f95dcd Truffle-DSL: 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 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	796 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	797 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	798
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	799 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	800
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	801 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	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 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	804 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	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
e8d2f3f95dcd Truffle-DSL: 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 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	808 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	809 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	810
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	811 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	812
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	813 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	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 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	816 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	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
e8d2f3f95dcd Truffle-DSL: 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 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	820 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	821 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	822
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	823 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	824
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	825 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	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 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	828 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	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
e8d2f3f95dcd Truffle-DSL: 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 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	832 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	833 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	834
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	835 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	836
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	837 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	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 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	840 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	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
e8d2f3f95dcd Truffle-DSL: 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 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	844 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	845 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	846
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	847 }
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	848
e8d2f3f95dcd Truffle-DSL: implemented duplication check for specializations with @Cached to avoid duplicates for multithreaded AST execution. Christian Humer <christian.humer@gmail.com> parents: 19291 diff changeset	849 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	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 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	852 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	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
e8d2f3f95dcd Truffle-DSL: 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 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	856 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	857 }
e8d2f3f95dcd Truffle-DSL: 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
18761 a665483c3881 Truffle-DSL: new node layout implementation. Christian Humer <christian.humer@gmail.com> parents: diff changeset	860 }

Mercurial > hg > truffle

annotate graal/com.oracle.truffle.api.dsl/src/com/oracle/truffle/api/dsl/internal/SpecializationNode.java @ 19770:7108d2319169