1 /*
  2  * Copyright (c) 2018 SAP SE. 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 8141551
 27  * @summary C2 can not handle returns with inccompatible interface arrays
 28  * @requires vm.opt.final.TieredCompilation
 29  * @requires vm.compMode == "Xmixed" & vm.flavor == "server"
 30  * @modules java.base/jdk.internal.org.objectweb.asm
 31  *          java.base/jdk.internal.misc
 32  * @library /test/lib /
 33  *
 34  * @build sun.hotspot.WhiteBox
 35  * @run driver jdk.test.lib.helpers.ClassFileInstaller sun.hotspot.WhiteBox
 36  * @run main/othervm
 37  *        -Xbootclasspath/a:.
 38  *        -XX:+UnlockDiagnosticVMOptions
 39  *        -XX:+WhiteBoxAPI
 40  *        -Xbatch
 41  *        -XX:-TieredCompilation
 42  *        -XX:TieredStopAtLevel=4
 43  *        -XX:CICompilerCount=1
 44  *        -XX:+PrintCompilation
 45  *        -XX:+PrintInlining
 46  *        -XX:CompileCommand=compileonly,MeetIncompatibleInterfaceArrays*::run
 47  *        -XX:CompileCommand=dontinline,compiler.types.TestMeetIncompatibleInterfaceArrays$Helper::createI2*
 48  *        -XX:CompileCommand=quiet
 49  *        compiler.types.TestMeetIncompatibleInterfaceArrays 0
 50  * @run main/othervm
 51  *        -Xbootclasspath/a:.
 52  *        -XX:+UnlockDiagnosticVMOptions
 53  *        -XX:+WhiteBoxAPI
 54  *        -Xbatch
 55  *        -XX:-TieredCompilation
 56  *        -XX:TieredStopAtLevel=4
 57  *        -XX:CICompilerCount=1
 58  *        -XX:+PrintCompilation
 59  *        -XX:+PrintInlining
 60  *        -XX:CompileCommand=compileonly,MeetIncompatibleInterfaceArrays*::run
 61  *        -XX:CompileCommand=inline,compiler.types.TestMeetIncompatibleInterfaceArrays$Helper::createI2*
 62  *        -XX:CompileCommand=quiet
 63  *        compiler.types.TestMeetIncompatibleInterfaceArrays 1
 64  * @run main/othervm
 65  *        -Xbootclasspath/a:.
 66  *        -XX:+UnlockDiagnosticVMOptions
 67  *        -XX:+WhiteBoxAPI
 68  *        -Xbatch
 69  *        -XX:+TieredCompilation
 70  *        -XX:TieredStopAtLevel=4
 71  *        -XX:CICompilerCount=2
 72  *        -XX:+PrintCompilation
 73  *        -XX:+PrintInlining
 74  *        -XX:CompileCommand=compileonly,MeetIncompatibleInterfaceArrays*::run
 75  *        -XX:CompileCommand=compileonly,compiler.types.TestMeetIncompatibleInterfaceArrays$Helper::createI2*
 76  *        -XX:CompileCommand=inline,compiler.types.TestMeetIncompatibleInterfaceArrays$Helper::createI2*
 77  *        -XX:CompileCommand=quiet
 78  *        compiler.types.TestMeetIncompatibleInterfaceArrays 2
 79  *
 80  * @author volker.simonis@gmail.com
 81  */
 82 
 83 package compiler.types;
 84 
 85 import compiler.whitebox.CompilerWhiteBoxTest;
 86 import jdk.internal.org.objectweb.asm.ClassWriter;
 87 import jdk.internal.org.objectweb.asm.MethodVisitor;
 88 import sun.hotspot.WhiteBox;
 89 
 90 import java.io.FileOutputStream;
 91 import java.lang.reflect.InvocationTargetException;
 92 import java.lang.reflect.Method;
 93 
 94 import static jdk.internal.org.objectweb.asm.Opcodes.AALOAD;
 95 import static jdk.internal.org.objectweb.asm.Opcodes.ACC_PUBLIC;
 96 import static jdk.internal.org.objectweb.asm.Opcodes.ACC_STATIC;
 97 import static jdk.internal.org.objectweb.asm.Opcodes.ALOAD;
 98 import static jdk.internal.org.objectweb.asm.Opcodes.ARETURN;
 99 import static jdk.internal.org.objectweb.asm.Opcodes.ASTORE;
