Mercurial > hg > graal-compiler
view graal/com.oracle.max.graal.nodes/src/com/oracle/max/graal/nodes/spi/EscapeOp.java @ 4411:cd2b68ef8e23
cleanup around filter and predicates :
remove duplicate compiler.util.NodeIterators
add contains to NodeIterable
support isNotA(Class).nor(Class) filtering
support filtering on interfaces
remove and/or(Class) from FilteredNodeIterable replace with isA(Class).or(Class)
lower the cost on extending NodeIterable (remove the until field)
NodeList is a NodeIterable
Use NodeIterable functions where possible
author | Gilles Duboscq <duboscq@ssw.jku.at> |
---|---|
date | Mon, 30 Jan 2012 13:06:11 +0100 |
parents | 4a609a685fa4 |
children | 539fca6a3b98 |
line wrap: on
line source
/* * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package com.oracle.max.graal.nodes.spi; import java.util.*; import com.oracle.max.cri.ci.*; import com.oracle.max.graal.graph.*; import com.oracle.max.graal.nodes.*; import com.oracle.max.graal.nodes.calc.*; import com.oracle.max.graal.nodes.java.*; import com.oracle.max.graal.nodes.virtual.*; public abstract class EscapeOp { public abstract boolean canAnalyze(Node node); public boolean escape(Node node, Node usage) { if (usage instanceof NullCheckNode) { assert ((NullCheckNode) usage).object() == node; return false; } else if (usage instanceof IsTypeNode) { assert ((IsTypeNode) usage).object() == node; return false; } else if (usage instanceof FrameState) { assert usage.inputs().contains(node); return true; } else if (usage instanceof AccessMonitorNode) { assert ((AccessMonitorNode) usage).object() == node; return false; } else if (usage instanceof LoadFieldNode) { assert ((LoadFieldNode) usage).object() == node; return false; } else if (usage instanceof StoreFieldNode) { StoreFieldNode x = (StoreFieldNode) usage; // self-references do escape return x.value() == node; // TODO(tw) Check if we can add this condition? && x.object() != node; } else if (usage instanceof LoadIndexedNode) { LoadIndexedNode x = (LoadIndexedNode) usage; if (x.index() == node) { return true; } else { assert x.array() == node; return !isValidConstantIndex(x); } } else if (usage instanceof StoreIndexedNode) { StoreIndexedNode x = (StoreIndexedNode) usage; if (x.index() == node) { return true; } else { assert x.array() == node || x.value() == node; // in order to not escape the access needs to have a valid constant index and either a store into node or self-referencing return !isValidConstantIndex(x) || x.value() == node && x.array() != node; } } else if (usage instanceof VirtualObjectFieldNode) { return false; } else if (usage instanceof RegisterFinalizerNode) { assert ((RegisterFinalizerNode) usage).object() == node; return false; } else if (usage instanceof ArrayLengthNode) { assert ((ArrayLengthNode) usage).array() == node; return false; } else { return true; } } public static boolean isValidConstantIndex(AccessIndexedNode x) { CiConstant index = x.index().asConstant(); if (x.array() instanceof NewArrayNode) { CiConstant length = ((NewArrayNode) x.array()).dimension(0).asConstant(); return index != null && length != null && index.asInt() >= 0 && index.asInt() < length.asInt(); } else { return false; } } public abstract EscapeField[] fields(Node node); public void beforeUpdate(Node node, Node usage) { // IsNonNullNode and IsTypeNode should have been eliminated by the CanonicalizerPhase, but we can't rely on this if (usage instanceof NullCheckNode) { NullCheckNode x = (NullCheckNode) usage; ((StructuredGraph) x.graph()).replaceFloating(x, ConstantNode.forBoolean(!x.expectedNull, node.graph())); } else if (usage instanceof IsTypeNode) { IsTypeNode x = (IsTypeNode) usage; assert x.type() == ((ValueNode) node).exactType(); ((StructuredGraph) x.graph()).replaceFloating(x, ConstantNode.forBoolean(true, node.graph())); } else if (usage instanceof AccessMonitorNode) { ((AccessMonitorNode) usage).makeEliminated(); } } public abstract int updateState(Node node, Node current, Map<Object, Integer> fieldIndex, ValueNode[] fieldState); }