[fpcmp] Use non-floating point parsing by default.

[Meinersbur]

Summary

Unless using the -a or -r options, do not parse floating point numbers in order to compare its numeric difference. Despite its name, fpcmp used used to compare every program output with its reference output even for programs that do not handle floating point and caused 0. and 0 to be always considered equal.

I the old behaviour is needed (as for the TSVC benchmark), floating point comparison with zero numeric tolerance can be enabled by explicitly setting -a 0 or -r 0.

Motivated by D128262.

[Meinersbur]

• Advance pointer on match

[MatzeB]

LGTM

BTW: I always wanted to switch the tools to use diff by default which is faster and produces more helpful output in case of differences; and only use fpcmp for the few benchmarks that need float tolerances. Anyway this change makes sense in the meantime.

MultiSource/Benchmarks/TSVC/CMakeLists.txt

2–6

I wonder if we shouldn't rather change the reference output. But fine with me if things aren't that easy to fix.

tools/fpcmp.c

385–386

Why didn't you also combine the last string with the others?

[Meinersbur]

• Collapse fprintf calls

[Meinersbur]

MultiSource/Benchmarks/TSVC/CMakeLists.txt

2–6

Different printf implementations may implement floating point formatting differently. I only tested under Linux, I don't know what other libc implementations do and I don't think the test should fail on other platforms.

Generally, I am hesitant to change the reference output, which was hand-vetted and may have come from the benchmark itself. For SPEC benchmarks we cannot because the references come with the benchmark. D128261 is another case where the output is different between LLVM and GNU, but both seem to be correct.

tools/fpcmp.c

385–386

I think I left the last string unchanged at first and only later added "also". Changed.

MultiSource/Benchmarks/TSVC/CMakeLists.txt

+
+# Expect exact numeric results. However, the libc printf implementation emits
+# 'E' in scientific notation, while the reference output contains 'e'.
+set(FP_ABSTOLERANCE 0.0)
+
 add_subdirectory(ControlFlow-dbl)
 add_subdirectory(ControlFlow-flt)
 add_subdirectory(ControlLoops-dbl)
 add_subdirectory(ControlLoops-flt)
 add_subdirectory(CrossingThresholds-dbl)
 add_subdirectory(CrossingThresholds-flt)
 add_subdirectory(Equivalencing-dbl)
 add_subdirectory(Equivalencing-flt)
 add_subdirectory(Expansion-dbl)

tools/fpcmp.c

char *load_file(const char *path, long *size_out) {
   }
 
   /* Close the file and return the data. */
   fclose(fp);
   *size_out = size;
   return data;
 }
 
