/*

 * Copyright (c) 2013, 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 org.graalvm.compiler.hotspot.test;

import static java.util.Collections.singletonList;

import static org.graalvm.compiler.core.CompilationWrapper.ExceptionAction.Print;

import static org.graalvm.compiler.core.GraalCompilerOptions.CompilationBailoutAsFailure;

import static org.graalvm.compiler.core.GraalCompilerOptions.CompilationFailureAction;

import static org.graalvm.compiler.core.test.ReflectionOptionDescriptors.extractEntries;

import static org.graalvm.compiler.debug.MemUseTrackerKey.getCurrentThreadAllocatedBytes;

import static org.graalvm.compiler.hotspot.CompilationTask.CompilationTime;

import static org.graalvm.compiler.hotspot.CompilationTask.CompiledAndInstalledBytecodes;

import static org.graalvm.compiler.hotspot.test.CompileTheWorld.Options.DESCRIPTORS;

import static org.graalvm.compiler.hotspot.test.CompileTheWorld.Options.InvalidateInstalledCode;

import static sun.misc.Unsafe.ARRAY_BYTE_BASE_OFFSET;

import java.io.ByteArrayOutputStream;

import java.io.Closeable;

import java.io.File;

import java.io.IOException;

import java.lang.annotation.Annotation;

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.net.URI;

import java.net.URL;

import java.net.URLClassLoader;

import java.nio.file.FileSystem;

import java.nio.file.FileSystems;

import java.nio.file.FileVisitResult;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.SimpleFileVisitor;

import java.nio.file.attribute.BasicFileAttributes;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.ServiceLoader;

import java.util.Set;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.Future;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicLong;

import java.util.jar.JarEntry;

import java.util.jar.JarFile;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import jdk.internal.vm.compiler.collections.EconomicMap;

import jdk.internal.vm.compiler.collections.UnmodifiableMapCursor;

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

import org.graalvm.compiler.bytecode.Bytecodes;

import org.graalvm.compiler.core.CompilerThreadFactory;

import org.graalvm.compiler.core.phases.HighTier;

import org.graalvm.compiler.core.test.ReflectionOptionDescriptors;

import org.graalvm.compiler.debug.DebugOptions;

import org.graalvm.compiler.debug.GlobalMetrics;

import org.graalvm.compiler.debug.GraalError;

import org.graalvm.compiler.debug.MethodFilter;

import org.graalvm.compiler.debug.MetricKey;

import org.graalvm.compiler.debug.TTY;

import org.graalvm.compiler.hotspot.CompilationTask;

import org.graalvm.compiler.hotspot.GraalHotSpotVMConfig;

import org.graalvm.compiler.hotspot.HotSpotGraalCompiler;

import org.graalvm.compiler.hotspot.HotSpotGraalRuntime;

import org.graalvm.compiler.hotspot.HotSpotGraalRuntimeProvider;

import org.graalvm.compiler.hotspot.test.CompileTheWorld.LibGraalParams.StackTraceBuffer;

import org.graalvm.compiler.options.OptionDescriptors;

import org.graalvm.compiler.options.OptionKey;

import org.graalvm.compiler.options.OptionValues;

import org.graalvm.compiler.options.OptionsParser;

import org.graalvm.compiler.serviceprovider.GraalUnsafeAccess;

import org.graalvm.compiler.serviceprovider.JavaVersionUtil;

import org.graalvm.compiler.test.ModuleSupport;

import jdk.internal.vm.compiler.libgraal.LibGraal;

import jdk.internal.vm.compiler.libgraal.LibGraalScope;

import jdk.internal.vm.compiler.libgraal.OptionsEncoder;

import jdk.vm.ci.hotspot.HotSpotCodeCacheProvider;

import jdk.vm.ci.hotspot.HotSpotCompilationRequest;

import jdk.vm.ci.hotspot.HotSpotInstalledCode;

import jdk.vm.ci.hotspot.HotSpotJVMCIRuntime;

import jdk.vm.ci.hotspot.HotSpotResolvedJavaMethod;

import jdk.vm.ci.hotspot.HotSpotResolvedObjectType;

import jdk.vm.ci.meta.ConstantPool;

import jdk.vm.ci.meta.MetaAccessProvider;

import jdk.vm.ci.runtime.JVMCI;

import jdk.vm.ci.runtime.JVMCICompiler;

import sun.misc.Unsafe;

/**

 * This class implements compile-the-world functionality with JVMCI.

 */

