1 /*
2 * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2018 SAP SE. All rights reserved.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 */
24
25 /**
26 * @test
27 * @summary Check that the verbose message of ICCE is printed correctly.
28 * The test forces errors in vtable stubs and interpreter.
29 * @requires !(os.arch=="arm")
30 * @library /test/lib /
31 * @build sun.hotspot.WhiteBox
32 * @run driver ClassFileInstaller sun.hotspot.WhiteBox sun.hotspot.WhiteBox$WhiteBoxPermission
33 * @compile IncompatibleClassChangeErrorTest.java
34 * @compile ImplementsSomeInterfaces.jasm ICC_B.jasm
35 * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
36 * -XX:-BackgroundCompilation -XX:-Inline
37 * -XX:CompileCommand=exclude,IncompatibleClassChangeErrorTest::test_iccInt
38 * IncompatibleClassChangeErrorTest
39 */
40
41 import sun.hotspot.WhiteBox;
42 import compiler.whitebox.CompilerWhiteBoxTest;
43 import java.lang.reflect.Method;
44
45 // This test assembles an errorneous installation of classes.
46 // First, compile the test by @compile. This results in a legal set
47 // of classes.
48 // Then, with jasm, generate incompatible classes that overwrite
49 // the class files in the build directory.
50 // Last, call the real tests throwing IncompatibleClassChangeErrors
51 // and check the messages generated.
52 public class IncompatibleClassChangeErrorTest {
53
54 private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
55
56 private static boolean enableChecks = true;
57
58 private static String expectedErrorMessageInterpreted =
59 "Class ImplementsSomeInterfaces " +
60 "does not implement the requested interface InterfaceICCE1";
61 private static String expectedErrorMessageCompiled =
62 "Class ICC_B does not implement the requested interface ICC_iB";
63 // old message: "vtable stub"
64
65 public static void setup_test() {
66 // Assure all exceptions are loaded.
67 new AbstractMethodError();
68 new IncompatibleClassChangeError();
69
70 enableChecks = false;
71 // Warmup
72 System.out.println("warmup:");
73 test_iccInt();
74 test_icc_compiled_itable_stub();
75 enableChecks = true;
76
77 // Compile
78 try {
79 Method method = IncompatibleClassChangeErrorTest.class.getMethod("test_icc_compiled_itable_stub");
80 WHITE_BOX.enqueueMethodForCompilation(method, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION);
81 if (!WHITE_BOX.isMethodCompiled(method)) {
82 throw new RuntimeException(method.getName() + " is not compiled");
83 }
84 method = ICC_C.class.getMethod("b");
85 WHITE_BOX.enqueueMethodForCompilation(method, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION);
86 if (!WHITE_BOX.isMethodCompiled(method)) {
87 throw new RuntimeException("ICC_C." + method.getName() + " is not compiled");
88 }
89 method = ICC_D.class.getMethod("b");
90 WHITE_BOX.enqueueMethodForCompilation(method, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION);
91 if (!WHITE_BOX.isMethodCompiled(method)) {
92 throw new RuntimeException("ICC_D." + method.getName() + " is not compiled");
93 }
94 method = ICC_E.class.getMethod("b");
95 WHITE_BOX.enqueueMethodForCompilation(method, CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION);
96 if (!WHITE_BOX.isMethodCompiled(method)) {
97 throw new RuntimeException("ICC_E." + method.getName() + " is not compiled");
98 }
99 } catch (NoSuchMethodException e) { }
100 System.out.println("warmup done.");
101 }
102
103 // Should never be compiled.
104 public static void test_iccInt() {
105 boolean caught_icc = false;
106 try {
107 InterfaceICCE1 objectInterface = new ImplementsSomeInterfaces();
108 // IncompatibleClassChangeError gets thrown in
109 // - TemplateTable::invokeinterface()
110 // - LinkResolver::runtime_resolve_interface_method()
111 objectInterface.aFunctionOfMyInterface();
112 } catch (IncompatibleClassChangeError e) {
113 String errorMsg = e.getMessage();
114 if (enableChecks && !errorMsg.equals(expectedErrorMessageInterpreted)) {
115 System.out.println("Expected: " + expectedErrorMessageInterpreted + "\n" +
116 "but got: " + errorMsg);
117 throw new RuntimeException("Wrong error message of IncompatibleClassChangeError.");
118 }
119 caught_icc = true;
120 } catch (Throwable e) {
121 throw new RuntimeException("Caught unexpected exception: " + e);
122 }
123
124 // Check we got the exception.
125 if (!caught_icc) {
126 throw new RuntimeException("Expected IncompatibleClassChangeError was not thrown.");
127 }
128 }
129
130 // -------------------------------------------------------------------------
131 // Test AbstractMethodErrors detected in itable stubs.
132 // Note: How can we verify that we really stepped through the vtable stub?
133 // - Bimorphic inlining should not happen since we have no profiling data when
134 // we compile the method
135 // - As a result, an inline cache call should be generated
136 // - This inline cache call is patched into a real vtable call at the first
137 // re-resolve, which happens constantly during the first 10 iterations of the loop.
138 // => we should be fine! :-)
139 public static void test_icc_compiled_itable_stub() {
140 // Allocated the objects we need and call a valid method.
141 boolean caught_icc = false;
142 ICC_B b = new ICC_B();
143 ICC_C c = new ICC_C();
144 ICC_D d = new ICC_D();
145 ICC_E e = new ICC_E();
146 b.a();
147 c.a();
148 d.a();
149 e.a();
150
151 try {
152 final int iterations = 10;
153 // Test: calls b.b() in the last iteration.
154 for (int i = 0; i < iterations; i++) {
155 ICC_iB a = b;
156 if (i % 3 == 0 && i < iterations - 1) {
157 a = c;
158 }
159 if (i % 3 == 1 && i < iterations - 1) {
160 a = d;
161 }
162 if (i % 3 == 2 && i < iterations - 1) {
163 a = e;
164 }
165 a.b();
166 }
167 } catch (AbstractMethodError exc) {
168 // It's a subclass of IncompatibleClassChangeError, so we must catch this first.
169 System.out.println();
170 System.out.println(exc);
171 if (enableChecks) {
172 String errorMsg = exc.getMessage();
173 if (errorMsg == null) {
174 throw new RuntimeException("Caught unexpected AbstractMethodError with empty message.");
175 }
176 throw new RuntimeException("Caught unexpected AbstractMethodError.");
177 }
178 } catch (IncompatibleClassChangeError exc) {
179 caught_icc = true;
180 System.out.println();
181 String errorMsg = exc.getMessage();
182 if (enableChecks && errorMsg == null) {
183 System.out.println(exc);
184 throw new RuntimeException("Empty error message of IncompatibleClassChangeError.");
185 }
186 if (enableChecks &&
187 !errorMsg.equals(expectedErrorMessageCompiled)) {
188 System.out.println("Expected: " + expectedErrorMessageCompiled + "\n" +
189 "but got: " + errorMsg);
190 System.out.println(exc);
191 throw new RuntimeException("Wrong error message of IncompatibleClassChangeError.");
192 }
193 if (enableChecks) {
194 System.out.println("Passed with message: " + errorMsg);
195 }
196 } catch (Throwable exc) {
197 throw exc; // new RuntimeException("Caught unexpected exception: " + exc);
198 }
199
200 // Check we got the exception at some point.
201 if (enableChecks && !caught_icc) {
202 throw new RuntimeException("Expected IncompatibleClassChangeError was not thrown.");
203 }
204 }
205
206 public static void main(String[] args) throws Exception {
207 setup_test();
208 test_iccInt();
209 test_icc_compiled_itable_stub();
210 }
211 }
212
213
214 // Helper classes to test incompatible class change in interpreter.
215 //
216 // The test also contains .jasm files with implementations
217 // of the classes that shall generate the errors.
218
219
220 // I0 // interface defining aFunctionOfMyInterface()
221 // |
222 // | I1 // interface
223 // | |
224 // A0 | // abstract class
225 // \ /
226 // C // class not implementing I1 and
227 // not implementing I0::aFunctionOfMyInterface()
228 //
229 // Test is expected to throw error because of missing interface and not
230 // because of missing method.
231
232 interface InterfaceICCE0 {
233 public String firstFunctionOfMyInterface0();
234 public String secondFunctionOfMyInterface0();
235 }
236
237 interface InterfaceICCE1 {
238
239 public String firstFunctionOfMyInterface();
240
241 public String secondFunctionOfMyInterface();
242
243 public String aFunctionOfMyInterface();
244 }
245
246 abstract class AbstractICCE0 implements InterfaceICCE0 {
247 abstract public String firstAbstractMethod();
248 abstract public String secondAbstractMethod();
249
250 abstract public String anAbstractMethod();
251 }
252
253 class ImplementsSomeInterfaces extends
254 AbstractICCE0
255 // This interface is missing in the .jasm implementation.
256 implements InterfaceICCE1
257 {
258
259 public String firstAbstractMethod() {
260 return this.getClass().getName();
261 }
262
263 public String secondAbstractMethod() {
264 return this.getClass().getName();
265 }
266
267 // This method is missing in the .jasm implementation.
268 public String anAbstractMethod() {
269 return this.getClass().getName();
270 }
271
272 public String firstFunctionOfMyInterface0() {
273 return this.getClass().getName();
274 }
275
276 public String secondFunctionOfMyInterface0() {
277 return this.getClass().getName();
278 }
279
280 public String firstFunctionOfMyInterface() {
281 return this.getClass().getName();
282 }
283
284 public String secondFunctionOfMyInterface() {
285 return this.getClass().getName();
286 }
287
288 // This method is missing in the .jasm implementation.
289 public String aFunctionOfMyInterface() {
290 return this.getClass().getName();
291 }
292 }
293
294 // Helper classes to test incompatible class change in itable stub.
295 //
296 // Class hierachy:
297 //
298 // iA,iB (interfaces)
299 // /|\ \
300 // C D E \
301 // B (bad class, missing interface implementation)
302
303 interface ICC_iA {
304 public void a();
305 }
306
307 interface ICC_iB {
308 public void b();
309 }
310
311 // This is the errorneous class. A variant of it not
312 // implementing ICC_iB is copied into the test before
313 // it is run.
314 class ICC_B implements ICC_iA,
315 // This interface is missing in the .jasm implementation.
316 ICC_iB {
317 public void a() {
318 System.out.print("B.a() ");
319 }
320
321 public void b() {
322 System.out.print("B.b() ");
323 }
324 }
325
326 class ICC_C implements ICC_iA, ICC_iB {
327 public void a() {
328 System.out.print("C.a() ");
329 }
330
331 public void b() {
332 System.out.print("C.b() ");
333 }
334 }
335
336 class ICC_D implements ICC_iA, ICC_iB {
337 public void a() {
338 System.out.print("D.a() ");
339 }
340
341 public void b() {
342 System.out.print("D.b() ");
343 }
344 }
345
346 class ICC_E implements ICC_iA, ICC_iB {
347 public void a() {
348 System.out.print("E.a() ");
349 }
350
351 public void b() {
352 System.out.print("E.b() ");
353 }
354 }