/*
* Copyright (c) 2022, 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 8282241
* @summary Verifies class redefinition correctly updates generic_signature and source_file_name attributes
* @requires vm.jvmti
* @modules java.base/jdk.internal.org.objectweb.asm
* java.instrument
* @library /test/lib
* @run main RedefineClassHelper
* @run main/othervm -javaagent:redefineagent.jar --add-opens=java.base/java.lang=ALL-UNNAMED RedefineGenericSignatureTest
*/
import java.io.File;
import java.io.FileOutputStream;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Type;
import java.nio.file.Files;
import java.util.List;
import jdk.internal.org.objectweb.asm.ClassReader;
import jdk.internal.org.objectweb.asm.ClassVisitor;
import jdk.internal.org.objectweb.asm.ClassWriter;
import jdk.internal.org.objectweb.asm.Opcodes;
import jdk.test.lib.Asserts;
import jdk.test.lib.JDKToolLauncher;
import jdk.test.lib.compiler.InMemoryJavaCompiler;
import jdk.test.lib.process.ProcessTools;
import jdk.test.lib.process.OutputAnalyzer;
class GenericSignatureTester {
public GenericSignatureTarget<List<String>> method1() {
return null;
}
}
class GenericSignatureTarget<T extends List<?>> {
public GenericSignatureTarget<T> foo() { return null; }
public static void throwException() { throw new RuntimeException(); }
}
public class RedefineGenericSignatureTest {
private static final String newTargetClassSource =
"class GenericSignatureTarget<T> {\n" +
" public GenericSignatureTarget<T> foo() { return null; }\n" +
" public static void throwException() { throw new RuntimeException(); }\n" +
"}\n";
public static void main (String[] args) throws Throwable {
RedefineGenericSignatureTest test = new RedefineGenericSignatureTest();
test.runTest();
}
private final static String sourceFileName = "RedefineGenericSignatureTest.java";
private final static String sourceFileNameNew = "RedefineGenericSignatureTestNew.java";
// expected signature of GenericSignatureTester.method1 return type
private final static String expectedRetType = "GenericSignatureTarget<java.util.List<java.lang.String>>";
// expected generic signature of the original GenericSignatureTarget
private final static String expectedSigOld = "<T::Ljava/util/List<*>;>Ljava/lang/Object;";
// expected generic signature of the redefined GenericSignatureTarget
private final static String expectedSigNew = "<T:Ljava/lang/Object;>Ljava/lang/Object;";
private static void log(Object o) {
System.out.println(o);
}
private String getTargetGenSig() throws Throwable {
MethodHandles.Lookup lookup = MethodHandles.lookup();
MethodHandles.Lookup classLookup = MethodHandles.privateLookupIn(Class.class, lookup);
MethodHandle getGenericSignature0 = classLookup.findVirtual(
Class.class, "getGenericSignature0", MethodType.methodType(String.class));
Object genericSignature = getGenericSignature0.invoke(GenericSignatureTarget.class);
return String.valueOf(genericSignature);
}
private String getTesterRetType() throws Throwable {
Type type = GenericSignatureTester.class.getDeclaredMethod("method1").getGenericReturnType();
return String.valueOf(type);
}
private String getTargetSourceFilename() {
try {
GenericSignatureTarget.throwException();
} catch (RuntimeException ex) {
return ex.getStackTrace()[0].getFileName();
}
return "Cannot get source file name";
}
// Prints dissassembled class bytes.
private void printDisassembled(String description, Class cls, byte[] bytes) throws Exception {
log(description + " -------------------");
File f = new File(cls.getSimpleName()+".class");
try (FileOutputStream fos = new FileOutputStream(f)) {
fos.write(bytes);
}
JDKToolLauncher javap = JDKToolLauncher.create("javap")
.addToolArg("-verbose")
.addToolArg("-p") // Shows all classes and members.
//.addToolArg("-c") // Prints out disassembled code
.addToolArg("-s") // Prints internal type signatures.
.addToolArg(f.toString());
ProcessBuilder pb = new ProcessBuilder(javap.getCommand());
OutputAnalyzer out = ProcessTools.executeProcess(pb);
out.shouldHaveExitValue(0);
try {
Files.delete(f.toPath());
} catch (Exception ex) {
// ignore
}
out.asLines().forEach(s -> log(s));
log("==========================================");
Files.deleteIfExists(f.toPath());
}
private byte[] getNewClassBytes() {
byte[] bytecode = InMemoryJavaCompiler.compile(GenericSignatureTarget.class.getName(), newTargetClassSource);
ClassWriter cw = new ClassWriter(0);
ClassReader cr = new ClassReader(bytecode);
cr.accept(new ClassVisitor(Opcodes.ASM7, cw) {
private boolean sourceSet = false;
@Override
public void visitSource(String source, String debug) {
sourceSet = true;
log("Changing source: \"" + source + "\" -> \"" + sourceFileNameNew + "\"");
super.visitSource(sourceFileNameNew, debug);
}
@Override
public void visitEnd() {
if (!sourceSet) {
log("Set source: \"" + sourceFileNameNew + "\"");
super.visitSource(sourceFileNameNew, null);
}
super.visitEnd();
}
}, 0);
return cw.toByteArray();
}
private void runTest() throws Throwable {
Class targetClass = GenericSignatureTarget.class;
String oldSig = getTargetGenSig();
log("old target class sig: \"" + oldSig + "\"");
byte[] oldClassBytes = targetClass.getResourceAsStream(targetClass.getName() + ".class").readAllBytes();
printDisassembled("Old " + targetClass.getName(), targetClass, oldClassBytes);
log("Redefining " + targetClass.getName() + " class");
byte[] newClassBytes = getNewClassBytes();
printDisassembled("New " + targetClass.getName(), targetClass, newClassBytes);
RedefineClassHelper.redefineClass(targetClass, newClassBytes);
String newSig = getTargetGenSig();
log("new target class sig: \"" + newSig + "\"");
String newRetType = getTesterRetType();
log("new tester ret type: \"" + newRetType + "\"");
String newSrcFileName = getTargetSourceFilename();
log("new source file name: \"" + newSrcFileName + "\"");
Asserts.assertStringsEqual(expectedSigOld, oldSig, "wrong old generic signature");
Asserts.assertStringsEqual(expectedSigNew, newSig, "wrong new generic signature");
Asserts.assertStringsEqual(expectedRetType, newRetType, "wrong ret type");
Asserts.assertStringsEqual(sourceFileNameNew, newSrcFileName, "wrong new source file name");
}
}