1 /* 2 * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 /* 25 * @test 26 * @bug 8238358 27 * @summary Lambda back-end should generate invokespecial for method handles referring to 28 * private instance methods when compiling with --release 14 29 * @enablePreview 30 * @library /tools/javac/lib 31 * @modules java.base/jdk.internal.classfile.impl 32 * jdk.compiler/com.sun.tools.javac.api 33 * jdk.compiler/com.sun.tools.javac.file 34 * jdk.compiler/com.sun.tools.javac.util 35 * @build combo.ComboTestHelper 36 * @run main TestLambdaBytecodeTargetRelease14 37 */ 38 39 import java.lang.classfile.*; 40 import java.lang.classfile.attribute.*; 41 import java.lang.classfile.constantpool.InvokeDynamicEntry; 42 import java.lang.classfile.constantpool.MethodHandleEntry; 43 import java.lang.classfile.instruction.InvokeDynamicInstruction; 44 45 import java.io.IOException; 46 import java.io.InputStream; 47 48 import combo.ComboInstance; 49 import combo.ComboParameter; 50 import combo.ComboTask.Result; 51 import combo.ComboTestHelper; 52 53 import java.lang.invoke.MethodHandleInfo; 54 import javax.tools.JavaFileObject; 55 56 public class TestLambdaBytecodeTargetRelease14 extends ComboInstance<TestLambdaBytecodeTargetRelease14> { 57 58 static final int MF_ARITY = 3; 59 static final String MH_SIG = "()V"; 60 61 enum ClassKind implements ComboParameter { 62 CLASS("class"), 63 INTERFACE("interface"); 64 65 String classStr; 66 67 ClassKind(String classStr) { 68 this.classStr = classStr; 69 } 70 71 @Override 72 public String expand(String optParameter) { 73 return classStr; 74 } 75 } 76 77 enum AccessKind implements ComboParameter { 78 PUBLIC("public"), 79 PRIVATE("private"); 80 81 String accessStr; 82 83 AccessKind(String accessStr) { 84 this.accessStr = accessStr; 85 } 86 87 @Override 88 public String expand(String optParameter) { 89 return accessStr; 90 } 91 } 92 93 enum StaticKind implements ComboParameter { 94 STATIC("static"), 95 INSTANCE(""); 96 97 String staticStr; 98 99 StaticKind(String staticStr) { 100 this.staticStr = staticStr; 101 } 102 103 @Override 104 public String expand(String optParameter) { 105 return staticStr; 106 } 107 } 108 109 enum DefaultKind implements ComboParameter { 110 DEFAULT("default"), 111 NO_DEFAULT(""); 112 113 String defaultStr; 114 115 DefaultKind(String defaultStr) { 116 this.defaultStr = defaultStr; 117 } 118 119 @Override 120 public String expand(String optParameter) { 121 return defaultStr; 122 } 123 } 124 125 static class MethodKind { 126 ClassKind ck; 127 AccessKind ak; 128 StaticKind sk; 129 DefaultKind dk; 130 131 MethodKind(ClassKind ck, AccessKind ak, StaticKind sk, DefaultKind dk) { 132 this.ck = ck; 133 this.ak = ak; 134 this.sk = sk; 135 this.dk = dk; 136 } 137 138 boolean inInterface() { 139 return ck == ClassKind.INTERFACE; 140 } 141 142 boolean isPrivate() { 143 return ak == AccessKind.PRIVATE; 144 } 145 146 boolean isStatic() { 147 return sk == StaticKind.STATIC; 148 } 149 150 boolean isDefault() { 151 return dk == DefaultKind.DEFAULT; 152 } 153 154 boolean isOK() { 155 if (isDefault() && (!inInterface() || isStatic())) { 156 return false; 157 } else if (inInterface() && 158 ((!isStatic() && !isDefault()) || isPrivate())) { 159 return false; 160 } else { 161 return true; 162 } 163 } 164 } 165 166 public static void main(String... args) throws Exception { 167 new ComboTestHelper<TestLambdaBytecodeTargetRelease14>() 168 .withDimension("CLASSKIND", (x, ck) -> x.ck = ck, ClassKind.values()) 169 .withArrayDimension("ACCESS", (x, acc, idx) -> x.accessKinds[idx] = acc, 2, AccessKind.values()) 170 .withArrayDimension("STATIC", (x, sk, idx) -> x.staticKinds[idx] = sk, 2, StaticKind.values()) 171 .withArrayDimension("DEFAULT", (x, dk, idx) -> x.defaultKinds[idx] = dk, 2, DefaultKind.values()) 172 .run(TestLambdaBytecodeTargetRelease14::new, TestLambdaBytecodeTargetRelease14::init); 173 } 174 175 ClassKind ck; 176 AccessKind[] accessKinds = new AccessKind[2]; 177 StaticKind[] staticKinds = new StaticKind[2]; 178 DefaultKind[] defaultKinds = new DefaultKind[2]; 179 MethodKind mk1, mk2; 180 181 void init() { 182 mk1 = new MethodKind(ck, accessKinds[0], staticKinds[0], defaultKinds[0]); 183 mk2 = new MethodKind(ck, accessKinds[1], staticKinds[1], defaultKinds[1]); 184 } 185 186 String source_template = 187 "#{CLASSKIND} Test {\n" + 188 " #{ACCESS[0]} #{STATIC[0]} #{DEFAULT[0]} void test() { Runnable r = ()->{ target(); }; }\n" + 189 " #{ACCESS[1]} #{STATIC[1]} #{DEFAULT[1]} void target() { }\n" + 190 "}\n"; 191 192 @Override 193 public void doWork() throws IOException { 194 newCompilationTask() 195 .withSourceFromTemplate(source_template) 196 .withOption("--release").withOption("14") 197 .generate(this::verifyBytecode); 198 } 199 200 void verifyBytecode(Result<Iterable<? extends JavaFileObject>> res) { 201 if (res.hasErrors()) { 202 boolean errorExpected = !mk1.isOK() || !mk2.isOK(); 203 errorExpected |= mk1.isStatic() && !mk2.isStatic(); 204 205 if (!errorExpected) { 206 fail("Diags found when compiling instance; " + res.compilationInfo()); 207 } 208 return; 209 } 210 try (InputStream is = res.get().iterator().next().openInputStream()) { 211 ClassModel cm = ClassFile.of().parse(is.readAllBytes()); 212 MethodModel testMethod = null; 213 for (MethodModel m : cm.methods()) { 214 if (m.methodName().equalsString("test")) { 215 testMethod = m; 216 break; 217 } 218 } 219 if (testMethod == null) { 220 fail("Test method not found"); 221 return; 222 } 223 CodeAttribute ea = testMethod.findAttribute(Attributes.CODE).orElse(null); 224 if (ea == null) { 225 fail("Code attribute for test() method not found"); 226 return; 227 } 228 229 int bsmIdx = -1; 230 231 for (CodeElement ce : ea.elementList()) { 232 if (ce instanceof InvokeDynamicInstruction indy) { 233 InvokeDynamicEntry indyInfo = indy.invokedynamic(); 234 bsmIdx = indyInfo.bootstrap().bsmIndex(); 235 if (!indyInfo.type().equalsString(makeIndyType())) { 236 fail("type mismatch for CONSTANT_InvokeDynamic_info " + 237 res.compilationInfo() + "\n" + indyInfo.type().stringValue() + 238 "\n" + makeIndyType()); 239 return; 240 } 241 } 242 } 243 if (bsmIdx == -1) { 244 fail("Missing invokedynamic in generated code"); 245 return; 246 } 247 248 BootstrapMethodsAttribute bsm_attr = cm.findAttribute(Attributes.BOOTSTRAP_METHODS).orElseThrow(); 249 if (bsm_attr.bootstrapMethodsSize() != 1) { 250 fail("Bad number of method specifiers " + 251 "in BootstrapMethods attribute"); 252 return; 253 } 254 BootstrapMethodEntry bsm_spec = bsm_attr.bootstrapMethods().get(0); 255 256 if (bsm_spec.arguments().size() != MF_ARITY) { 257 fail("Bad number of static invokedynamic args " + 258 "in BootstrapMethod attribute"); 259 return; 260 } 261 262 MethodHandleEntry mh = (MethodHandleEntry) bsm_spec.arguments().get(1); 263 264 boolean kindOK = switch (mh.kind()) { 265 case MethodHandleInfo.REF_invokeStatic -> mk2.isStatic(); 266 case MethodHandleInfo.REF_invokeSpecial -> !mk2.isStatic(); 267 case MethodHandleInfo.REF_invokeInterface -> mk2.inInterface(); 268 default -> false; 269 }; 270 271 if (!kindOK) { 272 fail("Bad invoke kind in implementation method handle"); 273 return; 274 } 275 276 if (!mh.reference().type().equalsString(MH_SIG)) { 277 fail("Type mismatch in implementation method handle"); 278 } 279 } catch (Exception e) { 280 e.printStackTrace(); 281 fail("error reading " + res.compilationInfo() + ": " + e); 282 } 283 } 284 285 String makeIndyType() { 286 StringBuilder buf = new StringBuilder(); 287 buf.append("("); 288 if (!mk2.isStatic()) { 289 buf.append("LTest;"); 290 } 291 buf.append(")Ljava/lang/Runnable;"); 292 return buf.toString(); 293 } 294 }