268 lines
11 KiB
Java
268 lines
11 KiB
Java
/*
|
|
* Copyright (c) 2021, 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 8277634
|
|
* @summary Verify the correct constantpool entries are created for invokedynamic instructions using
|
|
* the same bootstrap and type, but different name.
|
|
* @library /tools/lib
|
|
* @enablePreview
|
|
* @modules jdk.compiler/com.sun.tools.javac.api
|
|
* jdk.compiler/com.sun.tools.javac.code
|
|
* jdk.compiler/com.sun.tools.javac.comp
|
|
* jdk.compiler/com.sun.tools.javac.jvm
|
|
* jdk.compiler/com.sun.tools.javac.main
|
|
* jdk.compiler/com.sun.tools.javac.tree
|
|
* jdk.compiler/com.sun.tools.javac.util
|
|
* java.base/jdk.internal.classfile.impl
|
|
* jdk.jdeps/com.sun.tools.javap
|
|
* @build toolbox.JarTask toolbox.JavacTask toolbox.JavapTask toolbox.ToolBox
|
|
* @run main IndyCorrectInvocationName
|
|
*/
|
|
|
|
import java.net.URL;
|
|
import java.net.URLClassLoader;
|
|
import java.nio.file.DirectoryStream;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.util.HashSet;
|
|
import java.util.Objects;
|
|
import java.util.Set;
|
|
|
|
import com.sun.source.util.JavacTask;
|
|
import com.sun.source.util.Plugin;
|
|
import com.sun.source.util.TaskEvent;
|
|
import com.sun.source.util.TaskListener;
|
|
|
|
import java.lang.classfile.*;
|
|
import java.lang.classfile.attribute.*;
|
|
import java.lang.classfile.constantpool.*;
|
|
import java.lang.classfile.instruction.*;
|
|
|
|
import com.sun.tools.javac.api.BasicJavacTask;
|
|
import com.sun.tools.javac.code.Symbol;
|
|
import com.sun.tools.javac.code.Symbol.MethodSymbol;
|
|
import com.sun.tools.javac.code.Symtab;
|
|
import com.sun.tools.javac.code.Type;
|
|
import com.sun.tools.javac.jvm.PoolConstant;
|
|
import com.sun.tools.javac.tree.JCTree;
|
|
import com.sun.tools.javac.tree.JCTree.JCClassDecl;
|
|
import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
|
|
import com.sun.tools.javac.tree.JCTree.JCLiteral;
|
|
import com.sun.tools.javac.tree.JCTree.JCMethodInvocation;
|
|
import com.sun.tools.javac.tree.JCTree.Tag;
|
|
import com.sun.tools.javac.tree.TreeMaker;
|
|
import com.sun.tools.javac.tree.TreeScanner;
|
|
import com.sun.tools.javac.util.Context;
|
|
import com.sun.tools.javac.util.Names;
|
|
|
|
import toolbox.JarTask;
|
|
import toolbox.ToolBox;
|
|
|
|
|
|
public class IndyCorrectInvocationName implements Plugin {
|
|
private static final String NL = System.lineSeparator();
|
|
|
|
public static void main(String... args) throws Exception {
|
|
new IndyCorrectInvocationName().run();
|
|
}
|
|
|
|
void run() throws Exception {
|
|
ToolBox tb = new ToolBox();
|
|
Path pluginClasses = Path.of("plugin-classes");
|
|
tb.writeFile(pluginClasses.resolve("META-INF").resolve("services").resolve(Plugin.class.getName()),
|
|
IndyCorrectInvocationName.class.getName() + System.lineSeparator());
|
|
try (DirectoryStream<Path> ds = Files.newDirectoryStream(Path.of(ToolBox.testClasses))) {
|
|
for (Path p : ds) {
|
|
if (p.getFileName().toString().startsWith("IndyCorrectInvocationName") ||
|
|
p.getFileName().toString().endsWith(".class")) {
|
|
Files.copy(p, pluginClasses.resolve(p.getFileName()));
|
|
}
|
|
}
|
|
}
|
|
|
|
Path pluginJar = Path.of("plugin.jar");
|
|
new JarTask(tb, pluginJar)
|
|
.baseDir(pluginClasses)
|
|
.files(".")
|
|
.run();
|
|
|
|
Path src = Path.of("src");
|
|
tb.writeJavaFiles(src,
|
|
"""
|
|
import java.lang.invoke.CallSite;
|
|
import java.lang.invoke.ConstantCallSite;
|
|
import java.lang.invoke.MethodHandles;
|
|
import java.lang.invoke.MethodHandles.Lookup;
|
|
import java.lang.invoke.MethodType;
|
|
public class Test{
|
|
private static final String NL = System.lineSeparator();
|
|
private static StringBuilder output = new StringBuilder();
|
|
public static void doRun() {
|
|
method("a");
|
|
method("b");
|
|
method("a");
|
|
method("b");
|
|
}
|
|
public static String run() {
|
|
doRun();
|
|
return output.toString();
|
|
}
|
|
public static void method(String name) {}
|
|
public static void actualMethod(String name) {
|
|
output.append(name).append(NL);
|
|
}
|
|
public static CallSite bootstrap(Lookup lookup, String name, MethodType type) throws Exception {
|
|
return new ConstantCallSite(MethodHandles.lookup()
|
|
.findStatic(Test.class,
|
|
"actualMethod",
|
|
MethodType.methodType(void.class,
|
|
String.class))
|
|
.bindTo(name));
|
|
}
|
|
}
|
|
""");
|
|
Path classes = Files.createDirectories(Path.of("classes"));
|
|
|
|
new toolbox.JavacTask(tb)
|
|
.classpath(pluginJar)
|
|
.options("-XDaccessInternalAPI")
|
|
.outdir(classes)
|
|
.files(tb.findJavaFiles(src))
|
|
.run()
|
|
.writeAll();
|
|
|
|
URLClassLoader cl = new URLClassLoader(new URL[] {classes.toUri().toURL()});
|
|
|
|
String actual = (String) cl.loadClass("Test")
|
|
.getMethod("run")
|
|
.invoke(null);
|
|
String expected = "a" + NL + "b" + NL + "a" + NL +"b" + NL;
|
|
if (!Objects.equals(actual, expected)) {
|
|
throw new AssertionError("expected: " + expected + "; but got: " + actual);
|
|
}
|
|
|
|
Path testClass = classes.resolve("Test.class");
|
|
ClassModel cf = ClassFile.of().parse(testClass);
|
|
BootstrapMethodsAttribute bootAttr = cf.findAttribute(Attributes.bootstrapMethods()).orElseThrow();
|
|
if (bootAttr.bootstrapMethodsSize() != 1) {
|
|
throw new AssertionError("Incorrect number of bootstrap methods: " +
|
|
bootAttr.bootstrapMethodsSize());
|
|
}
|
|
CodeAttribute codeAttr = cf.methods().get(1).findAttribute(Attributes.code()).orElseThrow();
|
|
Set<BootstrapMethodEntry> seenBootstraps = new HashSet<>();
|
|
Set<NameAndTypeEntry> seenNameAndTypes = new HashSet<>();
|
|
Set<String> seenNames = new HashSet<>();
|
|
for (CodeElement i : codeAttr.elementList()) {
|
|
if (i instanceof Instruction instruction) {
|
|
switch (instruction ) {
|
|
case InvokeDynamicInstruction indy -> {
|
|
InvokeDynamicEntry dynamicInfo = indy.invokedynamic();
|
|
seenBootstraps.add(dynamicInfo.bootstrap());
|
|
seenNameAndTypes.add(dynamicInfo.nameAndType());
|
|
NameAndTypeEntry nameAndTypeInfo = dynamicInfo.nameAndType();
|
|
seenNames.add(nameAndTypeInfo.name().stringValue());
|
|
}
|
|
case ReturnInstruction returnInstruction -> {
|
|
}
|
|
default -> throw new AssertionError("Unexpected instruction: " + instruction.opcode());
|
|
}
|
|
}
|
|
}
|
|
if (seenBootstraps.size() != 1) {
|
|
throw new AssertionError("Unexpected bootstraps: " + seenBootstraps);
|
|
}
|
|
if (seenNameAndTypes.size() != 2) {
|
|
throw new AssertionError("Unexpected names and types: " + seenNameAndTypes);
|
|
}
|
|
if (!seenNames.equals(Set.of("a", "b"))) {
|
|
throw new AssertionError("Unexpected names and types: " + seenNames);
|
|
}
|
|
}
|
|
|
|
// Plugin impl...
|
|
|
|
@Override
|
|
public String getName() { return "IndyCorrectInvocationName"; }
|
|
|
|
@Override
|
|
public void init(JavacTask task, String... args) {
|
|
Context c = ((BasicJavacTask) task).getContext();
|
|
task.addTaskListener(new TaskListener() {
|
|
@Override
|
|
public void started(TaskEvent e) {
|
|
if (e.getKind() == TaskEvent.Kind.GENERATE) {
|
|
convert(c, (JCCompilationUnit) e.getCompilationUnit());
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public boolean autoStart() {
|
|
return true;
|
|
}
|
|
|
|
private void convert(Context context, JCCompilationUnit toplevel) {
|
|
TreeMaker make = TreeMaker.instance(context);
|
|
Names names = Names.instance(context);
|
|
Symtab syms = Symtab.instance(context);
|
|
new TreeScanner() {
|
|
MethodSymbol bootstrap;
|
|
@Override
|
|
public void visitClassDef(JCClassDecl tree) {
|
|
bootstrap = (MethodSymbol) tree.sym.members().getSymbolsByName(names.fromString("bootstrap")).iterator().next();
|
|
super.visitClassDef(tree);
|
|
}
|
|
@Override
|
|
public void visitApply(JCMethodInvocation tree) {
|
|
if (tree.args.size() == 1 && tree.args.head.hasTag(Tag.LITERAL)) {
|
|
String name = (String) ((JCLiteral) tree.args.head).value;
|
|
Type.MethodType indyType = new Type.MethodType(
|
|
com.sun.tools.javac.util.List.nil(),
|
|
syms.voidType,
|
|
com.sun.tools.javac.util.List.nil(),
|
|
syms.methodClass
|
|
);
|
|
Symbol.DynamicMethodSymbol dynSym = new Symbol.DynamicMethodSymbol(names.fromString(name),
|
|
syms.noSymbol,
|
|
bootstrap.asHandle(),
|
|
indyType,
|
|
new PoolConstant.LoadableConstant[0]);
|
|
|
|
JCTree.JCFieldAccess qualifier = make.Select(make.QualIdent(bootstrap.owner), dynSym.name);
|
|
qualifier.sym = dynSym;
|
|
qualifier.type = syms.voidType;
|
|
tree.meth = qualifier;
|
|
tree.args = com.sun.tools.javac.util.List.nil();
|
|
tree.type = syms.voidType;
|
|
}
|
|
super.visitApply(tree);
|
|
}
|
|
|
|
}.scan(toplevel);
|
|
}
|
|
|
|
}
|