-int diff_files_with_tolerance(const char *path_a, const char *path_b,
-                              double absolute_tolerance,
-                              double relative_tolerance,
-                              bool ignore_whitespace) {
+int diff_file(const char *path_a, const char *path_b, bool parse_fp,
+              double absolute_tolerance, double relative_tolerance,
   /* First, load the file buffers completely into memory. */
   long A_size, B_size;
   char *data_a = load_file(path_a, &A_size);
   char *data_b = load_file(path_b, &B_size);
 
   /* Fast path equivalent buffers. */
   if (A_size == B_size && memcmp(data_a, data_b, A_size) == 0) {
     free(data_a);
if (F1P >= File1End || F2P >= File2End) {
       if (ignore_whitespace) {
         skip_whitespace(&F1P, File1End);
         skip_whitespace(&F2P, File2End);
       }
       break;
     }
 
     // Scan for the end of file or next difference.
-    if (*F1P == *F2P && !isPossibleStartOfNumber(*F1P)) {
+    if (*F1P == *F2P && (!parse_fp || !isPossibleStartOfNumber(*F1P))) {
       ++F1P, ++F2P;
       continue;
     }
 
     // With whitespace ignored, skip whitespace chars (if any) and recheck for
     // the next difference. Otherwise, only ignore whitespace before numbers.
     const char *F1NumStart = F1P;
     const char *F2NumStart = F2P;
     if (ignore_whitespace) {
       if (skip_whitespace(&F1P, File1End) | skip_whitespace(&F2P, File2End))
         continue;
-    } else {
+    } else if (parse_fp) {
       skip_whitespace(&F1NumStart, File1End);
       skip_whitespace(&F2NumStart, File2End);
     }
 
+    if (!parse_fp) {
+      // In non-floating point mode, recheck for character difference after
+      // skipping whitespace.
+      if (F1P < File1End && F2P < File2End && *F1P == *F2P) {
+        ++F1P, ++F2P;
+        continue;
+      }
+      break;
+    }
+
     const char *F1NumEnd = AdvanceNumber(F1NumStart, File1End);
     const char *F2NumEnd = AdvanceNumber(F2NumStart, File2End);
 
     // If one side is a number, but not the other, we found a difference.
     if (!F1NumEnd || !F2NumEnd) {
       // If there is no number starting at the current position, it might be a
       // non-numeric difference.
       if (*F1P != *F2P)
int diff_file(const char *path_a, const char *path_b, bool parse_fp,
   }
 
   // Okay, we reached the end of file.  If both files are at the end, we
   // succeeded.
   bool F1AtEnd = F1P >= File1End;
   bool F2AtEnd = F2P >= File2End;
   if (!F1AtEnd && !F2AtEnd) {
     fprintf(stderr,
-            "%s: FP Comparison failed, not a numeric difference between '%c' "
-            "and '%c'\n",
+            "%s: Comparison failed, textual difference between '%c' and '%c'\n",
             g_program, F1P[0], F2P[0]);
     free(data_a);
     free(data_b);
     return 1;
   }
   if (!F1AtEnd || !F2AtEnd) {
     fprintf(stderr,
-            "%s: FP Comparison failed, unexpected end of one of the files\n",
+            "%s: Comparison failed, unexpected end of one of the files\n",
             g_program);
     free(data_a);
     free(data_b);
     return 1;
   }
 
   free(data_a);
   free(data_b);
 
   return 0;
 }
 
 void usage() {
   fprintf(stderr, "usage: %s [-a VALUE] [-r VALUE] [-i] <path-A> <path-B>\n\n",
           g_program);
-  fprintf(stderr, "Compare two files using absolute and relative tolerances\n");
-  fprintf(stderr, "when comparing differences between two character\n");
-  fprintf(stderr, "which could be real numbers\n");
-  fprintf(stderr, "The -i switch ignores whitespace differences\n");
+  fprintf(stderr, "Search two text files for differences.\n"
+                  "If either -a or -r is specified (even if zero), floating "
+                  "numbers are parsed and considered equal if neither the "
+                  "absolute nor relative tolerance is exceeded.\n"
+                  "The -i switch also ignores whitespace differences.\n");
   exit(2);
 }
 
 int main(int argc, char * const argv[]) {
   double relative_tolerance = 0.0;
   double absolute_tolerance = 0.0;
+  bool parse_fp = false;
   bool ignore_whitespace = false;
   int i;
 
   g_program = argv[0];
   for (i = 1; i != argc; ++i) {
     const char *arg = argv[i];
     if (arg[0] != '-')
         break;
case 'r':
           fprintf(stderr, "error: invalid argument to '%s': '%s'\n\n", arg,
                   argv[i]);
           usage();
         }
         if (arg[1] == 'a')
           absolute_tolerance = value;
         else
           relative_tolerance = value;
+        parse_fp = true;
       }
       break;
 
     case 'i':
       ignore_whitespace = true;
       break;
 
     default:
       fprintf(stderr, "error: invalid argument '%s'\n\n", arg);
       usage();
     }
   }
 
   if (i + 2 != argc) {
     fprintf(stderr, "error: invalid number of arguments\n\n");
     usage();
   }
 
-  return diff_files_with_tolerance(argv[i], argv[i + 1], absolute_tolerance,
-                                   relative_tolerance, ignore_whitespace);
+  return diff_file(argv[i], argv[i + 1], parse_fp, absolute_tolerance,
 }