From e89abb7d2d902c6e6b3c9953fc6663de10db77b9 Mon Sep 17 00:00:00 2001
From: Christian Hagedorn <chagedorn@openjdk.org>
Date: Mon, 15 Aug 2022 06:08:08 +0000
Subject: [PATCH] 8292190: [IR Framework] Remove redundant regex matching for
 failing counts constraints

Reviewed-by: kvn, rcastanedalo, thartmann
---
 .../driver/irmatching/irrule/Counts.java      | 37 ++++++++-----------
 .../irmatching/irrule/CountsRegexFailure.java |  3 +-
 2 files changed, 18 insertions(+), 22 deletions(-)

diff --git a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/Counts.java b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/Counts.java
index 4bda941c887..051beaedae3 100644
--- a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/Counts.java
+++ b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/Counts.java
@@ -30,8 +30,10 @@ import compiler.lib.ir_framework.shared.TestFormat;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.regex.MatchResult;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 /**
  * Class representing a counts attribute of an IR rule.
@@ -53,7 +55,7 @@ class Counts extends CheckAttribute {
             TestFormat.check(i + 1 < nodesWithCountConstraint.size(),
                              "Missing count " + getPostfixErrorMsg(irRule, node));
             String countConstraint = nodesWithCountConstraint.get(i + 1);
-            Comparison<Long> comparison = parseComparison(irRule, node, countConstraint);
+            Comparison<Integer> comparison = parseComparison(irRule, node, countConstraint);
             constraints.add(new Constraint(node, comparison, nodeId));
         }
         return new Counts(constraints);
@@ -63,9 +65,9 @@ class Counts extends CheckAttribute {
         return "for IR rule " + irRule.getRuleId() + ", node \"" + node + "\" at " + irRule.getMethod();
     }
 
-    private static Comparison<Long> parseComparison(IRRule irRule, String node, String constraint) {
+    private static Comparison<Integer> parseComparison(IRRule irRule, String node, String constraint) {
         String postfixErrorMsg = "in count constraint " + getPostfixErrorMsg(irRule, node);
-        return ComparisonConstraintParser.parse(constraint, Long::parseLong, postfixErrorMsg);
+        return ComparisonConstraintParser.parse(constraint, Integer::parseInt, postfixErrorMsg);
     }
 
     @Override
@@ -82,37 +84,30 @@ class Counts extends CheckAttribute {
     }
 
     private void checkConstraint(CountsMatchResult result, String compilation, Constraint constraint) {
-        long foundCount = getFoundCount(compilation, constraint);
-        Comparison<Long> comparison = constraint.comparison;
-        if (!comparison.compare(foundCount)) {
-            result.addFailure(createRegexFailure(compilation, constraint, foundCount));
+        List<String> countsMatches = getCountsMatches(compilation, constraint);
+        Comparison<Integer> comparison = constraint.comparison;
+        if (!comparison.compare(countsMatches.size())) {
+            result.addFailure(createRegexFailure(countsMatches, constraint));
         }
     }
 
-    private long getFoundCount(String compilation, Constraint constraint) {
+    private List<String> getCountsMatches(String compilation, Constraint constraint) {
         Pattern pattern = Pattern.compile(constraint.nodeRegex);
         Matcher matcher = pattern.matcher(compilation);
-        return matcher.results().count();
+        return matcher.results().map(MatchResult::group).collect(Collectors.toList());
     }
 
-    private CountsRegexFailure createRegexFailure(String compilation, Constraint constraint, long foundCount) {
-        Pattern p = Pattern.compile(constraint.nodeRegex);
-        Matcher m = p.matcher(compilation);
-        List<String> matches;
-        if (m.find()) {
-            matches = getMatchedNodes(m);
-        } else {
-            matches = new ArrayList<>();
-        }
-        return new CountsRegexFailure(constraint.nodeRegex, constraint.nodeId, foundCount, constraint.comparison, matches);
+    private CountsRegexFailure createRegexFailure(List<String> countsMatches, Constraint constraint) {
+        return new CountsRegexFailure(constraint.nodeRegex, constraint.nodeId, countsMatches.size(), constraint.comparison,
+                                      countsMatches);
     }
 
     static class Constraint {
         final String nodeRegex;
-        final Comparison<Long> comparison;
+        final Comparison<Integer> comparison;
         private final int nodeId;
 
-        Constraint(String nodeRegex, Comparison<Long> comparison, int nodeId) {
+        Constraint(String nodeRegex, Comparison<Integer> comparison, int nodeId) {
             this.nodeRegex = nodeRegex;
             this.comparison = comparison;
             this.nodeId = nodeId;
diff --git a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/CountsRegexFailure.java b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/CountsRegexFailure.java
index ae7b235ffd0..19faed6f646 100644
--- a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/CountsRegexFailure.java
+++ b/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/CountsRegexFailure.java
@@ -35,7 +35,8 @@ import java.util.List;
 class CountsRegexFailure extends RegexFailure {
     String failedComparison;
 
-    public CountsRegexFailure(String nodeRegex, int nodeId, long foundValue, Comparison<Long> comparison, List<String> matches) {
+    public CountsRegexFailure(String nodeRegex, int nodeId, int foundValue, Comparison<Integer> comparison,
+                              List<String> matches) {
         super(nodeRegex, nodeId, matches);
         this.failedComparison = "[found] " + foundValue + " " + comparison.getComparator() + " "
                                 + comparison.getGivenValue() + " [given]";