/* * Copyright (c) 2017, 2024, 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 8186046 * @summary Test nested dynamic constant declarations that are recursive * @compile CondyNestedTest_Code.jcod * @run testng CondyNestedTest * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:UseBootstrapCallInfo=3 CondyNestedTest */ import org.testng.Assert; import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; import java.lang.invoke.MethodHandles; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class CondyNestedTest { static final Class[] THROWABLES = {InvocationTargetException.class, StackOverflowError.class}; private static final MethodHandles.Lookup L = MethodHandles.lookup(); Class c; // static final MethodHandles.Lookup L = MethodHandles.lookup(); // // /** // * Generate class file bytes for a class named CondyNestedTest_Code // * whose bytes are converted to a jcod file: // * // * java -jar asmtools.jar jdec CondyNestedTest_Code.class > // * CondyNestedTest_Code.jcod // * // * which was then edited so that dynamic constant declarations are // * recursive both for an ldc or invokedynamic (specifically declaring a // * BSM+attributes whose static argument is a dynamic constant // * that refers to the same BSM+attributes). // */ // public static byte[] generator() throws Exception { // String genClassName = L.lookupClass().getSimpleName() + "_Code"; // ClassDesc genClassDesc = ClassDesc.of(genClassName); // String bsmDescriptor = MethodType.methodType(Object.class, MethodHandles.Lookup.class, String.class, Object.class, // Object.class).toMethodDescriptorString(); // String bsmIndyDescriptor = MethodType.methodType(CallSite.class, MethodHandles.Lookup.class, String.class, // Object.class, Object.class).toMethodDescriptorString(); // DirectMethodHandleDesc bsmMhDesc = MethodHandleDesc.of( // DirectMethodHandleDesc.Kind.STATIC, // genClassDesc, // "bsm", // bsmDescriptor // ); // DirectMethodHandleDesc bsmIndyMhDesc = MethodHandleDesc.of( // DirectMethodHandleDesc.Kind.STATIC, // genClassDesc, // "bsmIndy", // bsmIndyDescriptor // ); // byte[] byteArray = ClassFile.of().build(ClassDesc.of(genClassName), classBuilder -> classBuilder // .withVersion(55, 0) // .withSuperclass(ConstantDescs.CD_Object) // .withMethod(ConstantDescs.INIT_NAME, ConstantDescs.MTD_void, ClassFile.ACC_PUBLIC, methodBuilder -> methodBuilder // .withCode(codeBuilder -> codeBuilder // .aload(0) // .invokespecial(ConstantDescs.CD_Object, ConstantDescs.INIT_NAME, ConstantDescs.MTD_void) // .return_() // ) // ) // .withMethod("main", MethodTypeDesc.of(ConstantDescs.CD_void, ConstantDescs.CD_String.arrayType()), // ClassFile.ACC_PUBLIC + ClassFile.ACC_STATIC, methodBuilder -> methodBuilder // .withCode(codeBuilder -> { // codeBuilder // .aload(0) // .iconst_0() // .aaload() // .invokevirtual(ConstantDescs.CD_String, "intern", // MethodTypeDesc.of(ConstantDescs.CD_String)) // .astore(1); // Label case1 = codeBuilder.newLabel(); // codeBuilder // .aload(1) // .ldc("condy_bsm_condy_bsm") // .if_acmpne(case1) // .invokestatic(genClassDesc, "condy_bsm_condy_bsm", // MethodTypeDesc.of(ConstantDescs.CD_Object)) // .return_(); // Label case2 = codeBuilder.newLabel(); // codeBuilder // .labelBinding(case1) // .aload(1) // .ldc("indy_bsmIndy_condy_bsm") // .if_acmpne(case2) // .invokestatic(genClassDesc, "indy_bsmIndy_condy_bsm", // MethodTypeDesc.of(ConstantDescs.CD_Object)) // .return_(); // Label case3 = codeBuilder.newLabel(); // codeBuilder // .labelBinding(case2) // .aload(1) // .ldc("indy_bsm_condy_bsm") // .if_acmpne(case3) // .invokestatic(genClassDesc, "indy_bsm_condy_bsm", // MethodTypeDesc.of(ConstantDescs.CD_Object)) // .return_(); // codeBuilder // .labelBinding(case3) // .return_(); // } // ) // ) // // bsm that when used with indy returns a call site whose target is MethodHandles.constant(String.class, name), and // // when used with condy returns the name // .withMethod("bsm", MethodTypeDesc.ofDescriptor(bsmDescriptor), // ClassFile.ACC_PUBLIC + ClassFile.ACC_STATIC, methodBuilder -> methodBuilder // .withCode(codeBuilder -> { // codeBuilder // .aload(2) // .instanceOf(ConstantDescs.CD_MethodType) // .iconst_0(); // Label condy = codeBuilder.newLabel(); // codeBuilder // .if_acmpeq(condy) // .new_(ClassDesc.ofDescriptor(ConstantCallSite.class.descriptorString())) // .dup() // .ldc(ConstantDescs.CD_String) // .aload(1) // .invokestatic(ConstantDescs.CD_MethodHandles, "constant", // MethodTypeDesc.of(ConstantDescs.CD_MethodHandle, ConstantDescs.CD_Class, // ConstantDescs.CD_Object)) // .invokespecial(ClassDesc.ofDescriptor(ConstantCallSite.class.descriptorString()), // ConstantDescs.INIT_NAME, // MethodTypeDesc.of(ConstantDescs.CD_void, ConstantDescs.CD_MethodHandle)) // .areturn(); // codeBuilder // .labelBinding(condy) // .aload(1) // .areturn(); // } // // ) // ) // // an indy bsm, that returns a call site whose target is MethodHandles.constant(String.class, methodName) // .withMethod("bsmIndy", MethodTypeDesc.ofDescriptor(bsmIndyDescriptor), // ClassFile.ACC_PUBLIC + ClassFile.ACC_PUBLIC, methodBuilder -> methodBuilder // .withCode(codeBuilder -> codeBuilder // .new_(ClassDesc.ofDescriptor(ConstantCallSite.class.descriptorString())) // .dup() // .ldc(ConstantDescs.CD_String) // .aload(1) // .invokestatic(ConstantDescs.CD_MethodHandles, "constant", // MethodTypeDesc.of(ConstantDescs.CD_MethodHandle, ConstantDescs.CD_Class, // ConstantDescs.CD_Object)) // .invokespecial(ClassDesc.ofDescriptor(ConstantCallSite.class.descriptorString()), // ConstantDescs.INIT_NAME, // MethodTypeDesc.of(ConstantDescs.CD_void, ConstantDescs.CD_MethodHandle)) // .areturn() // ) // ) // .withMethod("condy_bsm_condy_bsm", MethodTypeDesc.of(ConstantDescs.CD_Object), // ClassFile.ACC_PUBLIC + ClassFile.ACC_STATIC, methodBuilder -> methodBuilder // .withCode(codeBuilder -> codeBuilder // .ldc(DynamicConstantDesc.ofNamed( // bsmMhDesc, // "name", // ConstantDescs.CD_String, // DynamicConstantDesc.ofNamed( // bsmMhDesc, // "name", // ConstantDescs.CD_String, // "DUMMY_ARG" // ) // ) // ) // .areturn() // ) // ) // .withMethod("indy_bsmIndy_condy_bsm", MethodTypeDesc.of(ConstantDescs.CD_Object), // ClassFile.ACC_PUBLIC + ClassFile.ACC_STATIC, methodBuilder -> methodBuilder // .withCode(codeBuilder -> codeBuilder // .invokedynamic(DynamicCallSiteDesc.of( // bsmIndyMhDesc, // "name", // MethodTypeDesc.of(ConstantDescs.CD_String), // DynamicConstantDesc.ofNamed( // bsmMhDesc, // "name", // ConstantDescs.CD_String, // "DUMMY_ARG" // ) // ) // ) // .areturn() // ) // ) // .withMethod("indy_bsm_condy_bsm", MethodTypeDesc.of(ConstantDescs.CD_Object), // ClassFile.ACC_PUBLIC + ClassFile.ACC_STATIC, methodBuilder -> methodBuilder // .withCode(codeBuilder -> codeBuilder // .invokedynamic(DynamicCallSiteDesc.of( // bsmMhDesc, // "name", // MethodTypeDesc.of(ConstantDescs.CD_String), // DynamicConstantDesc.ofNamed( // bsmMhDesc, // "name", // ConstantDescs.CD_String, // "DUMMY_ARG" // ) // ) // ) // .areturn() // ) // ) // ); // // File f = new File(genClassName + ".class"); // if (f.getParentFile() != null) { // f.getParentFile().mkdirs(); // } // new FileOutputStream(f).write(byteArray); // return byteArray; // } static void test(Method m, Class... ts) { Throwable caught = null; try { m.invoke(null); } catch (Throwable t) { caught = t; } if (caught == null) { Assert.fail("Throwable expected"); } String actualMessage = null; for (int i = 0; i < ts.length; i++) { actualMessage = caught.getMessage(); Assert.assertNotNull(caught); Assert.assertTrue(ts[i].isAssignableFrom(caught.getClass())); caught = caught.getCause(); } } @BeforeClass public void findClass() throws Exception { c = Class.forName("CondyNestedTest_Code"); } /** * Testing an ldc of a dynamic constant, C say, with a BSM whose static * argument is C. */ @Test public void testCondyBsmCondyBsm() throws Exception { test("condy_bsm_condy_bsm", THROWABLES); } /** * Testing an invokedynamic with a BSM whose static argument is a constant * dynamic, C say, with a BSM whose static argument is C. */ @Test public void testIndyBsmIndyCondyBsm() throws Exception { test("indy_bsmIndy_condy_bsm", THROWABLES); } /** * Testing an invokedynamic with a BSM, B say, whose static argument is * a dynamic constant, C say, that uses BSM B. */ @Test public void testIndyBsmCondyBsm() throws Exception { test("indy_bsm_condy_bsm", THROWABLES); } void test(String methodName, Class... ts) throws Exception { Method m = c.getMethod(methodName); m.setAccessible(true); test(m, ts); } }