Add a copy of gyp_flag_compare from Chromium to WebRTC's webrtc/tools.

tools/gyp_flag_compare.py

+#!/usr/bin/env python
+
+# Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS.  All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+"""Given the output of -t commands from a ninja build for a gyp and GN generated
+build, report on differences between the command lines.
+
+This script is best used interactively. Here's a recommended setup:

[kjellander_webrtc, 2016/08/19 13:09:09]

This part is no longer true, right? I think V8's version script was mainly
modified to better adapt to being run on a bot (where GYP and GN had already
executed), while Chromium's version was running GYP and GN every time it
executed (which could be nice, but it slow to iterate with).

The Chromium one seems to be more targeted to running interactively like
described here as well. If that's what we want, we should keep the
ConfigureBuild method (but update it to use our GYP script in
webrtc/build/gyp_webrtc.py). I'll let you decide which way you think the script
is most useful for us right now.

+  $ PYTHONPATH=tools/gn/bin python
+  >>> import sys
+  >>> import pprint
+  >>> sys.displayhook = pprint.pprint
+  >>> import gyp_flag_compare as fc
+  >>> fc.ConfigureBuild(['gyp_define=1', 'define=2'], ['gn_arg=1', 'arg=2'])
+  >>> chrome = fc.Comparison('chrome')
+
+The above starts interactive Python, sets up the output to be pretty-printed
+(useful for making lists, dicts, and sets readable), configures the build with
+GN arguments and GYP defines, and then generates a comparison for that build
+configuration for the "chrome" target.
+
+After that, the |chrome| object can be used to investigate differences in the
+build.
+
+To configure an official build, use this configuration. Disabling NaCl produces
+a more meaningful comparison, as certain files need to get compiled twice
+for the IRT build, which uses different flags:
+  >>> fc.ConfigureBuild(
+          ['disable_nacl=1', 'buildtype=Official', 'branding=Chrome'],
+          ['enable_nacl=false', 'is_official_build=true',
+           'is_chrome_branded=true'])
+"""
+
+
+import os
+import shlex
+import subprocess
+import sys
+
+# Must be in src/.
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+os.chdir(BASE_DIR)
+
+_GN_OUT_DIR = 'out/gn'
+_GYP_OUT_DIR = 'out/Release'
+
+
+def FilterChromium(filename):
+  """Replaces 'chromium/src/' by '' in the filename."""
+  return filename.replace('chromium/src/', '')
+
+
+def Counts(dict_of_list):
+  """Given a dictionary whose value are lists, returns a dictionary whose values
+  are the length of the list. This can be used to summarize a dictionary.
+  """
+  return {k: len(v) for k, v in dict_of_list.iteritems()}
+
+
+def CountsByDirname(dict_of_list):
+  """Given a list of files, returns a dict of dirname to counts in that dir."""
+  r = {}
+  for path in dict_of_list:
+    dirname = os.path.dirname(path)
+    r.setdefault(dirname, 0)
+    r[dirname] += 1
+  return r
+
+
+class Comparison(object):
+  """A comparison of the currently-configured build for a target."""
+
+  def __init__(self, gyp_target, gn_target=None):
+    """Creates a comparison of a GN and GYP target. If the target names differ
+    between the two build systems, then two names may be passed.
+    """
+    if gn_target is None:
+      gn_target = gyp_target
+    self._gyp_target = gyp_target
+    self._gn_target = gn_target
+
+    self._skipped = []
+
+    self._total_diffs = 0
+
+    self._missing_gyp_flags = {}
+    self._missing_gn_flags = {}
+
+    self._missing_gyp_files = {}
+    self._missing_gn_files = {}
+
+    self._CompareFiles()
+
+  @property
+  def gyp_files(self):
+    """Returns the set of files that are in the GYP target."""
+    return set(self._gyp_flags.keys())
+
+  @property
+  def gn_files(self):
+    """Returns the set of files that are in the GN target."""
+    return set(self._gn_flags.keys())
+
+  @property
+  def skipped(self):
+    """Returns the list of compiler commands that were not processed during the
+    comparison.
+    """
+    return self._skipped
+
+  @property
+  def total_differences(self):
+    """Returns the total number of differences detected."""
+    return self._total_diffs
+
+  @property
+  def missing_in_gyp(self):
+    """Differences that are only in GYP build but not in GN, indexed by the
+    difference."""
+    return self._missing_gyp_flags
+
+  @property
+  def missing_in_gn(self):
+    """Differences that are only in the GN build but not in GYP, indexed by
+    the difference."""
+    return self._missing_gn_flags
+
+  @property
+  def missing_in_gyp_by_file(self):
+    """Differences that are only in the GYP build but not in GN, indexed by
+    file.
+    """
+    return self._missing_gyp_files
+
+  @property
+  def missing_in_gn_by_file(self):
+    """Differences that are only in the GYP build but not in GN, indexed by
+    file.
+    """
+    return self._missing_gn_files
+
+  def _CompareFiles(self):
+    """Performs the actual target comparison."""
+    if sys.platform == 'win32':
+      # On Windows flags are stored in .rsp files which are created by building.
+      print >> sys.stderr, 'Building in %s...' % _GN_OUT_DIR
+      Run('ninja -C %s -d keeprsp %s' % (_GN_OUT_DIR, self._gn_target))
+      print >> sys.stderr, 'Building in %s...' % _GYP_OUT_DIR
+      Run('ninja -C %s -d keeprsp %s' % (_GYP_OUT_DIR, self._gn_target))
+
+    gn = Run('ninja -C %s -t commands %s' % (_GN_OUT_DIR, self._gn_target))
+    gyp = Run('ninja -C %s -t commands %s' % (_GYP_OUT_DIR, self._gyp_target))
+
+    self._gn_flags = self._GetFlags(gn.splitlines(),
+                                    os.path.join(os.getcwd(), _GN_OUT_DIR))
+    self._gyp_flags = self._GetFlags(gyp.splitlines(),
+                                     os.path.join(os.getcwd(), _GYP_OUT_DIR))
+
+    self._gn_flags = dict((FilterChromium(filename), value)
+                          for filename, value in self._gn_flags.iteritems())
+    self._gyp_flags = dict((FilterChromium(filename), value)
+                           for filename, value in self._gyp_flags.iteritems())
+
+    all_files = sorted(self.gn_files & self.gyp_files)
+    for filename in all_files:
+      gyp_flags = self._gyp_flags[filename]
+      gn_flags = self._gn_flags[filename]
+      self._CompareLists(filename, gyp_flags, gn_flags, 'dash_f')
+      self._CompareLists(filename, gyp_flags, gn_flags, 'defines')
+      self._CompareLists(filename, gyp_flags, gn_flags, 'include_dirs')
+      self._CompareLists(filename, gyp_flags, gn_flags, 'warnings',
+          # More conservative warnings in GN we consider to be OK.
+          dont_care_gyp=[
+            '/wd4091',  # 'keyword' : ignored on left of 'type' when no variable
+                        # is declared.
+            '/wd4456',  # Declaration hides previous local declaration.
+            '/wd4457',  # Declaration hides function parameter.
+            '/wd4458',  # Declaration hides class member.
+            '/wd4459',  # Declaration hides global declaration.
+            '/wd4702',  # Unreachable code.
+            '/wd4800',  # Forcing value to bool 'true' or 'false'.
+            '/wd4838',  # Conversion from 'type' to 'type' requires a narrowing
+                        # conversion.
+          ] if sys.platform == 'win32' else None,
+          dont_care_gn=[
+            '-Wendif-labels',
+            '-Wextra',
+            '-Wsign-compare',
+          ] if not sys.platform == 'win32' else None)
+      self._CompareLists(filename, gyp_flags, gn_flags, 'other')
+
+  def _CompareLists(self, filename, gyp, gn, name,
+                    dont_care_gyp=None, dont_care_gn=None):
+    """Return a report of any differences between gyp and gn lists, ignoring
+    anything in |dont_care_{gyp|gn}| respectively."""
+    if gyp[name] == gn[name]:
+      return
+    if not dont_care_gyp:
+      dont_care_gyp = []
+    if not dont_care_gn:
+      dont_care_gn = []
+    gyp_set = set(gyp[name])
+    gn_set = set(gn[name])
+    missing_in_gyp = gyp_set - gn_set
+    missing_in_gn = gn_set - gyp_set
+    missing_in_gyp -= set(dont_care_gyp)
+    missing_in_gn -= set(dont_care_gn)
+
+    for m in missing_in_gyp:
+      self._missing_gyp_flags.setdefault(name, {}) \
+                             .setdefault(m, []).append(filename)
+      self._total_diffs += 1
+    self._missing_gyp_files.setdefault(filename, {}) \
+                           .setdefault(name, set()).update(missing_in_gyp)
+
+    for m in missing_in_gn:
+      self._missing_gn_flags.setdefault(name, {}) \
+                            .setdefault(m, []).append(filename)
+      self._total_diffs += 1
+    self._missing_gn_files.setdefault(filename, {}) \
+                          .setdefault(name, set()).update(missing_in_gn)
+
+  def _GetFlags(self, lines, build_dir):
+    """Turn a list of command lines into a semi-structured dict."""
+    is_win = sys.platform == 'win32'
+    flags_by_output = {}
+    for line in lines:
+      command_line = shlex.split(line.strip(), posix=not is_win)[1:]
+
+      output_name = _FindAndRemoveArgWithValue(command_line, '-o')
+      dep_name = _FindAndRemoveArgWithValue(command_line, '-MF')
+
+      command_line = _MergeSpacedArgs(command_line, '-Xclang')
+
+      cc_file = [x for x in command_line if x.endswith('.cc') or
+                                            x.endswith('.c') or
+                                            x.endswith('.cpp') or
+                                            x.endswith('.mm') or
+                                            x.endswith('.m')]
+      if len(cc_file) != 1:
+        self._skipped.append(command_line)
+        continue
+      assert len(cc_file) == 1
+
+      if is_win:
+        rsp_file = [x for x in command_line if x.endswith('.rsp')]
+        assert len(rsp_file) <= 1
+        if rsp_file:
+          rsp_file = os.path.join(build_dir, rsp_file[0][1:])
+          with open(rsp_file, "r") as open_rsp_file:
+            command_line = shlex.split(open_rsp_file, posix=False)
+
+      defines = [x for x in command_line if x.startswith('-D')]
+      include_dirs = [x for x in command_line if x.startswith('-I')]
+      dash_f = [x for x in command_line if x.startswith('-f')]
+      warnings = \
+          [x for x in command_line if x.startswith('/wd' if is_win else '-W')]
+      others = [x for x in command_line if x not in defines and \
+                                           x not in include_dirs and \
+                                           x not in dash_f and \
+                                           x not in warnings and \
+                                           x not in cc_file]
+
+      for index, value in enumerate(include_dirs):
+        if value == '-Igen':
+          continue
+        path = value[2:]
+        if not os.path.isabs(path):
+          path = os.path.join(build_dir, path)
+        include_dirs[index] = '-I' + os.path.normpath(path)
+
+      # GYP supports paths above the source root like <(DEPTH)/../foo while such
+      # paths are unsupported by gn. But gn allows to use system-absolute paths
+      # instead (paths that start with single '/'). Normalize all paths.
+      cc_file = [os.path.normpath(os.path.join(build_dir, cc_file[0]))]
+
+      # Filter for libFindBadConstructs.so having a relative path in one and
+      # absolute path in the other.
+      others_filtered = []
+      for x in others:
+        if x.startswith('-Xclang ') and \
+            (x.endswith('libFindBadConstructs.so') or \
+             x.endswith('libFindBadConstructs.dylib')):
+          others_filtered.append(
+              '-Xclang ' +
+              os.path.join(os.getcwd(), os.path.normpath(
+                  os.path.join('out/gn_flags', x.split(' ', 1)[1]))))
+        elif x.startswith('-B'):
+          others_filtered.append(
+              '-B' +
+              os.path.join(os.getcwd(), os.path.normpath(
+                  os.path.join('out/gn_flags', x[2:]))))
+        else:
+          others_filtered.append(x)
+      others = others_filtered
+
+      flags_by_output[cc_file[0]] = {
+        'output': output_name,
+        'depname': dep_name,
+        'defines': sorted(defines),
+        'include_dirs': sorted(include_dirs),  # TODO(scottmg): This is wrong.
+        'dash_f': sorted(dash_f),
+        'warnings': sorted(warnings),
+        'other': sorted(others),
+      }
+    return flags_by_output
+
+
+def _FindAndRemoveArgWithValue(command_line, argname):
+  """Given a command line as a list, remove and return the value of an option
+  that takes a value as a separate entry.
+
+  Modifies |command_line| in place.
+  """
+  if argname not in command_line:
+    return ''
+  location = command_line.index(argname)
+  value = command_line[location + 1]
+  command_line[location:location + 2] = []
+  return value
+
+
+def _MergeSpacedArgs(command_line, argname):
+  """Combine all arguments |argname| with their values, separated by a space."""
+  i = 0
+  result = []
+  while i < len(command_line):
+    arg = command_line[i]
+    if arg == argname:
+      result.append(arg + ' ' + command_line[i + 1])
+      i += 1
+    else:
+      result.append(arg)
+    i += 1
+  return result
+
+
+def Run(command_line):
+  """Run |command_line| as a subprocess and return stdout. Raises on error."""
+  print >> sys.stderr, command_line
+  return subprocess.check_output(command_line, shell=True)
+
+
+def main():
+  if len(sys.argv) != 2 and len(sys.argv) != 3:
+    print 'usage: %s gyp_target gn_target' % __file__
+    print '   or: %s target' % __file__
+    return 1
+
+  gyp_target = sys.argv[1]
+  if len(sys.argv) == 2:
+    gn_target = gyp_target
+  else:
+    gn_target = sys.argv[2]
+  comparison = Comparison(gyp_target, gn_target)
+
+  gyp_files = comparison.gyp_files
+  gn_files = comparison.gn_files
+  different_source_list = comparison.gyp_files != comparison.gn_files
+  if different_source_list:
+    print 'Different set of sources files:'
+    print '  In gyp, not in GN:\n    %s' % '\n    '.join(
+        sorted(gyp_files - gn_files))
+    print '  In GN, not in gyp:\n    %s' % '\n    '.join(
+        sorted(gn_files - gyp_files))
+    print '\nNote that flags will only be compared for files in both sets.\n'
+
+  differing_files = set(comparison.missing_in_gn_by_file.keys()) & \
+                    set(comparison.missing_in_gyp_by_file.keys())
+  files_with_given_differences = {}
+  for filename in differing_files:
+    output = ''
+    missing_in_gyp = comparison.missing_in_gyp_by_file.get(filename, {})
+    missing_in_gn = comparison.missing_in_gn_by_file.get(filename, {})
+    difference_types = sorted(set(missing_in_gyp.keys() + missing_in_gn.keys()))
+    for difference_type in difference_types:
+      output += '  %s differ:\n' % difference_type
+      if difference_type in missing_in_gyp:
+        output += '    In gyp, but not in GN:\n      %s' % '\n      '.join(
+            sorted(missing_in_gyp[difference_type])) + '\n'
+      if difference_type in missing_in_gn:
+        output += '    In GN, but not in gyp:\n      %s' % '\n      '.join(
+            sorted(missing_in_gn[difference_type])) + '\n'
+    if output:
+      files_with_given_differences.setdefault(output, []).append(filename)
+
+  for diff, files in files_with_given_differences.iteritems():
+    print '\n'.join(sorted(files))
+    print diff
+
+  print 'Total differences:', comparison.total_differences
+  # TODO(scottmg): Return failure on difference once we're closer to identical.
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())