public final class CompileTheWorld {

    static {

        ModuleSupport.exportAndOpenAllPackagesToUnnamed("jdk.internal.vm.compiler");

    }

    /**

     * Magic token to denote that JDK classes are to be compiled. For JDK 8, the classes in

     * {@code rt.jar} are compiled. Otherwise the classes in the Java runtime image are compiled.

     */

    public static final String SUN_BOOT_CLASS_PATH = "sun.boot.class.path";

    /**

     * Magic token to denote the classes in the Java runtime image (i.e. in the {@code jrt:/} file

     * system).

     */

    public static final String JRT_CLASS_PATH_ENTRY = "<jrt>";

    /**

     * @param options a space separated set of option value settings with each option setting in a

     *            {@code -Dgraal.<name>=<value>} format but without the leading {@code -Dgraal.}.

     *            Ignored if null.

     */

    public static EconomicMap<OptionKey<?>, Object> parseOptions(String options) {

        EconomicMap<OptionKey<?>, Object> values = OptionValues.newOptionMap();

        if (options != null) {

            EconomicMap<String, String> optionSettings = EconomicMap.create();

            for (String optionSetting : options.split("\\s+|#")) {

                OptionsParser.parseOptionSettingTo(optionSetting, optionSettings);

            }

            ServiceLoader<OptionDescriptors> loader = ServiceLoader.load(OptionDescriptors.class, OptionDescriptors.class.getClassLoader());

            OptionsParser.parseOptions(optionSettings, values, loader);

        }

        if (!values.containsKey(HighTier.Options.Inline)) {

            values.put(HighTier.Options.Inline, false);

        }

        return values;

    }

    private final HotSpotJVMCIRuntime jvmciRuntime;

    private final HotSpotGraalCompiler compiler;

    /**

     * Class path denoting classes to compile.

     *

     * @see Options#Classpath

     */

    private final String inputClassPath;

    /**

     * Class index to start compilation at.

     *

     * @see Options#StartAt

     */

    private final int startAt;

    /**

     * Class index to stop compilation at.

     *

     * @see Options#StopAt

     */

    private final int stopAt;

    /**

     * Max classes to compile.

     *

     * @see Options#MaxClasses

     */

    private final int maxClasses;

    /** Only compile methods matching one of the filters in this array if the array is non-null. */

    private final MethodFilter[] methodFilters;

    /** Exclude methods matching one of the filters in this array if the array is non-null. */

    private final MethodFilter[] excludeMethodFilters;

    // Counters

    private int classFileCounter = 0;

    private AtomicLong compiledMethodsCounter = new AtomicLong();

    private AtomicLong compileTime = new AtomicLong();

    private AtomicLong memoryUsed = new AtomicLong();

    private boolean verbose;

    /**

     * Signal that the threads should start compiling in multithreaded mode.

     */

    private boolean running;

    private ThreadPoolExecutor threadPool;

    /**

     * Values for {@link CompileTheWorld.Options}.

     */

    private final OptionValues harnessOptions;

    /**

     * Option values used during compilation.

     */

    private final OptionValues compilerOptions;

    /**

     * Manages native memory buffers for passing arguments into libgraal and receiving return

     * values. The native memory buffers are freed when this object is {@linkplain #close() closed}.

     */

    static class LibGraalParams implements AutoCloseable {

        static {

            LibGraal.registerNativeMethods(HotSpotJVMCIRuntime.runtime(), CompileTheWorld.class);

        }

        /**

         * Native memory containing {@linkplain OptionsEncoder encoded} {@link OptionValues}.

         */

        static class OptionsBuffer {

            private long address;

            final int size;

            final int hash;

