Skip COFF timestamp difference.

tools/determinism/compare_build_artifacts.py

 #!/usr/bin/env python
 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Compare the artifacts from two builds."""
 
 import difflib
 import json
 import optparse
@@ skipping 418 matching lines @@
     elif isinstance(va, dict):
       c = diff_dict(va, vb)
       if c:
         out += '- %s:\n%s\n' % (
             key, '\n'.join('  ' + l for l in c.splitlines()))
     elif va != vb:
       out += '- %s:  %s != %s\n' % (key, va, vb)
   return out.rstrip()
 
 
+def may_skip_coff_header(lhs_header, rhs_header):
+  """Returns True if we can skip checking COFF headers."""
+  # COFF header:
+  #   0 - 1: magic.
+  #   2 - 3: # sections.
+  #   4 - 8: timestamp.
+  #   ...
+  if len(lhs_header) < 8:
+    return False
+  lhs_data = [l for l in lhs_header]

[M-A Ruel, 2016/09/06 15:35:54]

Replace the lines 448-452 with:
return lhs_data[4:8] != rhs_data[4:8]

[Yoshisato Yanagisawa, 2016/09/07 01:50:28]

I would basically change the code like so but let me do more than that.

I think callee should have knowledge of local information, and when I write a
function like this, we might need to think lhs_header and rhs_header are
arbitrary COFF header.  Then, I made this like general purpose function to
return True on timestamps in COFF header only differs.

However, we actually needs first 8 bytes, and we do not check anything else,
this function is overkill.  However expecting first 8 bytes of the file might
not be so trivial.

Let me merge this function to the caller, and only checks first 8 bytes, and
only skips first 8 bytes if timestamps are different.

+  rhs_data = [r for r in rhs_header]
+  for x in xrange(4):
+    lhs_data[4 + x] = rhs_data[4 + x] = chr(0)
+  return rhs_data == lhs_data
+
+
 def diff_binary(first_filepath, second_filepath, file_len):
   """Returns a compact binary diff if the diff is small enough."""
   CHUNK_SIZE = 32
   MAX_STREAMS = 10
   diffs = 0
   streams = []
   offset = 0
   with open(first_filepath, 'rb') as lhs:
     with open(second_filepath, 'rb') as rhs:
+      # Skip COFF header on Win32 object file if only timestamps are different.
+      if sys.platform == 'win32' and first_filepath.endswith('.obj'):
+        COFF_HEADER_SIZE = 22
+        lhs_data = lhs.read(COFF_HEADER_SIZE)
+        rhs_data = rhs.read(COFF_HEADER_SIZE)
+        if may_skip_coff_header(lhs_data, rhs_data):
+          offset += COFF_HEADER_SIZE
+        else:
+          lhs.seek(0)
+          rhs.seek(0)
+
       while True:
         lhs_data = lhs.read(CHUNK_SIZE)
         rhs_data = rhs.read(CHUNK_SIZE)
         if not lhs_data:
           break
         if lhs_data != rhs_data:
           diffs += sum(l != r for l, r in zip(lhs_data, rhs_data))
           if streams is not None:
             if len(streams) < MAX_STREAMS:
               streams.append((offset, lhs_data, rhs_data))
@@ skipping 94 matching lines @@
       # for this case.
       print 'deps on %s are different: %s' % (
           target, set(first_deps).symmetric_difference(set(second_deps)))
       continue
     max_filepath_len = max(len(n) for n in first_deps)
     for d in first_deps:
       first_file = os.path.join(first_dir, d)
       second_file = os.path.join(second_dir, d)
       result = compare_files(first_file, second_file)
       if result:
-        print('%-*s: %s' % (max_filepath_len, d, result))
+        print('  %-*s: %s' % (max_filepath_len, d, result))
 
 
 def compare_build_artifacts(first_dir, second_dir, target_platform,
                             recursive=False):
   """Compares the artifacts from two distinct builds."""
   if not os.path.isdir(first_dir):
     print >> sys.stderr, '%s isn\'t a valid directory.' % first_dir
     return 1
   if not os.path.isdir(second_dir):
     print >> sys.stderr, '%s isn\'t a valid directory.' % second_dir
@@ skipping 85 matching lines @@
     parser.error('--target-platform is required')
 
   return compare_build_artifacts(os.path.abspath(options.first_build_dir),
                                  os.path.abspath(options.second_build_dir),
                                  options.target_platform,
                                  options.recursive)
 
 
 if __name__ == '__main__':
   sys.exit(main())