Enable multiple 'src'/'tgt' pairs in a single source (#902)

Change:
Instead of only searching for 'src' and 'tgt' in single-file mode,
search for an arbitrary number of pairs of 'src{+d}'/'tgt{+d}' or
'src_*'/'tgt_*'.

I.e. if have the following functions in a file:

```
define @src {}
define @tgt {}
define @src2 {}
define @tgt2 {}
define @src_foo {}
define @tgt_foo {}
define @src4 {}
define @tgt_bar {}
```

Alive2 will have the following pairs: 'src'/'tgt', 'src2'/'tgt2', and
'src_foo'/'tgt_bar'. It will ignore 'src4' and 'tgt_bar'.

Motivation:
This just a QOL change. A lot of LLVM patches have associated alive2
links. In some cases there need to be many links (i.e.
https://reviews.llvm.org/D149521).

Being able to specify multiple 'src'/'tgt' pairs in a single file
would enable verifying multiple cases with a single link making it
easier.

Author: goldsteinn

tests/alive-tv/ssub-cmp-zero.v0.srctgt.ll

@@ -0,0 +1,44 @@
+declare i8 @llvm.ssub.sat.i8(i8, i8)
+define i1 @src(i8 %x, i8 %y) {
+  %m = call i8 @llvm.ssub.sat.i8(i8 %x, i8 %y)
+  %r = icmp eq i8 %m, 0
+  ret i1 %r
+}
+
+define i1 @tgt(i8 %x, i8 %y) {
+  %r = icmp eq i8 %x, %y
+  ret i1 %r
+}
+
+define i1 @src1(i8 %x, i8 %y) {
+  %m = call i8 @llvm.ssub.sat.i8(i8 %x, i8 %y)
+  %r = icmp ne i8 %m, 0
+  ret i1 %r
+}
+
+define i1 @tgt1(i8 %x, i8 %y) {
+  %r = icmp ne i8 %x, %y
+  ret i1 %r
+}
+
+define i1 @src2(i8 %x, i8 %y) {
+  %m = call i8 @llvm.ssub.sat.i8(i8 %x, i8 %y)
+  %r = icmp sle i8 %m, 0
+  ret i1 %r
+}
+
+define i1 @tgt2(i8 %x, i8 %y) {
+  %r = icmp sle i8 %x, %y
+  ret i1 %r
+}
+
+define i1 @src3(i8 %x, i8 %y) {
+  %m = call i8 @llvm.ssub.sat.i8(i8 %x, i8 %y)
+  %r = icmp slt i8 %m, 0
+  ret i1 %r
+}
+
+define i1 @tgt3(i8 %x, i8 %y) {
+  %r = icmp slt i8 %x, %y
+  ret i1 %r
+}

tests/alive-tv/ssub-cmp-zero.v1.srctgt.ll

@@ -0,0 +1,29 @@
+declare i8 @llvm.ssub.sat.i8(i8, i8)
+define i1 @src_sge(i8 %x, i8 %y) {
+  %m = call i8 @llvm.ssub.sat.i8(i8 %x, i8 %y)
+  %r = icmp sge i8 %m, 0
+  ret i1 %r
+}
+
+define i1 @tgt_sge(i8 %x, i8 %y) {
+  %r = icmp sge i8 %x, %y
+  ret i1 %r
+}
+
+define i1 @src_sgt(i8 %x, i8 %y) {
+  %m = call i8 @llvm.ssub.sat.i8(i8 %x, i8 %y)
+  %r = icmp sgt i8 %m, 0
+  ret i1 %r
+}
+
+define i1 @tgt_sgt(i8 %x, i8 %y) {
+  %r = icmp sgt i8 %x, %y
+  ret i1 %r
+}
+
+; unused
+define i1 @src(i8 %x, i8 %y) {
+  %m = call i8 @llvm.ssub.sat.i8(i8 %x, i8 %y)
+  %r = icmp sgt i8 %m, 0
+  ret i1 %r
+}

tests/alive-tv/sub-is-not.srctgt.ll

@@ -0,0 +1,47 @@
+define i8 @src(i8 %x) {
+  %m = sub i8 %x, -1
+  ret i8 %m
+}
+
+define i8 @tgt(i8 %x) {
+  %m = xor i8 %x, -1
+  ret i8 %m
+}
+
+; Transformation doesn't verify!
+
+define i8 @src3(i8 %x) {
+  %m = sub i8 0, %x
+  ret i8 %m
+}
+
+define i8 @tgt3(i8 %x) {
+  %m = xor i8 %x, -1
+  ret i8 %m
+}
+
+; Transformation doesn't verify!
+
+define i8 @src9(i8 %x) {
+  %m = sub i8 -1, %x
+  ret i8 %m
+}
+
+define i8 @tgt9(i8 %x) {
+  %m = xor i8 %x, -1
+  ret i8 %m
+}
+
+; Transformation seems to be correct!
+
+define i8 @src4(i8 %x, i8 %y) {
+  %m = add i8 %y, %x
+  ret i8 %m
+}
+
+define i8 @tgt4(i8 %x) {
+  %m = xor i8 %x, -1
+  ret i8 %m
+}
+
+; ERROR: Signature mismatch between src and tgt

tools/alive-tv.cpp

@@ -106,6 +106,14 @@ alive-tv will optimize the entire module using an optimization
 pipeline similar to -O2, and then verify that functions in the
 optimized module refine those in the original one. This provides a
 convenient way to demonstrate an existing optimizer bug.
+
+Multiple "src" and "tgt" functions can be specified in the same file
+by postfixing, after "src" and "tgt", either a unique integer or an
+'_' followed by an arbitrary string. For example if the file contains
+the following functions "src", "tgt", "src4", "tgt4", "src_foo",
+"tgt_foo", "src_bar", "tgt5", then the pairs "src" <-> "tgt", "src4"
+<-> "tgt4", and "src_foo" <-> "tgt_foo" will be verifed but "src_bar"
+and "tgt5" will unused.
 )EOF";
 
   llvm::cl::HideUnrelatedOptions(alive_cmdargs);
@@ -134,18 +142,53 @@ convenient way to demonstrate an existing optimizer bug.
 
   unique_ptr<llvm::Module> M2;
   if (opt_file2.empty()) {
-    auto SRC = findFunction(*M1, opt_src_fn);
-    auto TGT = findFunction(*M1, opt_tgt_fn);
-    if (SRC && TGT) {
-      verifier.compareFunctions(*SRC, *TGT);
-      goto end;
-    } else {
+    unsigned Cnt = 0;
+    for (auto &F1 : *M1.get()) {
+      if (F1.isDeclaration())
+        continue;
+      auto SrcFName = F1.getName();
+      if (!SrcFName.startswith(opt_src_fn))
+        continue;
+
+      // Check src{+d}/tgt{+d} variant
+      if (std::find_if(SrcFName.begin() + opt_src_fn.length(), SrcFName.end(),
+                       [](unsigned char c) { return !std::isdigit(c); }) ==
+          SrcFName.end()) {
+        // Pass, we found a valid postfix
+      }
+      // Check src_*/tgt_* variant
+      else if (SrcFName.str().length() > opt_src_fn.length() &&
+               SrcFName[opt_src_fn.length()] == '_') {
+        // Pass, we found a valid postfix
+      }
+      // No valid postfix.
+      else {
+        continue;
+      }
+
+      // Check if we have tgt + same postfix
+      auto DstFName =
+          SrcFName.str().replace(0, opt_src_fn.length(), opt_tgt_fn);
+      auto SRC = findFunction(*M1, SrcFName.str());
+      auto TGT = findFunction(*M1, DstFName);
+      if (SRC && TGT) {
+        ++Cnt;
+        if (!verifier.compareFunctions(*SRC, *TGT))
+          if (opt_error_fatal)
+            goto end;
+      }
+    }
+    if (Cnt == 0) {
       M2 = CloneModule(*M1);
       auto err = optimize_module(M2.get(), optPass);
       if (!err.empty()) {
         *out << "Error parsing list of LLVM passes: " << err << '\n';
         return -1;
       }
+    } else if (Cnt > 1) {
+      goto summary;
+    } else {
+      goto end;
     }
   } else {
     M2 = openInputFile(Context, opt_file2);
@@ -184,7 +227,7 @@ convenient way to demonstrate an existing optimizer bug.
       }
     }
   }
-
+summary:
   *out << "Summary:\n"
           "  " << verifier.num_correct << " correct transformations\n"
           "  " << verifier.num_unsound << " incorrect transformations\n"