1 /*
   2  * Copyright (c) 2021, 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 ir_framework.tests;
  25 
  26 import compiler.lib.ir_framework.*;
  27 import compiler.lib.ir_framework.driver.IRViolationException;
  28 import jdk.test.lib.Asserts;
  29 import jdk.test.lib.Platform;
  30 import sun.hotspot.WhiteBox;
  31 
  32 import java.io.ByteArrayOutputStream;
  33 import java.io.PrintStream;
  34 import java.util.*;
  35 import java.util.regex.Matcher;
  36 import java.util.regex.Pattern;
  37 
  38 /*
  39  * @test
  40  * @requires vm.debug == true & vm.compMode != "Xint" & vm.compiler1.enabled & vm.compiler2.enabled & vm.flagless
  41  * @summary Test IR matcher with different default IR node regexes. Use -DPrintIREncoding.
  42  *          Normally, the framework should be called with driver.
  43  * @library /test/lib /testlibrary_tests /
  44  * @build sun.hotspot.WhiteBox
  45  * @run driver jdk.test.lib.helpers.ClassFileInstaller sun.hotspot.WhiteBox
  46  * @run main/othervm/timeout=240 -Xbootclasspath/a:. -DSkipWhiteBoxInstall=true -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions
  47  *                               -XX:+WhiteBoxAPI -DPrintIREncoding=true  ir_framework.tests.TestIRMatching
  48  */
  49 
  50 public class TestIRMatching {
  51 
  52     private static final Map<Exception, String> exceptions = new LinkedHashMap<>();
  53     private static final ByteArrayOutputStream baos = new ByteArrayOutputStream();
  54     private static final ByteArrayOutputStream baosErr = new ByteArrayOutputStream();
  55     private static final PrintStream ps = new PrintStream(baos);
  56     private static final PrintStream psErr = new PrintStream(baosErr);
  57     private static final PrintStream oldOut = System.out;
  58     private static final PrintStream oldErr = System.err;
  59 
  60     private static void addException(Exception e) {
  61         System.out.flush();
  62         System.err.flush();
  63         exceptions.put(e, baos.toString() + System.lineSeparator() + baosErr.toString());
  64     }
  65 
  66     public static void main(String[] args) {
  67         // Redirect System.out and System.err to reduce noise.
  68         System.setOut(ps);
  69         System.setErr(psErr);
  70         runWithArguments(AndOr1.class, "-XX:TLABRefillWasteFraction=52", "-XX:+UsePerfData", "-XX:+UseTLAB");
  71         runWithArguments(CountComparisons.class, "-XX:TLABRefillWasteFraction=50");
  72         runWithArguments(GoodCount.class, "-XX:TLABRefillWasteFraction=50");
  73         runWithArguments(MultipleFailOnGood.class, "-XX:TLABRefillWasteFraction=50");
  74 
  75         runCheck(new String[] {"-XX:TLABRefillWasteFraction=50", "-XX:+UsePerfData", "-XX:+UseTLAB"}, BadFailOnConstraint.create(AndOr1.class, "test1(int)", 1, "CallStaticJava"));
  76         runCheck(new String[] {"-XX:TLABRefillWasteFraction=50", "-XX:-UsePerfData", "-XX:+UseTLAB"}, BadFailOnConstraint.create(AndOr1.class, "test2()", 1, "CallStaticJava"));
  77 
  78         String[] allocMatches = { "MyClass", "wrapper for: _new_instance_Java" };
  79         runCheck(BadFailOnConstraint.create(MultipleFailOnBad.class, "fail1()", 1, 1, "Store"),
  80                  BadFailOnConstraint.create(MultipleFailOnBad.class, "fail1()", 1,  3, "Store"),
  81                  GoodFailOnRegexConstraint.create(MultipleFailOnBad.class, "fail1()", 1,  2, 4),
  82                  GoodFailOnRegexConstraint.create(MultipleFailOnBad.class, "fail2()", 1,  1),
  83                  BadFailOnConstraint.create(MultipleFailOnBad.class, "fail2()", 1,  2, "CallStaticJava"),
  84                  BadFailOnConstraint.create(MultipleFailOnBad.class, "fail3()", 1,  2, "Store"),
  85                  GoodFailOnRegexConstraint.create(MultipleFailOnBad.class, "fail3()", 1,  1, 3),
  86                  BadFailOnConstraint.create(MultipleFailOnBad.class, "fail4()", 1,  1, "Store"),
  87                  GoodFailOnRegexConstraint.create(MultipleFailOnBad.class, "fail4()", 1,  2, 3),
  88                  BadFailOnConstraint.create(MultipleFailOnBad.class, "fail5()", 1,  1, "Store"),
  89                  GoodFailOnRegexConstraint.create(MultipleFailOnBad.class, "fail5()", 1,  2, 3),
  90                  GoodFailOnRegexConstraint.create(MultipleFailOnBad.class, "fail6()", 1,  1),
  91                  BadFailOnConstraint.create(MultipleFailOnBad.class, "fail6()", 1,  2, allocMatches),
  92                  BadFailOnConstraint.create(MultipleFailOnBad.class, "fail6()", 1,  3, "CallStaticJava"),
  93                  GoodFailOnRegexConstraint.create(MultipleFailOnBad.class, "fail7()", 1,  1),
  94                  BadFailOnConstraint.create(MultipleFailOnBad.class, "fail7()", 1,  2, allocMatches),
  95                  GoodFailOnRegexConstraint.create(MultipleFailOnBad.class, "fail8()", 1,  1),
  96                  BadFailOnConstraint.create(MultipleFailOnBad.class, "fail8()", 1,  2, allocMatches),
  97                  BadFailOnConstraint.create(MultipleFailOnBad.class, "fail9()", 1,  1, "Store"),
  98                  BadFailOnConstraint.create(MultipleFailOnBad.class, "fail9()", 1,  2, "CallStaticJava"),
  99                  BadFailOnConstraint.create(MultipleFailOnBad.class, "fail10()", 1,  1, "Store", "iFld"),
 100                  GoodFailOnRegexConstraint.create(MultipleFailOnBad.class, "fail10()", 1,  2, 3)
 101         );
 102 
 103         runCheck(BadCountsConstraint.create(BadCount.class, "bad1()", 1, 1, "Load"),
 104                  GoodCountsConstraint.create(BadCount.class, "bad1()", 2),
 105                  GoodCountsConstraint.create(BadCount.class, "bad2()", 1),
 106                  BadCountsConstraint.create(BadCount.class, "bad2()", 2,  1, "Store"),
 107                  BadCountsConstraint.create(BadCount.class, "bad3()", 1,  1, "Load"),
 108                  BadCountsConstraint.create(BadCount.class, "bad3()", 2,  1, "Store")
 109         );
 110 
 111         runCheck(GoodRuleConstraint.create(Calls.class, "calls()", 1),
 112                  BadFailOnConstraint.create(Calls.class, "calls()", 2, 1, "CallStaticJava", "dontInline"),
 113                  BadFailOnConstraint.create(Calls.class, "calls()", 2, 2, "CallStaticJava", "dontInline"),
 114                  GoodRuleConstraint.create(Calls.class, "calls()", 3)
 115         );
 116 
 117         String[] allocArrayMatches = { "MyClass", "wrapper for: _new_array_Java"};
 118         runCheck(BadFailOnConstraint.create(AllocArray.class, "allocArray()", 1, allocArrayMatches),
 119                  BadFailOnConstraint.create(AllocArray.class, "allocArray()", 2,  allocArrayMatches),
 120                  GoodFailOnConstraint.create(AllocArray.class, "allocArray()", 3),
 121                  GoodFailOnConstraint.create(AllocArray.class, "allocArray()", 4),
 122                  BadFailOnConstraint.create(AllocArray.class, "allocArray()", 5,  allocArrayMatches)
 123         );
 124 
 125         runCheck(GoodRuleConstraint.create(RunTests.class, "good1()", 1),
 126                  GoodRuleConstraint.create(RunTests.class, "good1()", 2),
 127                  GoodRuleConstraint.create(RunTests.class, "good2()", 1),
 128                  GoodRuleConstraint.create(RunTests.class, "good2()", 2),
 129                  GoodRuleConstraint.create(RunTests.class, "good3(int)", 1),
 130                  BadCountsConstraint.create(RunTests.class, "bad1(int)", 1, 0),
 131                  BadFailOnConstraint.create(RunTests.class, "bad1(int)", 2, "Load")
 132         );
 133 
 134         runCheck(BadFailOnConstraint.create(Loads.class, "load()", 1, 1, "Load"),
 135                  BadFailOnConstraint.create(Loads.class, "load()", 1, 3, "LoadI"),
 136                  BadCountsConstraint.create(Loads.class, "load()", 1, 1, 0),
 137                  BadCountsConstraint.create(Loads.class, "load()", 1, 2, 1,"Load"),
 138                  GoodRuleConstraint.create(Loads.class, "load()", 2),
 139                  GoodFailOnConstraint.create(Loads.class, "load()", 3),
 140                  BadCountsConstraint.create(Loads.class, "load()", 3, 2, 2,"Store"),
 141                  BadFailOnConstraint.create(Loads.class, "load()", 4, 2, "Store"),
 142                  BadFailOnConstraint.create(Loads.class, "load()", 5, "Load"),
 143                  BadFailOnConstraint.create(Loads.class, "load()", 6, "Load"),
 144                  BadFailOnConstraint.create(Loads.class, "load()", 7, "Load"),
 145                  GoodRuleConstraint.create(Loads.class, "load()", 8),
 146                  GoodRuleConstraint.create(Loads.class, "load()", 9),
 147                  GoodRuleConstraint.create(Loads.class, "load()", 10),
 148                  BadFailOnConstraint.create(Loads.class, "loadKlass()", 1),
 149                  BadCountsConstraint.create(Loads.class, "loadKlass()", 2, 2,"Field")
 150                  );
 151 
 152         // Loops
 153         runCheck(BadFailOnConstraint.create(Loops.class, "loop()", 1, "Loop"),
 154                  GoodRuleConstraint.create(Loops.class, "loop()", 2),
 155                  GoodRuleConstraint.create(Loops.class, "loop()", 3),
 156                  GoodRuleConstraint.create(Loops.class, "countedLoop()", 1),
 157                  BadFailOnConstraint.create(Loops.class, "countedLoop()", 2, "CountedLoop"),
 158                  GoodRuleConstraint.create(Loops.class, "countedLoop()", 3),
 159                  BadFailOnConstraint.create(Loops.class, "loopAndCountedLoop()", 1, "Loop"),
 160                  BadFailOnConstraint.create(Loops.class, "loopAndCountedLoop()", 2, "CountedLoop"),
 161                  GoodRuleConstraint.create(Loops.class, "loopAndCountedLoop()", 3),
 162                  GoodRuleConstraint.create(Loops.class, "countedLoopMain()", 1),
 163                  BadFailOnConstraint.create(Loops.class, "countedLoopMain()", 2, "CountedLoop"),
 164                  BadFailOnConstraint.create(Loops.class, "countedLoopMain()", 3, "CountedLoop", "main"),
 165                  GoodRuleConstraint.create(Loops.class, "countedLoopUnrolled()", 1),
 166                  GoodRuleConstraint.create(Loops.class, "countedLoopUnrolled()", 2),
 167                  GoodRuleConstraint.create(Loops.class, "countedLoopUnrolled()", 3)
 168         );
 169 
 170         // Traps
 171         runCheck(GoodRuleConstraint.create(Traps.class, "noTraps()", 1),
 172                  BadFailOnConstraint.create(Traps.class, "noTraps()", 2, "Store", "iFld"),
 173                  GoodRuleConstraint.create(Traps.class, "noTraps()", 3),
 174                  BadFailOnConstraint.create(Traps.class, "predicateTrap()", 1, "CallStaticJava", "uncommon_trap"),
 175                  BadFailOnConstraint.create(Traps.class, "predicateTrap()", 2, "CallStaticJava", "uncommon_trap", "predicate"),
 176                  GoodRuleConstraint.create(Traps.class, "predicateTrap()", 3),
 177                  GoodRuleConstraint.create(Traps.class, "predicateTrap()", 4),
 178                  BadFailOnConstraint.create(Traps.class, "nullCheck()", 1, "CallStaticJava", "uncommon_trap"),
 179                  BadFailOnConstraint.create(Traps.class, "nullCheck()", 2, "CallStaticJava", "uncommon_trap", "null_check"),
 180                  BadFailOnConstraint.create(Traps.class, "nullCheck()", 3, "uncommon_trap", "unstable_if"),
 181                  GoodRuleConstraint.create(Traps.class, "nullCheck()", 4),
 182                  BadFailOnConstraint.create(Traps.class, "nullAssert()", 1, "CallStaticJava", "uncommon_trap"),
 183                  BadFailOnConstraint.create(Traps.class, "nullAssert()", 2, "CallStaticJava", "uncommon_trap", "null_assert"),
 184                  BadFailOnConstraint.create(Traps.class, "nullAssert()", 3, "CallStaticJava", "uncommon_trap", "null_check"),
 185                  GoodRuleConstraint.create(Traps.class, "nullAssert()", 4),
 186                  BadFailOnConstraint.create(Traps.class, "unstableIf(boolean)", 1, "CallStaticJava", "uncommon_trap"),
 187                  BadFailOnConstraint.create(Traps.class, "unstableIf(boolean)",  2, "CallStaticJava", "uncommon_trap", "unstable_if"),
 188                  GoodRuleConstraint.create(Traps.class, "unstableIf(boolean)", 3),
 189                  BadFailOnConstraint.create(Traps.class, "classCheck()", 1, "CallStaticJava", "uncommon_trap"),
 190                  BadFailOnConstraint.create(Traps.class, "classCheck()", 2, "CallStaticJava", "uncommon_trap", "class_check"),
 191                  BadFailOnConstraint.create(Traps.class, "classCheck()", 3, "CallStaticJava", "uncommon_trap", "null_check"),
 192                  GoodRuleConstraint.create(Traps.class, "classCheck()", 4),
 193                  BadFailOnConstraint.create(Traps.class, "rangeCheck()", 1, "CallStaticJava", "uncommon_trap"),
 194                  BadFailOnConstraint.create(Traps.class, "rangeCheck()", 2, "CallStaticJava", "uncommon_trap", "range_check"),
 195                  BadFailOnConstraint.create(Traps.class, "rangeCheck()", 3, "CallStaticJava", "uncommon_trap", "null_check"),
 196                  GoodRuleConstraint.create(Traps.class, "rangeCheck()", 4),
 197                  BadFailOnConstraint.create(Traps.class, "instrinsicOrTypeCheckedInlining()", 1, "CallStaticJava", "uncommon_trap"),
 198                  WhiteBox.getWhiteBox().isJVMCISupportedByGC() ?
 199                     BadFailOnConstraint.create(Traps.class, "instrinsicOrTypeCheckedInlining()", 2, "CallStaticJava", "uncommon_trap", "intrinsic_or_type_checked_inlining")
 200                     : GoodRuleConstraint.create(Traps.class, "instrinsicOrTypeCheckedInlining()", 2),
 201                  BadFailOnConstraint.create(Traps.class, "instrinsicOrTypeCheckedInlining()", 3, "CallStaticJava", "uncommon_trap", "intrinsic"),
 202                  BadFailOnConstraint.create(Traps.class, "instrinsicOrTypeCheckedInlining()", 4, "CallStaticJava", "uncommon_trap", "null_check"),
 203                  GoodRuleConstraint.create(Traps.class, "instrinsicOrTypeCheckedInlining()", 5)
 204         );
 205 
 206 
 207         runCheck(new String[] {"-XX:+BailoutToInterpreterForThrows"},
 208                  BadFailOnConstraint.create(UnhandledTrap.class, "unhandled()", 1, "CallStaticJava", "uncommon_trap"),
 209                  BadFailOnConstraint.create(UnhandledTrap.class, "unhandled()", 2, "CallStaticJava", "uncommon_trap", "unhandled"),
 210                  GoodRuleConstraint.create(UnhandledTrap.class, "unhandled()", 3)
 211         );
 212 
 213         runCheck(BadFailOnConstraint.create(ScopeObj.class, "scopeObject()", 1, "ScObj"));
 214         runCheck(BadFailOnConstraint.create(Membar.class, "membar()", 1, "MemBar"));
 215 
 216         String cmp;
 217         if (Platform.isPPC() || Platform.isX86()) {
 218             cmp = "CMP";
 219         } else if (Platform.isS390x()){
 220             cmp = "CLFI";
 221         } else {
 222             cmp = "cmp";
 223         }
 224         runCheck(BadFailOnConstraint.create(CheckCastArray.class, "array()", 1, cmp, "precise"),
 225                  BadFailOnConstraint.create(CheckCastArray.class, "array()", 2, 1,cmp, "precise", "MyClass"),
 226                  BadFailOnConstraint.create(CheckCastArray.class, "array()", 2, 2,cmp, "precise", "ir_framework/tests/MyClass"),
 227                  GoodFailOnConstraint.create(CheckCastArray.class, "array()", 3),
 228                  Platform.isS390x() ? // There is no checkcast_arraycopy stub for C2 on s390
 229                      GoodFailOnConstraint.create(CheckCastArray.class, "arrayCopy(java.lang.Object[],java.lang.Class)", 1)
 230                      : BadFailOnConstraint.create(CheckCastArray.class, "arrayCopy(java.lang.Object[],java.lang.Class)", 1, "checkcast_arraycopy")
 231         );
 232 
 233         try {
 234             runWithArgumentsFail(CompilationOutputOfFails.class);
 235             Utils.shouldHaveThrownException(baos.toString());
 236         } catch (IRViolationException e) {
 237             try {
 238                 StringBuilder failures = new StringBuilder();
 239                 System.out.flush();
 240                 String output = baos.toString();
 241                 baos.reset();
 242                 Pattern pattern = Pattern.compile(">>> Compilation.*both\\d.*\\RPrintIdeal:(?:(?!PrintOpto|>>> Compilation)[\\S\\s])+PrintOptoAssembly");
 243                 Matcher matcher = pattern.matcher(output);
 244                 long bothCount = matcher.results().count();
 245                 if (bothCount != 7L) {
 246                     failures.append("- Could not find all both() methods, expected 7 but found ").append(bothCount).append(System.lineSeparator());
 247                 }
 248                 pattern = Pattern.compile(">>> Compilation.*ideal\\d.*\\RPrintIdeal:(?:(?!>>> Compilation)[\\S\\s])+");
 249                 matcher = pattern.matcher(output);
 250                 int count = 0;
 251                 while (matcher.find()) {
 252                     String match = matcher.group();
 253                     if (match.contains("PrintOptoAssembly")) {
 254                         failures.append("Cannot contain opto assembly: ").append(System.lineSeparator()).append(match);
 255                     }
 256                     count++;
 257                 }
 258                 if (count != 7) {
 259                     failures.append("- Could not find all ideal() methods, expected 7 but found ").append(count).append(System.lineSeparator());
 260                 }
 261                 pattern = Pattern.compile(">>> Compilation.*opto\\d.*\\RPrintOptoAssembly:(?:(?!>>> Compilation)[\\S\\s])+");
 262                 matcher = pattern.matcher(output);
 263                 count = 0;
 264                 while (matcher.find()) {
 265                     String match = matcher.group();
 266                     if (match.contains("PrintIdeal")) {
 267                         failures.append("Cannot contain print assembly: ").append(System.lineSeparator()).append(match);
 268                     }
 269                     count++;
 270                 }
 271                 if (count != 7) {
 272                     failures.append("- Could not find all opto() methods, expected 7 but found ").append(count).append(System.lineSeparator());
 273                 }
 274                 if (!failures.isEmpty()) {
 275                     addException(new RuntimeException(failures.toString()));
 276                 }
 277             } catch (Exception e1) {
 278                 addException(e1);
 279             }
 280         } catch (Exception e) {
 281             addException(e);
 282         }
 283 
 284         runWithArguments(FlagComparisons.class, "-XX:TLABRefillWasteFraction=50");
 285         System.out.flush();
 286         String output = baos.toString();
 287         findIrIds(output, "testMatchAllIf50", 0, 21);
 288         findIrIds(output, "testMatchNoneIf50", -1, -1);
 289 
 290         runWithArguments(FlagComparisons.class, "-XX:TLABRefillWasteFraction=49");
 291         System.out.flush();
 292         output = baos.toString();
 293         findIrIds(output, "testMatchAllIf50", 4, 6, 13, 18);
 294         findIrIds(output, "testMatchNoneIf50", 0, 3, 8, 10, 17, 22);
 295 
 296         runWithArguments(FlagComparisons.class, "-XX:TLABRefillWasteFraction=51");
 297         System.out.flush();
 298         output = baos.toString();
 299         findIrIds(output, "testMatchAllIf50", 7, 12, 19, 21);
 300         findIrIds(output, "testMatchNoneIf50", 4, 7, 11, 16, 20, 22);
 301         System.setOut(oldOut);
 302         System.setErr(oldErr);
 303 
 304         if (!exceptions.isEmpty()) {
 305             System.err.println("TestIRMatching failed with " + exceptions.size() + " exception(s):");
 306             int i = 1;
 307             System.err.println("************************");
 308             for (Map.Entry<Exception, String> entry : exceptions.entrySet()) {
 309                 System.err.println("***** Exception " + String.format("%02d", i++) +" *****");
 310                 System.err.println("************************");
 311 
 312                 Exception e = entry.getKey();
 313                 e.printStackTrace(System.err);
 314                 System.err.println();
 315                 System.err.println("===== OUTPUT ======");
 316                 System.err.println(entry.getValue());
 317                 System.err.println("MESSAGE: " + e.getMessage());
 318                 System.err.println("************************");
 319             }
 320             i = 1;
 321             System.err.println("====================================");
 322             System.err.println("********************");
 323             System.err.println("***** OVERVIEW *****");
 324             System.err.println("********************");
 325             for (Map.Entry<Exception, String> entry : exceptions.entrySet()) {
 326                 Exception e = entry.getKey();
 327                 System.err.print((i++) + ") ");
 328                 entry.getKey().printStackTrace(System.err);
 329                 System.err.println("********************");
 330             }
 331             throw new RuntimeException("TestIRMatching failed with " + exceptions.size() + " exception(s) - check stderr and stdout");
 332         }
 333     }
 334 
 335     private static void runFramework(TestFramework framework) {
 336         baos.reset();
 337         baosErr.reset();
 338         framework.start();
 339     }
 340 
 341     private static void runWithArguments(Class<?> clazz, String... args) {
 342         try {
 343             runFramework(new TestFramework(clazz).addFlags(args));
 344         } catch (Exception e) {
 345             addException(e);
 346         }
 347     }
 348 
 349     private static void runWithArgumentsFail(Class<?> clazz, String... args) {
 350         runFramework(new TestFramework(clazz).addFlags(args));
 351     }
 352 
 353     private static void runCheck(String[] args , Constraint... constraints) {
 354         try {
 355             TestFramework framework = new TestFramework(constraints[0].getKlass()); // All constraints have the same class.
 356             if (args != null) {
 357                 framework.addFlags(args);
 358             }
 359             runFramework(framework);
 360             Utils.shouldHaveThrownException(baos.toString());
 361         } catch (IRViolationException e) {
 362             checkConstraints(e, constraints);
 363         } catch (Exception e) {
 364             addException(e);
 365         }
 366     }
 367 
 368     private static void runCheck(Constraint... constraints) {
 369         runCheck(null, constraints);
 370     }
 371 
 372     private static void checkConstraints(IRViolationException e, Constraint[] constraints) {
 373         String message = e.getExceptionInfo();
 374         try {
 375             for (Constraint constraint : constraints) {
 376                 constraint.checkConstraint(e);
 377             }
 378         } catch (Exception e1) {
 379             System.out.println(e.getCompilations());
 380             System.out.println(message);
 381             addException(e1);
 382         }
 383     }
 384 
 385     public static void findIrIds(String output, String method, int... numbers) {
 386         StringBuilder builder = new StringBuilder();
 387         builder.append(method);
 388         for (int i = 0; i < numbers.length; i+=2) {
 389             int start = numbers[i];
 390             int endIncluded = numbers[i + 1];
 391             for (int j = start; j <= endIncluded; j++) {
 392                 builder.append(",");
 393                 builder.append(j);
 394             }
 395         }
 396         if (!output.contains(builder.toString())) {
 397             addException(new RuntimeException("Could not find encoding: \"" + builder.toString() + System.lineSeparator()));
 398         }
 399     }
 400 }
 401 
 402 class AndOr1 {
 403     @Test
 404     @Arguments(Argument.DEFAULT)
 405     @IR(applyIfAnd = {"UsePerfData", "true", "TLABRefillWasteFraction", "50", "UseTLAB", "true"}, failOn = {IRNode.CALL})
 406     public void test1(int i) {
 407         dontInline();
 408     }
 409 
 410     @Test
 411     @IR(applyIfOr = {"UsePerfData", "false", "TLABRefillWasteFraction", "51", "UseTLAB", "false"}, failOn = {IRNode.CALL})
 412     public void test2() {
 413         dontInline();
 414     }
 415 
 416     @DontInline
 417     private void dontInline() {
 418     }
 419 }
 420 
 421 class MultipleFailOnGood {
 422     private int iFld;
 423     private MyClassSub myClassSub = new MyClassSub();
 424 
 425     @Test
 426     @IR(applyIf = {"TLABRefillWasteFraction", "50"}, failOn = {IRNode.STORE, IRNode.CALL})
 427     @IR(failOn = {IRNode.STORE, IRNode.CALL})
 428     @IR(applyIfOr = {"TLABRefillWasteFraction", "99", "TLABRefillWasteFraction", "100"}, failOn = {IRNode.LOOP, IRNode.CALL}) // Not applied
 429     public void good1() {
 430         forceInline();
 431     }
 432 
 433     @Test
 434     @IR(failOn = {IRNode.STORE, IRNode.CALL})
 435     @IR(applyIfNot = {"TLABRefillWasteFraction", "20"}, failOn = {IRNode.ALLOC})
 436     @IR(applyIfNot = {"TLABRefillWasteFraction", "< 100"}, failOn = {IRNode.ALLOC_OF, "Test"})
 437     public void good2() {
 438         forceInline();
 439     }
 440 
 441     @Test
 442     @IR(failOn = {IRNode.STORE_OF_CLASS, "Test", IRNode.CALL})
 443     @IR(applyIfNot = {"TLABRefillWasteFraction", "20"}, failOn = {IRNode.ALLOC})
 444     @IR(applyIfNot = {"TLABRefillWasteFraction", "< 100"}, failOn = {IRNode.ALLOC_OF, "Test"})
 445     public void good3() {
 446         forceInline();
 447     }
 448 
 449     @Test
 450     @IR(failOn = {IRNode.CALL, IRNode.STORE_OF_CLASS, "UnknownClass"})
 451     public void good4() {
 452         iFld = 42;
 453     }
 454 
 455     @Test
 456     @IR(failOn = {IRNode.STORE_OF_FIELD, "xFld", IRNode.CALL})
 457     public void good5() {
 458         iFld = 42;
 459     }
 460 
 461     @Test
 462     @IR(failOn = {IRNode.STORE_OF_CLASS, "MyClass"}) // Needs exact match to fail
 463     public void good6() {
 464         myClassSub.iFld = 42;
 465     }
 466 
 467     @Test
 468     @IR(failOn = {IRNode.STORE_OF_CLASS, "MyClassSub"}) // Static write is with Class and not MySubClass
 469     public void good7() {
 470         MyClassSub.iFldStatic = 42;
 471     }
 472 
 473     @ForceInline
 474     private void forceInline() {}
 475 }
 476 
 477 class MultipleFailOnBad {
 478     private int iFld;
 479     private int myInt;
 480     private MyClassEmpty myClass;
 481 
 482     @Test
 483     @IR(failOn = {IRNode.STORE, IRNode.CALL, IRNode.STORE_I, IRNode.LOOP})
 484     public void fail1() {
 485         iFld = 42;
 486     }
 487 
 488     @Test
 489     @IR(failOn = {IRNode.STORE, IRNode.CALL})
 490     public void fail2() {
 491         dontInline();
 492     }
 493 
 494     @Test
 495     @IR(failOn = {IRNode.CALL, IRNode.STORE_OF_CLASS, "MultipleFailOnBad", IRNode.ALLOC})
 496     public void fail3() {
 497         iFld = 42;
 498     }
 499 
 500     @Test
 501     @IR(failOn = {IRNode.STORE_OF_CLASS, "ir_framework/tests/MultipleFailOnBad", IRNode.CALL, IRNode.ALLOC})
 502     public void fail4() {
 503         iFld = 42;
 504     }
 505 
 506     @Test
 507     @IR(failOn = {IRNode.STORE_OF_FIELD, "iFld", IRNode.CALL, IRNode.ALLOC})
 508     public void fail5() {
 509         iFld = 42;
 510     }
 511 
 512     @Test
 513     @IR(failOn = {IRNode.STORE_OF_CLASS, "MyClassEmpty", IRNode.ALLOC, IRNode.CALL})
 514     public void fail6() {
 515         myClass = new MyClassEmpty();
 516     }
 517 
 518     @Test
 519     @IR(failOn = {IRNode.STORE_OF_CLASS, "UnknownClass", IRNode.ALLOC_OF, "MyClassEmpty"})
 520     public void fail7() {
 521         myClass = new MyClassEmpty();
 522     }
 523 
 524     @Test
 525     @IR(failOn = {IRNode.STORE_OF_CLASS, "UnknownClass", IRNode.ALLOC_OF, "ir_framework/tests/MyClassEmptySub"})
 526     public void fail8() {
 527         myClass = new MyClassEmptySub();
 528     }
 529 
 530     @Test
 531     @IR(failOn = {IRNode.STORE, IRNode.CALL})
 532     public void fail9() {
 533         iFld = 42;
 534         dontInline();
 535     }
 536 
 537     @Test
 538     @IR(failOn = {IRNode.STORE_OF_FIELD, "iFld", IRNode.CALL, IRNode.ALLOC})
 539     public void fail10() {
 540         myInt = 34;
 541         iFld = 42;
 542     }
 543 
 544     @DontInline
 545     private void dontInline() {}
 546 }
 547 
 548 // Called with -XX:TLABRefillWasteFraction=X.
 549 class FlagComparisons {
 550     // Applies all IR rules if TLABRefillWasteFraction=50
 551     @Test
 552     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "50"}) // Index 0
 553     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "=50"})
 554     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "= 50"})
 555     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", " =   50"})
 556     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "<=50"}) // Index 4
 557     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "<= 50"})
 558     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", " <=  50"})
 559     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", ">=50"}) // Index 7
 560     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", ">= 50"})
 561     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", " >=  50"})
 562     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", ">49"})
 563     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "> 49"})
 564     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", " >  49"})
 565     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "<51"}) // Index 13
 566     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "< 51"})
 567     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", " <  51"})
 568     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "!=51"})
 569     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "!= 51"})
 570     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", " !=  51"})
 571     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "!=49"})
 572     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "!= 49"})
 573     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", " !=  49"}) // Index 21
 574     public void testMatchAllIf50() {}
 575 
 576     // Applies no IR rules if TLABRefillWasteFraction=50
 577     @Test
 578     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "49"}) // Index 0
 579     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "=49"})
 580     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "= 49"})
 581     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", " =  49"})
 582     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "51"}) // Index 4
 583     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "=51"})
 584     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "= 51"})
 585     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", " =  51"})
 586     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "<=49"}) // Index 8
 587     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "<= 49"})
 588     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", " <=  49"})
 589     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", ">=51"}) // Index 11
 590     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", ">= 51"})
 591     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", " >=  51"})
 592     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", ">50"})
 593     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "> 50"})
 594     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", " >  50"})
 595     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "<50"}) // Index 17
 596     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "< 50"})
 597     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", " <  50"})
 598     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "!=50"})
 599     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", "!= 50"})
 600     @IR(failOn = IRNode.CALL, applyIf = {"TLABRefillWasteFraction", " !=  50"}) // Index 22
 601     public void testMatchNoneIf50() {}
 602 }
 603 
 604 class CountComparisons {
 605     int iFld;
 606 
 607     @Test
 608     @IR(counts = {IRNode.STORE, "= 1",
 609                   IRNode.STORE, "=1",
 610                   IRNode.STORE, " = 1",
 611                   IRNode.STORE, "  =  1",
 612                   IRNode.STORE, ">= 1",
 613                   IRNode.STORE, ">=1",
 614                   IRNode.STORE, " >= 1",
 615                   IRNode.STORE, "  >=  1",
 616                   IRNode.STORE, "<= 1",
 617                   IRNode.STORE, "<=1",
 618                   IRNode.STORE, " <= 1",
 619                   IRNode.STORE, "  <=  1",
 620                   IRNode.STORE, "!= 0",
 621                   IRNode.STORE, "!=0",
 622                   IRNode.STORE, " != 0",
 623                   IRNode.STORE, "  !=  0",
 624                   IRNode.STORE, "> 0",
 625                   IRNode.STORE, ">0",
 626                   IRNode.STORE, " > 0",
 627                   IRNode.STORE, "  >  0",
 628                   IRNode.STORE, "< 2",
 629                   IRNode.STORE, "<2",
 630                   IRNode.STORE, " < 2",
 631                   IRNode.STORE, "  <  2",
 632     })
 633     public void countComparison() {
 634         iFld = 3;
 635     }
 636 }
 637 
 638 class GoodCount {
 639     boolean flag;
 640     char cFld;
 641     byte bFld;
 642     short sFld;
 643     int iFld;
 644     long lFld;
 645     float fFld;
 646     double dFld;
 647     long x;
 648 
 649     long result;
 650     MyClass myClass = new MyClass();
 651     MyClassEmpty myClassEmpty = new MyClassEmpty();
 652     MyClass myClassSubPoly = new MyClassSub();
 653     MyClassSub myClassSub = new MyClassSub();
 654 
 655     @Test
 656     @IR(counts = {IRNode.STORE, "1", IRNode.STORE_I, "1"},
 657         failOn = {IRNode.STORE_B, IRNode.STORE_C, IRNode.STORE_D,
 658                   IRNode.STORE_F, IRNode.STORE_L})
 659     public void good1() {
 660         iFld = 3;
 661     }
 662 
 663     @Test
 664     @IR(counts = {IRNode.STORE, "8",
 665                   IRNode.STORE_B, "2", // bFld + flag
 666                   IRNode.STORE_C, "2", // cFld + sFld
 667                   IRNode.STORE_I, "1",
 668                   IRNode.STORE_L, "1",
 669                   IRNode.STORE_F, "1",
 670                   IRNode.STORE_D, "1"})
 671     public void good2() {
 672         flag = true;
 673         cFld = 'a';
 674         bFld = 1;
 675         sFld = 2;
 676         iFld = 3;
 677         lFld = 4L;
 678         fFld = 5.0f;
 679         dFld = 6.0;
 680     }
 681 
 682     @Test
 683     @IR(counts = {IRNode.STORE, "8", IRNode.STORE_OF_CLASS, "GoodCount", "8",
 684                   IRNode.STORE_B, "2", IRNode.STORE_B_OF_CLASS, "GoodCount", "2",
 685                   IRNode.STORE_C, "2", IRNode.STORE_C_OF_CLASS, "GoodCount", "2",
 686                   IRNode.STORE_I, "1", IRNode.STORE_I_OF_CLASS, "GoodCount", "1",
 687                   IRNode.STORE_L, "1", IRNode.STORE_L_OF_CLASS, "GoodCount", "1",
 688                   IRNode.STORE_F, "1", IRNode.STORE_F_OF_CLASS, "GoodCount", "1",
 689                   IRNode.STORE_D, "1", IRNode.STORE_D_OF_CLASS, "GoodCount", "1"})
 690     public void good3() {
 691         flag = true;
 692         cFld = 'a';
 693         bFld = 1;
 694         sFld = 2;
 695         iFld = 3;
 696         lFld = 4L;
 697         fFld = 5.0f;
 698         dFld = 6.0;
 699     }
 700 
 701     @Test
 702     @IR(counts = {IRNode.STORE, "8", IRNode.STORE_OF_CLASS, "GoodCount", "8",
 703                   IRNode.STORE_B, "2", IRNode.STORE_B_OF_CLASS, "GoodCount", "2",
 704                   IRNode.STORE_C, "2", IRNode.STORE_C_OF_CLASS, "GoodCount", "2",
 705                   IRNode.STORE_I, "1", IRNode.STORE_I_OF_CLASS, "GoodCount", "1",
 706                   IRNode.STORE_L, "1", IRNode.STORE_L_OF_CLASS, "GoodCount", "1",
 707                   IRNode.STORE_F, "1", IRNode.STORE_F_OF_CLASS, "GoodCount", "1",
 708                   IRNode.STORE_D, "1", IRNode.STORE_D_OF_CLASS, "GoodCount", "1",
 709                   IRNode.STORE_OF_FIELD, "lFld", "1"})
 710     public void good4() {
 711         flag = true;
 712         cFld = 'a';
 713         bFld = 1;
 714         sFld = 2;
 715         iFld = 3;
 716         lFld = 4L;
 717         fFld = 5.0f;
 718         dFld = 6.0;
 719     }
 720 
 721     @Test
 722     @IR(counts = {IRNode.STORE, "2", IRNode.STORE_I, "1", IRNode.STORE_L, "1",
 723                   IRNode.STORE_OF_CLASS, "GoodCount", "1", IRNode.STORE_L_OF_CLASS, "GoodCount", "1",
 724                   IRNode.STORE_OF_CLASS, "ir_framework/tests/MyClass", "1",
 725                   IRNode.STORE_I_OF_CLASS, "ir_framework/tests/MyClass", "1",
 726                   IRNode.STORE_OF_CLASS, "ir_framework/tests/GoodCount", "1",
 727                   IRNode.STORE_L_OF_CLASS, "ir_framework/tests/GoodCount", "1",
 728                   IRNode.STORE_OF_FIELD, "x", "2"})
 729     public void good5() {
 730         x = 3; // long
 731         myClass.x = 4; // int
 732     }
 733 
 734     @Test
 735     @IR(counts = {IRNode.STORE_OF_FIELD, "myClassEmpty", "1", IRNode.STORE_OF_CLASS, "GoodCount", "1",
 736                   IRNode.STORE_OF_CLASS, "/GoodCount", "1", IRNode.STORE_OF_CLASS, "MyClassEmpty", "0"},
 737         failOn = {IRNode.STORE_OF_CLASS, "MyClassEmpty"})
 738     public void good6() {
 739         myClassEmpty = new MyClassEmpty();
 740     }
 741 
 742     @Test
 743     @IR(counts = {IRNode.STORE_OF_FIELD, "iFld", "3", IRNode.STORE_OF_CLASS, "GoodCount", "0",
 744                   IRNode.STORE_OF_CLASS, "MyClass", "2", IRNode.STORE_OF_CLASS, "MyClassSub", "1",
 745                   IRNode.STORE, "3"},
 746         failOn = {IRNode.STORE_OF_CLASS, "GoodCount"})
 747     public void good7() {
 748         myClass.iFld = 1;
 749         myClassSubPoly.iFld = 2;
 750         myClassSub.iFld = 3;
 751     }
 752 
 753     @Test
 754     @IR(counts = {IRNode.LOAD, "1", IRNode.STORE, "1"})
 755     public void good8() {
 756         result = iFld;
 757     }
 758 
 759 
 760     @Test
 761     @IR(counts = {IRNode.LOAD, "4", IRNode.STORE, "1", IRNode.LOAD_OF_FIELD, "iFld", "2", IRNode.LOAD_OF_FIELD, "iFld2", "0",
 762                   IRNode.LOAD_OF_FIELD, "lFldStatic", "1", IRNode.LOAD_OF_CLASS, "GoodCount", "2", IRNode.LOAD_OF_CLASS, "MyClass", "1",
 763                   IRNode.STORE_OF_CLASS, "GoodCount", "1", IRNode.STORE_OF_FIELD, "result", "1",
 764                   IRNode.LOAD_OF_FIELD, "myClass", "1"})
 765     public void good9() {
 766         result = iFld + MyClass.lFldStatic + myClass.iFld; // 1 + 1 + 2 loads (myClass is LoadN of GoodCount and myClass.iFld a LoadI of MyClass)
 767     }
 768 
 769     @Test
 770     @IR(counts = {IRNode.LOAD, "8",
 771                   IRNode.LOAD_B, "1",
 772                   IRNode.LOAD_UB, "1",
 773                   IRNode.LOAD_S, "1",
 774                   IRNode.LOAD_US, "1",
 775                   IRNode.LOAD_I, "1",
 776                   IRNode.LOAD_L, "1",
 777                   IRNode.LOAD_F, "1",
 778                   IRNode.LOAD_D, "1"})
 779     public void good10() {
 780         bFld++;
 781         cFld++;
 782         sFld++;
 783         iFld++;
 784         lFld++;
 785         fFld++;
 786         dFld++;
 787         flag = !flag;
 788     }
 789 
 790     @Test
 791     @IR(counts = {IRNode.LOAD, "8", IRNode.LOAD_OF_CLASS, "GoodCount", "8",
 792                   IRNode.LOAD_B, "1", IRNode.LOAD_B_OF_CLASS, "GoodCount", "1",
 793                   IRNode.LOAD_UB, "1", IRNode.LOAD_UB_OF_CLASS, "GoodCount", "1",
 794                   IRNode.LOAD_S, "1", IRNode.LOAD_S_OF_CLASS, "GoodCount", "1",
 795                   IRNode.LOAD_US, "1", IRNode.LOAD_US_OF_CLASS, "GoodCount", "1",
 796                   IRNode.LOAD_I, "1", IRNode.LOAD_I_OF_CLASS, "GoodCount", "1",
 797                   IRNode.LOAD_L, "1", IRNode.LOAD_L_OF_CLASS, "GoodCount", "1",
 798                   IRNode.LOAD_F, "1", IRNode.LOAD_F_OF_CLASS, "GoodCount", "1",
 799                   IRNode.LOAD_D, "1", IRNode.LOAD_D_OF_CLASS, "GoodCount", "1"})
 800     public void good11() {
 801         bFld++;
 802         cFld++;
 803         sFld++;
 804         iFld++;
 805         lFld++;
 806         fFld++;
 807         dFld++;
 808         flag = !flag;
 809     }
 810 }
 811 
 812 class BadCount {
 813     int iFld;
 814     int result;
 815     @Test
 816     @IR(counts = {IRNode.LOAD, "!= 1"})
 817     @IR(counts = {IRNode.STORE, "> 0"})
 818     public void bad1() {
 819         result = iFld;
 820     }
 821 
 822     @Test
 823     @IR(counts = {IRNode.LOAD, "1"})
 824     @IR(counts = {IRNode.STORE, "< 1"})
 825     public void bad2() {
 826         result = iFld;
 827     }
 828 
 829 
 830     @Test
 831     @IR(counts = {IRNode.LOAD, "0"})
 832     @IR(counts = {IRNode.STORE, " <= 0"})
 833     public void bad3() {
 834         result = iFld;
 835     }
 836 }
 837 
 838 
 839 class RunTests {
 840     public int iFld;
 841 
 842     @Test
 843     @IR(counts = {IRNode.STORE, "1"})
 844     @IR(failOn = IRNode.LOAD)
 845     public void good1() {
 846         iFld = 42;
 847     }
 848 
 849     @Test
 850     @IR(counts = {IRNode.LOAD, "1"})
 851     @IR(failOn = IRNode.STORE)
 852     public int good2() {
 853         return iFld;
 854     }
 855 
 856     @Run(test = {"good1", "good2"})
 857     public void runGood1() {
 858         good1();
 859         good2();
 860     }
 861 
 862 
 863     @Test
 864     @IR(counts = {IRNode.STORE, "1"})
 865     @IR(failOn = IRNode.LOAD)
 866     public void good3(int x) {
 867         iFld = x;
 868     }
 869 
 870     @Test
 871     @IR(counts = {IRNode.STORE, "1"})
 872     @IR(failOn = IRNode.LOAD)
 873     public int bad1(int x) {
 874         return iFld + x;
 875     }
 876 
 877     @Run(test = {"bad1", "good3"})
 878     public void run() {
 879         bad1(2);
 880         good3(4);
 881     }
 882 }
 883 
 884 class Calls {
 885 
 886     @Test
 887     @IR(counts = {IRNode.CALL, "1"})
 888     @IR(failOn = {IRNode.CALL_OF_METHOD, "dontInline",  // Fails
 889                   IRNode.STATIC_CALL_OF_METHOD, "dontInline"}) // Fails
 890     @IR(failOn = {IRNode.CALL_OF_METHOD, "forceInline",
 891                   IRNode.STATIC_CALL_OF_METHOD, "forceInline",
 892                   IRNode.CALL_OF_METHOD, "dontInlines",
 893                   IRNode.STATIC_CALL_OF_METHOD, "dontInlines",
 894                   IRNode.CALL_OF_METHOD, "dont",
 895                   IRNode.STATIC_CALL_OF_METHOD, "dont"})
 896     public void calls() {
 897         dontInline();
 898         forceInline();
 899     }
 900 
 901     @DontInline
 902     public void dontInline() {}
 903 
 904     @ForceInline
 905     public void forceInline() {}
 906 }
 907 
 908 class AllocArray {
 909     MyClass[] myClassArray;
 910 
 911     @Test
 912     @IR(failOn = {IRNode.ALLOC_ARRAY})
 913     @IR(failOn = {IRNode.ALLOC_ARRAY_OF, "MyClass"})
 914     @IR(failOn = {IRNode.ALLOC_ARRAY_OF, "MyClasss"}) // Does not fail
 915     @IR(failOn = {IRNode.ALLOC_ARRAY_OF, "ir_framework/tests/MySubClass"}) // Does not fail
 916     @IR(failOn = {IRNode.ALLOC_ARRAY_OF, "ir_framework/tests/MyClass"})
 917     public void allocArray() {
 918         myClassArray = new MyClass[2];
 919     }
 920 }
 921 
 922 class Loads {
 923     int iFld = 34;
 924     int result = 0;
 925     Object myClass = new MyClass();
 926 
 927     @Test
 928     @IR(failOn = {IRNode.LOAD, IRNode.LOOP, IRNode.LOAD_I}, counts = {IRNode.LOOP, "2", IRNode.LOAD, "2", IRNode.STORE, "2"})
 929     @IR(failOn = {IRNode.LOOP, IRNode.LOOP}, counts = {IRNode.LOOP, "0", IRNode.LOAD, "1"}) // Does not fail
 930     @IR(failOn = {IRNode.LOOP, IRNode.LOOP}, counts = {IRNode.LOOP, "0", IRNode.STORE, "1"})
 931     @IR(failOn = {IRNode.LOOP, IRNode.STORE}, counts = {IRNode.LOOP, "0", IRNode.LOAD, "1"})
 932     @IR(failOn = {IRNode.LOAD_OF_CLASS, "ir_framework/tests/Loads"})
 933     @IR(failOn = {IRNode.LOAD_OF_CLASS, "Loads"})
 934     @IR(failOn = {IRNode.LOAD_OF_FIELD, "iFld"})
 935     @IR(failOn = {IRNode.LOAD_OF_FIELD, "iFld2", IRNode.LOAD_OF_CLASS, "Load"}) // Does not fail
 936     @IR(failOn = {IRNode.LOAD_KLASS}) // Does not fail
 937     @IR(counts = {IRNode.FIELD_ACCESS, "3"}) // Does not fail
 938     public void load() {
 939         result = iFld;
 940         iFld = 3;
 941     }
 942 
 943     @Test
 944     @IR(failOn = {IRNode.LOAD_KLASS})
 945     @IR(counts = {IRNode.FIELD_ACCESS, "3"})
 946     public void loadKlass() {
 947         if (myClass instanceof MyClass) {
 948             result = 3;
 949         }
 950     }
 951 }
 952 
 953 class Loops {
 954     int limit = 1024;
 955     int[] iArr = new int[100];
 956 
 957     @DontInline
 958     public void dontInline() {}
 959 
 960     @Test
 961     @IR(failOn = IRNode.LOOP) // fails
 962     @IR(failOn = IRNode.COUNTEDLOOP)
 963     @IR(failOn = IRNode.COUNTEDLOOP_MAIN)
 964     public void loop() {
 965         for (int i = 0; i < limit; i++) {
 966             dontInline();
 967         }
 968     }
 969 
 970     @Test
 971     @IR(failOn = IRNode.LOOP)
 972     @IR(failOn = IRNode.COUNTEDLOOP) // fails
 973     @IR(failOn = IRNode.COUNTEDLOOP_MAIN)
 974     public void countedLoop() {
 975         for (int i = 0; i < 2000; i++) {
 976             dontInline();
 977         }
 978     }
 979 
 980     @Test
 981     @IR(failOn = IRNode.LOOP) // fails
 982     @IR(failOn = IRNode.COUNTEDLOOP) // fails
 983     @IR(failOn = IRNode.COUNTEDLOOP_MAIN)
 984     public void loopAndCountedLoop() {
 985         for (int i = 0; i < 2000; i++) {
 986             for (int j = 0; j < limit; j++) {
 987                 dontInline();
 988             }
 989         }
 990     }
 991 
 992     @Test
 993     @IR(failOn = IRNode.LOOP)
 994     @IR(failOn = IRNode.COUNTEDLOOP) // fails
 995     @IR(failOn = IRNode.COUNTEDLOOP_MAIN) // fails
 996     public void countedLoopMain() {
 997         // Cannot unroll completely -> create pre/main/post
 998         for (int i = 0; i < 100; i++) {
 999             iArr[i] = i;
1000         }
1001     }
1002 
1003     @Test
1004     @IR(failOn = IRNode.LOOP)
1005     @IR(failOn = IRNode.COUNTEDLOOP)
1006     @IR(failOn = IRNode.COUNTEDLOOP_MAIN)
1007     public void countedLoopUnrolled() {
1008         // Completely unrolled -> no pre/main/post
1009         for (int i = 0; i < 8; i++) {
1010             iArr[i] = i;
1011         }
1012     }
1013 }
1014 
1015 class Traps {
1016     int number42 = 42;
1017     int iFld = 10;
1018     int[] iArr = new int[2];
1019     MyClass myClass = new MyClass();
1020     MyClassSub myClassSub = new MyClassSub();
1021     NotLoaded notLoaded = new NotLoaded();
1022     Object[] oArr = new Object[10];
1023     MyClass[] mArr = new MyClass[10];
1024 
1025     @Test
1026     @IR(failOn = IRNode.TRAP)
1027     @IR(failOn = {IRNode.STORE_OF_FIELD, "iFld"}) // fails
1028     @IR(failOn = {IRNode.PREDICATE_TRAP,
1029                   IRNode.UNSTABLE_IF_TRAP,
1030                   IRNode.NULL_CHECK_TRAP,
1031                   IRNode.NULL_ASSERT_TRAP,
1032                   IRNode.RANGE_CHECK_TRAP,
1033                   IRNode.CLASS_CHECK_TRAP,
1034                   IRNode.INTRINSIC_TRAP,
1035                   IRNode.INTRINSIC_OR_TYPE_CHECKED_INLINING_TRAP,
1036                   IRNode.UNHANDLED_TRAP})
1037     public void noTraps() {
1038         for (int i = 0; i < 100; i++) {
1039             if (i < 42) {
1040                 // Reached, no uncommon trap
1041                 iFld = i;
1042             }
1043         }
1044     }
1045 
1046     @Test
1047     @IR(failOn = IRNode.TRAP) // fails
1048     @IR(failOn = IRNode.PREDICATE_TRAP) // fails
1049     @IR(failOn = {IRNode.STORE_OF_FIELD, "iFld"})
1050     @IR(failOn = {IRNode.UNSTABLE_IF_TRAP,
1051                   IRNode.NULL_CHECK_TRAP,
1052                   IRNode.NULL_ASSERT_TRAP,
1053                   IRNode.RANGE_CHECK_TRAP,
1054                   IRNode.CLASS_CHECK_TRAP,
1055                   IRNode.INTRINSIC_TRAP,
1056                   IRNode.INTRINSIC_OR_TYPE_CHECKED_INLINING_TRAP,
1057                   IRNode.UNHANDLED_TRAP})
1058     public void predicateTrap() {
1059         for (int i = 0; i < 100; i++) {
1060             if (number42 != 42) {
1061                 // Never reached
1062                 iFld = i;
1063             }
1064         }
1065     }
1066 
1067     @Test
1068     @IR(failOn = IRNode.TRAP) // fails
1069     @IR(failOn = IRNode.NULL_CHECK_TRAP) // fails
1070     @IR(failOn = IRNode.UNSTABLE_IF_TRAP) // fails
1071     @IR(failOn = {IRNode.PREDICATE_TRAP,
1072                   IRNode.NULL_ASSERT_TRAP,
1073                   IRNode.RANGE_CHECK_TRAP,
1074                   IRNode.CLASS_CHECK_TRAP,
1075                   IRNode.INTRINSIC_TRAP,
1076                   IRNode.INTRINSIC_OR_TYPE_CHECKED_INLINING_TRAP,
1077                   IRNode.UNHANDLED_TRAP})
1078     public void nullCheck() {
1079         if (myClass instanceof MyClassSub) {
1080             iFld = 4;
1081         }
1082     }
1083 
1084     @Test
1085     @IR(failOn = IRNode.TRAP) // fails
1086     @IR(failOn = IRNode.NULL_ASSERT_TRAP) // fails
1087     @IR(failOn = IRNode.NULL_CHECK_TRAP) // fails
1088     @IR(failOn = {IRNode.PREDICATE_TRAP,
1089                   IRNode.UNSTABLE_IF_TRAP,
1090                   IRNode.RANGE_CHECK_TRAP,
1091                   IRNode.CLASS_CHECK_TRAP,
1092                   IRNode.INTRINSIC_TRAP,
1093                   IRNode.INTRINSIC_OR_TYPE_CHECKED_INLINING_TRAP,
1094                   IRNode.UNHANDLED_TRAP})
1095     public Object nullAssert() {
1096         return notLoaded.notLoadedFld;
1097     }
1098 
1099     @Test
1100     @Arguments(Argument.TRUE)
1101     @IR(failOn = IRNode.TRAP) // fails
1102     @IR(failOn = IRNode.UNSTABLE_IF_TRAP) // fails
1103     @IR(failOn = {IRNode.PREDICATE_TRAP,
1104                   IRNode.NULL_CHECK_TRAP,
1105                   IRNode.NULL_ASSERT_TRAP,
1106                   IRNode.RANGE_CHECK_TRAP,
1107                   IRNode.CLASS_CHECK_TRAP,
1108                   IRNode.INTRINSIC_TRAP,
1109                   IRNode.INTRINSIC_OR_TYPE_CHECKED_INLINING_TRAP,
1110                   IRNode.UNHANDLED_TRAP})
1111     public void unstableIf(boolean flag) {
1112         if (flag) {
1113             iFld++;
1114         } else {
1115             iFld--;
1116         }
1117     }
1118 
1119     @Test
1120     @IR(failOn = IRNode.TRAP) // fails
1121     @IR(failOn = IRNode.CLASS_CHECK_TRAP) // fails
1122     @IR(failOn = IRNode.NULL_CHECK_TRAP) // fails
1123     @IR(failOn = {IRNode.PREDICATE_TRAP,
1124                   IRNode.UNSTABLE_IF_TRAP,
1125                   IRNode.NULL_ASSERT_TRAP,
1126                   IRNode.RANGE_CHECK_TRAP,
1127                   IRNode.INTRINSIC_TRAP,
1128                   IRNode.INTRINSIC_OR_TYPE_CHECKED_INLINING_TRAP,
1129                   IRNode.UNHANDLED_TRAP})
1130     public void classCheck() {
1131         try {
1132             myClassSub = (MyClassSub) myClass;
1133         } catch (ClassCastException e) {
1134             // Expected
1135         }
1136     }
1137 
1138     @Test
1139     @IR(failOn = IRNode.TRAP) // fails
1140     @IR(failOn = IRNode.RANGE_CHECK_TRAP) // fails
1141     @IR(failOn = IRNode.NULL_CHECK_TRAP) // fails
1142     @IR(failOn = {IRNode.PREDICATE_TRAP,
1143                   IRNode.UNSTABLE_IF_TRAP,
1144                   IRNode.NULL_ASSERT_TRAP,
1145                   IRNode.CLASS_CHECK_TRAP,
1146                   IRNode.INTRINSIC_TRAP,
1147                   IRNode.INTRINSIC_OR_TYPE_CHECKED_INLINING_TRAP,
1148                   IRNode.UNHANDLED_TRAP})
1149     public void rangeCheck() {
1150         iArr[1] = 3;
1151     }
1152 
1153 
1154     @Test
1155     @IR(failOn = IRNode.TRAP) // fails
1156     @IR(failOn = IRNode.INTRINSIC_OR_TYPE_CHECKED_INLINING_TRAP) // fails
1157     @IR(failOn = IRNode.INTRINSIC_TRAP) // fails
1158     @IR(failOn = IRNode.NULL_CHECK_TRAP) // fails
1159     @IR(failOn = {IRNode.PREDICATE_TRAP,
1160                   IRNode.UNSTABLE_IF_TRAP,
1161                   IRNode.NULL_ASSERT_TRAP,
1162                   IRNode.CLASS_CHECK_TRAP,
1163                   IRNode.RANGE_CHECK_TRAP,
1164                   IRNode.UNHANDLED_TRAP})
1165     public void instrinsicOrTypeCheckedInlining() {
1166         System.arraycopy(oArr, 0, mArr, 0, 8);
1167     }
1168 }
1169 
1170 class UnhandledTrap {
1171     int iFld = 34;
1172 
1173     @Test
1174     @IR(failOn = IRNode.TRAP) // fails
1175     @IR(failOn = IRNode.UNHANDLED_TRAP) // fails
1176     @IR(failOn = {IRNode.PREDICATE_TRAP,
1177                   IRNode.UNSTABLE_IF_TRAP,
1178                   IRNode.NULL_CHECK_TRAP,
1179                   IRNode.NULL_ASSERT_TRAP,
1180                   IRNode.RANGE_CHECK_TRAP,
1181                   IRNode.CLASS_CHECK_TRAP})
1182     public void unhandled() {
1183         try {
1184             throw new RuntimeException();
1185         } catch (RuntimeException e) {
1186             // Expected
1187         }
1188     }
1189 }
1190 
1191 class ScopeObj {
1192 
1193     @DontInline
1194     public void dontInline(int i) {}
1195 
1196     @Test
1197     @IR(failOn = IRNode.SCOPE_OBJECT) // fails
1198     public int scopeObject() {
1199         MyClass myClass = new MyClass();
1200         for (int i = 0; i < 100; i++) {
1201             dontInline(myClass.iFld);
1202         }
1203         return 3;
1204     }
1205 }
1206 
1207 class Membar {
1208     volatile MyClass myClass;
1209 
1210     @Test
1211     @IR(failOn = IRNode.MEMBAR) // fails
1212     public int membar() {
1213         myClass = new MyClass();
1214         return myClass.x;
1215     }
1216 }
1217 
1218 class CheckCastArray {
1219     Object[] oArr = new Object[10];
1220     MyClass[] mArr = new MyClass[10];
1221 
1222     @Test
1223     @IR(failOn = IRNode.CHECKCAST_ARRAY) // fails
1224     @IR(failOn = {IRNode.CHECKCAST_ARRAY_OF, "MyClass", // fails
1225                   IRNode.CHECKCAST_ARRAY_OF, "ir_framework/tests/MyClass"}) // fails
1226     @IR(failOn = {IRNode.CHECKCAST_ARRAY_OF, "MyClasss", IRNode.CHECKCAST_ARRAY_OF, "Object"})
1227     public boolean array() {
1228         return oArr instanceof MyClass[];
1229     }
1230 
1231     @Test
1232     @IR(failOn = IRNode.CHECKCAST_ARRAYCOPY) // fails
1233     public Object[] arrayCopy(Object[] src, Class klass) {
1234         return Arrays.copyOf(src, 8, klass);
1235     }
1236 
1237     @Run(test = "arrayCopy")
1238     public void testArrayCopy() {
1239         arrayCopy(mArr, MyClass[].class);
1240         arrayCopy(mArr, Object[].class);
1241         arrayCopy(mArr, MyClassEmpty[].class);
1242     }
1243 }
1244 
1245 class CompilationOutputOfFails {
1246 
1247     @Test
1248     @IR(failOn = IRNode.COUNTEDLOOP + "[\\s\\S]*" + "call")
1249     public void both1() {
1250         for (int i = 0; i < 100; i++) {
1251             dontInline();
1252         }
1253     }
1254 
1255     @Test
1256     @IR(failOn = IRNode.COUNTEDLOOP + "|" + "call")
1257     public void both2() {
1258         for (int i = 0; i < 100; i++) {
1259             dontInline();
1260         }
1261     }
1262 
1263     @Test
1264     @IR(failOn = IRNode.COUNTEDLOOP)
1265     @IR(failOn = "call")
1266     public void both3() {
1267         for (int i = 0; i < 100; i++) {
1268             dontInline();
1269         }
1270     }
1271 
1272     @Test
1273     @IR(counts = {IRNode.COUNTEDLOOP + "[\\s\\S]*" + "call", "0"})
1274     public void both4() {
1275         for (int i = 0; i < 100; i++) {
1276             dontInline();
1277         }
1278     }
1279 
1280     @Test
1281     @IR(counts = {IRNode.COUNTEDLOOP + "|" + "call", "1"})
1282     public void both5() {
1283         for (int i = 0; i < 100; i++) {
1284             dontInline();
1285         }
1286     }
1287 
1288     @Test
1289     @IR(counts = {IRNode.COUNTEDLOOP, "0"})
1290     @IR(counts = {"call", "0"})
1291     public void both6() {
1292         for (int i = 0; i < 100; i++) {
1293             dontInline();
1294         }
1295     }
1296 
1297     @Test
1298     @IR(failOn = IRNode.COUNTEDLOOP)
1299     @IR(counts = {"call", "0"})
1300     public void both7() {
1301         for (int i = 0; i < 100; i++) {
1302             dontInline();
1303         }
1304     }
1305 
1306     @Test
1307     @IR(failOn = IRNode.COUNTEDLOOP)
1308     public void ideal1() {
1309         for (int i = 0; i < 100; i++) {
1310             dontInline();
1311         }
1312     }
1313 
1314     @Test
1315     @IR(failOn = IRNode.COUNTEDLOOP)
1316     @IR(failOn = IRNode.ALLOC) // not fail
1317     public void ideal2() {
1318         for (int i = 0; i < 100; i++) {
1319             dontInline();
1320         }
1321     }
1322 
1323     @Test
1324     @IR(failOn = IRNode.COUNTEDLOOP)
1325     @IR(counts = {IRNode.ALLOC, "0"}) // not fail
1326     public void ideal3() {
1327         for (int i = 0; i < 100; i++) {
1328             dontInline();
1329         }
1330     }
1331 
1332     @Test
1333     @IR(counts = {IRNode.COUNTEDLOOP, "2"})
1334     public void ideal4() {
1335         for (int i = 0; i < 100; i++) {
1336             dontInline();
1337         }
1338     }
1339 
1340     @Test
1341     @IR(failOn = IRNode.ALLOC) // not fail
1342     @IR(counts = {IRNode.COUNTEDLOOP, "2"})
1343     public void ideal5() {
1344         for (int i = 0; i < 100; i++) {
1345             dontInline();
1346         }
1347     }
1348 
1349     @Test
1350     @IR(counts = {IRNode.ALLOC, "0"}) // not fail
1351     @IR(counts = {IRNode.COUNTEDLOOP, "2"})
1352     public void ideal6() {
1353         for (int i = 0; i < 100; i++) {
1354             dontInline();
1355         }
1356     }
1357 
1358     @Test
1359     @IR(counts = {IRNode.COUNTEDLOOP, "5"})
1360     @IR(counts = {IRNode.COUNTEDLOOP, "2"})
1361     public void ideal7() {
1362         for (int i = 0; i < 100; i++) {
1363             dontInline();
1364         }
1365     }
1366 
1367     @Test
1368     @IR(failOn = "call")
1369     public void opto1() {
1370         for (int i = 0; i < 100; i++) {
1371             dontInline();
1372         }
1373     }
1374 
1375     @Test
1376     @IR(failOn = "call")
1377     @IR(failOn = IRNode.STORE) // not fail
1378     public void opto2() {
1379         for (int i = 0; i < 100; i++) {
1380             dontInline();
1381         }
1382     }
1383 
1384     @Test
1385     @IR(failOn = "call")
1386     @IR(counts = {IRNode.COUNTEDLOOP, "1"}) // not fail
1387     public void opto3() {
1388         for (int i = 0; i < 100; i++) {
1389             dontInline();
1390         }
1391     }
1392 
1393     @Test
1394     @IR(counts = {"call", "0"})
1395     public void opto4() {
1396         for (int i = 0; i < 100; i++) {
1397             dontInline();
1398         }
1399     }
1400 
1401     @Test
1402     @IR(failOn = IRNode.STORE) // not fail
1403     @IR(counts = {"call", "0"})
1404     public void opto5() {
1405         for (int i = 0; i < 100; i++) {
1406             dontInline();
1407         }
1408     }
1409 
1410     @Test
1411     @IR(counts = {IRNode.STORE, "0"}) // not fail
1412     @IR(counts = {"call", "0"})
1413     public void opto6() {
1414         for (int i = 0; i < 100; i++) {
1415             dontInline();
1416         }
1417     }
1418 
1419     @Test
1420     @IR(counts = {"call", "10"})
1421     @IR(counts = {"call", "0"})
1422     public void opto7() {
1423         for (int i = 0; i < 100; i++) {
1424             dontInline();
1425         }
1426     }
1427 
1428     @DontInline
1429     private void dontInline() {}
1430 }
1431 
1432 
1433 // Used only by class Traps
1434 class NotLoaded {
1435     NotLoadedHelper notLoadedFld;
1436 }
1437 
1438 // Used only by class Traps
1439 class NotLoadedHelper {}
1440 
1441 class MyClass {
1442     int iFld = 3;
1443     int x = 5;
1444     static long lFldStatic;
1445 }
1446 
1447 class MyClassEmpty {}
1448 
1449 class MyClassEmptySub extends MyClassEmpty {}
1450 
1451 class MyClassSub extends MyClass {
1452     int iFld;
1453     static int iFldStatic;
1454 }
1455 
1456 
1457 // Base class for any kind of constraint that is used to verify if the framework reports the correct IR failures.
1458 abstract class Constraint {
1459     private final Class<?> klass;
1460     protected final int ruleIdx;
1461     private final Pattern methodPattern;
1462     private final String classAndMethod;
1463     protected final Pattern irPattern;
1464     private final String methodName;
1465     protected boolean matched;
1466 
1467     Constraint(Class<?> klass, String methodName, int ruleIdx, Pattern irPattern) {
1468         this.klass = klass;
1469         classAndMethod = klass.getSimpleName() + "." + methodName;
1470         this.ruleIdx = ruleIdx;
1471         this.methodPattern = Pattern.compile(Pattern.quote(classAndMethod));
1472         this.irPattern = irPattern;
1473         this.methodName = methodName;
1474         this.matched = false;
1475     }
1476 
1477     // For good constraints only
1478     Constraint(Class<?> klass, String methodName, int ruleIdx) {
1479         this.klass = klass;
1480         classAndMethod = klass.getSimpleName() + "." + methodName;
1481         this.ruleIdx = ruleIdx;
1482         this.methodPattern = Pattern.compile(Pattern.quote(classAndMethod));
1483         this.irPattern = null;
1484         this.methodName = methodName;
1485         this.matched = false;
1486     }
1487 
1488     @Override
1489     public String toString() {
1490         return "Constraint " + getClass().getSimpleName() + ", " + errorPrefix();
1491     }
1492 
1493     public Class<?> getKlass() {
1494         return klass;
1495     }
1496 
1497     protected String errorPrefix() {
1498         return "Class " + klass.getSimpleName() + ", Method " + methodName + ", Rule " + ruleIdx;
1499     }
1500 
1501     public void checkConstraint(IRViolationException e) {
1502         String message = e.getExceptionInfo();
1503         String[] splitMethods = message.split("Method");
1504         for (int i = 1; i < splitMethods.length; i++) {
1505             String method = splitMethods[i];
1506             if (methodPattern.matcher(method).find()) {
1507                 String[] splitIrRules = method.split("@IR ");
1508                 for (int j = 1; j < splitIrRules.length; j++) {
1509                     String irRule = splitIrRules[j];
1510                     if (irRule.startsWith("rule " + ruleIdx)) {
1511                         checkIRRule(irRule);
1512                     }
1513                 }
1514             }
1515         }
1516         Asserts.assertTrue(matched, toString() + " should have been matched");
1517     }
1518 
1519     abstract protected void checkIRRule(String irRule);
1520 }
1521 
1522 // Constraint for rule that does not fail.
1523 class GoodRuleConstraint extends Constraint {
1524 
1525     GoodRuleConstraint(Class<?> klass, String methodName, int ruleIdx) {
1526         super(klass, methodName, ruleIdx);
1527         matched = true;
1528     }
1529 
1530     public static GoodRuleConstraint create(Class<?> klass, String methodName, int ruleIdx) {
1531         return new GoodRuleConstraint(klass, methodName, ruleIdx);
1532     }
1533 
1534     @Override
1535     protected void checkIRRule(String irRule) {
1536         Asserts.fail(errorPrefix() + " should not fail:" + System.lineSeparator() + irRule);
1537     }
1538 }
1539 
1540 // Constraint for rule that might fail but not with "failOn".
1541 class GoodFailOnConstraint extends GoodRuleConstraint {
1542 
1543     private GoodFailOnConstraint(Class<?> klass, String methodName, int ruleIdx) {
1544         super(klass, methodName, ruleIdx);
1545     }
1546 
1547     public static GoodFailOnConstraint create(Class<?> klass, String methodName, int ruleIdx) {
1548         return new GoodFailOnConstraint(klass, methodName, ruleIdx);
1549     }
1550 
1551     @Override
1552     protected void checkIRRule(String irRule) {
1553         Asserts.assertFalse(irRule.contains("- failOn"), errorPrefix() + " should not have failed:" + System.lineSeparator() + irRule);
1554     }
1555 }
1556 
1557 // Constraint for rule that might fail but not with "counts".
1558 class GoodCountsConstraint extends GoodRuleConstraint {
1559 
1560     private GoodCountsConstraint(Class<?> klass, String methodName, int ruleIdx) {
1561         super(klass, methodName, ruleIdx);
1562     }
1563 
1564     public static GoodCountsConstraint create(Class<?> klass, String methodName, int ruleIdx) {
1565         return new GoodCountsConstraint(klass, methodName, ruleIdx);
1566     }
1567 
1568     @Override
1569     protected void checkIRRule(String irRule) {
1570         Asserts.assertFalse(irRule.contains("- counts"), errorPrefix() + " should not have failed with counts:"
1571                                                          + System.lineSeparator() + irRule);
1572     }
1573 }
1574 
1575 // Base class for all Regex based constraint.
1576 abstract class RegexConstraint extends Constraint {
1577     final String category;
1578     final String otherCategory;
1579     final int[] regexIndexes;
1580     final boolean isGood;
1581     final List<String> matches;
1582 
1583     RegexConstraint(Class<?> klass, String methodName, String category, boolean isGood, List<String> matches, int ruleIdx, int... regexIndexes) {
1584         super(klass, methodName, ruleIdx, initIRPattern(category, ruleIdx));
1585         this.category = category;
1586         this.regexIndexes = regexIndexes;
1587         if (category.equals("failOn")) {
1588             this.otherCategory = "counts";
1589         } else {
1590             Asserts.assertTrue(category.equals("counts"));
1591             this.otherCategory = "failOn";
1592         }
1593         this.isGood = isGood;
1594         this.matches = matches;
1595     }
1596 
1597     @Override
1598     public String toString() {
1599         String msg = super.toString() + ", ";
1600         if (regexIndexes.length > 1) {
1601             msg += "regexes: [" + String.join(", ", Arrays.stream(regexIndexes).mapToObj(String::valueOf).toArray(String[]::new)) + "]";
1602         } else {
1603             msg += "regex: " + regexIndexes[0];
1604         }
1605         return msg;
1606     }
1607 
1608     @Override
1609     protected String errorPrefix() {
1610         return super.errorPrefix() + " with \"" + category + "\"";
1611     }
1612 
1613     private static Pattern initIRPattern(String category, int ruleIdx) {
1614         if (category.equals("failOn")) {
1615             return Pattern.compile("rule " + ruleIdx + ":.*\\R.*- failOn: Graph contains forbidden nodes.*\\R" +
1616                                    ".*Regex \\d+:.*\\R.*Matched forbidden node.*");
1617         } else {
1618             return Pattern.compile("rule " + ruleIdx + ":.*\\R.*- counts: Graph contains wrong number of nodes:\\R" +
1619                                    ".*Regex \\d+:.*\\R.*Expected.*");
1620         }
1621     }
1622 
1623     @Override
1624     protected void checkIRRule(String irRule) {
1625         int categoryIndex = irRule.indexOf("- " + category);
1626         Asserts.assertTrue(categoryIndex != -1, errorPrefix() + " should have failed");
1627 
1628         int endIndex;
1629         int otherCategoryIndex = irRule.indexOf("- " + otherCategory);
1630         if (otherCategoryIndex == -1 || categoryIndex > otherCategoryIndex) {
1631             endIndex = irRule.length();
1632         } else {
1633             endIndex = otherCategoryIndex;
1634         }
1635         String categoryString = irRule.substring(irRule.indexOf("- " + category), endIndex);
1636         Pattern pattern;
1637         Matcher matcher;
1638         for (int regexIndex : this.regexIndexes) {
1639             pattern = Pattern.compile("Regex " + regexIndex + ":.*");
1640             matcher = pattern.matcher(categoryString);
1641             if (isGood) {
1642                 Asserts.assertFalse(matcher.find(), errorPrefix() + " failed with Regex " + regexIndex);
1643                 matched = true;
1644             } else {
1645                 Asserts.assertTrue(matcher.find(), errorPrefix() + " should have failed at Regex " + regexIndex);
1646                 String[] splitRegex = categoryString.split("Regex ");
1647                 if (matches != null) {
1648                     for (int i = 1; i < splitRegex.length; i++) {
1649                         String regexString = splitRegex[i];
1650                         if (regexString.startsWith(String.valueOf(regexIndex))) {
1651                             // Do matching on actual match and not on regex string
1652                             String actualMatch = regexString.split("\\R", 2)[1];
1653                             Asserts.assertTrue(matches.stream().allMatch(actualMatch::contains),
1654                                                errorPrefix() + " could not find all matches at Regex " + regexIndex);
1655                             matched = true;
1656                         }
1657                     }
1658                 }
1659             }
1660         }
1661     }
1662 }
1663 
1664 // Base class for all good regex based constraints.
1665 abstract class GoodRegexConstraint extends RegexConstraint {
1666 
1667     GoodRegexConstraint(Class<?> klass, String methodName, String category, int ruleIdx, int... regexIndexes) {
1668         super(klass, methodName, category, true, null, ruleIdx, regexIndexes);
1669     }
1670 }
1671 
1672 // Constraint for rule that might fail with "counts" or "failOn", but the specified regex in "failOn" does not fail.
1673 class GoodFailOnRegexConstraint extends GoodRegexConstraint {
1674 
1675     private GoodFailOnRegexConstraint(Class<?> klass, String methodName, int ruleIdx, int... regexIndexes) {
1676         super(klass, methodName, "failOn", ruleIdx, regexIndexes);
1677     }
1678 
1679 
1680     public static GoodFailOnRegexConstraint create(Class<?> klass, String methodName, int ruleIdx, int... regexIndexes) {
1681         return new GoodFailOnRegexConstraint(klass, methodName, ruleIdx, regexIndexes);
1682     }
1683 }
1684 
1685 
1686 // Constraint for rule that might fail with "counts" or "failOn", but the specified regex in "counts" does not fail.
1687 class GoodCountsRegexConstraint extends GoodRegexConstraint {
1688 
1689     private GoodCountsRegexConstraint(Class<?> klass, String methodName, int ruleIdx, int... regexIndexes) {
1690         super(klass, methodName, "counts", ruleIdx, regexIndexes);
1691     }
1692 
1693 
1694     public static GoodCountsRegexConstraint create(Class<?> klass, String methodName, int ruleIdx, int... regexIndexes) {
1695         return new GoodCountsRegexConstraint(klass, methodName, ruleIdx, regexIndexes);
1696     }
1697 }
1698 
1699 // Constraint for rule that fails with "failOn" and the specified regex must also fail.
1700 class BadFailOnConstraint extends RegexConstraint {
1701 
1702     BadFailOnConstraint(Class<?> klass, String methodName, int ruleIdx, List<String> matches, int... regexIndexes) {
1703         super(klass, methodName, "failOn", false, matches, ruleIdx, regexIndexes);
1704     }
1705 
1706     public static BadFailOnConstraint create(Class<?> klass, String methodName, int ruleIdx, int regexId, String... matches) {
1707         return new BadFailOnConstraint(klass, methodName, ruleIdx, new ArrayList<>(Arrays.asList(matches)), regexId);
1708     }
1709 
1710     public static BadFailOnConstraint create(Class<?> klass, String methodName, int ruleIdx, String... matches) {
1711         return new BadFailOnConstraint(klass, methodName, ruleIdx, new ArrayList<>(Arrays.asList(matches)), 1);
1712     }
1713 }
1714 
1715 // Constraint for rule that fails with "counts" and the specified regex must also fail.
1716 class BadCountsConstraint extends RegexConstraint {
1717 
1718     BadCountsConstraint(Class<?> klass, String methodName, int ruleIdx, List<String> matches, int... regexIndexes) {
1719         super(klass, methodName, "counts", false, matches, ruleIdx, regexIndexes);
1720     }
1721 
1722     public static BadCountsConstraint create(Class<?> klass, String methodName, int ruleIdx, int regexId, int foundCount, String... matches) {
1723         List<String> matchesList = getMatchesList(foundCount, matches, Arrays.asList(matches));
1724         return new BadCountsConstraint(klass, methodName, ruleIdx, matchesList, regexId);
1725     }
1726 
1727     public static BadCountsConstraint create(Class<?> klass, String methodName, int ruleIdx, int foundCount, String... matches) {
1728         List<String> matchesList = getMatchesList(foundCount, matches, Arrays.asList(matches));
1729         return new BadCountsConstraint(klass, methodName, ruleIdx, matchesList, 1);
1730     }
1731 
1732     private static List<String> getMatchesList(int foundCount, String[] matches, List<String> strings) {
1733         List<String> matchesList = new ArrayList<>();
1734         matchesList.add("but found " + foundCount);
1735         if (matches != null) {
1736             matchesList.addAll(strings);
1737         }
1738         return matchesList;
1739     }
1740 }