[utils] Add exact check to check_cfc.py dash_s_no_change

[russell.gallop]

Summary

Files compiled with -via-file-asm should be byte for byte identical to those compiled in the same way without that option. This change adds an exact check to check_cfc.py to spot non-code differences. If there is a difference, the check then compares code and debug to try and report more detail on the check failure.

This could be helpful in finding bugs like this one: https://llvm.org/bugs/show_bug.cgi?id=14524

Running the llvm-test-suite there are dash_s_no_change check failures (as of r238815) but not failures in check_cfc.py or new failures introduced by this change. I will report bugs for these check failures.

Please let me know if okay to commit?

[• rafael]

Lgtm

[russell.gallop]

Thanks for the review Rafael.

Commited revision 238926.

utils/check_cfc/check_cfc.py

def perform_check(self, arguments, my_env):
         in different code than compiling to object directly."""
         output_file_b = get_temp_file_name('.o')
 
         alternate_command = arguments + ['-via-file-asm']
         alternate_command = set_output_file(alternate_command, output_file_b)
         run_step(alternate_command, my_env,
                  "Error compiling with -via-file-asm")
 
+        # Compare if object files are exactly the same
+        exactly_equal = obj_diff.compare_exact(self._output_file_a, output_file_b)
+        if not exactly_equal:
             # Compare disassembly (returns first diff if differs)
             difference = obj_diff.compare_object_files(self._output_file_a,
                                                        output_file_b)
             if difference:
                 raise WrapperCheckException(
                     "Code difference detected with -S\n{}".format(difference))
 
+            # Code is identical, compare debug info
+            dbgdifference = obj_diff.compare_debug_info(self._output_file_a,
+                                                        output_file_b)
+            if dbgdifference:
+                raise WrapperCheckException(
+                    "Debug info difference detected with -S\n{}".format(dbgdifference))
+
+            raise WrapperCheckException("Object files not identical with -S\n")
+
         # Clean up temp file if comparison okay
         os.remove(output_file_b)
 
 if __name__ == '__main__':
     # Create configuration defaults from list of checks
     default_config = """
 [Checks]
 """

utils/check_cfc/obj_diff.py

 #!/usr/bin/env python2.7
 
 from __future__ import print_function
 
 import argparse
 import difflib
+import filecmp
 import os
 import subprocess
 import sys
 
 disassembler = 'objdump'
 
 def keep_line(line):
     """Returns true for lines that should be compared in the disassembly
     output."""
     return "file format" not in line
 
 def disassemble(objfile):
     """Disassemble object to a file."""
     p = subprocess.Popen([disassembler, '-d', objfile],
                          stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE)
     (out, err) = p.communicate()
     if p.returncode or err:
         print("Disassemble failed: {}".format(objfile))
         sys.exit(1)
     return filter(keep_line, out.split(os.linesep))
 
+def dump_debug(objfile):
+    """Dump all of the debug info from a file."""
+    p = subprocess.Popen([disassembler, '-WliaprmfsoRt', objfile], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    (out, err) = p.communicate()
+    if p.returncode or err:
+        print("Dump debug failed: {}".format(objfile))
+        sys.exit(1)
+    return filter(keep_line, out.split(os.linesep))
+
 def first_diff(a, b, fromfile, tofile):
     """Returns the first few lines of a difference, if there is one.  Python
     diff can be very slow with large objects and the most interesting changes
     are the first ones. Truncate data before sending to difflib.  Returns None
     is there is no difference."""
 
     # Find first diff
     first_diff_idx = None
def compare_object_files(objfilea, objfileb):
     """Compare disassembly of two different files.
        Allowing unavoidable differences, such as filenames.
        Return the first difference if the disassembly differs, or None.
     """
     disa = disassemble(objfilea)
     disb = disassemble(objfileb)
     return first_diff(disa, disb, objfilea, objfileb)
 
+def compare_debug_info(objfilea, objfileb):
+    """Compare debug info of two different files.
+       Allowing unavoidable differences, such as filenames.
+       Return the first difference if the debug info differs, or None.
+       If there are differences in the code, there will almost certainly be differences in the debug info too.
+    """
+    dbga = dump_debug(objfilea)
+    dbgb = dump_debug(objfileb)
+    return first_diff(dbga, dbgb, objfilea, objfileb)
+
+def compare_exact(objfilea, objfileb):
+    """Byte for byte comparison between object files.
+       Returns True if equal, False otherwise.
+    """
+    return filecmp.cmp(objfilea, objfileb)
+
 if __name__ == '__main__':
     parser = argparse.ArgumentParser()
     parser.add_argument('objfilea', nargs=1)
     parser.add_argument('objfileb', nargs=1)
     parser.add_argument('-v', '--verbose', action='store_true')
     args = parser.parse_args()
     diff = compare_object_files(args.objfilea[0], args.objfileb[0])
     if diff:
         print("Difference detected")
         if args.verbose:
             print(diff)
         sys.exit(1)
     else:
         print("The same")