/*

 * Copyright (c) 2018, Red Hat, Inc. 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.

 */

/*

 * common code to run and validate tests of code generation for

 * volatile ops on AArch64

 *

 * incoming args are <testclass> <testtype>

 *

 * where <testclass> in {TestVolatileLoad,

 *                       TestVolatileStore,

 *                       TestUnsafeVolatileLoad,

 *                       TestUnsafeVolatileStore,

 *                       TestUnsafeVolatileCAS,

 *                       TestUnsafeVolatileWeakCAS,

 *                       TestUnsafeVolatileCAE,

 *                       TestUnsafeVolatileGAS}

 * and <testtype> in {G1,

 *                    CMS,

 *                    CMSCondMark,

 *                    Serial,

 */

package compiler.c2.aarch64;

import java.util.List;

import java.util.ListIterator;

import java.util.Iterator;

import java.util.regex.Pattern;

import java.io.*;

import jdk.test.lib.Asserts;

import jdk.test.lib.compiler.InMemoryJavaCompiler;

import jdk.test.lib.process.OutputAnalyzer;

import jdk.test.lib.process.ProcessTools;

import sun.hotspot.WhiteBox;

// runner class that spawns a new JVM to exercises a combination of

// volatile MemOp and GC. The ops are compiled with the dmb -->

// ldar/stlr transforms either enabled or disabled. this runner parses

// the PrintOptoAssembly output checking that the generated code is

// correct.

public class TestVolatiles {

    public void runtest(String classname, String testType) throws Throwable {

        // n.b. clients omit the package name for the class

        String fullclassname = "compiler.c2.aarch64." + classname;

        // build up a command line for the spawned JVM

        String[] procArgs;

        int argcount;

        // add one or two extra arguments according to test type

        // i.e. GC type plus GC conifg

        switch(testType) {

        case "G1":

            argcount = 9;

            procArgs = new String[argcount];

            procArgs[argcount - 2] = "-XX:+UseG1GC";

            break;

        case "Parallel":

            argcount = 9;

            procArgs = new String[argcount];

            procArgs[argcount - 2] = "-XX:+UseParallelGC";

            break;

        case "Serial":

            argcount = 9;

            procArgs = new String[argcount];

            procArgs[argcount - 2] = "-XX:+UseSerialGC";

            break;

        case "CMS":

            argcount = 10;

            procArgs = new String[argcount];

            procArgs[argcount - 3] = "-XX:+UseConcMarkSweepGC";

            procArgs[argcount - 2] = "-XX:-UseCondCardMark";

            break;

        case "CMSCondMark":

            argcount = 10;

            procArgs = new String[argcount];

            procArgs[argcount - 3] = "-XX:+UseConcMarkSweepGC";

            procArgs[argcount - 2] = "-XX:+UseCondCardMark";

            break;

        default:

            throw new RuntimeException("unexpected test type " + testType);

        }

        // fill in arguments common to all cases

        // the first round of test enables transform of barriers to

        // use acquiring loads and releasing stores by setting arg

        // zero appropriately. this arg is reset in the second run to

        // disable the transform.

        procArgs[0] = "-XX:-UseBarriersForVolatile";

        procArgs[1] = "-XX:+UseCompressedOops";

        procArgs[2] = "-XX:-TieredCompilation";

        procArgs[3] = "-XX:+PrintOptoAssembly";

        procArgs[4] = "-XX:CompileCommand=compileonly," + fullclassname + "::" + "test*";

        procArgs[5] = "--add-exports";

        procArgs[6] = "java.base/jdk.internal.misc=ALL-UNNAMED";

        procArgs[argcount - 1] = fullclassname;

        runtest(classname, testType, false, true, procArgs);

        // rerun the test class without the transform applied and

        // check the alternative generation is as expected

        procArgs[0] = "-XX:+UseBarriersForVolatile";

        runtest(classname, testType, true, true, procArgs);

        if (!classname.equals("TestUnsafeVolatileGAA")) {

            procArgs[0] = "-XX:-UseBarriersForVolatile";

            procArgs[1] = "-XX:-UseCompressedOops";

            runtest(classname, testType, false, false, procArgs);

            procArgs[0] = "-XX:+UseBarriersForVolatile";

            runtest(classname, testType, true, false, procArgs);

        }

    }