            OptionsBuffer(OptionValues options) {

                Map<String, Object> map = new HashMap<>();

                UnmodifiableMapCursor<OptionKey<?>, Object> cursor = options.getMap().getEntries();

                while (cursor.advance()) {

                    final OptionKey<?> key = cursor.getKey();

                    Object value = cursor.getValue();

                    map.put(key.getName(), value);

                }

                byte[] encoded = OptionsEncoder.encode(map);

                size = encoded.length;

                hash = Arrays.hashCode(encoded);

                address = UNSAFE.allocateMemory(encoded.length);

                UNSAFE.copyMemory(encoded, ARRAY_BYTE_BASE_OFFSET, null, address, size);

            }

            long getAddress() {

                if (address == 0) {

                    throw new IllegalStateException();

                }

                return address;

            }

            void free() {

                if (address != 0) {

                    UNSAFE.freeMemory(address);

                    address = 0;

                }

            }

        }

        /**

         * Manages native memory for receiving a {@linkplain Throwable#printStackTrace() stack

         * trace} from libgraal serialized via {@link ByteArrayOutputStream} to a byte array.

         */

        static class StackTraceBuffer {

            final int size;

            private long address;

            StackTraceBuffer(int size) {

                this.size = size;

                address = UNSAFE.allocateMemory(size);

            }

            void free() {

                if (address != 0L) {

                    UNSAFE.freeMemory(address);

                    address = 0L;

                }

            }

            long getAddress() {

                if (address == 0) {

                    throw new IllegalStateException();

                }

                return address;

            }

        }

        final OptionsBuffer options;

        private final List<StackTraceBuffer> stackTraceBuffers = new ArrayList<>();

        /**

         * Gets a stack trace buffer for the current thread.

         */

        StackTraceBuffer getStackTraceBuffer() {

            return stackTraceBuffer.get();

        }

        private final ThreadLocal<StackTraceBuffer> stackTraceBuffer = new ThreadLocal<StackTraceBuffer>() {

            @Override

            protected StackTraceBuffer initialValue() {

                StackTraceBuffer buffer = new StackTraceBuffer(10_000);

                synchronized (stackTraceBuffers) {

                    stackTraceBuffers.add(buffer);

                }

                return buffer;

            }

        };

        LibGraalParams(OptionValues options) {

            this.options = new OptionsBuffer(options);

        }

        @Override

        public void close() {

            options.free();

            synchronized (stackTraceBuffers) {

                for (StackTraceBuffer buffer : stackTraceBuffers) {

                    buffer.free();

                }

                stackTraceBuffers.clear();

            }

        }

    }

    /**

     * Creates a compile-the-world instance.

     *

     * @param files {@link File#pathSeparator} separated list of Zip/Jar files to compile

     * @param startAt index of the class file to start compilation at

     * @param stopAt index of the class file to stop compilation at

     * @param maxClasses maximum number of classes to process

     * @param methodFilters

     * @param excludeMethodFilters

     * @param harnessOptions values for {@link CompileTheWorld.Options}

     * @param compilerOptions option values used by the compiler

     */

    public CompileTheWorld(HotSpotJVMCIRuntime jvmciRuntime,

                    HotSpotGraalCompiler compiler,

                    String files,

                    int startAt,

                    int stopAt,

                    int maxClasses,

                    String methodFilters,

                    String excludeMethodFilters,

                    boolean verbose,

                    OptionValues harnessOptions,

                    OptionValues compilerOptions) {

        this.jvmciRuntime = jvmciRuntime;

        this.compiler = compiler;

        this.inputClassPath = files;

        this.startAt = Math.max(startAt, 1);

        this.stopAt = Math.max(stopAt, 1);

        this.maxClasses = Math.max(maxClasses, 1);

        this.methodFilters = methodFilters == null || methodFilters.isEmpty() ? null : MethodFilter.parse(methodFilters);

        this.excludeMethodFilters = excludeMethodFilters == null || excludeMethodFilters.isEmpty() ? null : MethodFilter.parse(excludeMethodFilters);

        this.verbose = verbose;

        this.harnessOptions = harnessOptions;

        // Copy the initial options and add in any extra options

        EconomicMap<OptionKey<?>, Object> compilerOptionsMap = EconomicMap.create(compilerOptions.getMap());

        // We want to see stack traces when a method fails to compile

        CompilationBailoutAsFailure.putIfAbsent(compilerOptionsMap, true);

        CompilationFailureAction.putIfAbsent(compilerOptionsMap, Print);

        // By default only report statistics for the CTW threads themselves

        DebugOptions.MetricsThreadFilter.putIfAbsent(compilerOptionsMap, "^CompileTheWorld");

        this.compilerOptions = new OptionValues(compilerOptionsMap);

    }

