Test6932496.java

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

/**
 * @test
 * @bug 6932496
 * @summary incorrect deopt of jsr subroutine on 64 bit c1
 * @modules java.base/jdk.internal.org.objectweb.asm
 *
 * @run main/othervm -Xcomp
 *      -XX:CompileCommand=compileonly,compiler.c1.Test6932496::test
 *      compiler.c1.Test6932496
 */

package compiler.c1;

import jdk.internal.org.objectweb.asm.ClassWriter;
import jdk.internal.org.objectweb.asm.FieldVisitor;
import jdk.internal.org.objectweb.asm.Label;
import jdk.internal.org.objectweb.asm.MethodVisitor;
import jdk.internal.org.objectweb.asm.Opcodes;
import jdk.internal.org.objectweb.asm.Type;

import java.io.IOException;
import java.lang.reflect.Method;
import java.nio.file.Files;
import java.nio.file.Paths;

public class Test6932496 extends ClassLoader {
    private static final int CLASS_FILE_VERSION = 49;
    private static final String CLASS_TEST = "Test";
    private static final String CLASS_OBJECT = "java/lang/Object";
    private static final String METHOD_INIT = "<init>";
    private static final String METHOD_TEST = "test";
    private static final String DESC_VOID_METHOD = "()V";
    private static final String FIELD_FLAG = "flag";

    public static void main(String[] args) {
        Test6932496 test = new Test6932496();
        test.execute();
    }

    private void execute() {
        byte[] bytecode = Test6932496.generateTestClass();

        try {
            Files.write(Paths.get("Test.class.dump"), bytecode);
        } catch (IOException e) {
            System.err.println("classfile dump failed : " + e.getMessage());
            e.printStackTrace();
        }
        try {
            Class aClass = defineClass(CLASS_TEST, bytecode, 0, bytecode.length);
            Method test = aClass.getDeclaredMethod(METHOD_TEST);
            test.invoke(null);
        } catch (ClassFormatError | IllegalArgumentException
                    | ReflectiveOperationException e) {
            throw new RuntimeException("TESTBUG : generated class is invalid", e);
        }
    }

    /*
        public class Test {
            volatile boolean flag = false;
            public static void m() {
                try {
                } finally {
                    Test test = new Test();
                    test.flag = true;
                }
            }
        }
    */
    private static byte[] generateTestClass() {
        ClassWriter cw = new ClassWriter(0);
        cw.visit(CLASS_FILE_VERSION, Opcodes.ACC_PUBLIC + Opcodes.ACC_SUPER,
                CLASS_TEST, null, CLASS_OBJECT, null);
        // volatile boolean flag;
        {
            FieldVisitor fv = cw.visitField(Opcodes.ACC_VOLATILE, FIELD_FLAG,
                    Type.BOOLEAN_TYPE.getDescriptor(),
                    /* signature = */ null, /* value = */ null);
        }

        /*
            public Test() {
                flag = false;
            }
        */
        {
            MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC,
                    METHOD_INIT, DESC_VOID_METHOD,
                    /* signature = */ null, /* exceptions = */ null);

            mv.visitCode();
            mv.visitVarInsn(Opcodes.ALOAD, 0);
            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, CLASS_OBJECT, METHOD_INIT,
                    DESC_VOID_METHOD, false);

            mv.visitVarInsn(Opcodes.ALOAD, 0);
            mv.visitInsn(Opcodes.ICONST_0);
            mv.visitFieldInsn(Opcodes.PUTFIELD, CLASS_TEST, FIELD_FLAG,
                    Type.BOOLEAN_TYPE.getDescriptor());

            mv.visitInsn(Opcodes.RETURN);
            mv.visitMaxs(/* stack = */ 2, /* locals = */ 1);
            mv.visitEnd();
        }

        /*
            public static void m() {
                try {
                } finally {
                    Test test = new Test();
                    test.flag = true;
                }
            }
        */
        {
            MethodVisitor mv = cw.visitMethod(
                    Opcodes.ACC_STATIC + Opcodes.ACC_PUBLIC,
                    METHOD_TEST, DESC_VOID_METHOD,
                    /* signature = */ null, /* exceptions = */ null);
            Label beginLabel = new Label();
            Label block1EndLabel = new Label();
            Label handlerLabel = new Label();
            Label block2EndLabel = new Label();
            Label label = new Label();
            Label endLabel = new Label();

            mv.visitCode();
            mv.visitTryCatchBlock(beginLabel, block1EndLabel, handlerLabel,
                    /* type = <any> */ null);
            mv.visitTryCatchBlock(handlerLabel, block2EndLabel, handlerLabel,
                    /* type = <any> */ null);

            mv.visitLabel(beginLabel);
            mv.visitJumpInsn(Opcodes.JSR, label);
            mv.visitLabel(block1EndLabel);
            mv.visitJumpInsn(Opcodes.GOTO, endLabel);

            mv.visitLabel(handlerLabel);
            mv.visitVarInsn(Opcodes.ASTORE, 0);
            mv.visitJumpInsn(Opcodes.JSR, label);
            mv.visitLabel(block2EndLabel);
            mv.visitVarInsn(Opcodes.ALOAD, 0);
            mv.visitInsn(Opcodes.ATHROW);

            mv.visitLabel(label);
            mv.visitVarInsn(Opcodes.ASTORE, 1);
            mv.visitTypeInsn(Opcodes.NEW, CLASS_TEST);
            mv.visitInsn(Opcodes.DUP);
            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, CLASS_TEST, METHOD_INIT,
                    DESC_VOID_METHOD);
            mv.visitVarInsn(Opcodes.ASTORE, 2);

            mv.visitVarInsn(Opcodes.ALOAD, 2);
            mv.visitInsn(Opcodes.ICONST_1);
            mv.visitFieldInsn(Opcodes.PUTFIELD, CLASS_TEST, FIELD_FLAG,
                    Type.BOOLEAN_TYPE.getDescriptor());

            mv.visitVarInsn(Opcodes.RET, 1);

            mv.visitLabel(endLabel);
            mv.visitInsn(Opcodes.RETURN);
            mv.visitMaxs(/* stack = */ 2, /* locals = */ 3);
            mv.visitEnd();
        }

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