/*

 * Copyright (c) 2011, 2016, 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.replacements;

import static org.graalvm.compiler.nodes.NamedLocationIdentity.ARRAY_LENGTH_LOCATION;

import static org.graalvm.compiler.nodes.java.ArrayLengthNode.readArrayLength;

import static jdk.vm.ci.code.MemoryBarriers.JMM_POST_VOLATILE_READ;

import static jdk.vm.ci.code.MemoryBarriers.JMM_POST_VOLATILE_WRITE;

import static jdk.vm.ci.code.MemoryBarriers.JMM_PRE_VOLATILE_READ;

import static jdk.vm.ci.code.MemoryBarriers.JMM_PRE_VOLATILE_WRITE;

import static jdk.vm.ci.meta.DeoptimizationAction.InvalidateReprofile;

import static jdk.vm.ci.meta.DeoptimizationReason.BoundsCheckException;

import static jdk.vm.ci.meta.DeoptimizationReason.NullCheckException;

import java.util.ArrayList;

import java.util.BitSet;

import java.util.List;

import org.graalvm.compiler.api.directives.GraalDirectives;

import org.graalvm.compiler.api.replacements.Snippet;

import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;

import org.graalvm.compiler.core.common.LocationIdentity;

import org.graalvm.compiler.core.common.spi.ForeignCallDescriptor;

import org.graalvm.compiler.core.common.spi.ForeignCallsProvider;

import org.graalvm.compiler.core.common.type.IntegerStamp;

import org.graalvm.compiler.core.common.type.ObjectStamp;

import org.graalvm.compiler.core.common.type.Stamp;

import org.graalvm.compiler.core.common.type.StampFactory;

import org.graalvm.compiler.core.common.type.TypeReference;

import org.graalvm.compiler.debug.GraalError;

import org.graalvm.compiler.graph.Node;

import org.graalvm.compiler.nodes.ConstantNode;

import org.graalvm.compiler.nodes.FieldLocationIdentity;

import org.graalvm.compiler.nodes.FixedNode;

import org.graalvm.compiler.nodes.LogicNode;

import org.graalvm.compiler.nodes.NamedLocationIdentity;

import org.graalvm.compiler.nodes.PiNode;

import org.graalvm.compiler.nodes.StructuredGraph;

import org.graalvm.compiler.nodes.ValueNode;

import org.graalvm.compiler.nodes.calc.AddNode;

import org.graalvm.compiler.nodes.calc.IntegerBelowNode;

import org.graalvm.compiler.nodes.calc.IntegerConvertNode;

import org.graalvm.compiler.nodes.calc.IsNullNode;

import org.graalvm.compiler.nodes.calc.LeftShiftNode;

import org.graalvm.compiler.nodes.calc.NarrowNode;

import org.graalvm.compiler.nodes.calc.RightShiftNode;

import org.graalvm.compiler.nodes.calc.SignExtendNode;

import org.graalvm.compiler.nodes.calc.SubNode;

import org.graalvm.compiler.nodes.calc.ZeroExtendNode;

import org.graalvm.compiler.nodes.debug.VerifyHeapNode;

import org.graalvm.compiler.nodes.extended.BoxNode;

import org.graalvm.compiler.nodes.extended.FixedValueAnchorNode;

import org.graalvm.compiler.nodes.extended.ForeignCallNode;

import org.graalvm.compiler.nodes.extended.GuardedUnsafeLoadNode;

import org.graalvm.compiler.nodes.extended.GuardingNode;

import org.graalvm.compiler.nodes.extended.JavaReadNode;

import org.graalvm.compiler.nodes.extended.JavaWriteNode;

import org.graalvm.compiler.nodes.extended.LoadHubNode;

import org.graalvm.compiler.nodes.extended.MembarNode;

import org.graalvm.compiler.nodes.extended.UnboxNode;

import org.graalvm.compiler.nodes.extended.UnsafeLoadNode;

import org.graalvm.compiler.nodes.extended.UnsafeMemoryLoadNode;

import org.graalvm.compiler.nodes.extended.UnsafeMemoryStoreNode;

import org.graalvm.compiler.nodes.extended.UnsafeStoreNode;

import org.graalvm.compiler.nodes.java.AbstractNewArrayNode;

import org.graalvm.compiler.nodes.java.AbstractNewObjectNode;

import org.graalvm.compiler.nodes.java.AccessIndexedNode;

import org.graalvm.compiler.nodes.java.ArrayLengthNode;

import org.graalvm.compiler.nodes.java.AtomicReadAndWriteNode;

import org.graalvm.compiler.nodes.java.CompareAndSwapNode;

import org.graalvm.compiler.nodes.java.FinalFieldBarrierNode;

import org.graalvm.compiler.nodes.java.InstanceOfDynamicNode;

import org.graalvm.compiler.nodes.java.InstanceOfNode;

import org.graalvm.compiler.nodes.java.LoadFieldNode;

import org.graalvm.compiler.nodes.java.LoadIndexedNode;

import org.graalvm.compiler.nodes.java.LoweredAtomicReadAndWriteNode;

import org.graalvm.compiler.nodes.java.LoweredCompareAndSwapNode;

import org.graalvm.compiler.nodes.java.MonitorEnterNode;

import org.graalvm.compiler.nodes.java.MonitorIdNode;

import org.graalvm.compiler.nodes.java.NewArrayNode;

import org.graalvm.compiler.nodes.java.NewInstanceNode;

import org.graalvm.compiler.nodes.java.RawMonitorEnterNode;

import org.graalvm.compiler.nodes.java.StoreFieldNode;

import org.graalvm.compiler.nodes.java.StoreIndexedNode;

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.AddressNode;

import org.graalvm.compiler.nodes.memory.address.OffsetAddressNode;

import org.graalvm.compiler.nodes.memory.address.RawAddressNode;

import org.graalvm.compiler.nodes.spi.Lowerable;

import org.graalvm.compiler.nodes.spi.LoweringProvider;

import org.graalvm.compiler.nodes.spi.LoweringTool;

import org.graalvm.compiler.nodes.type.StampTool;

import org.graalvm.compiler.nodes.util.GraphUtil;

import org.graalvm.compiler.nodes.virtual.AllocatedObjectNode;

import org.graalvm.compiler.nodes.virtual.CommitAllocationNode;

import org.graalvm.compiler.nodes.virtual.VirtualArrayNode;

import org.graalvm.compiler.nodes.virtual.VirtualInstanceNode;

import org.graalvm.compiler.nodes.virtual.VirtualObjectNode;

import org.graalvm.compiler.phases.util.Providers;

import org.graalvm.compiler.replacements.nodes.BinaryMathIntrinsicNode;

import org.graalvm.compiler.replacements.nodes.BinaryMathIntrinsicNode.BinaryOperation;

import org.graalvm.compiler.replacements.nodes.UnaryMathIntrinsicNode;

import org.graalvm.compiler.replacements.nodes.UnaryMathIntrinsicNode.UnaryOperation;

import jdk.vm.ci.code.CodeUtil;

import jdk.vm.ci.code.MemoryBarriers;

import jdk.vm.ci.code.TargetDescription;

import jdk.vm.ci.meta.DeoptimizationAction;

import jdk.vm.ci.meta.DeoptimizationReason;

import jdk.vm.ci.meta.JavaConstant;

import jdk.vm.ci.meta.JavaKind;

import jdk.vm.ci.meta.MetaAccessProvider;

import jdk.vm.ci.meta.ResolvedJavaField;

import jdk.vm.ci.meta.ResolvedJavaMethod;

import jdk.vm.ci.meta.ResolvedJavaType;

/**

 * VM-independent lowerings for standard Java nodes. VM-specific methods are abstract and must be

 * implemented by VM-specific subclasses.

 */