    public CompileTheWorld(HotSpotJVMCIRuntime jvmciRuntime,

                    HotSpotGraalCompiler compiler,

                    OptionValues harnessOptions,

                    OptionValues compilerOptions) {

        this(jvmciRuntime, compiler, Options.Classpath.getValue(harnessOptions),

                        Options.StartAt.getValue(harnessOptions),

                        Options.StopAt.getValue(harnessOptions),

                        Options.MaxClasses.getValue(harnessOptions),

                        Options.MethodFilter.getValue(harnessOptions),

                        Options.ExcludeMethodFilter.getValue(harnessOptions),

                        Options.Verbose.hasBeenSet(harnessOptions) ? Options.Verbose.getValue(harnessOptions) : !Options.MultiThreaded.getValue(harnessOptions),

                        harnessOptions,

                        new OptionValues(compilerOptions, parseOptions(Options.Config.getValue(harnessOptions))));

    }

    /**

     * Compiles all methods in all classes in {@link #inputClassPath}. If {@link #inputClassPath}

     * equals {@link #SUN_BOOT_CLASS_PATH} the boot classes are used.

     */

    @SuppressWarnings("try")

    public void compile() throws Throwable {

        try (LibGraalParams libgraal = LibGraal.isAvailable() ? new LibGraalParams(compilerOptions) : null) {

            if (SUN_BOOT_CLASS_PATH.equals(inputClassPath)) {

                String bcpEntry = null;

                if (JavaVersionUtil.JAVA_SPEC <= 8) {

                    final String[] entries = System.getProperty(SUN_BOOT_CLASS_PATH).split(File.pathSeparator);

                    for (int i = 0; i < entries.length && bcpEntry == null; i++) {

                        String entry = entries[i];

                        File entryFile = new File(entry);

                        if (entryFile.getName().endsWith("rt.jar") && entryFile.isFile()) {

                            bcpEntry = entry;

                        }

                    }

                    if (bcpEntry == null) {

                        throw new GraalError("Could not find rt.jar on boot class path %s", System.getProperty(SUN_BOOT_CLASS_PATH));

                    }

                } else {

                    bcpEntry = JRT_CLASS_PATH_ENTRY;

                }

                compile(bcpEntry, libgraal);

            } else {

                compile(inputClassPath, libgraal);

            }

        }

    }

    public void println() {

        println("");

    }

    public void println(String format, Object... args) {

        println(String.format(format, args));

    }

    public void println(String s) {

        println(verbose, s);

    }

    public static void println(boolean cond, String s) {

        if (cond) {

            TTY.println(s);

        }

    }

    public void printStackTrace(Throwable t) {

        if (verbose) {

            t.printStackTrace(TTY.out);

        }

    }

    @SuppressWarnings("unused")

    private static void dummy() {

    }

    /**

     * Abstraction over different types of class path entries.

     */

    abstract static class ClassPathEntry implements Closeable {

        final String name;

        ClassPathEntry(String name) {

            this.name = name;

        }

        /**

         * Creates a {@link ClassLoader} for loading classes from this entry.

         */

        public abstract ClassLoader createClassLoader() throws IOException;

        /**

         * Gets the list of classes available under this entry.

         */

        public abstract List<String> getClassNames() throws IOException;

        @Override

        public String toString() {

            return name;

        }

        @Override

        public void close() throws IOException {

        }

    }

    /**

     * A class path entry that is a normal file system directory.

     */

    static class DirClassPathEntry extends ClassPathEntry {

        private final File dir;

        DirClassPathEntry(String name) {

            super(name);

            dir = new File(name);

            assert dir.isDirectory();

        }

        @Override

        public ClassLoader createClassLoader() throws IOException {

            URL url = dir.toURI().toURL();

            return new URLClassLoader(new URL[]{url});