/*
 * Copyright (c) 2014, 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.
 */

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

import jdk.internal.org.objectweb.asm.ClassWriter;
import jdk.internal.org.objectweb.asm.Label;
import jdk.internal.org.objectweb.asm.MethodVisitor;
import static jdk.internal.org.objectweb.asm.Opcodes.*;

/**
 * @test
 * @bug 8051344
 * @summary Force OSR compilation with non-empty stack at the OSR entry point.
 * @modules java.base/jdk.internal.org.objectweb.asm
 * @compile -XDignore.symbol.file TestOSRWithNonEmptyStack.java
 * @run main/othervm -XX:CompileOnly=TestCase.test TestOSRWithNonEmptyStack
 */
public class TestOSRWithNonEmptyStack extends ClassLoader {
    private static final int CLASS_FILE_VERSION = 52;
    private static final String CLASS_NAME = "TestCase";
    private static final String METHOD_NAME = "test";
    private static final int ITERATIONS = 1_000_000;

    private static byte[] generateTestClass() {
        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);

        cw.visit(TestOSRWithNonEmptyStack.CLASS_FILE_VERSION, ACC_PUBLIC,
                TestOSRWithNonEmptyStack.CLASS_NAME, null, "java/lang/Object",
                null);

        TestOSRWithNonEmptyStack.generateConstructor(cw);
        TestOSRWithNonEmptyStack.generateTestMethod(cw);

        cw.visitEnd();
        return cw.toByteArray();
    }

    private static void generateConstructor(ClassWriter classWriter) {
        MethodVisitor mv = classWriter.visitMethod(ACC_PUBLIC, "<init>", "()V",
                null, null);

        mv.visitCode();

        mv.visitVarInsn(ALOAD, 0);
        mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V",
                false);
        mv.visitInsn(RETURN);

        mv.visitMaxs(0, 0);
        mv.visitEnd();
    }

    private static void generateTestMethod(ClassWriter classWriter) {
        MethodVisitor mv = classWriter.visitMethod(ACC_PUBLIC,
                TestOSRWithNonEmptyStack.METHOD_NAME, "()V", null, null);
        Label osrEntryPoint = new Label();

        mv.visitCode();
        // Push 'this' into stack before OSR entry point to bail out compilation
        mv.visitVarInsn(ALOAD, 0);
        // Setup loop counter
        mv.visitInsn(ICONST_0);
        mv.visitVarInsn(ISTORE, 1);
        // Begin loop
        mv.visitLabel(osrEntryPoint);
        // Increment loop counter
        mv.visitVarInsn(ILOAD, 1);
        mv.visitInsn(ICONST_1);
        mv.visitInsn(IADD);
        // Duplicate it for loop condition check
        mv.visitInsn(DUP);
        mv.visitVarInsn(ISTORE, 1);
        // Check loop condition
        mv.visitLdcInsn(TestOSRWithNonEmptyStack.ITERATIONS);
        mv.visitJumpInsn(IF_ICMPLT, osrEntryPoint);
        // Pop 'this'.
        mv.visitInsn(POP);
        mv.visitInsn(RETURN);

        mv.visitMaxs(0, 0);
        mv.visitEnd();
    }

    private void run() {
        byte[] bytecode = TestOSRWithNonEmptyStack.generateTestClass();

        try {
            Class klass = defineClass(TestOSRWithNonEmptyStack.CLASS_NAME,
                    bytecode, 0, bytecode.length);

            Constructor ctor = klass.getConstructor();
            Method method = klass.getDeclaredMethod(
                    TestOSRWithNonEmptyStack.METHOD_NAME);

            Object testCase = ctor.newInstance();
            method.invoke(testCase);
        } catch (Exception e) {
            throw new RuntimeException(
                    "Test bug: generated class should be valid.", e);
        }
    }

    public static void main(String args[]) {
        new TestOSRWithNonEmptyStack().run();
    }
}