public abstract class DefaultJavaLoweringProvider implements LoweringProvider {

    protected final MetaAccessProvider metaAccess;

    protected final ForeignCallsProvider foreignCalls;

    protected final TargetDescription target;

    private BoxingSnippets.Templates boxingSnippets;

    public DefaultJavaLoweringProvider(MetaAccessProvider metaAccess, ForeignCallsProvider foreignCalls, TargetDescription target) {

        this.metaAccess = metaAccess;

        this.foreignCalls = foreignCalls;

        this.target = target;

    }

    public void initialize(Providers providers, SnippetReflectionProvider snippetReflection) {

        boxingSnippets = new BoxingSnippets.Templates(providers, snippetReflection, target);

        providers.getReplacements().registerSnippetTemplateCache(new SnippetCounterNode.SnippetCounterSnippets.Templates(providers, snippetReflection, target));

    }

    public final TargetDescription getTarget() {

        return target;

    }

    @Override

    public void lower(Node n, LoweringTool tool) {

        assert n instanceof Lowerable;

        StructuredGraph graph = (StructuredGraph) n.graph();

        if (n instanceof LoadFieldNode) {

            lowerLoadFieldNode((LoadFieldNode) n, tool);

        } else if (n instanceof StoreFieldNode) {

            lowerStoreFieldNode((StoreFieldNode) n, tool);

        } else if (n instanceof LoadIndexedNode) {

            lowerLoadIndexedNode((LoadIndexedNode) n, tool);

        } else if (n instanceof StoreIndexedNode) {

            lowerStoreIndexedNode((StoreIndexedNode) n, tool);

        } else if (n instanceof ArrayLengthNode) {

            lowerArrayLengthNode((ArrayLengthNode) n, tool);

        } else if (n instanceof LoadHubNode) {

            lowerLoadHubNode((LoadHubNode) n, tool);

        } else if (n instanceof MonitorEnterNode) {

            lowerMonitorEnterNode((MonitorEnterNode) n, tool, graph);

        } else if (n instanceof CompareAndSwapNode) {

            lowerCompareAndSwapNode((CompareAndSwapNode) n);

        } else if (n instanceof AtomicReadAndWriteNode) {

            lowerAtomicReadAndWriteNode((AtomicReadAndWriteNode) n);

        } else if (n instanceof UnsafeLoadNode) {

            lowerUnsafeLoadNode((UnsafeLoadNode) n, tool);

        } else if (n instanceof UnsafeMemoryLoadNode) {

            lowerUnsafeMemoryLoadNode((UnsafeMemoryLoadNode) n);

        } else if (n instanceof UnsafeStoreNode) {

            lowerUnsafeStoreNode((UnsafeStoreNode) n);

        } else if (n instanceof UnsafeMemoryStoreNode) {

            lowerUnsafeMemoryStoreNode((UnsafeMemoryStoreNode) n);

        } else if (n instanceof JavaReadNode) {

            lowerJavaReadNode((JavaReadNode) n);

        } else if (n instanceof JavaWriteNode) {

            lowerJavaWriteNode((JavaWriteNode) n);

        } else if (n instanceof CommitAllocationNode) {

            lowerCommitAllocationNode((CommitAllocationNode) n, tool);

        } else if (n instanceof BoxNode) {

            boxingSnippets.lower((BoxNode) n, tool);

        } else if (n instanceof UnboxNode) {

            boxingSnippets.lower((UnboxNode) n, tool);

        } else if (n instanceof VerifyHeapNode) {

            lowerVerifyHeap((VerifyHeapNode) n);

        } else if (n instanceof UnaryMathIntrinsicNode) {

            lowerUnaryMath((UnaryMathIntrinsicNode) n, tool);

        } else if (n instanceof BinaryMathIntrinsicNode) {

            lowerBinaryMath((BinaryMathIntrinsicNode) n, tool);

        } else {

            throw GraalError.shouldNotReachHere("Node implementing Lowerable not handled: " + n);

        }

    }