    public void runtest(String classname, String testType, boolean useBarriersForVolatile, boolean useCompressedOops, String[] procArgs) throws Throwable {

        ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(procArgs);

        OutputAnalyzer output = new OutputAnalyzer(pb.start());

        output.stderrShouldBeEmptyIgnoreVMWarnings();

        output.stdoutShouldNotBeEmpty();

        output.shouldHaveExitValue(0);

        // check the output for the correct asm sequence as

        // appropriate to test class, test type and whether transform

        // was applied

        checkoutput(output, classname, testType, useBarriersForVolatile, useCompressedOops);

    }

    // skip through output returning a line containing the desireed

    // substring or null

    private String skipTo(Iterator<String> iter, String substring)

    {

        while (iter.hasNext()) {

            String nextLine = iter.next();

            if (nextLine.matches(".*" + substring + ".*")) {

                return nextLine;

            }

        }

        return null;

    }

    // locate the start of compiler output for the desired method and

    // then check that each expected instruction occurs in the output

    // in the order supplied. throw an excpetion if not found.

    // n.b. the spawned JVM's output is included in the exception

    // message to make it easeir to identify what is missing.

    private boolean checkCompile(Iterator<String> iter, String methodname, String[] expected, OutputAnalyzer output, boolean do_throw)

    {

        // trace call to allow eyeball check of what we are checking against

        System.out.println("checkCompile(" + methodname + ",");

        String sepr = "  { ";

        for (String s : expected) {

            System.out.print(sepr);

            System.out.print(s);

            sepr = ",\n    ";

        }

        System.out.println(" })");

        // look for the start of an opto assembly print block

        String match = skipTo(iter, Pattern.quote("{method}"));

        if (match == null) {

            if (do_throw) {

                throw new RuntimeException("Missing compiler output for " + methodname + "!\n\n" + output.getOutput());

            }

            return false;

        }

        // check the compiled method name is right

        match = skipTo(iter, Pattern.quote("- name:"));

        if (match == null) {

            if (do_throw) {

                throw new RuntimeException("Missing compiled method name!\n\n" + output.getOutput());

            }

            return false;

        }

        if (!match.contains(methodname)) {

            if (do_throw) {

                throw new RuntimeException("Wrong method " + match + "!\n  -- expecting " + methodname + "\n\n" + output.getOutput());

            }

            return false;

        }

        // make sure we can match each expected term in order

        for (String s : expected) {

            match = skipTo(iter, s);

            if (match == null) {

                if (do_throw) {

                    throw new RuntimeException("Missing expected output " + s + "!\n\n" + output.getOutput());

                }

                return false;

            }

        }

        return true;

    }

    // check for expected asm output from a volatile load

    private void checkload(OutputAnalyzer output, String testType, boolean useBarriersForVolatile, boolean useCompressedOops) throws Throwable

    {

        Iterator<String> iter = output.asLines().listIterator();

        // we shoud see this same sequence for normal or unsafe volatile load

        // for both int and Object fields

        String[] matches;

        if (!useBarriersForVolatile) {

            matches = new String[] {

                "ldarw",

                "membar_acquire \\(elided\\)",

                "ret"

            };

        } else {

            matches = new String[] {

                "ldrw",

                "membar_acquire",

                "dmb ish",

                "ret"

            };

        }

        checkCompile(iter, "testInt", matches, output, true);

        if (!useBarriersForVolatile) {

            matches = new String[] {

                useCompressedOops ? "ldarw?" : "ldar",

                "membar_acquire \\(elided\\)",

                "ret"

            };

        } else {

            matches = new String[] {

                useCompressedOops ? "ldrw?" : "ldr",

                "membar_acquire",

                "dmb ish",

                "ret"

            };

        }

        checkCompile(iter, "testObj", matches, output, true);

    }

    // check for expected asm output from a volatile store

    private void checkstore(OutputAnalyzer output, String testType, boolean useBarriersForVolatile, boolean useCompressedOops) throws Throwable

