/*

 * Copyright (c) 2015, 2019, 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 jdk.vm.ci.hotspot;

import static jdk.vm.ci.common.InitTimer.timer;

import static jdk.vm.ci.hotspot.HotSpotJVMCICompilerFactory.CompilationLevelAdjustment.None;

import static jdk.vm.ci.services.Services.IS_BUILDING_NATIVE_IMAGE;

import static jdk.vm.ci.services.Services.IS_IN_NATIVE_IMAGE;

import java.io.IOException;

import java.io.OutputStream;

import java.io.PrintStream;

import java.io.Serializable;

import java.lang.invoke.CallSite;

import java.lang.invoke.ConstantCallSite;

import java.lang.invoke.MethodHandle;

import java.lang.module.ModuleDescriptor.Requires;

import java.lang.ref.WeakReference;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.ServiceLoader;

import java.util.function.Predicate;

import jdk.internal.misc.Unsafe;

import jdk.vm.ci.code.Architecture;

import jdk.vm.ci.code.CompilationRequestResult;

import jdk.vm.ci.code.CompiledCode;

import jdk.vm.ci.code.InstalledCode;

import jdk.vm.ci.common.InitTimer;

import jdk.vm.ci.common.JVMCIError;

import jdk.vm.ci.common.NativeImageReinitialize;

import jdk.vm.ci.meta.JavaKind;

import jdk.vm.ci.meta.JavaType;

import jdk.vm.ci.meta.ResolvedJavaType;

import jdk.vm.ci.meta.UnresolvedJavaType;

import jdk.vm.ci.runtime.JVMCI;

import jdk.vm.ci.runtime.JVMCIBackend;

import jdk.vm.ci.runtime.JVMCICompiler;

import jdk.vm.ci.runtime.JVMCICompilerFactory;

import jdk.vm.ci.runtime.JVMCIRuntime;

import jdk.vm.ci.services.JVMCIServiceLocator;

import jdk.vm.ci.services.Services;

/**

 * HotSpot implementation of a JVMCI runtime.

 */

public final class HotSpotJVMCIRuntime implements JVMCIRuntime {

    /**

     * Singleton instance lazily initialized via double-checked locking.

     */

    @NativeImageReinitialize private static volatile HotSpotJVMCIRuntime instance;

    private HotSpotResolvedObjectTypeImpl javaLangObject;

    private HotSpotResolvedObjectTypeImpl javaLangInvokeMethodHandle;

    private HotSpotResolvedObjectTypeImpl constantCallSiteType;

    private HotSpotResolvedObjectTypeImpl callSiteType;

    private HotSpotResolvedObjectTypeImpl javaLangString;

    private HotSpotResolvedObjectTypeImpl javaLangClass;

    private HotSpotResolvedObjectTypeImpl throwableType;

    private HotSpotResolvedObjectTypeImpl serializableType;

    private HotSpotResolvedObjectTypeImpl cloneableType;

    private HotSpotResolvedObjectTypeImpl enumType;

    HotSpotResolvedObjectTypeImpl getJavaLangObject() {

        if (javaLangObject == null) {

            javaLangObject = (HotSpotResolvedObjectTypeImpl) fromClass(Object.class);

        }

        return javaLangObject;

    }

    HotSpotResolvedObjectTypeImpl getJavaLangString() {

        if (javaLangString == null) {

            javaLangString = (HotSpotResolvedObjectTypeImpl) fromClass(String.class);

        }

        return javaLangString;

    }

    HotSpotResolvedObjectTypeImpl getJavaLangClass() {

        if (javaLangClass == null) {

            javaLangClass = (HotSpotResolvedObjectTypeImpl) fromClass(Class.class);

        }

        return javaLangClass;

    }

    HotSpotResolvedObjectTypeImpl getJavaLangCloneable() {

        if (cloneableType == null) {

            cloneableType = (HotSpotResolvedObjectTypeImpl) fromClass(Cloneable.class);

        }

        return cloneableType;

    }

    HotSpotResolvedObjectTypeImpl getJavaLangSerializable() {

        if (serializableType == null) {

            serializableType = (HotSpotResolvedObjectTypeImpl) fromClass(Serializable.class);

        }

        return serializableType;

    }

    HotSpotResolvedObjectTypeImpl getJavaLangThrowable() {

        if (throwableType == null) {

            throwableType = (HotSpotResolvedObjectTypeImpl) fromClass(Throwable.class);

        }

        return throwableType;

    }

    HotSpotResolvedObjectTypeImpl getJavaLangEnum() {

        if (enumType == null) {

            enumType = (HotSpotResolvedObjectTypeImpl) fromClass(Enum.class);

        }

        return enumType;

    }