    private void lowerBinaryMath(BinaryMathIntrinsicNode math, LoweringTool tool) {

        if (tool.getLoweringStage() == LoweringTool.StandardLoweringStage.HIGH_TIER) {

            return;

        }

        ResolvedJavaMethod method = math.graph().method();

        if (method != null) {

            if (method.getAnnotation(Snippet.class) != null) {

                /*

                 * In the context of the snippet use the LIR lowering instead of the Node lowering.

                 */

                return;

            }

            if (method.getName().equalsIgnoreCase(math.getOperation().name()) && tool.getMetaAccess().lookupJavaType(Math.class).equals(method.getDeclaringClass())) {

                /*

                 * A root compilation of the intrinsic method should emit the full assembly

                 * implementation.

                 */

                return;

            }

        }

        ForeignCallDescriptor foreignCall = toForeignCall(math.getOperation());

        if (foreignCall != null) {

            StructuredGraph graph = math.graph();

            ForeignCallNode call = graph.add(new ForeignCallNode(foreignCalls, toForeignCall(math.getOperation()), math.getX(), math.getY()));

            graph.addAfterFixed(tool.lastFixedNode(), call);

            math.replaceAtUsages(call);

        }

    }

    private void lowerUnaryMath(UnaryMathIntrinsicNode math, LoweringTool tool) {

        if (tool.getLoweringStage() == LoweringTool.StandardLoweringStage.HIGH_TIER) {

            return;

        }

        ResolvedJavaMethod method = math.graph().method();

        if (method != null) {

            if (method.getAnnotation(Snippet.class) != null) {

                /*

                 * In the context of the snippet use the LIR lowering instead of the Node lowering.

                 */

                return;

            }

            if (method.getName().equalsIgnoreCase(math.getOperation().name()) && tool.getMetaAccess().lookupJavaType(Math.class).equals(method.getDeclaringClass())) {

                /*

                 * A root compilation of the intrinsic method should emit the full assembly

                 * implementation.

                 */

                return;

            }

        }

        ForeignCallDescriptor foreignCall = toForeignCall(math.getOperation());

        if (foreignCall != null) {

            StructuredGraph graph = math.graph();

            ForeignCallNode call = math.graph().add(new ForeignCallNode(foreignCalls, foreignCall, math.getValue()));

            graph.addAfterFixed(tool.lastFixedNode(), call);

            math.replaceAtUsages(call);

        }

    }

