Refactor "Suppressions used" printing code in memcheck and tsan analyzer scripts

tools/valgrind/tsan_analyze.py

 #!/usr/bin/python
 # Copyright (c) 2011 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.
 
 # tsan_analyze.py
 
 ''' Given a ThreadSanitizer output file, parses errors and uniques them.'''
 
 import gdb_helper
 
-import common
+from collections import defaultdict
 import hashlib
 import logging
 import optparse
 import os
 import re
 import subprocess
 import sys
 import time
 
+import common
+
 # Global symbol table (ugh)
 TheAddressTable = None
 
 class _StackTraceLine(object):
   def __init__(self, line, address, binary):
     self.raw_line_ = line
     self.address = address
     self.binary = binary
   def __str__(self):
     global TheAddressTable
     file, line = TheAddressTable.GetFileLine(self.binary, self.address)
     if (file is None) or (line is None):
       return self.raw_line_
     else:
       return self.raw_line_.replace(self.binary, '%s:%s' % (file, line))
 
 class TsanAnalyzer(object):
   ''' Given a set of ThreadSanitizer output files, parse all the errors out of
   them, unique them and output the results.'''
 
   LOAD_LIB_RE = re.compile('--[0-9]+-- ([^(:]*) \((0x[0-9a-f]+)\)')
   TSAN_LINE_RE = re.compile('==[0-9]+==\s*[#0-9]+\s*'
                             '([0-9A-Fa-fx]+):'
                             '(?:[^ ]* )*'
                             '([^ :\n]+)'
                             '')
   THREAD_CREATION_STR = ("INFO: T.* "
       "(has been created by T.* at this point|is program's main thread)")
 
-  SANITY_TEST_SUPPRESSION = "ThreadSanitizer sanity test"
+  SANITY_TEST_SUPPRESSION = ("ThreadSanitizer sanity test "
+                             "(ToolsSanityTest.DataRace)")
   TSAN_RACE_DESCRIPTION = "Possible data race"
   TSAN_WARNING_DESCRIPTION =  ("Unlocking a non-locked lock"
       "|accessing an invalid lock"
       "|which did not acquire this lock")
   RACE_VERIFIER_LINE = "Confirmed a race|unexpected race"
   TSAN_ASSERTION = "Assertion failed: "
 
   def __init__(self, source_dir, use_gdb=False):
     '''Reads in a set of files.
 
@@ skipping 117 matching lines @@
       tmp = []
       if re.search(TsanAnalyzer.TSAN_ASSERTION, self.line_):
         tmp.extend(self.ReadTillTheEnd())
         ret.append(tmp)
         break
 
       match = re.search("used_suppression:\s+([0-9]+)\s(.*)", self.line_)
       if match:
         count, supp_name = match.groups()
         count = int(count)
-        if supp_name in self.used_suppressions:
-          self.used_suppressions[supp_name] += count
-        else:
-          self.used_suppressions[supp_name] = count
+        self.used_suppressions[supp_name] += count
     self.cur_fd_.close()
     return ret
 
   def GetReports(self, files):
     '''Extracts reports from a set of files.
 
     Reads a set of files and returns a list of all discovered
     ThreadSanitizer race reports. As a side effect, populates
     self.used_suppressions with appropriate info.
     '''
 
     global TheAddressTable
     if self._use_gdb:
       TheAddressTable = gdb_helper.AddressTable()
     else:
       TheAddressTable = None
     reports = []
-    self.used_suppressions = {}
+    self.used_suppressions = defaultdict(int)
     for file in files:
       reports.extend(self.ParseReportFile(file))
     if self._use_gdb:
       TheAddressTable.ResolveAll()
       # Make each line of each report a string.
       reports = map(lambda(x): map(str, x), reports)
     return [''.join(report_lines) for report_lines in reports]
 
   def Report(self, files, testcase, check_sanity=False):
     '''Reads in a set of files and prints ThreadSanitizer report.
 
     Args:
       files: A list of filenames.
       check_sanity: if true, search for SANITY_TEST_SUPPRESSIONS
     '''
 
     # We set up _cur_testcase class-wide variable to avoid passing it through
     # about 5 functions.
     self._cur_testcase = testcase
     reports = self.GetReports(files)
     self._cur_testcase = None  # just in case, shouldn't be used anymore
 
-    is_sane = False
-    print "-----------------------------------------------------"
-    print "Suppressions used:"
-    print "  count name"
-    for item in sorted(self.used_suppressions.items(), key=lambda (k,v): (v,k)):
-      print "%7s %s" % (item[1], item[0])
-      if item[0].startswith(TsanAnalyzer.SANITY_TEST_SUPPRESSION):
-        is_sane = True
-    print "-----------------------------------------------------"
-    sys.stdout.flush()
+    common.PrintUsedSuppressionsList(self.used_suppressions)
+
 
     retcode = 0
     if reports:
       logging.error("FAIL! Found %i report(s)" % len(reports))
       for report in reports:
         logging.error('\n' + report)
       retcode = -1
 
     # Report tool's insanity even if there were errors.
-    if check_sanity and not is_sane:
+    if (check_sanity and
+        TsanAnalyzer.SANITY_TEST_SUPPRESSION not in self.used_suppressions):
       logging.error("FAIL! Sanity check failed!")
       retcode = -3
 
     if retcode != 0:
       return retcode
+
     logging.info("PASS: No reports found")
     return 0
 
 if __name__ == '__main__':
   '''For testing only. The TsanAnalyzer class should be imported instead.'''
   retcode = 0
   parser = optparse.OptionParser("usage: %prog [options] <files to analyze>")
   parser.add_option("", "--source_dir",
                     help="path to top of source tree for this build"
                     "(used to normalize source paths in baseline)")
 
   (options, args) = parser.parse_args()
   if not args:
     parser.error("no filename specified")
   filenames = args
 
   analyzer = TsanAnalyzer(options.source_dir, use_gdb=True)
   retcode = analyzer.Report(filenames, None)
 
   sys.exit(retcode)