    HotSpotResolvedObjectTypeImpl getConstantCallSite() {

        if (constantCallSiteType == null) {

            constantCallSiteType = (HotSpotResolvedObjectTypeImpl) fromClass(ConstantCallSite.class);

        }

        return constantCallSiteType;

    }

    HotSpotResolvedObjectTypeImpl getCallSite() {

        if (callSiteType == null) {

            callSiteType = (HotSpotResolvedObjectTypeImpl) fromClass(CallSite.class);

        }

        return callSiteType;

    }

    HotSpotResolvedObjectType getMethodHandleClass() {

        if (javaLangInvokeMethodHandle == null) {

            javaLangInvokeMethodHandle = (HotSpotResolvedObjectTypeImpl) fromClass(MethodHandle.class);

        }

        return javaLangInvokeMethodHandle;

    }

    /**

     * Gets the singleton {@link HotSpotJVMCIRuntime} object.

     */

    @VMEntryPoint

    @SuppressWarnings("try")

    public static HotSpotJVMCIRuntime runtime() {

        HotSpotJVMCIRuntime result = instance;

        if (result == null) {

            // Synchronize on JVMCI.class to avoid deadlock

            // between the two JVMCI initialization paths:

            // HotSpotJVMCIRuntime.runtime() and JVMCI.getRuntime().

            synchronized (JVMCI.class) {

                result = instance;

                if (result == null) {

                    try (InitTimer t = timer("HotSpotJVMCIRuntime.<init>")) {

                        instance = result = new HotSpotJVMCIRuntime();

                        // Can only do eager initialization of the JVMCI compiler

                        // once the singleton instance is available.

                        }

                    }

                    // Ensures JVMCIRuntime::_HotSpotJVMCIRuntime_instance is

                    // initialized.

                    JVMCI.getRuntime();

                }

            }

        }