    protected ForeignCallDescriptor toForeignCall(UnaryOperation operation) {

        return operation.foreignCallDescriptor;

    }

    protected ForeignCallDescriptor toForeignCall(BinaryOperation operation) {

        return operation.foreignCallDescriptor;

    }

    protected void lowerVerifyHeap(VerifyHeapNode n) {

        GraphUtil.removeFixedWithUnusedInputs(n);

    }

    protected AddressNode createOffsetAddress(StructuredGraph graph, ValueNode object, long offset) {

        ValueNode o = ConstantNode.forIntegerKind(target.wordJavaKind, offset, graph);

        return graph.unique(new OffsetAddressNode(object, o));

    }

    protected AddressNode createFieldAddress(StructuredGraph graph, ValueNode object, ResolvedJavaField field) {

        int offset = fieldOffset(field);

        if (offset >= 0) {

            return createOffsetAddress(graph, object, offset);

        } else {

            return null;

        }

    }

    protected void lowerLoadFieldNode(LoadFieldNode loadField, LoweringTool tool) {

        assert loadField.getStackKind() != JavaKind.Illegal;

        StructuredGraph graph = loadField.graph();

        ResolvedJavaField field = loadField.field();

        ValueNode object = loadField.isStatic() ? staticFieldBase(graph, field) : loadField.object();

        Stamp loadStamp = loadStamp(loadField.stamp(), field.getJavaKind());

        AddressNode address = createFieldAddress(graph, object, field);

        assert address != null : "Field that is loaded must not be eliminated: " + field.getDeclaringClass().toJavaName(true) + "." + field.getName();

        ReadNode memoryRead = graph.add(new ReadNode(address, fieldLocationIdentity(field), loadStamp, fieldLoadBarrierType(field)));

        ValueNode readValue = implicitLoadConvert(graph, field.getJavaKind(), memoryRead);

        loadField.replaceAtUsages(readValue);

        graph.replaceFixed(loadField, memoryRead);

        memoryRead.setGuard(createNullCheck(object, memoryRead, tool));

        if (loadField.isVolatile()) {

            MembarNode preMembar = graph.add(new MembarNode(JMM_PRE_VOLATILE_READ));

            graph.addBeforeFixed(memoryRead, preMembar);

            MembarNode postMembar = graph.add(new MembarNode(JMM_POST_VOLATILE_READ));

            graph.addAfterFixed(memoryRead, postMembar);

        }

    }