    {

        Iterator<String> iter = output.asLines().listIterator();

        String[] matches;

        // non object stores are straightforward

        if (!useBarriersForVolatile) {

            // this is the sequence of instructions for all cases

            matches = new String[] {

                "membar_release \\(elided\\)",

                "stlrw",

                "membar_volatile \\(elided\\)",

                "ret"

            };

        } else {

            // this is the alternative sequence of instructions

            matches = new String[] {

                "membar_release",

                "dmb ish",

                "strw",

                "membar_volatile",

                "dmb ish",

                "ret"

            };

        }

        checkCompile(iter, "testInt", matches, output, true);

        // object stores will be as above except for when the GC

        // introduces barriers for card marking

        if (!useBarriersForVolatile) {

            switch (testType) {

            default:

                // this is the basic sequence of instructions

                matches = new String[] {

                    "membar_release \\(elided\\)",

                    useCompressedOops ? "stlrw?" : "stlr",

                    "membar_volatile \\(elided\\)",

                    "ret"

                };

                break;

            case "G1":

                // a card mark volatile barrier should be generated

                // before the card mark strb

                matches = new String[] {

                    "membar_release \\(elided\\)",

                    useCompressedOops ? "stlrw?" : "stlr",

                    "membar_volatile",

                    "dmb ish",

                    "strb",

                    "membar_volatile \\(elided\\)",

                    "ret"

                };

                break;

            case "CMSCondMark":

                // a card mark volatile barrier should be generated

                // before the card mark strb from the StoreCM and the

                // storestore barrier from the StoreCM should be elided

                matches = new String[] {

                    "membar_release \\(elided\\)",

                    useCompressedOops ? "stlrw?" : "stlr",

                    "membar_volatile",

                    "dmb ish",

                    "storestore \\(elided\\)",

                    "strb",

                    "membar_volatile \\(elided\\)",

                    "ret"

                };

                break;

            case "CMS":

                // a volatile card mark membar should not be generated

                // before the card mark strb from the StoreCM and the

                // storestore barrier from the StoreCM should be

                // generated as "dmb ishst"

                matches = new String[] {

                    "membar_release \\(elided\\)",

                    useCompressedOops ? "stlrw?" : "stlr",

                    "storestore",

                    "dmb ishst",

                    "strb",

                    "membar_volatile \\(elided\\)",

                    "ret"

                };

                break;

            }

        } else {

            switch (testType) {

            default:

                // this is the basic sequence of instructions

                matches = new String[] {

                    "membar_release",

                    "dmb ish",

                    useCompressedOops ? "strw?" : "str",

                    "membar_volatile",

                    "dmb ish",

                    "ret"

                };

                break;

            case "G1":

                // a card mark volatile barrier should be generated

                // before the card mark strb

                matches = new String[] {

                    "membar_release",

                    "dmb ish",

                    useCompressedOops ? "strw?" : "str",

                    "membar_volatile",

                    "dmb ish",

                    "strb",

                    "membar_volatile",

                    "dmb ish",

                    "ret"

                };

                break;

            case "CMSCondMark":

                // a card mark volatile barrier should be generated

                // before the card mark strb from the StoreCM and the

                // storestore barrier from the StoreCM should be elided

                matches = new String[] {

                    "membar_release",

                    "dmb ish",

                    useCompressedOops ? "strw?" : "str",

                    "membar_volatile",

                    "dmb ish",

                    "storestore \\(elided\\)",

                    "strb",

                    "membar_volatile",

                    "dmb ish",

                    "ret"

                };

                break;

            case "CMS":

                // a volatile card mark membar should not be generated

                // before the card mark strb from the StoreCM and the

                // storestore barrier from the StoreCM should be generated

                // as "dmb ishst"

                matches = new String[] {

                    "membar_release",

                    "dmb ish",

                    useCompressedOops ? "strw?" : "str",

                    "storestore",

                    "dmb ishst",

                    "strb",

                    "membar_volatile",

                    "dmb ish",

                    "ret"

                };

                break;

            }

        }

        checkCompile(iter, "testObj", matches, output, true);

    }

    // check for expected asm output from a volatile cas

    private void checkcas(OutputAnalyzer output, String testType, boolean useBarriersForVolatile, boolean useCompressedOops) throws Throwable

    {

        Iterator<String> iter = output.asLines().listIterator();

        String[] matches;

        String[][] tests = {

            { "testInt", "cmpxchgw" },

            { "testLong", "cmpxchg" },

            { "testByte", "cmpxchgb" },

            { "testShort", "cmpxchgs" },

        };

        for (String[] test : tests) {

            // non object stores are straightforward

            if (!useBarriersForVolatile) {

                // this is the sequence of instructions for all cases

                matches = new String[] {

                    "membar_release \\(elided\\)",

                    test[1] + "_acq",

                    "membar_acquire \\(elided\\)",

                    "ret"

                };

            } else {

                // this is the alternative sequence of instructions

                matches = new String[] {

                    "membar_release",

                    "dmb ish",

                    test[1] + " ",

                    "membar_acquire",

                    "dmb ish",

                    "ret"

                };

            }

            checkCompile(iter, test[0], matches, output, true);

        }

        // object stores will be as above except for when the GC

        // introduces barriers for card marking

        if (!useBarriersForVolatile) {