        return result;

    }

    @VMEntryPoint

    static Throwable decodeThrowable(String encodedThrowable) throws Throwable {

        return TranslatedException.decodeThrowable(encodedThrowable);

    }

    @VMEntryPoint

    static String encodeThrowable(Throwable throwable) throws Throwable {

        return TranslatedException.encodeThrowable(throwable);

    }

    @VMEntryPoint

    static String callToString(Object o) {

        return o.toString();

    }

    /**

     * A list of all supported JVMCI options.

     */

    public enum Option {

        // @formatter:off

        Compiler(String.class, null, "Selects the system compiler. This must match the getCompilerName() value returned " +

                "by a jdk.vm.ci.runtime.JVMCICompilerFactory provider. " +

                "An empty string or the value \"null\" selects a compiler " +

                "that will raise an exception upon receiving a compilation request."),

        // Note: The following one is not used (see InitTimer.ENABLED). It is added here

        // so that -XX:+JVMCIPrintProperties shows the option.

        InitTimer(Boolean.class, false, "Specifies if initialization timing is enabled."),

        PrintConfig(Boolean.class, false, "Prints VM configuration available via JVMCI."),

        TraceMethodDataFilter(String.class, null,

                "Enables tracing of profiling info when read by JVMCI.",

                "Empty value: trace all methods",

                "Non-empty value: trace methods whose fully qualified name contains the value."),

        UseProfilingInformation(Boolean.class, true, "");

        // @formatter:on

        /**

         * The prefix for system properties that are JVMCI options.

         */

        private static final String JVMCI_OPTION_PROPERTY_PREFIX = "jvmci.";

        /**

         * Sentinel for value initialized to {@code null} since {@code null} means uninitialized.

         */

        private static final String NULL_VALUE = "NULL";

        private final Class<?> type;

        @NativeImageReinitialize private Object value;

        private final Object defaultValue;

        private boolean isDefault;

        private final String[] helpLines;

        Option(Class<?> type, Object defaultValue, String... helpLines) {

            assert Character.isUpperCase(name().charAt(0)) : "Option name must start with upper-case letter: " + name();

            this.type = type;

            this.defaultValue = defaultValue;

            this.helpLines = helpLines;

        }

        @SuppressFBWarnings(value = "ES_COMPARING_STRINGS_WITH_EQ", justification = "sentinel must be String since it's a static final in an enum")

        private Object getValue() {

            if (value == null) {

                String propertyValue = Services.getSavedProperty(getPropertyName());

                if (propertyValue == null) {

                    this.value = defaultValue == null ? NULL_VALUE : defaultValue;

                    this.isDefault = true;

                } else {

                    if (type == Boolean.class) {

                        this.value = Boolean.parseBoolean(propertyValue);

                    } else if (type == String.class) {

                        this.value = propertyValue;

                    } else {

                        throw new JVMCIError("Unexpected option type " + type);

                    }

                    this.isDefault = false;

                }

            }

            return value == NULL_VALUE ? null : value;

        }

        /**

         * Gets the name of system property from which this option gets its value.

         */

        public String getPropertyName() {

            return JVMCI_OPTION_PROPERTY_PREFIX + name();

        }

        /**

         * Returns the option's value as boolean.

         *

         * @return option's value

         */

        public boolean getBoolean() {

            return (boolean) getValue();

        }

        /**

         * Returns the option's value as String.

         *

         * @return option's value

         */

        public String getString() {

            return (String) getValue();

        }

        private static final int PROPERTY_LINE_WIDTH = 80;

        private static final int PROPERTY_HELP_INDENT = 10;

        /**

         * Prints a description of the properties used to configure shared JVMCI code.

         *

         * @param out stream to print to

         */

        public static void printProperties(PrintStream out) {

            out.println("[JVMCI properties]");

            Option[] values = values();

            for (Option option : values) {

                Object value = option.getValue();

                if (value instanceof String) {

                    value = '"' + String.valueOf(value) + '"';

                }

                String name = option.getPropertyName();

                String assign = option.isDefault ? "=" : ":=";

                String typeName = option.type.getSimpleName();

                String linePrefix = String.format("%s %s %s ", name, assign, value);

                int typeStartPos = PROPERTY_LINE_WIDTH - typeName.length();

                int linePad = typeStartPos - linePrefix.length();

                if (linePad > 0) {

                    out.printf("%s%-" + linePad + "s[%s]%n", linePrefix, "", typeName);

                } else {

                    out.printf("%s[%s]%n", linePrefix, typeName);

                }

                for (String line : option.helpLines) {

                    out.printf("%" + PROPERTY_HELP_INDENT + "s%s%n", "", line);

                }

            }

        }

    }

    private static HotSpotJVMCIBackendFactory findFactory(String architecture) {

        Iterable<HotSpotJVMCIBackendFactory> factories = getHotSpotJVMCIBackendFactories();

assert factories != null : "sanity";

        for (HotSpotJVMCIBackendFactory factory : factories) {

            if (factory.getArchitecture().equalsIgnoreCase(architecture)) {

                return factory;

            }

        }

        throw new JVMCIError("No JVMCI runtime available for the %s architecture", architecture);

    }

    private static volatile List<HotSpotJVMCIBackendFactory> cachedHotSpotJVMCIBackendFactories;

    @SuppressFBWarnings(value = "LI_LAZY_INIT_UPDATE_STATIC", justification = "not sure about this")

    private static Iterable<HotSpotJVMCIBackendFactory> getHotSpotJVMCIBackendFactories() {

        if (IS_IN_NATIVE_IMAGE || cachedHotSpotJVMCIBackendFactories != null) {

            return cachedHotSpotJVMCIBackendFactories;

        }

        Iterable<HotSpotJVMCIBackendFactory> result = ServiceLoader.load(HotSpotJVMCIBackendFactory.class, ClassLoader.getSystemClassLoader());

        if (IS_BUILDING_NATIVE_IMAGE) {

            cachedHotSpotJVMCIBackendFactories = new ArrayList<>();

            for (HotSpotJVMCIBackendFactory factory : result) {

                cachedHotSpotJVMCIBackendFactories.add(factory);

            }

        }

        return result;

    }

    /**

     * Gets the kind of a word value on the {@linkplain #getHostJVMCIBackend() host} backend.

     */

    public static JavaKind getHostWordKind() {

        return runtime().getHostJVMCIBackend().getCodeCache().getTarget().wordJavaKind;

    }

    protected final CompilerToVM compilerToVm;

    protected final HotSpotVMConfigStore configStore;

    protected final HotSpotVMConfig config;

    private final JVMCIBackend hostBackend;

    private final JVMCICompilerFactory compilerFactory;

    private final HotSpotJVMCICompilerFactory hsCompilerFactory;

    private volatile JVMCICompiler compiler;

    protected final HotSpotJVMCIReflection reflection;

    @NativeImageReinitialize private volatile boolean creatingCompiler;

    /**

     * Cache for speeding up {@link #fromClass(Class)}.

     */

    @NativeImageReinitialize private volatile ClassValue<WeakReference<HotSpotResolvedJavaType>> resolvedJavaType;

    @NativeImageReinitialize private HashMap<Long, WeakReference<ResolvedJavaType>> resolvedJavaTypes;

    /**

     * Stores the value set by {@link #excludeFromJVMCICompilation(Module...)} so that it can

     * be read from the VM.

     */

    @SuppressWarnings("unused")//

    @NativeImageReinitialize private Module[] excludeFromJVMCICompilation;

    private final Map<Class<? extends Architecture>, JVMCIBackend> backends = new HashMap<>();

    private volatile List<HotSpotVMEventListener> vmEventListeners;

    private Iterable<HotSpotVMEventListener> getVmEventListeners() {

        if (vmEventListeners == null) {

            synchronized (this) {

                if (vmEventListeners == null) {

                    vmEventListeners = JVMCIServiceLocator.getProviders(HotSpotVMEventListener.class);

                }

            }

        }

        return vmEventListeners;

    }

    @SuppressWarnings("try")

    private HotSpotJVMCIRuntime() {

        compilerToVm = new CompilerToVM();

        try (InitTimer t = timer("HotSpotVMConfig<init>")) {

            configStore = new HotSpotVMConfigStore(compilerToVm);

            config = new HotSpotVMConfig(configStore);

        }

        reflection = IS_IN_NATIVE_IMAGE ? new SharedLibraryJVMCIReflection() : new HotSpotJDKReflection();

        PrintStream vmLogStream = null;

        if (IS_IN_NATIVE_IMAGE) {

            // Redirect System.out and System.err to HotSpot's TTY stream

            vmLogStream = new PrintStream(getLogStream());

            System.setOut(vmLogStream);

            System.setErr(vmLogStream);

        }

        String hostArchitecture = config.getHostArchitectureName();

        HotSpotJVMCIBackendFactory factory;

        try (InitTimer t = timer("find factory:", hostArchitecture)) {

            factory = findFactory(hostArchitecture);

        }

        try (InitTimer t = timer("create JVMCI backend:", hostArchitecture)) {

            hostBackend = registerBackend(factory.createJVMCIBackend(this, null));

        }

        compilerFactory = HotSpotJVMCICompilerConfig.getCompilerFactory();

        if (compilerFactory instanceof HotSpotJVMCICompilerFactory) {

            hsCompilerFactory = (HotSpotJVMCICompilerFactory) compilerFactory;

            if (hsCompilerFactory.getCompilationLevelAdjustment() != None) {

                String name = HotSpotJVMCICompilerFactory.class.getName();

                String msg = String.format("%s.getCompilationLevelAdjustment() is no longer supported. " +

                                "Use %s.excludeFromJVMCICompilation() instead.", name, name);

                throw new UnsupportedOperationException(msg);

            }

        } else {

            hsCompilerFactory = null;

        }

        if (config.getFlag("JVMCIPrintProperties", Boolean.class)) {

            if (vmLogStream == null) {

                vmLogStream = new PrintStream(getLogStream());

            }

            Option.printProperties(vmLogStream);

            compilerFactory.printProperties(vmLogStream);

            System.exit(0);

        }

        if (Option.PrintConfig.getBoolean()) {

        }

    }

    HotSpotResolvedJavaType createClass(Class<?> javaClass) {

        if (javaClass.isPrimitive()) {

            return HotSpotResolvedPrimitiveType.forKind(JavaKind.fromJavaClass(javaClass));

        }

        if (IS_IN_NATIVE_IMAGE) {

            try {

                return compilerToVm.lookupType(javaClass.getName().replace('.', '/'), null, true);

            } catch (ClassNotFoundException e) {

                throw new JVMCIError(e);

            }

        }

        return compilerToVm.lookupClass(javaClass);

    }

    private HotSpotResolvedJavaType fromClass0(Class<?> javaClass) {

        if (resolvedJavaType == null) {

            synchronized (this) {

                if (resolvedJavaType == null) {

                    resolvedJavaType = new ClassValue<WeakReference<HotSpotResolvedJavaType>>() {

                        @Override

                        protected WeakReference<HotSpotResolvedJavaType> computeValue(Class<?> type) {

                            return new WeakReference<>(createClass(type));

                        }

                    };

                }

            }

        }

        HotSpotResolvedJavaType javaType = null;

        while (javaType == null) {

            WeakReference<HotSpotResolvedJavaType> type = resolvedJavaType.get(javaClass);

            javaType = type.get();

            if (javaType == null) {

                /*

                 * If the referent has become null, clear out the current value and let computeValue

                 * above create a new value. Reload the value in a loop because in theory the

                 * WeakReference referent can be reclaimed at any point.

                 */