    protected void lowerStoreFieldNode(StoreFieldNode storeField, LoweringTool tool) {

        StructuredGraph graph = storeField.graph();

        ResolvedJavaField field = storeField.field();

        ValueNode object = storeField.isStatic() ? staticFieldBase(graph, field) : storeField.object();

        ValueNode value = implicitStoreConvert(graph, storeField.field().getJavaKind(), storeField.value());

        AddressNode address = createFieldAddress(graph, object, field);

        assert address != null;

        WriteNode memoryWrite = graph.add(new WriteNode(address, fieldLocationIdentity(field), value, fieldStoreBarrierType(storeField.field())));

        memoryWrite.setStateAfter(storeField.stateAfter());

        graph.replaceFixedWithFixed(storeField, memoryWrite);

        memoryWrite.setGuard(createNullCheck(object, memoryWrite, tool));

        if (storeField.isVolatile()) {

            MembarNode preMembar = graph.add(new MembarNode(JMM_PRE_VOLATILE_WRITE));

            graph.addBeforeFixed(memoryWrite, preMembar);

            MembarNode postMembar = graph.add(new MembarNode(JMM_POST_VOLATILE_WRITE));

            graph.addAfterFixed(memoryWrite, postMembar);

        }

    }

    public AddressNode createArrayAddress(StructuredGraph graph, ValueNode array, JavaKind elementKind, ValueNode index) {

        ValueNode wordIndex;

        if (target.wordSize > 4) {

            wordIndex = graph.unique(new SignExtendNode(index, target.wordSize * 8));

        } else {

            assert target.wordSize == 4 : "unsupported word size";

            wordIndex = index;

        }

        int shift = CodeUtil.log2(arrayScalingFactor(elementKind));

        ValueNode scaledIndex = graph.unique(new LeftShiftNode(wordIndex, ConstantNode.forInt(shift, graph)));

        int base = arrayBaseOffset(elementKind);

        ValueNode offset = graph.unique(new AddNode(scaledIndex, ConstantNode.forIntegerKind(target.wordJavaKind, base, graph)));

        return graph.unique(new OffsetAddressNode(array, offset));

    }

    protected void lowerLoadIndexedNode(LoadIndexedNode loadIndexed, LoweringTool tool) {

        StructuredGraph graph = loadIndexed.graph();

        JavaKind elementKind = loadIndexed.elementKind();

        Stamp loadStamp = loadStamp(loadIndexed.stamp(), elementKind);

        PiNode pi = getBoundsCheckedIndex(loadIndexed, tool, null);

        ValueNode checkedIndex = pi;

        if (checkedIndex == null) {

            checkedIndex = loadIndexed.index();

        }

        AddressNode address = createArrayAddress(graph, loadIndexed.array(), elementKind, checkedIndex);

        ReadNode memoryRead = graph.add(new ReadNode(address, NamedLocationIdentity.getArrayLocation(elementKind), loadStamp, BarrierType.NONE));

        ValueNode readValue = implicitLoadConvert(graph, elementKind, memoryRead);

        if (pi != null) {

            memoryRead.setGuard(pi.getGuard());

        }

        loadIndexed.replaceAtUsages(readValue);

        graph.replaceFixed(loadIndexed, memoryRead);

    }

