supersize: Tweak diff symbol matching for generated symbols

tools/binary_size/libsupersize/diff.py

 # Copyright 2017 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.
 """Logic for diffing two SizeInfo objects."""
 
 import collections
+import re
 
 import models
 
 
+def _SymbolKey(symbol):
+  """Returns a tuple that can be used to see if two Symbol are the same.
+
+  Keys are not guaranteed to be unique within a SymbolGroup. When multiple
+  symbols have the same key, they will be matched up in order of appearance.
+  We do this because the numbering of these generated symbols is not stable.
+
+  Examples of symbols with shared keys:
+    "** merge strings"
+    "** symbol gap 3", "** symbol gap 5"
+    "foo() [clone ##]"
+    "CSWTCH.61", "CSWTCH.62"
+    "._468", "._467"
+    ".L__unnamed_1193", ".L__unnamed_712"
+  """
+  name = symbol.full_name or symbol.name
+  clone_idx = name.find(' [clone ')
+  if clone_idx != -1:
+    name = name[:clone_idx]
+  if name.startswith('*'):
+    # "symbol gap 3 (bar)" -> "symbol gaps"
+    name = re.sub(r'\s+\d+( \(.*\))?$', 's', name)
+
+  if '.' not in name:
+    return (symbol.section_name, name)
+  # Compiler or Linker generated symbol.
+  name = re.sub(r'[.0-9]', '', name)  # Strip out all numbers and dots.
+  return (symbol.section_name, name, symbol.object_path)
+
+
 def _CloneSymbol(sym, size):
   """Returns a copy of |sym| with an updated |size|.
 
   Padding and aliases are not copied.
   """
   return models.Symbol(
       sym.section_name, size, address=sym.address, name=sym.name,
       source_path=sym.source_path, object_path=sym.object_path,
       full_name=sym.full_name, flags=sym.flags)
 
@@ skipping 73 matching lines @@
     else:
       cloned = _CloneSymbol(sym, -sym.size_without_padding)
       cloned.padding = -sym.padding
     ret[i] = cloned
   return ret
 
 
 def _DiffSymbolGroups(before, after):
   before_symbols_by_key = collections.defaultdict(list)
   for s in before:
-    before_symbols_by_key[s._Key()].append(s)
+    before_symbols_by_key[_SymbolKey(s)].append(s)
 
   similar = []
   diffed_symbol_by_after_aliases = {}
   matched_before_aliases = set()
   unmatched_after_syms = []
   # For similar symbols, padding is zeroed out. In order to not lose the
   # information entirely, store it in aggregate.
   padding_by_section_name = collections.defaultdict(int)
 
   # Step 1: Create all delta symbols and record unmatched symbols.
   for after_sym in after:
-    matching_syms = before_symbols_by_key.get(after_sym._Key())
+    matching_syms = before_symbols_by_key.get(_SymbolKey(after_sym))
     if matching_syms:
       before_sym = matching_syms.pop(0)
       if before_sym.IsGroup() and after_sym.IsGroup():
         similar.append(_DiffSymbolGroups(before_sym, after_sym))
       else:
         if before_sym.aliases:
           matched_before_aliases.add(id(before_sym.aliases))
         similar.append(
             _DiffSymbol(before_sym, after_sym, diffed_symbol_by_after_aliases,
                         padding_by_section_name))
@@ skipping 31 matching lines @@
   """
   assert isinstance(before, models.SizeInfo)
   assert isinstance(after, models.SizeInfo)
   section_sizes = {k: after.section_sizes[k] - v
                    for k, v in before.section_sizes.iteritems()}
   symbol_diff = _DiffSymbolGroups(before.symbols, after.symbols)
   if cluster:
     symbol_diff = symbol_diff.Cluster()
   return models.SizeInfoDiff(section_sizes, symbol_diff, before.metadata,
                              after.metadata)