< prev index next >

test/hotspot/jtreg/compiler/types/TestMeetIncompatibleInterfaceArrays.java

Print this page
rev 49267 : 8198915: [Graal] 3rd testcase of compiler/types/TestMeetIncompatibleInterfaceArrays.java takes more than 10 mins
   1 /*
   2  * Copyright (c) 2015 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  * @modules java.base/jdk.internal.org.objectweb.asm
  29  *          java.base/jdk.internal.misc
  30  * @library /test/lib
  31  *
  32  * @build sun.hotspot.WhiteBox
  33  * @run driver ClassFileInstaller sun.hotspot.WhiteBox
  34  *                                sun.hotspot.WhiteBox$WhiteBoxPermission
  35  * @run main/othervm
  36  *        -Xbootclasspath/a:.
  37  *        -XX:+UnlockDiagnosticVMOptions
  38  *        -XX:+WhiteBoxAPI
  39  *        -Xbatch
  40  *        -XX:CompileThreshold=1
  41  *        -XX:-TieredCompilation
  42  *        -XX:CICompilerCount=1
  43  *        -XX:+PrintCompilation
  44  *        -XX:+PrintInlining
  45  *        -XX:CompileCommand=compileonly,MeetIncompatibleInterfaceArrays*::run
  46  *        -XX:CompileCommand=dontinline,compiler.types.TestMeetIncompatibleInterfaceArrays$Helper::createI2*
  47  *        -XX:CompileCommand=quiet
  48  *        compiler.types.TestMeetIncompatibleInterfaceArrays 0
  49  * @run main/othervm
  50  *        -Xbootclasspath/a:.
  51  *        -XX:+UnlockDiagnosticVMOptions
  52  *        -XX:+WhiteBoxAPI
  53  *        -Xbatch
  54  *        -XX:CompileThreshold=1
  55  *        -XX:-TieredCompilation
  56  *        -XX:CICompilerCount=1
  57  *        -XX:+PrintCompilation
  58  *        -XX:+PrintInlining
  59  *        -XX:CompileCommand=compileonly,MeetIncompatibleInterfaceArrays*::run
  60  *        -XX:CompileCommand=inline,compiler.types.TestMeetIncompatibleInterfaceArrays$Helper::createI2*
  61  *        -XX:CompileCommand=quiet
  62  *        compiler.types.TestMeetIncompatibleInterfaceArrays 1
  63  * @run main/othervm
  64  *        -Xbootclasspath/a:.
  65  *        -XX:+UnlockDiagnosticVMOptions
  66  *        -XX:+WhiteBoxAPI
  67  *        -Xbatch
  68  *        -XX:CompileThreshold=1
  69  *        -XX:Tier0InvokeNotifyFreqLog=0 -XX:Tier2InvokeNotifyFreqLog=0 -XX:Tier3InvokeNotifyFreqLog=0 -XX:Tier23InlineeNotifyFreqLog=0
  70  *        -XX:Tier3InvocationThreshold=2 -XX:Tier3MinInvocationThreshold=2 -XX:Tier3CompileThreshold=2
  71  *        -XX:Tier4InvocationThreshold=1 -XX:Tier4MinInvocationThreshold=1 -XX:Tier4CompileThreshold=1
  72  *        -XX:+TieredCompilation
  73  *        -XX:CICompilerCount=2
  74  *        -XX:+PrintCompilation
  75  *        -XX:+PrintInlining
  76  *        -XX:CompileCommand=compileonly,MeetIncompatibleInterfaceArrays*::run
  77  *        -XX:CompileCommand=compileonly,compiler.types.TestMeetIncompatibleInterfaceArrays$Helper::createI2*
  78  *        -XX:CompileCommand=inline,compiler.types.TestMeetIncompatibleInterfaceArrays$Helper::createI2*
  79  *        -XX:CompileCommand=quiet
  80  *        compiler.types.TestMeetIncompatibleInterfaceArrays 2
  81  *
  82  * @author volker.simonis@gmail.com
  83  */
  84 
  85 package compiler.types;
  86 

  87 import jdk.internal.org.objectweb.asm.ClassWriter;
  88 import jdk.internal.org.objectweb.asm.MethodVisitor;
  89 import sun.hotspot.WhiteBox;
  90 
  91 import java.io.FileOutputStream;
  92 import java.lang.reflect.InvocationTargetException;
  93 import java.lang.reflect.Method;
  94 
  95 import static jdk.internal.org.objectweb.asm.Opcodes.AALOAD;
  96 import static jdk.internal.org.objectweb.asm.Opcodes.ACC_PUBLIC;
  97 import static jdk.internal.org.objectweb.asm.Opcodes.ACC_STATIC;
  98 import static jdk.internal.org.objectweb.asm.Opcodes.ALOAD;
  99 import static jdk.internal.org.objectweb.asm.Opcodes.ARETURN;
 100 import static jdk.internal.org.objectweb.asm.Opcodes.ASTORE;
 101 import static jdk.internal.org.objectweb.asm.Opcodes.GETSTATIC;
 102 import static jdk.internal.org.objectweb.asm.Opcodes.ICONST_0;
 103 import static jdk.internal.org.objectweb.asm.Opcodes.INVOKEINTERFACE;
 104 import static jdk.internal.org.objectweb.asm.Opcodes.INVOKESPECIAL;
 105 import static jdk.internal.org.objectweb.asm.Opcodes.INVOKESTATIC;
 106 import static jdk.internal.org.objectweb.asm.Opcodes.INVOKEVIRTUAL;


 173      *     System.out.println(i1.getName());
 174      *   }
 175      * }
 176      * public class MeetIncompatibleInterfaceArrays1ASM {
 177      *   public static I1[] run() {
 178      *     return Helper.createI2Array1(); // returns I2[]
 179      *   }
 180      *   public static void test() {
 181      *     I1[] i1 = run();
 182      *     System.out.println(i1[0].getName());
 183      *   }
 184      * }
 185      * ...
 186      * // MeetIncompatibleInterfaceArrays4ASM is special because it creates
 187      * // an illegal class which will be rejected by the verifier.
 188      * public class MeetIncompatibleInterfaceArrays4ASM {
 189      *   public static I1[][][][] run() {
 190      *     return Helper.createI2Array3(); // returns I1[][][] which gives a verifier error because return expects I1[][][][]
 191      *   }
 192      *   public static void test() {
 193      *     I1[][][][][] i1 = run();
 194      *     System.out.println(i1[0][0][0][0][0].getName());
 195      *   }
 196      * ...
 197      * public class MeetIncompatibleInterfaceArrays5ASM {
 198      *   public static I1[][][][][] run() {
 199      *     return Helper.createI2Array5(); // returns I2[][][][][]
 200      *   }
 201      *   public static void test() {
 202      *     I1[][][][][] i1 = run();
 203      *     System.out.println(i1[0][0][0][0][0].getName());
 204      *   }
 205      * }
 206      *
 207      * Notice that this is not legal Java code. We would have to use a cast in "run()" to make it legal:
 208      *
 209      *   public static I1[] run() {
 210      *     return (I1[])Helper.createI2Array1(); // returns I2[]
 211      *   }
 212      *
 213      * But in pure bytecode, the "run()" methods are perfectly legal:
 214      *


 289             test.visitVarInsn(ASTORE, 1);
 290         }
 291         test.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
 292         test.visitVarInsn(ALOAD, dim > 0 ? 1 : 0);
 293         test.visitMethodInsn(INVOKEINTERFACE, "compiler/types/TestMeetIncompatibleInterfaceArrays$I1", "getName",
 294                 "()Ljava/lang/String;", true);
 295         test.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/Object;)V", false);
 296         test.visitInsn(RETURN);
 297         test.visitMaxs(0, 0);
 298         test.visitEnd();
 299 
 300         // Get the bytes of the class..
 301         byte[] b = cw.toByteArray();
 302         // ..and write them into a class file (for debugging)
 303         FileOutputStream fos = new FileOutputStream(PATH + baseClassName + dim + "ASM.class");
 304         fos.write(b);
 305         fos.close();
 306 
 307     }
 308 
 309     public static String[][] tier = { { "interpreted", "C2 (tier 4) without inlining", "C2 (tier4) without inlining" },
 310             { "interpreted", "C2 (tier 4) with inlining", "C2 (tier4) with inlining" },
 311             { "interpreted", "C1 (tier 3) with inlining", "C2 (tier4) with inlining" } };
















 312 
 313     public static void main(String[] args) throws Exception {
 314         final int pass = Integer.parseInt(args.length > 0 ? args[0] : "0");
 315 
 316         // Load and initialize some classes required for compilation
 317         Class.forName("compiler.types.TestMeetIncompatibleInterfaceArrays$I1");
 318         Class.forName("compiler.types.TestMeetIncompatibleInterfaceArrays$I2");
 319         Class.forName("compiler.types.TestMeetIncompatibleInterfaceArrays$Helper");
 320 
 321         for (int g = 0; g < 2; g++) {
 322             String baseClassName = "MeetIncompatibleInterfaceArrays";
 323             boolean good = (g == 0) ? false : true;
 324             if (good)
 325                 baseClassName += "Good";
 326             for (int i = 0; i < 6; i++) {
 327                 System.out.println();
 328                 System.out.println("Creating " + baseClassName + i + "ASM.class");
 329                 System.out.println("========================================" + "=" + "=========");
 330                 // Create the "MeetIncompatibleInterfaceArrays<i>ASM" class
 331                 generateTestClass(i, good);
 332                 Class<?> c = null;
 333                 try {
 334                     c = Class.forName(baseClassName + i + "ASM");
 335                 } catch (VerifyError ve) {
 336                     if (i == 4) {
 337                         System.out.println("OK - must be (" + ve.getMessage() + ").");
 338                     } else {
 339                         throw ve;
 340                     }
 341                     continue;
 342                 }
 343                 // Call MeetIncompatibleInterfaceArrays<i>ASM.test()
 344                 Method m = c.getMethod("test");
 345                 Method r = c.getMethod("run");
 346                 for (int j = 0; j < 3; j++) {
 347                     System.out.println((j + 1) + ". invokation of " + baseClassName + i + "ASM.test() [should be "
 348                             + tier[pass][j] + "]");



 349                     try {
 350                         m.invoke(null);
 351                     } catch (InvocationTargetException ite) {
 352                         if (good) {
 353                             throw ite;
 354                         } else {
 355                             if (ite.getCause() instanceof IncompatibleClassChangeError) {
 356                                 System.out.println("  OK - catched InvocationTargetException("
 357                                         + ite.getCause().getMessage() + ").");
 358                             } else {
 359                                 throw ite;
 360                             }
 361                         }
 362                     }







 363                 }
 364                 System.out.println("Method " + r + (WB.isMethodCompiled(r) ? " has" : " has not") + " been compiled.");
 365                 if (!WB.isMethodCompiled(r)) {
 366                     throw new Exception("Method " + r + " must be compiled!");
 367                 }
 368             }
 369         }
 370     }
 371 }
   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  * @modules java.base/jdk.internal.org.objectweb.asm
  29  *          java.base/jdk.internal.misc
  30  * @library /test/lib /
  31  *
  32  * @build sun.hotspot.WhiteBox
  33  * @run driver ClassFileInstaller sun.hotspot.WhiteBox
  34  *                                sun.hotspot.WhiteBox$WhiteBoxPermission
  35  * @run main/othervm
  36  *        -Xbootclasspath/a:.
  37  *        -XX:+UnlockDiagnosticVMOptions
  38  *        -XX:+WhiteBoxAPI
  39  *        -Xbatch

  40  *        -XX:-TieredCompilation
  41  *        -XX:CICompilerCount=1
  42  *        -XX:+PrintCompilation
  43  *        -XX:+PrintInlining
  44  *        -XX:CompileCommand=compileonly,MeetIncompatibleInterfaceArrays*::run
  45  *        -XX:CompileCommand=dontinline,compiler.types.TestMeetIncompatibleInterfaceArrays$Helper::createI2*
  46  *        -XX:CompileCommand=quiet
  47  *        compiler.types.TestMeetIncompatibleInterfaceArrays 0
  48  * @run main/othervm
  49  *        -Xbootclasspath/a:.
  50  *        -XX:+UnlockDiagnosticVMOptions
  51  *        -XX:+WhiteBoxAPI
  52  *        -Xbatch

  53  *        -XX:-TieredCompilation
  54  *        -XX:CICompilerCount=1
  55  *        -XX:+PrintCompilation
  56  *        -XX:+PrintInlining
  57  *        -XX:CompileCommand=compileonly,MeetIncompatibleInterfaceArrays*::run
  58  *        -XX:CompileCommand=inline,compiler.types.TestMeetIncompatibleInterfaceArrays$Helper::createI2*
  59  *        -XX:CompileCommand=quiet
  60  *        compiler.types.TestMeetIncompatibleInterfaceArrays 1
  61  * @run main/othervm
  62  *        -Xbootclasspath/a:.
  63  *        -XX:+UnlockDiagnosticVMOptions
  64  *        -XX:+WhiteBoxAPI
  65  *        -Xbatch





  66  *        -XX:CICompilerCount=2
  67  *        -XX:+PrintCompilation
  68  *        -XX:+PrintInlining
  69  *        -XX:CompileCommand=compileonly,MeetIncompatibleInterfaceArrays*::run
  70  *        -XX:CompileCommand=compileonly,compiler.types.TestMeetIncompatibleInterfaceArrays$Helper::createI2*
  71  *        -XX:CompileCommand=inline,compiler.types.TestMeetIncompatibleInterfaceArrays$Helper::createI2*
  72  *        -XX:CompileCommand=quiet
  73  *        compiler.types.TestMeetIncompatibleInterfaceArrays 2
  74  *
  75  * @author volker.simonis@gmail.com
  76  */
  77 
  78 package compiler.types;
  79 
  80 import compiler.whitebox.CompilerWhiteBoxTest;
  81 import jdk.internal.org.objectweb.asm.ClassWriter;
  82 import jdk.internal.org.objectweb.asm.MethodVisitor;
  83 import sun.hotspot.WhiteBox;
  84 
  85 import java.io.FileOutputStream;
  86 import java.lang.reflect.InvocationTargetException;
  87 import java.lang.reflect.Method;
  88 
  89 import static jdk.internal.org.objectweb.asm.Opcodes.AALOAD;
  90 import static jdk.internal.org.objectweb.asm.Opcodes.ACC_PUBLIC;
  91 import static jdk.internal.org.objectweb.asm.Opcodes.ACC_STATIC;
  92 import static jdk.internal.org.objectweb.asm.Opcodes.ALOAD;
  93 import static jdk.internal.org.objectweb.asm.Opcodes.ARETURN;
  94 import static jdk.internal.org.objectweb.asm.Opcodes.ASTORE;
  95 import static jdk.internal.org.objectweb.asm.Opcodes.GETSTATIC;
  96 import static jdk.internal.org.objectweb.asm.Opcodes.ICONST_0;
  97 import static jdk.internal.org.objectweb.asm.Opcodes.INVOKEINTERFACE;
  98 import static jdk.internal.org.objectweb.asm.Opcodes.INVOKESPECIAL;
  99 import static jdk.internal.org.objectweb.asm.Opcodes.INVOKESTATIC;
 100 import static jdk.internal.org.objectweb.asm.Opcodes.INVOKEVIRTUAL;


 167      *     System.out.println(i1.getName());
 168      *   }
 169      * }
 170      * public class MeetIncompatibleInterfaceArrays1ASM {
 171      *   public static I1[] run() {
 172      *     return Helper.createI2Array1(); // returns I2[]
 173      *   }
 174      *   public static void test() {
 175      *     I1[] i1 = run();
 176      *     System.out.println(i1[0].getName());
 177      *   }
 178      * }
 179      * ...
 180      * // MeetIncompatibleInterfaceArrays4ASM is special because it creates
 181      * // an illegal class which will be rejected by the verifier.
 182      * public class MeetIncompatibleInterfaceArrays4ASM {
 183      *   public static I1[][][][] run() {
 184      *     return Helper.createI2Array3(); // returns I1[][][] which gives a verifier error because return expects I1[][][][]
 185      *   }
 186      *   public static void test() {
 187      *     I1[][][][] i1 = run();
 188      *     System.out.println(i1[0][0][0][0].getName());
 189      *   }
 190      * ...
 191      * public class MeetIncompatibleInterfaceArrays5ASM {
 192      *   public static I1[][][][][] run() {
 193      *     return Helper.createI2Array5(); // returns I2[][][][][]
 194      *   }
 195      *   public static void test() {
 196      *     I1[][][][][] i1 = run();
 197      *     System.out.println(i1[0][0][0][0][0].getName());
 198      *   }
 199      * }
 200      *
 201      * Notice that this is not legal Java code. We would have to use a cast in "run()" to make it legal:
 202      *
 203      *   public static I1[] run() {
 204      *     return (I1[])Helper.createI2Array1(); // returns I2[]
 205      *   }
 206      *
 207      * But in pure bytecode, the "run()" methods are perfectly legal:
 208      *


 283             test.visitVarInsn(ASTORE, 1);
 284         }
 285         test.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
 286         test.visitVarInsn(ALOAD, dim > 0 ? 1 : 0);
 287         test.visitMethodInsn(INVOKEINTERFACE, "compiler/types/TestMeetIncompatibleInterfaceArrays$I1", "getName",
 288                 "()Ljava/lang/String;", true);
 289         test.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/Object;)V", false);
 290         test.visitInsn(RETURN);
 291         test.visitMaxs(0, 0);
 292         test.visitEnd();
 293 
 294         // Get the bytes of the class..
 295         byte[] b = cw.toByteArray();
 296         // ..and write them into a class file (for debugging)
 297         FileOutputStream fos = new FileOutputStream(PATH + baseClassName + dim + "ASM.class");
 298         fos.write(b);
 299         fos.close();
 300 
 301     }
 302 
 303     public static String[][] tier = { { "interpreted (tier 0)",
 304                                         "C2 (tier 4) without inlining",
 305                                         "C2 (tier4) without inlining" },
 306                                       { "interpreted (tier 0)",
 307                                         "C2 (tier 4) with inlining",
 308                                         "C2 (tier4) with inlining" },
 309                                       { "interpreted (tier 0)",
 310                                         "C1 (tier 3) with inlining",
 311                                         "C2 (tier4) with inlining" } };
 312 
 313     public static int[][] level = { { CompilerWhiteBoxTest.COMP_LEVEL_NONE,
 314                                       CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION,
 315                                       CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION },
 316                                     { CompilerWhiteBoxTest.COMP_LEVEL_NONE,
 317                                       CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION,
 318                                       CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION },
 319                                     { CompilerWhiteBoxTest.COMP_LEVEL_NONE,
 320                                       CompilerWhiteBoxTest.COMP_LEVEL_FULL_PROFILE,
 321                                       CompilerWhiteBoxTest.COMP_LEVEL_FULL_OPTIMIZATION } };
 322 
 323     public static void main(String[] args) throws Exception {
 324         final int pass = Integer.parseInt(args.length > 0 ? args[0] : "0");
 325 
 326         // Load and initialize some classes required for compilation
 327         Class.forName("compiler.types.TestMeetIncompatibleInterfaceArrays$I1");
 328         Class.forName("compiler.types.TestMeetIncompatibleInterfaceArrays$I2");
 329         Class.forName("compiler.types.TestMeetIncompatibleInterfaceArrays$Helper");
 330 
 331         for (int g = 0; g < 2; g++) {
 332             String baseClassName = "MeetIncompatibleInterfaceArrays";
 333             boolean good = (g == 0) ? false : true;
 334             if (good)
 335                 baseClassName += "Good";
 336             for (int i = 0; i < 6; i++) {
 337                 System.out.println();
 338                 System.out.println("Creating " + baseClassName + i + "ASM.class");
 339                 System.out.println("========================================" + "=" + "=========");
 340                 // Create the "MeetIncompatibleInterfaceArrays<i>ASM" class
 341                 generateTestClass(i, good);
 342                 Class<?> c = null;
 343                 try {
 344                     c = Class.forName(baseClassName + i + "ASM");
 345                 } catch (VerifyError ve) {
 346                     if (i == 4) {
 347                         System.out.println("OK - must be (" + ve.getMessage() + ").");
 348                     } else {
 349                         throw ve;
 350                     }
 351                     continue;
 352                 }
 353                 // Call MeetIncompatibleInterfaceArrays<i>ASM.test()
 354                 Method m = c.getMethod("test");
 355                 Method r = c.getMethod("run");
 356                 for (int j = 0; j < 3; j++) {
 357                     System.out.println((j + 1) + ". invokation of " + baseClassName + i + "ASM.test() [::" +
 358                                        r.getName() + "() should be '" + tier[pass][j] + "' compiled]");
 359 
 360                     WB.enqueueMethodForCompilation(r, level[pass][j]);
 361 
 362                     try {
 363                         m.invoke(null);
 364                     } catch (InvocationTargetException ite) {
 365                         if (good) {
 366                             throw ite;
 367                         } else {
 368                             if (ite.getCause() instanceof IncompatibleClassChangeError) {
 369                                 System.out.println("  OK - catched InvocationTargetException("
 370                                         + ite.getCause().getMessage() + ").");
 371                             } else {
 372                                 throw ite;
 373                             }
 374                         }
 375                     }
 376 
 377                     int r_comp_level = WB.getMethodCompilationLevel(r);
 378                     System.out.println("   invokation of " + baseClassName + i + "ASM.test() [::" +
 379                                        r.getName() + "() was compiled at tier " + r_comp_level + "]");
 380 
 381                     if (r_comp_level != level[pass][j]) {
 382                       throw new Exception("Method " + r + " must be compiled at tier " + r_comp_level + " !");
 383                     }
 384 
 385                     WB.deoptimizeMethod(r);

 386                 }
 387             }
 388         }
 389     }
 390 }
< prev index next >