    protected void lowerStoreIndexedNode(StoreIndexedNode storeIndexed, LoweringTool tool) {

        StructuredGraph graph = storeIndexed.graph();

        GuardingNode[] nullCheckReturn = new GuardingNode[1];

        PiNode pi = getBoundsCheckedIndex(storeIndexed, tool, nullCheckReturn);

        ValueNode checkedIndex;

        GuardingNode boundsCheck;

        if (pi == null) {

            checkedIndex = storeIndexed.index();

            boundsCheck = null;

        } else {

            checkedIndex = pi;

            boundsCheck = pi.getGuard();

        }

        JavaKind elementKind = storeIndexed.elementKind();

        ValueNode value = storeIndexed.value();

        ValueNode array = storeIndexed.array();

        LogicNode condition = null;

        if (elementKind == JavaKind.Object && !StampTool.isPointerAlwaysNull(value)) {

            /* Array store check. */

            TypeReference arrayType = StampTool.typeReferenceOrNull(array);

            if (arrayType != null && arrayType.isExact()) {

                ResolvedJavaType elementType = arrayType.getType().getComponentType();

                if (!elementType.isJavaLangObject()) {

                    TypeReference typeReference = TypeReference.createTrusted(storeIndexed.graph().getAssumptions(), elementType);

                    LogicNode typeTest = graph.addOrUniqueWithInputs(InstanceOfNode.create(typeReference, value));

                    condition = LogicNode.or(graph.unique(IsNullNode.create(value)), typeTest, GraalDirectives.UNLIKELY_PROBABILITY);

                }

            } else {

                /*

                 * The guard on the read hub should be the null check of the array that was

                 * introduced earlier.

                 */

                GuardingNode nullCheck = nullCheckReturn[0];

                assert nullCheckReturn[0] != null || createNullCheck(array, storeIndexed, tool) == null;

                ValueNode arrayClass = createReadHub(graph, graph.unique(new PiNode(array, (ValueNode) nullCheck)), tool);

                ValueNode componentHub = createReadArrayComponentHub(graph, arrayClass, storeIndexed);

                LogicNode typeTest = graph.unique(InstanceOfDynamicNode.create(graph.getAssumptions(), tool.getConstantReflection(), componentHub, value, false));

                condition = LogicNode.or(graph.unique(IsNullNode.create(value)), typeTest, GraalDirectives.UNLIKELY_PROBABILITY);

            }

        }

        AddressNode address = createArrayAddress(graph, array, elementKind, checkedIndex);

        WriteNode memoryWrite = graph.add(new WriteNode(address, NamedLocationIdentity.getArrayLocation(elementKind), implicitStoreConvert(graph, elementKind, value),

                        arrayStoreBarrierType(storeIndexed.elementKind())));

        memoryWrite.setGuard(boundsCheck);

        if (condition != null) {

            GuardingNode storeCheckGuard = tool.createGuard(storeIndexed, condition, DeoptimizationReason.ArrayStoreException, DeoptimizationAction.InvalidateReprofile);

            memoryWrite.setStoreCheckGuard(storeCheckGuard);

        }

        memoryWrite.setStateAfter(storeIndexed.stateAfter());

        graph.replaceFixedWithFixed(storeIndexed, memoryWrite);

    }

    protected void lowerArrayLengthNode(ArrayLengthNode arrayLengthNode, LoweringTool tool) {

        StructuredGraph graph = arrayLengthNode.graph();

        ValueNode array = arrayLengthNode.array();

        AddressNode address = createOffsetAddress(graph, array, arrayLengthOffset());

        ReadNode arrayLengthRead = graph.add(new ReadNode(address, ARRAY_LENGTH_LOCATION, StampFactory.positiveInt(), BarrierType.NONE));

        arrayLengthRead.setGuard(createNullCheck(array, arrayLengthNode, tool));

        graph.replaceFixedWithFixed(arrayLengthNode, arrayLengthRead);

    }

