[SpecialCaseList] Filtering Globs with matching prefix and suffix (llvm#164543)

This commit enhances the `SpecialCaseList::GlobMatcher` to filter globs
more efficiently by considering both prefixes and suffixes.

Previously, the `GlobMatcher` used a `RadixTree` to store globs based
on their prefixes. This allowed for quick lookup of potential matches
by matching the query string's prefix against the stored prefixes.
However, for globs with common prefixes but different suffixes,
unnecessary glob matching attempts could still occur.

This change introduces a nested `RadixTree` structure:
`PrefixSuffixToGlob: RadixTree<Prefix, RadixTree<Suffix, Globs>>`.
Now, when a query string is matched, it first finds matching prefixes,
and then within those prefix matches, it further filters by matching
the reversed suffix of the query string against the reversed suffixes
of the globs. This significantly reduces the number of `Glob::match`
calls, especially for large special case lists with many globs sharing
common prefixes but differing in their suffixes.

According to SpecialCaseListBM:

Lookup benchmarks (significant improvements):
```
OVERALL_GEOMEAN                       -0.5815
```

Lookup `*suffix` and `prefix*suffix` like benchmarks (huge
improvements):
```
OVERALL_GEOMEAN                       -0.9316
```

https://gist.github.com/vitalybuka/e586751902760ced6beefcdf0d7b26fd

Author: vitalybuka

llvm/include/llvm/Support/SpecialCaseList.h

@@ -167,8 +167,9 @@ class SpecialCaseList {
     std::vector<GlobMatcher::Glob> Globs;
 
     RadixTree<iterator_range<StringRef::const_iterator>,
-              SmallVector<const GlobMatcher::Glob *, 1>>
-        PrefixToGlob;
+              RadixTree<iterator_range<StringRef::const_reverse_iterator>,
+                        SmallVector<const GlobMatcher::Glob *, 1>>>
+        PrefixSuffixToGlob;
   };
 
   /// Represents a set of patterns and their line numbers

llvm/lib/Support/SpecialCaseList.cpp

@@ -92,25 +92,29 @@ void SpecialCaseList::GlobMatcher::preprocess(bool BySize) {
 
   for (const auto &G : reverse(Globs)) {
     StringRef Prefix = G.Pattern.prefix();
+    StringRef Suffix = G.Pattern.suffix();
 
-    auto &V = PrefixToGlob.emplace(Prefix).first->second;
+    auto &SToGlob = PrefixSuffixToGlob.emplace(Prefix).first->second;
+    auto &V = SToGlob.emplace(reverse(Suffix)).first->second;
     V.emplace_back(&G);
   }
 }
 
 void SpecialCaseList::GlobMatcher::match(
     StringRef Query,
     llvm::function_ref<void(StringRef Rule, unsigned LineNo)> Cb) const {
-  if (!PrefixToGlob.empty()) {
-    for (const auto &[_, V] : PrefixToGlob.find_prefixes(Query)) {
-      for (const auto *G : V) {
-        if (G->Pattern.match(Query)) {
-          Cb(G->Name, G->LineNo);
-          // As soon as we find a match in the vector, we can break for this
-          // vector, since the globs are already sorted by priority within the
-          // prefix group. However, we continue searching other prefix groups in
-          // the map, as they may contain a better match overall.
-          break;
+  if (!PrefixSuffixToGlob.empty()) {
+    for (const auto &[_, SToGlob] : PrefixSuffixToGlob.find_prefixes(Query)) {
+      for (const auto &[_, V] : SToGlob.find_prefixes(reverse(Query))) {
+        for (const auto *G : V) {
+          if (G->Pattern.match(Query)) {
+            Cb(G->Name, G->LineNo);
+            // As soon as we find a match in the vector, we can break for this
+            // vector, since the globs are already sorted by priority within the
+            // prefix group. However, we continue searching other prefix groups
+            // in the map, as they may contain a better match overall.
+            break;
+          }
         }
       }
     }