--- /dev/null 2016-05-31 09:42:47.975716356 -0700 +++ new/src/jdk.vm.compiler/share/classes/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/phases/WriteBarrierVerificationPhase.java 2016-12-07 13:50:36.448389323 -0800 @@ -0,0 +1,182 @@ +/* + * Copyright (c) 2013, 2015, 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 org.graalvm.compiler.hotspot.phases; + +import java.util.Iterator; + +import org.graalvm.compiler.debug.GraalError; +import org.graalvm.compiler.graph.Node; +import org.graalvm.compiler.graph.NodeFlood; +import org.graalvm.compiler.hotspot.GraalHotSpotVMConfig; +import org.graalvm.compiler.hotspot.nodes.ArrayRangeWriteBarrier; +import org.graalvm.compiler.hotspot.nodes.G1PostWriteBarrier; +import org.graalvm.compiler.hotspot.nodes.ObjectWriteBarrier; +import org.graalvm.compiler.hotspot.nodes.SerialWriteBarrier; +import org.graalvm.compiler.nodes.DeoptimizingNode; +import org.graalvm.compiler.nodes.FixedWithNextNode; +import org.graalvm.compiler.nodes.LoopBeginNode; +import org.graalvm.compiler.nodes.StructuredGraph; +import org.graalvm.compiler.nodes.ValueNode; +import org.graalvm.compiler.nodes.extended.ArrayRangeWriteNode; +import org.graalvm.compiler.nodes.java.LoweredAtomicReadAndWriteNode; +import org.graalvm.compiler.nodes.java.LoweredCompareAndSwapNode; +import org.graalvm.compiler.nodes.memory.FixedAccessNode; +import org.graalvm.compiler.nodes.memory.HeapAccess; +import org.graalvm.compiler.nodes.memory.HeapAccess.BarrierType; +import org.graalvm.compiler.nodes.memory.ReadNode; +import org.graalvm.compiler.nodes.memory.WriteNode; +import org.graalvm.compiler.nodes.memory.address.OffsetAddressNode; +import org.graalvm.compiler.nodes.type.StampTool; +import org.graalvm.compiler.phases.Phase; + +/** + * Verification phase that checks if, for every write, at least one write barrier is present at all + * paths leading to the previous safepoint. For every write, necessitating a write barrier, a + * bottom-up traversal of the graph is performed up to the previous safepoints via all possible + * paths. If, for a certain path, no write barrier satisfying the processed write is found, an + * assertion is generated. + */ +public class WriteBarrierVerificationPhase extends Phase { + + private final GraalHotSpotVMConfig config; + + public WriteBarrierVerificationPhase(GraalHotSpotVMConfig config) { + this.config = config; + } + + @Override + protected void run(StructuredGraph graph) { + processWrites(graph); + } + + private void processWrites(StructuredGraph graph) { + for (Node node : graph.getNodes()) { + if (isObjectWrite(node) || isObjectArrayRangeWrite(node)) { + validateWrite(node); + } + } + } + + private void validateWrite(Node write) { + /* + * The currently validated write is checked in order to discover if it has an appropriate + * attached write barrier. + */ + if (hasAttachedBarrier((FixedWithNextNode) write)) { + return; + } + NodeFlood frontier = write.graph().createNodeFlood(); + expandFrontier(frontier, write); + Iterator iterator = frontier.iterator(); + while (iterator.hasNext()) { + Node currentNode = iterator.next(); + if (isSafepoint(currentNode)) { + throw new AssertionError("Write barrier must be present " + write); + } + if (useG1GC()) { + if (!(currentNode instanceof G1PostWriteBarrier) || (!validateBarrier((FixedAccessNode) write, (ObjectWriteBarrier) currentNode))) { + expandFrontier(frontier, currentNode); + } + } else { + if (!(currentNode instanceof SerialWriteBarrier) || (!validateBarrier((FixedAccessNode) write, (ObjectWriteBarrier) currentNode)) || + ((currentNode instanceof SerialWriteBarrier) && !validateBarrier((FixedAccessNode) write, (ObjectWriteBarrier) currentNode))) { + expandFrontier(frontier, currentNode); + } + } + } + } + + private boolean useG1GC() { + return config.useG1GC; + } + + private boolean hasAttachedBarrier(FixedWithNextNode node) { + final Node next = node.next(); + final Node previous = node.predecessor(); + final boolean validatePreBarrier = useG1GC() && (isObjectWrite(node) || !((ArrayRangeWriteNode) node).isInitialization()); + if (isObjectWrite(node)) { + return (isObjectBarrier(node, next) || StampTool.isPointerAlwaysNull(getValueWritten(node))) && (!validatePreBarrier || isObjectBarrier(node, previous)); + } else if (isObjectArrayRangeWrite(node)) { + return (isArrayBarrier(node, next) || StampTool.isPointerAlwaysNull(getValueWritten(node))) && (!validatePreBarrier || isArrayBarrier(node, previous)); + } else { + return true; + } + } + + private static boolean isObjectBarrier(FixedWithNextNode node, final Node next) { + return next instanceof ObjectWriteBarrier && validateBarrier((FixedAccessNode) node, (ObjectWriteBarrier) next); + } + + private static boolean isArrayBarrier(FixedWithNextNode node, final Node next) { + return (next instanceof ArrayRangeWriteBarrier) && ((ArrayRangeWriteNode) node).getArray() == ((ArrayRangeWriteBarrier) next).getObject(); + } + + private static boolean isObjectWrite(Node node) { + // Read nodes with barrier attached (G1 Ref field) are not validated yet. + return node instanceof FixedAccessNode && ((HeapAccess) node).getBarrierType() != BarrierType.NONE && !(node instanceof ReadNode); + } + + private static boolean isObjectArrayRangeWrite(Node node) { + return node instanceof ArrayRangeWriteNode && ((ArrayRangeWriteNode) node).isObjectArray(); + } + + private static void expandFrontier(NodeFlood frontier, Node node) { + for (Node previousNode : node.cfgPredecessors()) { + if (previousNode != null) { + frontier.add(previousNode); + } + } + } + + private static boolean isSafepoint(Node node) { + /* + * LoopBegin nodes are also treated as safepoints since a bottom-up analysis is performed + * and loop safepoints are placed before LoopEnd nodes. Possible elimination of write + * barriers inside loops, derived from writes outside loops, can not be permitted. + */ + return ((node instanceof DeoptimizingNode) && ((DeoptimizingNode) node).canDeoptimize()) || (node instanceof LoopBeginNode); + } + + private static ValueNode getValueWritten(FixedWithNextNode write) { + if (write instanceof WriteNode) { + return ((WriteNode) write).value(); + } else if (write instanceof LoweredCompareAndSwapNode) { + return ((LoweredCompareAndSwapNode) write).getNewValue(); + } else if (write instanceof LoweredAtomicReadAndWriteNode) { + return ((LoweredAtomicReadAndWriteNode) write).getNewValue(); + } else { + throw GraalError.shouldNotReachHere(String.format("unexpected write node %s", write)); + } + } + + private static boolean validateBarrier(FixedAccessNode write, ObjectWriteBarrier barrier) { + assert write instanceof WriteNode || write instanceof LoweredCompareAndSwapNode || write instanceof LoweredAtomicReadAndWriteNode : "Node must be of type requiring a write barrier " + write; + if (!barrier.usePrecise()) { + if (barrier.getAddress() instanceof OffsetAddressNode && write.getAddress() instanceof OffsetAddressNode) { + return ((OffsetAddressNode) barrier.getAddress()).getBase() == ((OffsetAddressNode) write.getAddress()).getBase(); + } + } + return barrier.getAddress() == write.getAddress(); + } +}