1 /*
  2  * Copyright (c) 2021, 2022, 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 package compiler.lib.ir_framework.test;
 25 
 26 import compiler.lib.ir_framework.*;
 27 import compiler.lib.ir_framework.Compiler;
 28 import compiler.lib.ir_framework.shared.*;
 29 import jdk.test.lib.Platform;
 30 import jdk.test.lib.Utils;
 31 import jdk.test.whitebox.WhiteBox;
 32 
 33 import java.io.PrintWriter;
 34 import java.io.StringWriter;
 35 import java.lang.annotation.Annotation;
 36 import java.lang.reflect.*;
 37 import java.util.*;
 38 import java.util.stream.Collectors;
 39 import java.util.stream.Stream;
 40 
 41 /**
 42  * This class' main method is called from {@link TestFramework} and represents the so-called "test VM". The class is
 43  * the heart of the framework and is responsible for executing all the specified tests in the test class. It uses the
 44  * Whitebox API and reflection to achieve this task.
 45  */
 46 public class TestVM {
 47     private static final WhiteBox WHITE_BOX;
 48 
 49     static {
 50         try {
 51             WHITE_BOX = WhiteBox.getWhiteBox();
 52         } catch (UnsatisfiedLinkError e) {
 53             System.err.println(System.lineSeparator() + """
 54                                ##########################################################
 55                                 - Did you call a test-related interface method from
 56                                   TestFramework in main() of your test? Make sure to
 57                                   only call setup/run methods and no checks or
 58                                   assertions from main() of your test!
 59                                 - Are you rerunning the test VM (TestVM class)
 60                                   directly after a JTreg run? Make sure to start it
 61                                   from within JTwork/scratch and with the flag
 62                                   -DReproduce=true!
 63                                ##########################################################
 64                                """);
 65             throw e;
 66         }
 67     }
 68 
 69     /**
 70      * The default number of warm-up iterations used to warm up a {@link Test} annotated test method.
 71      * Use {@code -DWarmup=XY} to specify a different default value. An individual warm-up can also be
 72      * set by specifying a {@link Warmup} iteration for a test.
 73      */
 74     public static final int WARMUP_ITERATIONS = Integer.parseInt(System.getProperty("Warmup", "2000"));
 75 
 76     private static final boolean TIERED_COMPILATION = (Boolean)WHITE_BOX.getVMFlag("TieredCompilation");
 77     private static final CompLevel TIERED_COMPILATION_STOP_AT_LEVEL;
 78     private static final boolean CLIENT_VM = Platform.isClient();
 79 
 80     static {
 81         CompLevel level = CompLevel.forValue(((Long)WHITE_BOX.getVMFlag("TieredStopAtLevel")).intValue());
 82         if (CLIENT_VM && level == CompLevel.C2) {
 83             // No C2 available, use C1 level without profiling.
 84             level = CompLevel.C1_SIMPLE;
 85         }
 86         TIERED_COMPILATION_STOP_AT_LEVEL = level;
 87     }
 88     public static final boolean TEST_C1 = (TIERED_COMPILATION && TIERED_COMPILATION_STOP_AT_LEVEL.getValue() < CompLevel.C2.getValue()) || CLIENT_VM;
 89 
 90     static final boolean XCOMP = Platform.isComp();
 91     static final boolean VERBOSE = Boolean.getBoolean("Verbose");
 92     private static final boolean PRINT_TIMES = Boolean.getBoolean("PrintTimes");
 93     public static final boolean USE_COMPILER = WHITE_BOX.getBooleanVMFlag("UseCompiler");
 94     static final boolean EXCLUDE_RANDOM = Boolean.getBoolean("ExcludeRandom");
 95     private static final String TESTLIST = System.getProperty("Test", "");
 96     private static final String EXCLUDELIST = System.getProperty("Exclude", "");
 97     private static final boolean DUMP_REPLAY = Boolean.getBoolean("DumpReplay");
 98     private static final boolean GC_AFTER = Boolean.getBoolean("GCAfter");
 99     private static final boolean SHUFFLE_TESTS = Boolean.parseBoolean(System.getProperty("ShuffleTests", "true"));
100     // Use separate flag as VERIFY_IR could have been set by user but due to other flags it was disabled by flag VM.
101     private static final boolean PRINT_VALID_IR_RULES = Boolean.getBoolean("ShouldDoIRVerification");
102     protected static final long PER_METHOD_TRAP_LIMIT = (Long)WHITE_BOX.getVMFlag("PerMethodTrapLimit");
103     protected static final boolean PROFILE_INTERPRETER = (Boolean)WHITE_BOX.getVMFlag("ProfileInterpreter");
104     protected static final boolean DEOPT_BARRIERS_ALOT = (Boolean)WHITE_BOX.getVMFlag("DeoptimizeNMethodBarriersALot");
105     private static final boolean FLIP_C1_C2 = Boolean.getBoolean("FlipC1C2");
106     private static final boolean IGNORE_COMPILER_CONTROLS = Boolean.getBoolean("IgnoreCompilerControls");
107 
108     private final HashMap<Method, DeclaredTest> declaredTests = new HashMap<>();
109     private final List<AbstractTest> allTests = new ArrayList<>();
110     private final HashMap<String, Method> testMethodMap = new HashMap<>();
111     private final List<String> excludeList;
112     private final List<String> testList;
113     private Set<Class<?>> helperClasses = null; // Helper classes that contain framework annotations to be processed.
114     private final IREncodingPrinter irMatchRulePrinter;
115     private final Class<?> testClass;
116     private final Map<Executable, CompLevel> forceCompileMap = new HashMap<>();
117 
118     private TestVM(Class<?> testClass) {
119         TestRun.check(testClass != null, "Test class cannot be null");
120         this.testClass = testClass;
121         this.testList = createTestFilterList(TESTLIST, testClass);
122         this.excludeList = createTestFilterList(EXCLUDELIST, testClass);
123 
124         if (PRINT_VALID_IR_RULES) {
125             irMatchRulePrinter = new IREncodingPrinter();
126         } else {
127             irMatchRulePrinter = null;
128         }
129     }
130 
131     /**
132      * Parse "test1,test2,test3" into a list.
133      */
134     private static List<String> createTestFilterList(String list, Class<?> testClass) {
135         List<String> filterList = null;
136         if (!list.isEmpty()) {
137             String classPrefix = testClass.getSimpleName() + ".";
138             filterList = new ArrayList<>(Arrays.asList(list.split(",")));
139             for (int i = filterList.size() - 1; i >= 0; i--) {
140                 String test = filterList.get(i);
141                 if (test.indexOf(".") > 0) {
142                     if (test.startsWith(classPrefix)) {
143                         test = test.substring(classPrefix.length());
144                         filterList.set(i, test);
145                     } else {
146                         filterList.remove(i);
147                     }
148                 }
149             }
150         }
151         return filterList;
152     }
153 
154     /**
155      * Main entry point of the test VM.
156      */
157     public static void main(String[] args) {
158         try {
159             String testClassName = args[0];
160             System.out.println("TestVM main() called - about to run tests in class " + testClassName);
161             Class<?> testClass = getClassObject(testClassName, "test");
162 
163             TestVM framework = new TestVM(testClass);
164             framework.addHelperClasses(args);
165             framework.start();
166         } finally {
167             TestFrameworkSocket.closeClientSocket();
168         }
169     }
170 
171     protected static Class<?> getClassObject(String className, String classType) {
172         try {
173             return Class.forName(className);
174         } catch (Exception e) {
175             throw new TestRunException("Could not find " + classType + " class", e);
176         }
177     }
178 
179     /**
180      * Set up all helper classes and verify they are specified correctly.
181      */
182     private void addHelperClasses(String[] args) {
183         Class<?>[] helperClassesList = getHelperClasses(args);
184         if (helperClassesList != null) {
185             TestRun.check(Arrays.stream(helperClassesList).noneMatch(Objects::isNull), "A Helper class cannot be null");
186             this.helperClasses = new HashSet<>();
187 
188             for (Class<?> helperClass : helperClassesList) {
189                 if (Arrays.stream(testClass.getDeclaredClasses()).anyMatch(c -> c == helperClass)) {
190                     // Nested class of test class is automatically treated as helper class
191                     TestFormat.failNoThrow("Nested " + helperClass + " inside test " + testClass + " is implicitly"
192                                            + " treated as helper class and does not need to be specified as such.");
193                     continue;
194                 }
195                 TestRun.check(!this.helperClasses.contains(helperClass), "Cannot add the same class twice: " + helperClass);
196                 this.helperClasses.add(helperClass);
197             }
198         }
199     }
200 
201     private static Class<?>[] getHelperClasses(String[] args) {
202         if (args.length == 1) {
203             return null;
204         }
205         Class<?>[] helperClasses = new Class<?>[args.length - 1]; // First argument is test class
206         for (int i = 1; i < args.length; i++) {
207             String helperClassName = args[i];
208             helperClasses[i - 1] = getClassObject(helperClassName, "helper");
209         }
210         return helperClasses;
211     }
212 
213     private void checkHelperClass(Class<?> clazz) {
214         checkAnnotationsInClass(clazz, "helper");
215         for (Class<?> c : clazz.getDeclaredClasses()) {
216             checkAnnotationsInClass(c, "nested (and helper)");
217         }
218     }
219 
220     private void checkAnnotationsInClass(Class<?> c, String clazzType) {
221         Method[] methods = c.getDeclaredMethods();
222         for (Method m : methods) {
223             TestFormat.checkNoThrow(getAnnotation(m, Test.class) == null,
224                                     "Cannot use @Test annotation in " + clazzType + " " + c + " at " + m);
225             TestFormat.checkNoThrow(getAnnotation(m, Run.class) == null,
226                                     "Cannot use @Run annotation in " + clazzType + " " + c + " at " + m);
227             TestFormat.checkNoThrow(getAnnotation(m, Check.class) == null,
228                                     "Cannot use @Check annotation in " + clazzType + " " + c + " at " + m);
229         }
230     }
231 
232     /**
233      * Only called by internal tests testing the framework itself. Accessed by reflection. Not exposed to normal users.
234      */
235     private static void runTestsOnSameVM(Class<?> testClass) {
236         if (testClass == null) {
237             StackWalker walker = StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE);
238             testClass = walker.getCallerClass();
239         }
240         TestVM framework = new TestVM(testClass);
241         framework.start();
242     }
243 
244     /**
245      * Once everything is initialized and set up, start collecting tests and executing them afterwards.
246      */
247     private void start() {
248         setupTests();
249         checkForcedCompilationsCompleted();
250         runTests();
251     }
252 
253     private void setupTests() {
254         // TODO remove this once JDK-8273591 is fixed
255         if (!IGNORE_COMPILER_CONTROLS) {
256             for (Class<?> clazz : testClass.getDeclaredClasses()) {
257                 checkAnnotationsInClass(clazz, "inner");
258             }
259         }
260         if (DUMP_REPLAY) {
261             addReplay();
262         }
263         // Make sure to first setup test methods and make them non-inlineable and only then process compile commands.
264         setupDeclaredTests();
265         processControlAnnotations(testClass);
266         processHelperClasses();
267         setupCheckedAndCustomRunTests();
268 
269         // All remaining tests are simple base tests without check or specific way to run them.
270         addBaseTests();
271         if (PRINT_VALID_IR_RULES) {
272             irMatchRulePrinter.emit();
273         }
274         TestFormat.throwIfAnyFailures();
275         declaredTests.clear();
276         testMethodMap.clear();
277     }
278 
279     private void addBaseTests() {
280         declaredTests.forEach((m, test) -> {
281             if (test.getAttachedMethod() == null) {
282                 try {
283                     Arguments argumentsAnno = getAnnotation(m, Arguments.class);
284                     TestFormat.check(argumentsAnno != null || m.getParameterCount() == 0, "Missing @Arguments annotation to define arguments of " + m);
285                     BaseTest baseTest = new BaseTest(test, shouldExcludeTest(m.getName()));
286                     allTests.add(baseTest);
287                     if (PRINT_VALID_IR_RULES) {
288                         irMatchRulePrinter.emitRuleEncoding(m, baseTest.isSkipped());
289                     }
290                 } catch (TestFormatException e) {
291                     // Failure logged. Continue and report later.
292                 }
293             }
294         });
295     }
296 
297     /**
298      * Check if user wants to exclude this test by checking the -DTest and -DExclude lists.
299      */
300     private boolean shouldExcludeTest(String testName) {
301         boolean hasTestList = testList != null;
302         boolean hasExcludeList = excludeList != null;
303         if (hasTestList) {
304             return !testList.contains(testName) || (hasExcludeList && excludeList.contains(testName));
305         } else if (hasExcludeList) {
306             return excludeList.contains(testName);
307         }
308         return false;
309     }
310 
311     /**
312      * Generate replay compilation files.
313      */
314     private void addReplay() {
315         String directive = "[{ match: \"*.*\", DumpReplay: true }]";
316         TestFramework.check(WHITE_BOX.addCompilerDirective(directive) == 1, "Failed to add DUMP_REPLAY directive");
317     }
318 
319     private void processControlAnnotations(Class<?> clazz) {
320         if (IGNORE_COMPILER_CONTROLS) {
321             return;
322         }
323         // Also apply compile commands to all inner classes of 'clazz'.
324         ArrayList<Class<?>> classes = new ArrayList<>(Arrays.asList(clazz.getDeclaredClasses()));
325         classes.add(clazz);
326         for (Class<?> c : classes) {
327             applyClassAnnotations(c);
328             List<Executable> executables = new ArrayList<>(Arrays.asList(c.getDeclaredMethods()));
329             Collections.addAll(executables, c.getDeclaredConstructors());
330             for (Executable ex : executables) {
331                 checkClassAnnotations(ex);
332                 try {
333                     applyIndependentCompilationCommands(ex);
334                 } catch (TestFormatException e) {
335                     // Failure logged. Continue and report later.
336                 }
337             }
338 
339             // Only force compilation now because above annotations affect inlining
340             for (Executable ex : executables) {
341                 try {
342                     applyForceCompileCommand(ex);
343                 } catch (TestFormatException e) {
344                     // Failure logged. Continue and report later.
345                 }
346             }
347         }
348     }
349 
350     private void applyClassAnnotations(Class<?> c) {
351         ForceCompileClassInitializer anno = getAnnotation(c, ForceCompileClassInitializer.class);
352         if (anno == null) {
353             return;
354         }
355 
356         // Compile class initializer
357         CompLevel level = anno.value();
358         if (level == CompLevel.SKIP || level == CompLevel.WAIT_FOR_COMPILATION) {
359             TestFormat.failNoThrow("Cannot define compilation level SKIP or WAIT_FOR_COMPILATION in " +
360                                    "@ForceCompileClassInitializer at " + c);
361             return;
362         }
363         level = restrictCompLevel(anno.value());
364         if (level != CompLevel.SKIP) {
365             // Make sure class is initialized to avoid compilation bailout of <clinit>
366             getClassObject(c.getName(), "nested"); // calls Class.forName() to initialize 'c'
367             TestFormat.checkNoThrow(WHITE_BOX.enqueueInitializerForCompilation(c, level.getValue()),
368                                     "Failed to enqueue <clinit> of " + c + " for compilation. Did you specify "
369                                     + "@ForceCompileClassInitializer without providing a static class initialization? "
370                                     + "Make sure to provide any form of static initialization or remove the annotation. "
371                                     + "For debugging purposes, -DIgnoreCompilerControls=true can be used to temporarly "
372                                     + "ignore @ForceCompileClassInitializer annotations.");
373         }
374     }
375 
376     private void checkClassAnnotations(Executable ex) {
377         TestFormat.checkNoThrow(getAnnotation(ex, ForceCompileClassInitializer.class) == null,
378                                 "@ForceCompileClassInitializer only allowed at classes but not at method " + ex);
379     }
380 
381     /**
382      * Exclude a method from compilation with a compiler randomly. Return the compiler for which the method was made
383      * not compilable.
384      */
385     public static Compiler excludeRandomly(Executable ex) {
386         Compiler compiler = switch (Utils.getRandomInstance().nextInt() % 3) {
387             case 1 -> Compiler.C1;
388             case 2 -> Compiler.C2;
389             default -> Compiler.ANY;
390         };
391         WHITE_BOX.makeMethodNotCompilable(ex, compiler.getValue(), false);
392         WHITE_BOX.makeMethodNotCompilable(ex, compiler.getValue(), true);
393         System.out.println("Excluding from " + compiler.name() + " compilation: " + ex);
394         return compiler;
395     }
396 
397     private void applyIndependentCompilationCommands(Executable ex) {
398         ForceInline forceInlineAnno = getAnnotation(ex, ForceInline.class);
399         DontInline dontInlineAnno = getAnnotation(ex, DontInline.class);
400         ForceCompile forceCompileAnno = getAnnotation(ex, ForceCompile.class);
401         DontCompile dontCompileAnno = getAnnotation(ex, DontCompile.class);
402         checkCompilationCommandAnnotations(ex, forceInlineAnno, dontInlineAnno, forceCompileAnno, dontCompileAnno);
403         // First handle inline annotations
404         if (dontInlineAnno != null) {
405             WHITE_BOX.testSetDontInlineMethod(ex, true);
406         } else if (forceInlineAnno != null) {
407             WHITE_BOX.testSetForceInlineMethod(ex, true);
408         }
409         if (dontCompileAnno != null) {
410             dontCompileWithCompiler(ex, dontCompileAnno.value());
411         }
412         if (EXCLUDE_RANDOM && getAnnotation(ex, Test.class) == null && forceCompileAnno == null && dontCompileAnno == null) {
413             // Randomly exclude helper methods from compilation
414             if (Utils.getRandomInstance().nextBoolean()) {
415                 excludeRandomly(ex);
416             }
417         }
418     }
419 
420     private void checkCompilationCommandAnnotations(Executable ex, ForceInline forceInlineAnno, DontInline dontInlineAnno, ForceCompile forceCompileAnno, DontCompile dontCompileAnno) {
421         Test testAnno = getAnnotation(ex, Test.class);
422         Run runAnno = getAnnotation(ex, Run.class);
423         Check checkAnno = getAnnotation(ex, Check.class);
424         TestFormat.check((testAnno == null && runAnno == null && checkAnno == null) || Stream.of(forceCompileAnno, dontCompileAnno, forceInlineAnno, dontInlineAnno).noneMatch(Objects::nonNull),
425                          "Cannot use explicit compile command annotations (@ForceInline, @DontInline, " +
426                          "@ForceCompile or @DontCompile) together with @Test, @Check or @Run: " + ex + ". Use compLevel in @Test for fine tuning.");
427         if (Stream.of(forceInlineAnno, dontCompileAnno, dontInlineAnno).filter(Objects::nonNull).count() > 1) {
428             // Failure
429             TestFormat.check(dontCompileAnno == null || dontInlineAnno == null,
430                              "@DontInline is implicitely done with @DontCompile annotation at " + ex);
431             TestFormat.fail("Cannot mix @ForceInline, @DontInline and @DontCompile at the same time at " + ex);
432         }
433         TestFormat.check(forceInlineAnno == null || dontInlineAnno == null, "Cannot have @ForceInline and @DontInline at the same time at " + ex);
434         if (forceCompileAnno != null && dontCompileAnno != null) {
435             CompLevel forceCompileLevel = forceCompileAnno.value();
436             Compiler dontCompileCompiler = dontCompileAnno.value();
437             TestFormat.check(dontCompileCompiler != Compiler.ANY,
438                              "Cannot have @DontCompile(Compiler.ANY) and @ForceCompile at the same time at " + ex);
439             TestFormat.check(forceCompileLevel != CompLevel.ANY,
440                              "Cannot have @ForceCompile(CompLevel.ANY) and @DontCompile at the same time at " + ex);
441             TestFormat.check(forceCompileLevel.isNotCompilationLevelOfCompiler(dontCompileCompiler),
442                              "Overlapping compilation level and compiler with @ForceCompile and @DontCompile at " + ex);
443         }
444     }
445 
446     /**
447      * Exlude the method from compilation and make sure it is not inlined.
448      */
449     private void dontCompileAndDontInlineMethod(Method m) {
450         if (!IGNORE_COMPILER_CONTROLS) {
451             WHITE_BOX.makeMethodNotCompilable(m, CompLevel.ANY.getValue(), true);
452             WHITE_BOX.makeMethodNotCompilable(m, CompLevel.ANY.getValue(), false);
453             WHITE_BOX.testSetDontInlineMethod(m, true);
454         }
455     }
456 
457     private void dontCompileWithCompiler(Executable ex, Compiler compiler) {
458         if (VERBOSE) {
459             System.out.println("dontCompileWithCompiler " + ex + " , compiler = " + compiler.name());
460         }
461         WHITE_BOX.makeMethodNotCompilable(ex, compiler.getValue(), true);
462         WHITE_BOX.makeMethodNotCompilable(ex, compiler.getValue(), false);
463         if (compiler == Compiler.ANY) {
464             WHITE_BOX.testSetDontInlineMethod(ex, true);
465         }
466     }
467 
468     private void applyForceCompileCommand(Executable ex) {
469         ForceCompile forceCompileAnno = getAnnotation(ex, ForceCompile.class);
470         if (forceCompileAnno != null) {
471             CompLevel compLevel = forceCompileAnno.value();
472             TestFormat.check(compLevel != CompLevel.SKIP && compLevel != CompLevel.WAIT_FOR_COMPILATION,
473                              "Cannot define compilation level SKIP or WAIT_FOR_COMPILATION in @ForceCompile at " + ex);
474             compLevel = restrictCompLevel(forceCompileAnno.value());
475             if (FLIP_C1_C2) {
476                 compLevel = compLevel.flipCompLevel();
477                 compLevel = restrictCompLevel(compLevel.flipCompLevel());
478             }
479             if (EXCLUDE_RANDOM) {
480                 compLevel = compLevel.excludeCompilationRandomly(ex);
481             }
482             if (compLevel != CompLevel.SKIP) {
483                 enqueueForCompilation(ex, compLevel);
484                 forceCompileMap.put(ex, compLevel);
485             }
486         }
487     }
488 
489     static void enqueueForCompilation(Executable ex, CompLevel requestedCompLevel) {
490         if (TestVM.VERBOSE) {
491             System.out.println("enqueueForCompilation " + ex + ", level = " + requestedCompLevel);
492         }
493         CompLevel compLevel = restrictCompLevel(requestedCompLevel);
494         if (compLevel != CompLevel.SKIP) {
495             WHITE_BOX.enqueueMethodForCompilation(ex, compLevel.getValue());
496         } else {
497             System.out.println("Skipped compilation on level " + requestedCompLevel + " due to VM flags not allowing it.");
498         }
499     }
500 
501     /**
502      * Setup @Test annotated method an add them to the declaredTests map to have a convenient way of accessing them
503      * once setting up a framework test (base  checked, or custom run test).
504      */
505     private void setupDeclaredTests() {
506         for (Method m : testClass.getDeclaredMethods()) {
507             Test testAnno = getAnnotation(m, Test.class);
508             try {
509                 if (testAnno != null) {
510                     addDeclaredTest(m);
511                 } else {
512                     TestFormat.checkNoThrow(!m.isAnnotationPresent(IR.class) && !m.isAnnotationPresent(IRs.class),
513                                             "Found @IR annotation on non-@Test method " + m);
514                     TestFormat.checkNoThrow(!m.isAnnotationPresent(Warmup.class) || getAnnotation(m, Run.class) != null,
515                                             "Found @Warmup annotation on non-@Test or non-@Run method " + m);
516                 }
517             } catch (TestFormatException e) {
518                 // Failure logged. Continue and report later.
519             }
520         }
521         TestFormat.checkNoThrow(!declaredTests.isEmpty(), "Did not specify any @Test methods in " + testClass);
522     }
523 
524     private void addDeclaredTest(Method m) {
525         Test testAnno = getAnnotation(m, Test.class);
526         checkTestAnnotations(m, testAnno);
527         Warmup warmup = getAnnotation(m, Warmup.class);
528         int warmupIterations = WARMUP_ITERATIONS;
529         if (warmup != null) {
530             warmupIterations = warmup.value();
531             TestFormat.checkNoThrow(warmupIterations >= 0, "Cannot have negative value for @Warmup at " + m);
532         }
533 
534         if (!IGNORE_COMPILER_CONTROLS) {
535             // Don't inline test methods by default. Do not apply this when -DIgnoreCompilerControls=true is set.
536             WHITE_BOX.testSetDontInlineMethod(m, true);
537         }
538         CompLevel compLevel = restrictCompLevel(testAnno.compLevel());
539         if (FLIP_C1_C2) {
540             compLevel = compLevel.flipCompLevel();
541             compLevel = restrictCompLevel(compLevel.flipCompLevel());
542         }
543         if (EXCLUDE_RANDOM) {
544             compLevel = compLevel.excludeCompilationRandomly(m);
545         }
546         DeclaredTest test = new DeclaredTest(m, ArgumentValue.getArguments(m), compLevel, warmupIterations);
547         declaredTests.put(m, test);
548         testMethodMap.put(m.getName(), m);
549     }
550 
551     private void checkTestAnnotations(Method m, Test testAnno) {
552         TestFormat.check(!testMethodMap.containsKey(m.getName()),
553                          "Cannot overload two @Test methods: " + m + ", " + testMethodMap.get(m.getName()));
554         TestFormat.check(testAnno != null, m + " must be a method with a @Test annotation");
555 
556         Check checkAnno = getAnnotation(m, Check.class);
557         Run runAnno = getAnnotation(m, Run.class);
558         TestFormat.check(checkAnno == null && runAnno == null,
559                          m + " has invalid @Check or @Run annotation while @Test annotation is present.");
560 
561         TestFormat.checkNoThrow(Arrays.stream(m.getParameterTypes()).noneMatch(AbstractInfo.class::isAssignableFrom),
562                                 "Cannot " + AbstractInfo.class + " or any of its subclasses as parameter type at " +
563                                 "@Test method " + m);
564 
565         TestFormat.checkNoThrow(!AbstractInfo.class.isAssignableFrom(m.getReturnType()),
566                                 "Cannot " + AbstractInfo.class + " or any of its subclasses as return type at " +
567                                 "@Test method " + m);
568     }
569 
570 
571     /**
572      * Get the appropriate level as permitted by the test scenario and VM flags.
573      */
574     private static CompLevel restrictCompLevel(CompLevel compLevel) {
575         if (!USE_COMPILER) {
576             return CompLevel.SKIP;
577         }
578         if (compLevel == CompLevel.ANY) {
579             // Use highest available compilation level by default (usually C2).
580             compLevel = TIERED_COMPILATION_STOP_AT_LEVEL;
581         }
582         if (TEST_C1 && compLevel == CompLevel.C2) {
583             return CompLevel.SKIP;
584         }
585         if ((!TIERED_COMPILATION && !CLIENT_VM) && compLevel.getValue() < CompLevel.C2.getValue()) {
586             return CompLevel.SKIP;
587         }
588         if ((TIERED_COMPILATION || CLIENT_VM) && compLevel.getValue() > TIERED_COMPILATION_STOP_AT_LEVEL.getValue()) {
589             return CompLevel.SKIP;
590         }
591         return compLevel;
592     }
593 
594     /**
595      * Verify that the helper classes do not contain illegal framework annotations and then apply the actions as
596      * specified by the different helper class annotations.
597      */
598     private void processHelperClasses() {
599         if (helperClasses != null) {
600             for (Class<?> helperClass : helperClasses) {
601                 // Process the helper classes and apply the explicit compile commands
602                 TestFormat.checkNoThrow(helperClass != testClass,
603                                         "Cannot specify test " + testClass + " as helper class, too.");
604                 checkHelperClass(helperClass);
605                 processControlAnnotations(helperClass);
606             }
607         }
608     }
609 
610     /**
611      * First set up checked (with @Check) and custom run tests (with @Run). All remaining unmatched/unused @Test methods
612      * are treated as base tests and set up as such later.
613      */
614     private void setupCheckedAndCustomRunTests() {
615         for (Method m : testClass.getDeclaredMethods()) {
616             Check checkAnno = getAnnotation(m, Check.class);
617             Run runAnno = getAnnotation(m, Run.class);
618             Arguments argumentsAnno = getAnnotation(m, Arguments.class);
619             try {
620                 TestFormat.check(argumentsAnno == null || (checkAnno == null && runAnno == null),
621                                  "Cannot have @Argument annotation in combination with @Run or @Check at " + m);
622                 if (checkAnno != null) {
623                     addCheckedTest(m, checkAnno, runAnno);
624                 } else if (runAnno != null) {
625                     addCustomRunTest(m, runAnno);
626                 }
627             } catch (TestFormatException e) {
628                 // Failure logged. Continue and report later.
629             }
630         }
631     }
632 
633     /**
634      * Set up a checked test by first verifying the correct format of the @Test and @Check method and then adding it
635      * to the allTests list which keeps track of all framework tests that are eventually executed.
636      */
637     private void addCheckedTest(Method m, Check checkAnno, Run runAnno) {
638         Method testMethod = testMethodMap.get(checkAnno.test());
639         DeclaredTest test = declaredTests.get(testMethod);
640         checkCheckedTest(m, checkAnno, runAnno, testMethod, test);
641         test.setAttachedMethod(m);
642         TestFormat.check(getAnnotation(testMethod, Arguments.class) != null || testMethod.getParameterCount() == 0,
643                          "Missing @Arguments annotation to define arguments of " + testMethod + " required by "
644                          + "checked test " + m);
645         CheckedTest.Parameter parameter = getCheckedTestParameter(m, testMethod);
646         dontCompileAndDontInlineMethod(m);
647         CheckedTest checkedTest = new CheckedTest(test, m, checkAnno, parameter, shouldExcludeTest(testMethod.getName()));
648         allTests.add(checkedTest);
649         if (PRINT_VALID_IR_RULES) {
650             // Only need to emit IR verification information if IR verification is actually performed.
651             irMatchRulePrinter.emitRuleEncoding(testMethod, checkedTest.isSkipped());
652         }
653     }
654 
655     private void checkCheckedTest(Method m, Check checkAnno, Run runAnno, Method testMethod, DeclaredTest test) {
656         TestFormat.check(runAnno == null, m + " has invalid @Run annotation while @Check annotation is present.");
657         TestFormat.check(testMethod != null, "Did not find associated test method \"" + m.getDeclaringClass().getName()
658                                              + "." + checkAnno.test() + "\" for @Check at " + m);
659         TestFormat.check(test != null, "Missing @Test annotation for associated test method " + testMethod + " for @Check at " + m);
660         Method attachedMethod = test.getAttachedMethod();
661         TestFormat.check(attachedMethod == null,
662                          "Cannot use @Test " + testMethod + " for more than one @Run or one @Check method. Found: " + m + ", " + attachedMethod);
663     }
664 
665     /**
666      * Only allow parameters as specified in {@link Check}.
667      */
668     private CheckedTest.Parameter getCheckedTestParameter(Method m, Method testMethod) {
669         boolean firstParameterTestInfo = m.getParameterCount() > 0 && m.getParameterTypes()[0].equals(TestInfo.class);
670         boolean secondParameterTestInfo = m.getParameterCount() > 1 && m.getParameterTypes()[1].equals(TestInfo.class);
671         CheckedTest.Parameter parameter = null;
672         Class<?> testReturnType = testMethod.getReturnType();
673         switch (m.getParameterCount()) {
674             case 0 -> parameter = CheckedTest.Parameter.NONE;
675             case 1 -> {
676                 TestFormat.checkNoThrow(firstParameterTestInfo || m.getParameterTypes()[0] == testReturnType,
677                                         "Single-parameter version of @Check method " + m + " must match return type of @Test " + testMethod);
678                 parameter = firstParameterTestInfo ? CheckedTest.Parameter.TEST_INFO_ONLY : CheckedTest.Parameter.RETURN_ONLY;
679             }
680             case 2 -> {
681                 TestFormat.checkNoThrow(m.getParameterTypes()[0] == testReturnType && secondParameterTestInfo,
682                                         "Two-parameter version of @Check method " + m + " must provide as first parameter the same"
683                                         + " return type as @Test method " + testMethod + " and as second parameter an object of " + TestInfo.class);
684                 parameter = CheckedTest.Parameter.BOTH;
685             }
686             default -> TestFormat.failNoThrow("@Check method " + m + " must provide either a none, single or two-parameter variant.");
687         }
688         return parameter;
689     }
690 
691     /**
692      * Set up a custom run test by first verifying the correct format of the @Test and @Run method and then adding it
693      * to the allTests list which keeps track of all framework tests that are eventually executed.
694      */
695     private void addCustomRunTest(Method m, Run runAnno) {
696         checkRunMethod(m, runAnno);
697         List<DeclaredTest> tests = new ArrayList<>();
698         boolean shouldExcludeTest = true;
699         for (String testName : runAnno.test()) {
700             try {
701                 Method testMethod = testMethodMap.get(testName);
702                 DeclaredTest test = declaredTests.get(testMethod);
703                 checkCustomRunTest(m, testName, testMethod, test, runAnno.mode());
704                 test.setAttachedMethod(m);
705                 tests.add(test);
706                 // Only exclude custom run test if all test methods excluded
707                 shouldExcludeTest &= shouldExcludeTest(testMethod.getName());
708             } catch (TestFormatException e) {
709                 // Logged, continue.
710             }
711         }
712         if (tests.isEmpty()) {
713             return; // There was a format violation. Return.
714         }
715         dontCompileAndDontInlineMethod(m);
716         CustomRunTest customRunTest = new CustomRunTest(m, getAnnotation(m, Warmup.class), runAnno, tests, shouldExcludeTest);
717         allTests.add(customRunTest);
718         if (PRINT_VALID_IR_RULES) {
719             tests.forEach(test -> irMatchRulePrinter.emitRuleEncoding(test.getTestMethod(), customRunTest.isSkipped()));
720         }
721     }
722 
723     /**
724      * Only allow parameters as specified in {@link Run}.
725      */
726     private void checkCustomRunTest(Method m, String testName, Method testMethod, DeclaredTest test, RunMode runMode) {
727         TestFormat.check(testMethod != null, "Did not find associated @Test method \""  + m.getDeclaringClass().getName()
728                                              + "." + testName + "\" specified in @Run at " + m);
729         TestFormat.check(test != null,
730                          "Missing @Test annotation for associated test method " + testName + " for @Run at " + m);
731         Method attachedMethod = test.getAttachedMethod();
732         TestFormat.check(attachedMethod == null,
733                          "Cannot use @Test " + testMethod + " for more than one @Run/@Check method. Found: "
734                          + m + ", " + attachedMethod);
735         TestFormat.check(!test.hasArguments(),
736                          "Cannot use @Arguments at test method " + testMethod + " in combination with @Run method " + m);
737         Warmup warmupAnno = getAnnotation(testMethod, Warmup.class);
738         TestFormat.checkNoThrow(warmupAnno == null,
739                                 "Cannot set @Warmup at @Test method " + testMethod + " when used with its @Run method "
740                                 + m + ". Use @Warmup at @Run method instead.");
741         Test testAnno = getAnnotation(testMethod, Test.class);
742         TestFormat.checkNoThrow(runMode != RunMode.STANDALONE || testAnno.compLevel() == CompLevel.ANY,
743                                 "Setting explicit compilation level for @Test method " + testMethod + " has no effect "
744                                 + "when used with STANDALONE @Run method " + m);
745     }
746 
747     private void checkRunMethod(Method m, Run runAnno) {
748         TestFormat.check(runAnno.test().length > 0, "@Run method " + m + " must specify at least one test method");
749         TestFormat.checkNoThrow(m.getParameterCount() == 0 || (m.getParameterCount() == 1 && m.getParameterTypes()[0].equals(RunInfo.class)),
750                                 "@Run method " + m + " must specify either no parameter or exactly one " + RunInfo.class + " parameter.");
751         Warmup warmupAnno = getAnnotation(m, Warmup.class);
752         TestFormat.checkNoThrow(warmupAnno == null || runAnno.mode() != RunMode.STANDALONE,
753                                 "Cannot set @Warmup at @Run method " + m + " when used with RunMode.STANDALONE. The @Run method is only invoked once.");
754     }
755 
756     private static <T extends Annotation> T getAnnotation(AnnotatedElement element, Class<T> c) {
757         T[] annos =  element.getAnnotationsByType(c);
758         TestFormat.check(annos.length < 2, element + " has duplicated annotations");
759         return Arrays.stream(annos).findFirst().orElse(null);
760     }
761 
762     /**
763      * Ensure that all compilations that were enforced (added to compilation queue) by framework annotations are
764      * completed. Wait if necessary for a short amount of time for their completion.
765      */
766     private void checkForcedCompilationsCompleted() {
767         if (forceCompileMap.isEmpty()) {
768             return;
769         }
770         final long started = System.currentTimeMillis();
771         long elapsed;
772         do {
773             forceCompileMap.entrySet().removeIf(entry -> WHITE_BOX.getMethodCompilationLevel(entry.getKey()) == entry.getValue().getValue());
774             if (forceCompileMap.isEmpty()) {
775                 // All @ForceCompile methods are compiled at the requested level.
776                 return;
777             }
778             // Retry again if not yet compiled.
779             forceCompileMap.forEach(TestVM::enqueueForCompilation);
780             elapsed = System.currentTimeMillis() - started;
781         } while (elapsed < 5000);
782         StringBuilder builder = new StringBuilder();
783         forceCompileMap.forEach((key, value) -> builder.append("- ").append(key).append(" at CompLevel.").append(value)
784                                                        .append(System.lineSeparator()));
785         throw new TestRunException("Could not force compile the following @ForceCompile methods:"
786                                    + System.lineSeparator() + builder.toString());
787     }
788 
789     /**
790      * Once all framework tests are collected, they are run in this method.
791      */
792     private void runTests() {
793         TreeMap<Long, String> durations = (PRINT_TIMES || VERBOSE) ? new TreeMap<>() : null;
794         long startTime = System.nanoTime();
795         List<AbstractTest> testList;
796         boolean testFilterPresent = testFilterPresent();
797         if (testFilterPresent) {
798             // Only run the specified tests by the user filters -DTest and/or -DExclude.
799             testList = allTests.stream().filter(test -> !test.isSkipped()).collect(Collectors.toList());
800             if (testList.isEmpty()) {
801                 // Throw an exception to inform the user about an empty specified test set with -DTest and/or -DExclude
802                 throw new NoTestsRunException();
803             }
804         } else {
805             testList = allTests;
806         }
807 
808         if (SHUFFLE_TESTS) {
809             // Execute tests in random order (execution sequence affects profiling). This is done by default.
810             Collections.shuffle(testList, Utils.getRandomInstance());
811         }
812         StringBuilder builder = new StringBuilder();
813         int failures = 0;
814 
815         // Execute all tests and keep track of each exception that is thrown. These are then reported once all tests
816         // are executing. This prevents a premature exit without running all tests.
817         for (AbstractTest test : testList) {
818             if (VERBOSE) {
819                 System.out.println("Run " + test.toString());
820             }
821             if (testFilterPresent) {
822                 TestFrameworkSocket.write("Run " + test.toString(), TestFrameworkSocket.TESTLIST_TAG, true);
823             }
824             try {
825                 test.run();
826             } catch (TestRunException e) {
827                 StringWriter sw = new StringWriter();
828                 PrintWriter pw = new PrintWriter(sw);
829                 e.printStackTrace(pw);
830                 builder.append(test.toString()).append(":").append(System.lineSeparator()).append(sw.toString())
831                        .append(System.lineSeparator()).append(System.lineSeparator());
832                 failures++;
833             }
834             if (PRINT_TIMES || VERBOSE) {
835                 long endTime = System.nanoTime();
836                 long duration = (endTime - startTime);
837                 durations.put(duration, test.getName());
838                 if (VERBOSE) {
839                     System.out.println("Done " + test.getName() + ": " + duration + " ns = " + (duration / 1000000) + " ms");
840                 }
841             }
842             if (GC_AFTER) {
843                 System.out.println("doing GC");
844                 WHITE_BOX.fullGC();
845             }
846         }
847 
848         // Print execution times
849         if (VERBOSE || PRINT_TIMES) {
850             System.out.println(System.lineSeparator() + System.lineSeparator() + "Test execution times:");
851             for (Map.Entry<Long, String> entry : durations.entrySet()) {
852                 System.out.format("%-10s%15d ns%n", entry.getValue() + ":", entry.getKey());
853             }
854         }
855 
856         if (failures > 0) {
857             // Finally, report all occurred exceptions in a nice format.
858             String msg = System.lineSeparator() + System.lineSeparator() + "Test Failures (" + failures + ")"
859                          + System.lineSeparator() + "----------------" + "-".repeat(String.valueOf(failures).length());
860             throw new TestRunException(msg + System.lineSeparator() + builder.toString());
861         }
862     }
863 
864     private boolean testFilterPresent() {
865         return testList != null || excludeList != null;
866     }
867 
868     enum TriState {
869         Maybe,
870         Yes,
871         No
872     }
873 
874     public static void compile(Method m, CompLevel compLevel) {
875         TestRun.check(compLevel != CompLevel.SKIP && compLevel != CompLevel.WAIT_FOR_COMPILATION,
876                       "Invalid compilation request with level " + compLevel);
877         enqueueForCompilation(m, compLevel);
878     }
879 
880     public static void deoptimize(Method m) {
881         WHITE_BOX.deoptimizeMethod(m);
882     }
883 
884     public static boolean isCompiled(Method m) {
885         return compiledAtLevel(m, CompLevel.ANY) == TriState.Yes;
886     }
887 
888     public static boolean isC1Compiled(Method m) {
889         return compiledByC1(m) == TriState.Yes;
890     }
891 
892     public static boolean isC2Compiled(Method m) {
893         return compiledByC2(m) == TriState.Yes;
894     }
895 
896     public static boolean isCompiledAtLevel(Method m, CompLevel compLevel) {
897         return compiledAtLevel(m, compLevel) == TriState.Yes;
898     }
899 
900     public static void assertDeoptimizedByC1(Method m) {
901         if (isStableDeopt(m, CompLevel.C1_SIMPLE)) {
902             TestRun.check(compiledByC1(m) != TriState.Yes, m + " should have been deoptimized by C1");

903         }
904     }
905 
906     public static void assertDeoptimizedByC2(Method m) {
907         if (isStableDeopt(m, CompLevel.C2)) {
908             TestRun.check(compiledByC2(m) != TriState.Yes, m + " should have been deoptimized by C2");

909         }
910     }
911 
912     /**
913      * Some VM flags could make the deopt assertions unstable.
914      */
915     public static boolean isStableDeopt(Method m, CompLevel level) {
916         return (USE_COMPILER && !XCOMP && !IGNORE_COMPILER_CONTROLS && !TEST_C1 &&
917                 PER_METHOD_TRAP_LIMIT != 0 && PROFILE_INTERPRETER && !DEOPT_BARRIERS_ALOT &&
918                 (!EXCLUDE_RANDOM || WHITE_BOX.isMethodCompilable(m, level.getValue(), false)));
919     }
920 
921     public static void assertCompiledByC1(Method m) {
922         TestRun.check(compiledByC1(m) != TriState.No, m + " should have been C1 compiled");
923     }
924 
925     public static void assertCompiledByC2(Method m) {
926         TestRun.check(compiledByC2(m) != TriState.No, m + " should have been C2 compiled");
927     }
928 
929     public static void assertCompiledAtLevel(Method m, CompLevel level) {
930         TestRun.check(compiledAtLevel(m, level) != TriState.No, m + " should have been compiled at level " + level.name());
931     }
932 
933     public static void assertNotCompiled(Method m) {
934         TestRun.check(!isC1Compiled(m), m + " should not have been compiled by C1");
935         TestRun.check(!isC2Compiled(m), m + " should not have been compiled by C2");
936     }
937 
938     public static void assertCompiled(Method m) {
939         TestRun.check(compiledByC1(m) != TriState.No || compiledByC2(m) != TriState.No, m + " should have been compiled");
940     }
941 
942     private static TriState compiledByC1(Method m) {
943         TriState triState = compiledAtLevel(m, CompLevel.C1_SIMPLE);
944         if (triState != TriState.No) {
945             return triState;
946         }
947         triState = compiledAtLevel(m, CompLevel.C1_LIMITED_PROFILE);
948         if (triState != TriState.No) {
949             return triState;
950         }
951         triState = compiledAtLevel(m, CompLevel.C1_FULL_PROFILE);
952         return triState;
953     }
954 
955     private static TriState compiledByC2(Method m) {
956         return compiledAtLevel(m, CompLevel.C2);
957     }
958 
959     private static TriState compiledAtLevel(Method m, CompLevel level) {
960         if (WHITE_BOX.isMethodCompiled(m, false)) {
961             switch (level) {
962                 case C1_SIMPLE, C1_LIMITED_PROFILE, C1_FULL_PROFILE, C2 -> {
963                     if (WHITE_BOX.getMethodCompilationLevel(m, false) == level.getValue()) {
964                         return TriState.Yes;
965                     }
966                 }
967                 case ANY -> {
968                     return TriState.Yes;
969                 }
970                 default -> throw new TestRunException("compiledAtLevel() should not be called with " + level);
971             }
972         }
973         if (!USE_COMPILER || XCOMP || TEST_C1 || IGNORE_COMPILER_CONTROLS || FLIP_C1_C2 || DEOPT_BARRIERS_ALOT ||
974             (EXCLUDE_RANDOM && !WHITE_BOX.isMethodCompilable(m, level.getValue(), false))) {
975             return TriState.Maybe;
976         }
977         return TriState.No;
978     }
979 }
--- EOF ---