1 /*
   2  * Copyright (c) 2013, 2014, 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 import sun.hotspot.WhiteBox;
  25 import sun.hotspot.code.NMethod;
  26 
  27 import java.lang.reflect.Constructor;
  28 import java.lang.reflect.Executable;
  29 import java.lang.reflect.Method;
  30 import java.util.Objects;
  31 import java.util.concurrent.Callable;
  32 import java.util.function.Function;
  33 
  34 /**
  35  * Abstract class for WhiteBox testing of JIT.
  36  *
  37  * @author igor.ignatyev@oracle.com
  38  */
  39 public abstract class CompilerWhiteBoxTest {
  40     /** {@code CompLevel::CompLevel_none} -- Interpreter */
  41     protected static int COMP_LEVEL_NONE = 0;
  42     /** {@code CompLevel::CompLevel_any}, {@code CompLevel::CompLevel_all} */
  43     protected static int COMP_LEVEL_ANY = -1;
  44     /** {@code CompLevel::CompLevel_simple} -- C1 */
  45     protected static int COMP_LEVEL_SIMPLE = 1;
  46     /** {@code CompLevel::CompLevel_limited_profile} -- C1, invocation & backedge counters */
  47     protected static int COMP_LEVEL_LIMITED_PROFILE = 2;
  48     /** {@code CompLevel::CompLevel_full_profile} -- C1, invocation & backedge counters + mdo */
  49     protected static int COMP_LEVEL_FULL_PROFILE = 3;
  50     /** {@code CompLevel::CompLevel_full_optimization} -- C2 or Shark */
  51     protected static int COMP_LEVEL_FULL_OPTIMIZATION = 4;
  52     /** Maximal value for CompLevel */
  53     protected static int COMP_LEVEL_MAX = COMP_LEVEL_FULL_OPTIMIZATION;
  54 
  55     /** Instance of WhiteBox */
  56     protected static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
  57     /** Value of {@code -XX:CompileThreshold} */
  58     protected static final int COMPILE_THRESHOLD
  59             = Integer.parseInt(getVMOption("CompileThreshold", "10000"));
  60     /** Value of {@code -XX:BackgroundCompilation} */
  61     protected static final boolean BACKGROUND_COMPILATION
  62             = Boolean.valueOf(getVMOption("BackgroundCompilation", "true"));
  63     /** Value of {@code -XX:TieredCompilation} */
  64     protected static final boolean TIERED_COMPILATION
  65             = Boolean.valueOf(getVMOption("TieredCompilation", "false"));
  66     /** Value of {@code -XX:TieredStopAtLevel} */
  67     protected static final int TIERED_STOP_AT_LEVEL
  68             = Integer.parseInt(getVMOption("TieredStopAtLevel", "0"));
  69     /** Flag for verbose output, true if {@code -Dverbose} specified */
  70     protected static final boolean IS_VERBOSE
  71             = System.getProperty("verbose") != null;
  72     /** invocation count to trigger compilation */
  73     protected static final int THRESHOLD;
  74     /** invocation count to trigger OSR compilation */
  75     protected static final long BACKEDGE_THRESHOLD;
  76     /** invocation count to warm up method before triggering OSR compilation */
  77     protected static final long OSR_WARMUP = 2000;
  78     /** Value of {@code java.vm.info} (interpreted|mixed|comp mode) */
  79     protected static final String MODE = System.getProperty("java.vm.info");
  80 
  81     static {
  82         if (TIERED_COMPILATION) {
  83             BACKEDGE_THRESHOLD = THRESHOLD = 150000;
  84         } else {
  85             THRESHOLD = COMPILE_THRESHOLD;
  86             BACKEDGE_THRESHOLD = COMPILE_THRESHOLD * Long.parseLong(getVMOption(
  87                     "OnStackReplacePercentage"));
  88         }
  89     }
  90 
  91     /**
  92      * Returns value of VM option.
  93      *
  94      * @param name option's name
  95      * @return value of option or {@code null}, if option doesn't exist
  96      * @throws NullPointerException if name is null
  97      */
  98     protected static String getVMOption(String name) {
  99         Objects.requireNonNull(name);
 100         return Objects.toString(WHITE_BOX.getVMFlag(name), null);
 101     }
 102 
 103     /**
 104      * Returns value of VM option or default value.
 105      *
 106      * @param name         option's name
 107      * @param defaultValue default value
 108      * @return value of option or {@code defaultValue}, if option doesn't exist
 109      * @throws NullPointerException if name is null
 110      * @see #getVMOption(String)
 111      */
 112     protected static String getVMOption(String name, String defaultValue) {
 113         String result = getVMOption(name);
 114         return result == null ? defaultValue : result;
 115     }
 116 
 117     /** copy of is_c1_compile(int) from utilities/globalDefinitions.hpp */
 118     protected static boolean isC1Compile(int compLevel) {
 119         return (compLevel > COMP_LEVEL_NONE)
 120                 && (compLevel < COMP_LEVEL_FULL_OPTIMIZATION);
 121     }
 122 
 123     /** copy of is_c2_compile(int) from utilities/globalDefinitions.hpp */
 124     protected static boolean isC2Compile(int compLevel) {
 125         return compLevel == COMP_LEVEL_FULL_OPTIMIZATION;
 126     }
 127 
 128     protected static void main(
 129             Function<TestCase, CompilerWhiteBoxTest> constructor,
 130             String[] args) {
 131         if (args.length == 0) {
 132             for (TestCase test : SimpleTestCase.values()) {
 133                 constructor.apply(test).runTest();
 134             }
 135         } else {
 136             for (String name : args) {
 137                 constructor.apply(SimpleTestCase.valueOf(name)).runTest();
 138             }
 139         }
 140     }
 141 
 142     /** tested method */
 143     protected final Executable method;
 144     protected final TestCase testCase;
 145 
 146     /**
 147      * Constructor.
 148      *
 149      * @param testCase object, that contains tested method and way to invoke it.
 150      */
 151     protected CompilerWhiteBoxTest(TestCase testCase) {
 152         Objects.requireNonNull(testCase);
 153         System.out.println("TEST CASE:" + testCase.name());
 154         method = testCase.getExecutable();
 155         this.testCase = testCase;
 156     }
 157 
 158     /**
 159      * Template method for testing. Prints tested method's info before
 160      * {@linkplain #test()} and after {@linkplain #test()} or on thrown
 161      * exception.
 162      *
 163      * @throws RuntimeException if method {@linkplain #test()} throws any
 164      *                          exception
 165      * @see #test()
 166      */
 167     protected final void runTest() {
 168         if (CompilerWhiteBoxTest.MODE.startsWith("interpreted ")) {
 169             System.err.println(
 170                     "Warning: test is not applicable in interpreted mode");
 171             return;
 172         }
 173         System.out.println("at test's start:");
 174         printInfo();
 175         try {
 176             test();
 177         } catch (Exception e) {
 178             System.out.printf("on exception '%s':", e.getMessage());
 179             printInfo();
 180             e.printStackTrace();
 181             if (e instanceof RuntimeException) {
 182                 throw (RuntimeException) e;
 183             }
 184             throw new RuntimeException(e);
 185         }
 186         System.out.println("at test's end:");
 187         printInfo();
 188     }
 189 
 190     /**
 191      * Checks, that {@linkplain #method} is not compiled at the given compilation
 192      * level or above.
 193      *
 194      * @param compLevel
 195      *
 196      * @throws RuntimeException if {@linkplain #method} is in compiler queue or
 197      *                          is compiled, or if {@linkplain #method} has zero
 198      *                          compilation level.
 199      */
 200 
 201     protected final void checkNotCompiled(int compLevel) {
 202         if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
 203             throw new RuntimeException(method + " must not be in queue");
 204         }
 205         if (WHITE_BOX.getMethodCompilationLevel(method, false) >= compLevel) {
 206             throw new RuntimeException(method + " comp_level must be >= maxCompLevel");
 207         }
 208         if (WHITE_BOX.getMethodCompilationLevel(method, true) >= compLevel) {
 209             throw new RuntimeException(method + " osr_comp_level must be >= maxCompLevel");
 210         }
 211     }
 212 
 213     /**
 214      * Checks, that {@linkplain #method} is not compiled.
 215      *
 216      * @throws RuntimeException if {@linkplain #method} is in compiler queue or
 217      *                          is compiled, or if {@linkplain #method} has zero
 218      *                          compilation level.
 219      */
 220     protected final void checkNotCompiled() {



 221         if (WHITE_BOX.isMethodCompiled(method, false)) {
 222             throw new RuntimeException(method + " must be not compiled");
 223         }
 224         if (WHITE_BOX.getMethodCompilationLevel(method, false) != 0) {
 225             throw new RuntimeException(method + " comp_level must be == 0");
 226         }
 227         checkNotOsrCompiled();
 228     }
 229 
 230     protected final void checkNotOsrCompiled() {
 231         if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
 232             throw new RuntimeException(method + " must not be in queue");
 233         }
 234         if (WHITE_BOX.isMethodCompiled(method, true)) {
 235             throw new RuntimeException(method + " must be not osr_compiled");
 236         }
 237         if (WHITE_BOX.getMethodCompilationLevel(method, true) != 0) {
 238             throw new RuntimeException(method + " osr_comp_level must be == 0");
 239         }
 240     }
 241 
 242     /**
 243      * Checks, that {@linkplain #method} is compiled.
 244      *
 245      * @throws RuntimeException if {@linkplain #method} isn't in compiler queue
 246      *                          and isn't compiled, or if {@linkplain #method}
 247      *                          has nonzero compilation level
 248      */
 249     protected final void checkCompiled() {
 250         final long start = System.currentTimeMillis();
 251         waitBackgroundCompilation();
 252         if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
 253             System.err.printf("Warning: %s is still in queue after %dms%n",
 254                     method, System.currentTimeMillis() - start);
 255             return;
 256         }
 257         if (!WHITE_BOX.isMethodCompiled(method, testCase.isOsr())) {
 258             throw new RuntimeException(method + " must be "
 259                     + (testCase.isOsr() ? "osr_" : "") + "compiled");
 260         }
 261         if (WHITE_BOX.getMethodCompilationLevel(method, testCase.isOsr())
 262                 == 0) {
 263             throw new RuntimeException(method
 264                     + (testCase.isOsr() ? " osr_" : " ")
 265                     + "comp_level must be != 0");
 266         }
 267     }
 268 
 269     protected final void deoptimize() {
 270         WHITE_BOX.deoptimizeMethod(method, testCase.isOsr());
 271         if (testCase.isOsr()) {
 272             WHITE_BOX.deoptimizeMethod(method, false);
 273         }
 274     }
 275 
 276     protected final int getCompLevel() {
 277         NMethod nm = NMethod.get(method, testCase.isOsr());
 278         return nm == null ? COMP_LEVEL_NONE : nm.comp_level;
 279     }
 280 
 281     protected final boolean isCompilable() {
 282         return WHITE_BOX.isMethodCompilable(method, COMP_LEVEL_ANY,
 283                 testCase.isOsr());
 284     }
 285 
 286     protected final boolean isCompilable(int compLevel) {
 287         return WHITE_BOX
 288                 .isMethodCompilable(method, compLevel, testCase.isOsr());
 289     }
 290 
 291     protected final void makeNotCompilable() {
 292         WHITE_BOX.makeMethodNotCompilable(method, COMP_LEVEL_ANY,
 293                 testCase.isOsr());
 294     }
 295 
 296     protected final void makeNotCompilable(int compLevel) {
 297         WHITE_BOX.makeMethodNotCompilable(method, compLevel, testCase.isOsr());
 298     }
 299 
 300     /**
 301      * Waits for completion of background compilation of {@linkplain #method}.
 302      */
 303     protected final void waitBackgroundCompilation() {
 304         waitBackgroundCompilation(method);
 305     }
 306 
 307     /**
 308      * Waits for completion of background compilation of the given executable.
 309      *
 310      * @param executable Executable
 311      */
 312     protected static final void waitBackgroundCompilation(Executable executable) {
 313         if (!BACKGROUND_COMPILATION) {
 314             return;
 315         }
 316         final Object obj = new Object();
 317         for (int i = 0; i < 10
 318                 && WHITE_BOX.isMethodQueuedForCompilation(executable); ++i) {
 319             synchronized (obj) {
 320                 try {
 321                     obj.wait(1000);
 322                 } catch (InterruptedException e) {
 323                     Thread.currentThread().interrupt();
 324                 }
 325             }
 326         }
 327     }
 328 
 329     /**
 330      * Prints information about {@linkplain #method}.
 331      */
 332     protected final void printInfo() {
 333         System.out.printf("%n%s:%n", method);
 334         System.out.printf("\tcompilable:\t%b%n",
 335                 WHITE_BOX.isMethodCompilable(method, COMP_LEVEL_ANY, false));
 336         System.out.printf("\tcompiled:\t%b%n",
 337                 WHITE_BOX.isMethodCompiled(method, false));
 338         System.out.printf("\tcomp_level:\t%d%n",
 339                 WHITE_BOX.getMethodCompilationLevel(method, false));
 340         System.out.printf("\tosr_compilable:\t%b%n",
 341                 WHITE_BOX.isMethodCompilable(method, COMP_LEVEL_ANY, true));
 342         System.out.printf("\tosr_compiled:\t%b%n",
 343                 WHITE_BOX.isMethodCompiled(method, true));
 344         System.out.printf("\tosr_comp_level:\t%d%n",
 345                 WHITE_BOX.getMethodCompilationLevel(method, true));
 346         System.out.printf("\tin_queue:\t%b%n",
 347                 WHITE_BOX.isMethodQueuedForCompilation(method));
 348         System.out.printf("compile_queues_size:\t%d%n%n",
 349                 WHITE_BOX.getCompileQueuesSize());
 350     }
 351 
 352     /**
 353      * Executes testing.
 354      */
 355     protected abstract void test() throws Exception;
 356 
 357     /**
 358      * Tries to trigger compilation of {@linkplain #method} by call
 359      * {@linkplain TestCase#getCallable()} enough times.
 360      *
 361      * @return accumulated result
 362      * @see #compile(int)
 363      */
 364     protected final int compile() {
 365         if (testCase.isOsr()) {
 366             return compile(1);
 367         } else {
 368             return compile(THRESHOLD);
 369         }
 370     }
 371 
 372     /**
 373      * Tries to trigger compilation of {@linkplain #method} by call
 374      * {@linkplain TestCase#getCallable()} specified times.
 375      *
 376      * @param count invocation count
 377      * @return accumulated result
 378      */
 379     protected final int compile(int count) {
 380         int result = 0;
 381         Integer tmp;
 382         for (int i = 0; i < count; ++i) {
 383             try {
 384                 tmp = testCase.getCallable().call();
 385             } catch (Exception e) {
 386                 tmp = null;
 387             }
 388             result += tmp == null ? 0 : tmp;
 389         }
 390         if (IS_VERBOSE) {
 391             System.out.println("method was invoked " + count + " times");
 392         }
 393         return result;
 394     }
 395 
 396     /**
 397      * Utility interface provides tested method and object to invoke it.
 398      */
 399     public interface TestCase {
 400         /** the name of test case */
 401         String name();
 402 
 403         /** tested method */
 404         Executable getExecutable();
 405 
 406         /** object to invoke {@linkplain #getExecutable()} */
 407         Callable<Integer> getCallable();
 408 
 409         /** flag for OSR test case */
 410         boolean isOsr();
 411     }
 412 
 413     /**
 414      * @return {@code true} if the current test case is OSR and the mode is
 415      *          Xcomp, otherwise {@code false}
 416      */
 417     protected boolean skipXcompOSR() {
 418         boolean result =  testCase.isOsr()
 419                 && CompilerWhiteBoxTest.MODE.startsWith("compiled ");
 420         if (result && IS_VERBOSE) {
 421             System.err.printf("Warning: %s is not applicable in %s%n",
 422                     testCase.name(), CompilerWhiteBoxTest.MODE);
 423         }
 424         return result;
 425     }
 426 }
 427 
 428 enum SimpleTestCase implements CompilerWhiteBoxTest.TestCase {
 429     /** constructor test case */
 430     CONSTRUCTOR_TEST(Helper.CONSTRUCTOR, Helper.CONSTRUCTOR_CALLABLE, false),
 431     /** method test case */
 432     METHOD_TEST(Helper.METHOD, Helper.METHOD_CALLABLE, false),
 433     /** static method test case */
 434     STATIC_TEST(Helper.STATIC, Helper.STATIC_CALLABLE, false),
 435     /** OSR constructor test case */
 436     OSR_CONSTRUCTOR_TEST(Helper.OSR_CONSTRUCTOR,
 437             Helper.OSR_CONSTRUCTOR_CALLABLE, true),
 438     /** OSR method test case */
 439     OSR_METHOD_TEST(Helper.OSR_METHOD, Helper.OSR_METHOD_CALLABLE, true),
 440     /** OSR static method test case */
 441     OSR_STATIC_TEST(Helper.OSR_STATIC, Helper.OSR_STATIC_CALLABLE, true);
 442 
 443     private final Executable executable;
 444     private final Callable<Integer> callable;
 445     private final boolean isOsr;
 446 
 447     private SimpleTestCase(Executable executable, Callable<Integer> callable,
 448             boolean isOsr) {
 449         this.executable = executable;
 450         this.callable = callable;
 451         this.isOsr = isOsr;
 452     }
 453 
 454     @Override
 455     public Executable getExecutable() {
 456         return executable;
 457     }
 458 
 459     @Override
 460     public Callable<Integer> getCallable() {
 461         return callable;
 462     }
 463 
 464     @Override
 465     public boolean isOsr() {
 466         return isOsr;
 467     }
 468 
 469     private static class Helper {
 470 
 471         private static final Callable<Integer> CONSTRUCTOR_CALLABLE
 472                 = new Callable<Integer>() {
 473             @Override
 474             public Integer call() throws Exception {
 475                 return new Helper(1337).hashCode();
 476             }
 477         };
 478 
 479         private static final Callable<Integer> METHOD_CALLABLE
 480                 = new Callable<Integer>() {
 481             private final Helper helper = new Helper();
 482 
 483             @Override
 484             public Integer call() throws Exception {
 485                 return helper.method();
 486             }
 487         };
 488 
 489         private static final Callable<Integer> STATIC_CALLABLE
 490                 = new Callable<Integer>() {
 491             @Override
 492             public Integer call() throws Exception {
 493                 return staticMethod();
 494             }
 495         };
 496 
 497         private static final Callable<Integer> OSR_CONSTRUCTOR_CALLABLE
 498                 = new Callable<Integer>() {
 499             @Override
 500             public Integer call() throws Exception {
 501                 int result = warmup(OSR_CONSTRUCTOR);
 502                 return result + new Helper(null, CompilerWhiteBoxTest.BACKEDGE_THRESHOLD).hashCode();
 503             }
 504         };
 505 
 506         private static final Callable<Integer> OSR_METHOD_CALLABLE
 507                 = new Callable<Integer>() {
 508             private final Helper helper = new Helper();
 509 
 510             @Override
 511             public Integer call() throws Exception {
 512                 int result = warmup(OSR_METHOD);
 513                 return result + helper.osrMethod(CompilerWhiteBoxTest.BACKEDGE_THRESHOLD);
 514             }
 515         };
 516 
 517         private static final Callable<Integer> OSR_STATIC_CALLABLE
 518                 = new Callable<Integer>() {
 519             @Override
 520             public Integer call() throws Exception {
 521                 int result = warmup(OSR_STATIC);
 522                 return result + osrStaticMethod(CompilerWhiteBoxTest.BACKEDGE_THRESHOLD);
 523             }
 524         };
 525 
 526         /**
 527          * Deoptimizes all non-osr versions of the given executable after 
 528          * compilation finished.
 529          *
 530          * @param e Executable
 531          * @throws Exception
 532          */
 533         private static void waitAndDeoptimize(Executable e) throws Exception {
 534             CompilerWhiteBoxTest.waitBackgroundCompilation(e);
 535             if (WhiteBox.getWhiteBox().isMethodQueuedForCompilation(e)) {
 536                 throw new RuntimeException(e + " must not be in queue");
 537             }
 538             // Deoptimize non-osr versions of executable
 539             WhiteBox.getWhiteBox().deoptimizeMethod(e, false);
 540         }
 541 
 542         /**
 543          * Executes the method multiple times to make sure we have
 544          * enough profiling information before triggering an OSR
 545          * compilation. Otherwise the C2 compiler may add uncommon traps.
 546          *
 547          * @param m Method to be executed
 548          * @return Number of times the method was executed
 549          * @throws Exception
 550          */
 551         private static int warmup(Method m) throws Exception {
 552             Helper helper = new Helper();
 553             int result = 0;
 554             for (long i = 0; i < CompilerWhiteBoxTest.OSR_WARMUP; ++i) {
 555                 result += (int)m.invoke(helper, 1);
 556             }
 557             // Deoptimize non-osr versions
 558             waitAndDeoptimize(m);
 559             return result;
 560         }
 561 
 562         /**
 563          * Executes the constructor multiple times to make sure we
 564          * have enough profiling information before triggering an OSR
 565          * compilation. Otherwise the C2 compiler may add uncommon traps.
 566          *
 567          * @param c Constructor to be executed
 568          * @return Number of times the constructor was executed
 569          * @throws Exception
 570          */
 571         private static int warmup(Constructor c) throws Exception {
 572             int result = 0;
 573             for (long i = 0; i < CompilerWhiteBoxTest.OSR_WARMUP; ++i) {
 574                 result += c.newInstance(null, 1).hashCode();
 575             }
 576             // Deoptimize non-osr versions
 577             waitAndDeoptimize(c);
 578             return result;
 579         }
 580 
 581         private static final Constructor CONSTRUCTOR;
 582         private static final Constructor OSR_CONSTRUCTOR;
 583         private static final Method METHOD;
 584         private static final Method STATIC;
 585         private static final Method OSR_METHOD;
 586         private static final Method OSR_STATIC;
 587 
 588         static {
 589             try {
 590                 CONSTRUCTOR = Helper.class.getDeclaredConstructor(int.class);
 591             } catch (NoSuchMethodException | SecurityException e) {
 592                 throw new RuntimeException(
 593                         "exception on getting method Helper.<init>(int)", e);
 594             }
 595             try {
 596                 OSR_CONSTRUCTOR = Helper.class.getDeclaredConstructor(
 597                         Object.class, long.class);
 598             } catch (NoSuchMethodException | SecurityException e) {
 599                 throw new RuntimeException(
 600                         "exception on getting method Helper.<init>(Object, long)", e);
 601             }
 602             METHOD = getMethod("method");
 603             STATIC = getMethod("staticMethod");
 604             OSR_METHOD = getMethod("osrMethod", long.class);
 605             OSR_STATIC = getMethod("osrStaticMethod", long.class);
 606         }
 607 
 608         private static Method getMethod(String name, Class<?>... parameterTypes) {
 609             try {
 610                 return Helper.class.getDeclaredMethod(name, parameterTypes);
 611             } catch (NoSuchMethodException | SecurityException e) {
 612                 throw new RuntimeException(
 613                         "exception on getting method Helper." + name, e);
 614             }

 615         }
 616 
 617         private static int staticMethod() {
 618             return 1138;
 619         }
 620 
 621         private int method() {
 622             return 42;
 623         }
 624 
 625         private static int osrStaticMethod(long limit) {
 626             int result = 0;
 627             for (long i = 0; i < limit; ++i) {
 628                 result += staticMethod();
 629             }
 630             return result;
 631         }
 632 
 633         private int osrMethod(long limit) {
 634             int result = 0;
 635             for (long i = 0; i < limit; ++i) {
 636                 result += method();
 637             }
 638             return result;
 639         }
 640 
 641         private final int x;
 642 
 643         // for method and OSR method test case
 644         public Helper() {
 645             x = 0;
 646         }
 647 
 648         // for OSR constructor test case
 649         private Helper(Object o, long limit) {
 650             int result = 0;
 651             for (long i = 0; i < limit; ++i) {
 652                 result += method();
 653             }
 654             x = result;
 655         }
 656 
 657         // for constructor test case
 658         private Helper(int x) {
 659             this.x = x;
 660         }
 661 
 662         @Override
 663         public int hashCode() {
 664             return x;
 665         }
 666     }
 667 }
--- EOF ---