    protected void lowerLoadHubNode(LoadHubNode loadHub, LoweringTool tool) {

        StructuredGraph graph = loadHub.graph();

        if (tool.getLoweringStage() != LoweringTool.StandardLoweringStage.LOW_TIER) {

            return;

        }

        if (graph.getGuardsStage().allowsFloatingGuards()) {

            return;

        }

        ValueNode hub = createReadHub(graph, loadHub.getValue(), tool);

        loadHub.replaceAtUsagesAndDelete(hub);

    }

    protected void lowerMonitorEnterNode(MonitorEnterNode monitorEnter, LoweringTool tool, StructuredGraph graph) {

        ValueNode object = monitorEnter.object();

        GuardingNode nullCheck = createNullCheck(object, monitorEnter, tool);

        if (nullCheck != null) {

            object = graph.unique(new PiNode(object, ((ObjectStamp) object.stamp()).improveWith(StampFactory.objectNonNull()), (ValueNode) nullCheck));

        }

        ValueNode hub = graph.addOrUnique(LoadHubNode.create(object, tool.getStampProvider(), tool.getMetaAccess(), tool.getConstantReflection()));

        RawMonitorEnterNode rawMonitorEnter = graph.add(new RawMonitorEnterNode(object, hub, monitorEnter.getMonitorId()));

        rawMonitorEnter.setStateBefore(monitorEnter.stateBefore());

        rawMonitorEnter.setStateAfter(monitorEnter.stateAfter());

        graph.replaceFixedWithFixed(monitorEnter, rawMonitorEnter);

    }

    protected void lowerCompareAndSwapNode(CompareAndSwapNode cas) {

        StructuredGraph graph = cas.graph();

        JavaKind valueKind = cas.getValueKind();

        ValueNode expectedValue = implicitStoreConvert(graph, valueKind, cas.expected());

        ValueNode newValue = implicitStoreConvert(graph, valueKind, cas.newValue());

        AddressNode address = graph.unique(new OffsetAddressNode(cas.object(), cas.offset()));

        LoweredCompareAndSwapNode atomicNode = graph.add(new LoweredCompareAndSwapNode(address, cas.getLocationIdentity(), expectedValue, newValue, compareAndSwapBarrierType(cas)));

        atomicNode.setStateAfter(cas.stateAfter());

        graph.replaceFixedWithFixed(cas, atomicNode);

    }

    protected void lowerAtomicReadAndWriteNode(AtomicReadAndWriteNode n) {

        StructuredGraph graph = n.graph();

        JavaKind valueKind = n.getValueKind();

        ValueNode newValue = implicitStoreConvert(graph, valueKind, n.newValue());

        AddressNode address = graph.unique(new OffsetAddressNode(n.object(), n.offset()));

        LoweredAtomicReadAndWriteNode memoryRead = graph.add(new LoweredAtomicReadAndWriteNode(address, n.getLocationIdentity(), newValue, atomicReadAndWriteBarrierType(n)));

        memoryRead.setStateAfter(n.stateAfter());

        ValueNode readValue = implicitLoadConvert(graph, valueKind, memoryRead);

        n.stateAfter().replaceFirstInput(n, memoryRead);

        n.replaceAtUsages(readValue);

        graph.replaceFixedWithFixed(n, memoryRead);

    }

    /**

     * @param tool utility for performing the lowering

     */

    protected void lowerUnsafeLoadNode(UnsafeLoadNode load, LoweringTool tool) {

        StructuredGraph graph = load.graph();

        if (load instanceof GuardedUnsafeLoadNode) {

            GuardedUnsafeLoadNode guardedLoad = (GuardedUnsafeLoadNode) load;

            GuardingNode guard = guardedLoad.getGuard();

            if (guard == null) {

                // can float freely if the guard folded away

                ReadNode memoryRead = createUnsafeRead(graph, load, null);

                memoryRead.setForceFixed(false);

                graph.replaceFixedWithFixed(load, memoryRead);

            } else {

                // must be guarded, but flows below the guard

                ReadNode memoryRead = createUnsafeRead(graph, load, guard);

                graph.replaceFixedWithFixed(load, memoryRead);

            }

        } else {

            // never had a guarding condition so it must be fixed, creation of the read will force