100 import static jdk.internal.org.objectweb.asm.Opcodes.GETSTATIC;
101 import static jdk.internal.org.objectweb.asm.Opcodes.ICONST_0;
102 import static jdk.internal.org.objectweb.asm.Opcodes.INVOKEINTERFACE;
103 import static jdk.internal.org.objectweb.asm.Opcodes.INVOKESPECIAL;
104 import static jdk.internal.org.objectweb.asm.Opcodes.INVOKESTATIC;
105 import static jdk.internal.org.objectweb.asm.Opcodes.INVOKEVIRTUAL;
106 import static jdk.internal.org.objectweb.asm.Opcodes.RETURN;
107 import static jdk.internal.org.objectweb.asm.Opcodes.V1_8;
108 
109 public class TestMeetIncompatibleInterfaceArrays extends ClassLoader {
110 
111     private static final WhiteBox WB = WhiteBox.getWhiteBox();
112 
113     public static interface I1 { public String getName(); }
114     public static interface I2 { public String getName(); }
115     public static class I2C implements I2 { public String getName() { return "I2";} }
116     public static class I21C implements I2, I1 { public String getName() { return "I2 and I1";} }
117 
118     public static class Helper {
119         public static I2 createI2Array0() {
120             return new I2C();
121         }
122         public static I2[] createI2Array1() {
123             return new I2C[] { new I2C() };
124         }
125         public static I2[][] createI2Array2() {
126             return new I2C[][] { new I2C[] { new I2C() } };
127         }
128         public static I2[][][] createI2Array3() {
129             return new I2C[][][] { new I2C[][] { new I2C[] { new I2C() } } };
130         }
131         public static I2[][][][] createI2Array4() {
132             return new I2C[][][][] { new I2C[][][] { new I2C[][] { new I2C[] { new I2C() } } } };
133         }
134         public static I2[][][][][] createI2Array5() {
135             return new I2C[][][][][] { new I2C[][][][] { new I2C[][][] { new I2C[][] { new I2C[] { new I2C() } } } } };
136         }
137         public static I2 createI21Array0() {
138             return new I21C();
139         }
140         public static I2[] createI21Array1() {
141             return new I21C[] { new I21C() };
142         }
143         public static I2[][] createI21Array2() {
144             return new I21C[][] { new I21C[] { new I21C() } };
145         }
146         public static I2[][][] createI21Array3() {
147             return new I21C[][][] { new I21C[][] { new I21C[] { new I21C() } } };
148         }
149         public static I2[][][][] createI21Array4() {
150             return new I21C[][][][] { new I21C[][][] { new I21C[][] { new I21C[] { new I21C() } } } };
151         }
152         public static I2[][][][][] createI21Array5() {
153             return new I21C[][][][][] { new I21C[][][][] { new I21C[][][] { new I21C[][] { new I21C[] { new I21C() } } } } };
154         }
155     }
156 
157     // Location for the generated class files
158     public static final String PATH = System.getProperty("test.classes", ".") + java.io.File.separator;
159 
160     /*
161      * With 'good == false' this helper method creates the following classes
162      * (using the nested 'Helper' class and the nested interfaces 'I1' and 'I2').
163      * For brevity I omit the enclosing class 'TestMeetIncompatibleInterfaceArrays' in the
164      * following examples:
165      *
166      * public class MeetIncompatibleInterfaceArrays0ASM {
167      *   public static I1 run() {
168      *     return Helper.createI2Array0(); // returns I2
169      *   }
170      *   public static void test() {
171      *     I1 i1 = run();
172      *     System.out.println(i1.getName());
173      *   }
174      * }
175      * public class MeetIncompatibleInterfaceArrays1ASM {
176      *   public static I1[] run() {
177      *     return Helper.createI2Array1(); // returns I2[]
178      *   }
179      *   public static void test() {
180      *     I1[] i1 = run();
181      *     System.out.println(i1[0].getName());
182      *   }
183      * }
184      * ...
185      * // MeetIncompatibleInterfaceArrays4ASM is special because it creates
186      * // an illegal class which will be rejected by the verifier.
187      * public class MeetIncompatibleInterfaceArrays4ASM {
188      *   public static I1[][][][] run() {
189      *     return Helper.createI2Array3(); // returns I1[][][] which gives a verifier error because return expects I1[][][][]
190      *   }
191      *   public static void test() {
192      *     I1[][][][] i1 = run();
193      *     System.out.println(i1[0][0][0][0].getName());
194      *   }
195      * ...
196      * public class MeetIncompatibleInterfaceArrays5ASM {
197      *   public static I1[][][][][] run() {
198      *     return Helper.createI2Array5(); // returns I2[][][][][]
199      *   }
200      *   public static void test() {
201      *     I1[][][][][] i1 = run();
202      *     System.out.println(i1[0][0][0][0][0].getName());
203      *   }
204      * }
205      *
206      * Notice that this is not legal Java code. We would have to use a cast in "run()" to make it legal:
207      *
208      *   public static I1[] run() {
209      *     return (I1[])Helper.createI2Array1(); // returns I2[]
210      *   }
211      *
212      * But in pure bytecode, the "run()" methods are perfectly legal:
213      *
214      *   public static I1[] run();
215      *     Code:
216      *       0: invokestatic  #16  // Method Helper.createI2Array1:()[LI2;
217      *       3: areturn
218      *
219      * The "test()" method calls the "getName()" function from I1 on the objects returned by "run()".
220      * This will epectedly fail with an "IncompatibleClassChangeError" because the objects returned
221      * by "run()" (and by createI2Array()) are actually of type "I2C" and only implement "I2" but not "I1".
222      *
223      *
224      * With 'good == true' this helper method will create the following classes:
225      *
226      * public class MeetIncompatibleInterfaceArraysGood0ASM {
227      *   public static I1 run() {
228      *     return Helper.createI21Array0(); // returns I2
229      *   }
230      *   public static void test() {
231      *     I1 i1 = run();
232      *     System.out.println(i1.getName());
233      *   }
234      * }
235      *
236      * Calling "test()" on these objects will succeed and output "I2 and I1" because now the "run()"
237      * method calls "createI21Array()" which actually return an object (or an array of objects) of
238      * type "I21C" which implements both "I2" and "I1".
239      *
240      * Notice that at the bytecode level, the code for the "run()" and "test()" methods in
241      * "MeetIncompatibleInterfaceArraysASM" and "MeetIncompatibleInterfaceArraysGoodASM" look exactly
242      * the same. I.e. the verifier has no chance to verify if the I2 object returned by "createI1Array()"
243      * or "createI21Array()" implements "I1" or not. That's actually the reason why both versions of
244      * generated classes are legal from a verifier point of view.
245      *
246      */
247     static void generateTestClass(int dim, boolean good) throws Exception {
248         String baseClassName = "MeetIncompatibleInterfaceArrays";
249         if (good)
250             baseClassName += "Good";
251         String createName = "createI2" + (good ? "1" : "") + "Array";
252         String a = "";
253         for (int i = 0; i < dim; i++)
254             a += "[";
255         ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
256         cw.visit(V1_8, ACC_PUBLIC, baseClassName + dim + "ASM", null, "java/lang/Object", null);
257         MethodVisitor constr = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
258         constr.visitCode();
259         constr.visitVarInsn(ALOAD, 0);
260         constr.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
261         constr.visitInsn(RETURN);
262         constr.visitMaxs(0, 0);
263         constr.visitEnd();
264         MethodVisitor run = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "run",
265                 "()" + a + "Lcompiler/types/TestMeetIncompatibleInterfaceArrays$I1;", null, null);
266         run.visitCode();
267         if (dim == 4) {
268             run.visitMethodInsn(INVOKESTATIC, "compiler/types/TestMeetIncompatibleInterfaceArrays$Helper", createName + 3,
269                     "()" + "[[[" + "Lcompiler/types/TestMeetIncompatibleInterfaceArrays$I2;", false);
270         } else {
271             run.visitMethodInsn(INVOKESTATIC, "compiler/types/TestMeetIncompatibleInterfaceArrays$Helper", createName + dim,
272                     "()" + a + "Lcompiler/types/TestMeetIncompatibleInterfaceArrays$I2;", false);
273         }
274         run.visitInsn(ARETURN);
275         run.visitMaxs(0, 0);
276         run.visitEnd();
277         MethodVisitor test = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "test", "()V", null, null);
278         test.visitCode();
279         test.visitMethodInsn(INVOKESTATIC, baseClassName + dim + "ASM", "run",
280                 "()" + a + "Lcompiler/types/TestMeetIncompatibleInterfaceArrays$I1;", false);
281         test.visitVarInsn(ASTORE, 0);
282         if (dim > 0) {
283             test.visitVarInsn(ALOAD, 0);
284             for (int i = 1; i <= dim; i++) {
285                 test.visitInsn(ICONST_0);
286                 test.visitInsn(AALOAD);
287             }
288             test.visitVarInsn(ASTORE, 1);
289         }
290         test.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
291         test.visitVarInsn(ALOAD, dim > 0 ? 1 : 0);
292         test.visitMethodInsn(INVOKEINTERFACE, "compiler/types/TestMeetIncompatibleInterfaceArrays$I1", "getName",
293                 "()Ljava/lang/String;", true);
294         test.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/Object;)V", false);
295         test.visitInsn(RETURN);
296         test.visitMaxs(0, 0);
297         test.visitEnd();
298 
299         // Get the bytes of the class..
300         byte[] b = cw.toByteArray();
301         // ..and write them into a class file (for debugging)
302         FileOutputStream fos = new FileOutputStream(PATH + baseClassName + dim + "ASM.class");
303         fos.write(b);
304         fos.close();
305 
306     }
307 
308     public static String[][] tier = { { "interpreted (tier 0)",
309                                         "C2 (tier 4) without inlining",
310                                         "C2 (tier 4) without inlining" },
311                                       { "interpreted (tier 0)",
312                                         "C2 (tier 4) with inlining",
313                                         "C2 (tier 4) with inlining" },
314                                       { "interpreted (tier 0)",
315                                         "C1 (tier 3) with inlining",
316                                         "C2 (tier 4) with inlining" } };
317 
318     public static int[][] level = { { CompilerWhiteBoxTest.COMP_LEVEL_NONE,
319                                       CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION,
320                                       CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION },
321                                     { CompilerWhiteBoxTest.COMP_LEVEL_NONE,
322                                       CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION,
323                                       CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION },
324                                     { CompilerWhiteBoxTest.COMP_LEVEL_NONE,
325                                       CompilerWhiteBoxTest.COMP_LEVEL_FULL_PROFILE,
326                                       CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION } };
327 
328     public static void main(String[] args) throws Exception {
329         final int pass = Integer.parseInt(args.length > 0 ? args[0] : "0");
330 
331         // Load and initialize some classes required for compilation
332         Class.forName("compiler.types.TestMeetIncompatibleInterfaceArrays$I1");
333         Class.forName("compiler.types.TestMeetIncompatibleInterfaceArrays$I2");
334         Class.forName("compiler.types.TestMeetIncompatibleInterfaceArrays$Helper");
335 
336         for (int g = 0; g < 2; g++) {
337             String baseClassName = "MeetIncompatibleInterfaceArrays";
338             boolean good = (g == 0) ? false : true;
339             if (good)
340                 baseClassName += "Good";
341             for (int i = 0; i < 6; i++) {
342                 System.out.println();
343                 System.out.println("Creating " + baseClassName + i + "ASM.class");
344                 System.out.println("========================================" + "=" + "=========");
345                 // Create the "MeetIncompatibleInterfaceArrays<i>ASM" class
346                 generateTestClass(i, good);
347                 Class<?> c = null;
348                 try {
349                     c = Class.forName(baseClassName + i + "ASM");
350                 } catch (VerifyError ve) {
351                     if (i == 4) {
352                         System.out.println("OK - must be (" + ve.getMessage() + ").");
353                     } else {
354                         throw ve;
355                     }
356                     continue;
357                 }
358                 // Call MeetIncompatibleInterfaceArrays<i>ASM.test()
359                 Method m = c.getMethod("test");
360                 Method r = c.getMethod("run");
361                 for (int j = 0; j < 3; j++) {
362                     System.out.println((j + 1) + ". invokation of " + baseClassName + i + "ASM.test() [::" +
363                                        r.getName() + "() should be '" + tier[pass][j] + "' compiled]");
364 
365                     // Skip Profiling compilation (C1) when Tiered is disabled.
366                     boolean profile = (level[pass][j] == CompilerWhiteBoxTest.COMP_LEVEL_FULL_PROFILE);
367                     if (profile && CompilerWhiteBoxTest.skipOnTieredCompilation(false)) {
368                         continue;
369                     }
370 
371                     WB.enqueueMethodForCompilation(r, level[pass][j]);
372 
373                     try {
374                         m.invoke(null);
375                     } catch (InvocationTargetException ite) {
376                         if (good) {
377                             throw ite;
378                         } else {
379                             if (ite.getCause() instanceof IncompatibleClassChangeError) {
380                                 System.out.println("  OK - catched InvocationTargetException("
381                                         + ite.getCause().getMessage() + ").");
382                             } else {
383                                 throw ite;
384                             }
385                         }
386                     }
387 
388                     int r_comp_level = WB.getMethodCompilationLevel(r);
389                     System.out.println("   invokation of " + baseClassName + i + "ASM.test() [::" +
390                                        r.getName() + "() was compiled at tier " + r_comp_level + "]");
391 
392                     if (r_comp_level != level[pass][j]) {
393                       throw new Exception("Method " + r + " must be compiled at tier " + level[pass][j] +
394                                           " but was compiled at " + r_comp_level + " instead!");
395                     }
396 
397                     WB.deoptimizeMethod(r);
398                 }
399             }
400         }
401     }
402 }