/*

 * Copyright (c) 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.nodes.graphbuilderconf;

import static jdk.vm.ci.code.BytecodeFrame.AFTER_BCI;

import static jdk.vm.ci.code.BytecodeFrame.AFTER_EXCEPTION_BCI;

import static jdk.vm.ci.code.BytecodeFrame.BEFORE_BCI;

import static jdk.vm.ci.code.BytecodeFrame.INVALID_FRAMESTATE_BCI;

import static org.graalvm.compiler.nodes.graphbuilderconf.IntrinsicContext.CompilationContext.INLINE_AFTER_PARSING;

import static org.graalvm.compiler.nodes.graphbuilderconf.IntrinsicContext.CompilationContext.ROOT_COMPILATION;

import org.graalvm.compiler.bytecode.BytecodeProvider;

import org.graalvm.compiler.graph.NodeSourcePosition;

import org.graalvm.compiler.nodes.AbstractMergeNode;

import org.graalvm.compiler.nodes.FrameState;

import org.graalvm.compiler.nodes.Invoke;

import org.graalvm.compiler.nodes.StateSplit;

import org.graalvm.compiler.nodes.StructuredGraph;

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

import jdk.vm.ci.meta.ResolvedJavaMethod;

/**

 * An intrinsic is a substitute implementation of a Java method (or a bytecode in the case of

 * snippets) that is itself implemented in Java. This interface provides information about the

 * intrinsic currently being processed by the graph builder.

 *

 * When in the scope of an intrinsic, the graph builder does not check the value kinds flowing

 * through the JVM state since intrinsics can employ non-Java kinds to represent values such as raw

 * machine words and pointers.

 */

public class IntrinsicContext {

    /**

     * Method being intrinsified.

     */

    final ResolvedJavaMethod method;

    /**

     * Method providing the intrinsic implementation.

     */

    final ResolvedJavaMethod intrinsic;

    /**

     * Provider of bytecode to be parsed for a method that is part of an intrinsic.

     */

    final BytecodeProvider bytecodeProvider;

    /**

     * Gets the method being intrinsified.

     */

    public ResolvedJavaMethod getOriginalMethod() {

        return method;

    }

    /**

     * Gets the method providing the intrinsic implementation.

     */

    public ResolvedJavaMethod getIntrinsicMethod() {

        return intrinsic;

    }

    /**

     * Gets provider of bytecode to be parsed for a method that is part of an intrinsic.

     */

    public BytecodeProvider getBytecodeProvider() {

        return bytecodeProvider;

    }

    /**

     * Determines if a call within the compilation scope of this intrinsic represents a call to the

     * {@linkplain #getOriginalMethod() original} method. This denotes the path where a partial

     * intrinsification falls back to the original method.

     */

    public boolean isCallToOriginal(ResolvedJavaMethod targetMethod) {

        return method.equals(targetMethod) || intrinsic.equals(targetMethod);

    }

    public boolean isPostParseInlined() {

        return compilationContext.equals(INLINE_AFTER_PARSING);

    }

    public boolean isCompilationRoot() {

        return compilationContext.equals(ROOT_COMPILATION);

    }

    /**

     * Denotes the compilation context in which an intrinsic is being parsed.

     */

    public enum CompilationContext {

        /**

         * An intrinsic is being processed when parsing an invoke bytecode that calls the

         * intrinsified method.

         */

        INLINE_DURING_PARSING,

        /**

         * An intrinsic is being processed when inlining an {@link Invoke} in an existing graph.

         */

        INLINE_AFTER_PARSING,

        /**

         * An intrinsic is the root of compilation.

         */

        ROOT_COMPILATION

    }

    /**

     * Models the state of a graph in terms of {@link StateSplit#hasSideEffect() side effects} that

     * are control flow predecessors of the current point in a graph.

     */

    public interface SideEffectsState {

        /**

         * Determines if the current program point is preceded by one or more side effects.

         */

        boolean isAfterSideEffect();

        /**

         * Gets the side effects preceding the current program point.

         */

        Iterable<StateSplit> sideEffects();

        /**

         * Records a side effect for the current program point.

         */

        void addSideEffect(StateSplit sideEffect);

    }

    public FrameState createFrameState(StructuredGraph graph, SideEffectsState sideEffects, StateSplit forStateSplit, NodeSourcePosition sourcePosition) {

        assert forStateSplit != graph.start();

        if (forStateSplit.hasSideEffect()) {

            if (sideEffects.isAfterSideEffect()) {

                // Only the last side effect on any execution path in a replacement

                // can inherit the stateAfter of the replaced node

                FrameState invalid = graph.add(new FrameState(INVALID_FRAMESTATE_BCI));

                invalid.setNodeSourcePosition(sourcePosition);

                for (StateSplit lastSideEffect : sideEffects.sideEffects()) {

                    lastSideEffect.setStateAfter(invalid);

                }

            }

            sideEffects.addSideEffect(forStateSplit);

            FrameState frameState;

            if (forStateSplit instanceof ExceptionObjectNode) {

                frameState = graph.add(new FrameState(AFTER_EXCEPTION_BCI, (ExceptionObjectNode) forStateSplit));

            } else {

                frameState = graph.add(new FrameState(AFTER_BCI));

            }

            frameState.setNodeSourcePosition(sourcePosition);

            return frameState;

        } else {

            if (forStateSplit instanceof AbstractMergeNode) {

                // Merge nodes always need a frame state

                if (sideEffects.isAfterSideEffect()) {

                    // A merge after one or more side effects

                    FrameState frameState = graph.add(new FrameState(AFTER_BCI));

                    frameState.setNodeSourcePosition(sourcePosition);

                    return frameState;

                } else {

                    // A merge before any side effects

                    FrameState frameState = graph.add(new FrameState(BEFORE_BCI));

                    frameState.setNodeSourcePosition(sourcePosition);

                    return frameState;

                }

            } else {

                // Other non-side-effects do not need a state

                return null;

            }

        }

    }

    @Override

    public String toString() {

        return "Intrinsic{original: " + method.format("%H.%n(%p)") + ", intrinsic: " + intrinsic.format("%H.%n(%p)") + ", context: " + compilationContext + "}";

    }

}