Print suppression hashes for TSan reports

tools/valgrind/memcheck_analyze.py

 #!/usr/bin/python
 # Copyright (c) 2010 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.
 
 # memcheck_analyze.py
 
 ''' Given a valgrind XML file, parses errors and uniques them.'''
 
 import gdb_helper
 
 import logging
+import hashlib

[Alexander Potapenko, 2011/06/20 14:57:04]

Please fix the import order

[Timur Iskhodzhanov, 2011/06/20 15:04:51]

Done.

 import optparse
 import os
 import re
 import subprocess
 import sys
 import time
 from xml.dom.minidom import parse
 from xml.parsers.expat import ExpatError
 
 import common
@@ skipping 224 matching lines @@
         elif frame[SRC_FILE_DIR] != "":
           output += (" (" + frame[SRC_FILE_DIR] + "/" + frame[SRC_FILE_NAME] +
                      ":" + frame[SRC_LINE] + ")")
         else:
           output += " (" + frame[OBJECT_FILE] + ")"
         output += "\n"
 
     assert self._suppression != None, "Your Valgrind doesn't generate " \
                                       "suppressions - is it too old?"
 
-    output += "Suppression (error hash=#%016X#):" % \
-        (self.__hash__() & 0xffffffffffffffff)
+    output += "Suppression (error hash=#%016X#):\n" % self.ErrorHash()
+    output += ("  For more info on using suppressions see "
+               "http://dev.chromium.org/developers/how-tos/using-valgrind#TOC-Suppressing-Errors")
+
     # Widen suppression slightly to make portable between mac and linux
     supp = self._suppression;
     supp = supp.replace("fun:_Znwj", "fun:_Znw*")
     supp = supp.replace("fun:_Znwm", "fun:_Znw*")
     supp = supp.replace("fun:_Znaj", "fun:_Zna*")
     supp = supp.replace("fun:_Znam", "fun:_Zna*")
     # Split into lines so we can enforce length limits
     supplines = supp.split("\n")
 
     # Truncate at line 26 (VG_MAX_SUPP_CALLERS plus 2 for name and type)
@@ skipping 24 matching lines @@
       for frame in backtrace[1]:
         rep += frame[FUNCTION_NAME]
 
         if frame[SRC_FILE_DIR] != "":
           rep += frame[SRC_FILE_DIR] + "/" + frame[SRC_FILE_NAME]
         else:
           rep += frame[OBJECT_FILE]
 
     return rep
 
+  # This is a device-independent hash identifying the suppression.
+  # By printing out this hash we can find duplicate reports between tests and
+  # different shards running on multiple buildbots
+  def ErrorHash(self):
+    return int(hashlib.md5(self.UniqueString()).hexdigest()[:16], 16)
+
   def __hash__(self):
     return hash(self.UniqueString())
   def __eq__(self, rhs):
     return self.UniqueString() == rhs
 
 def find_and_truncate(f):
   f.seek(0)
   while True:
     line = f.readline()
     if line == "":
@@ skipping 169 matching lines @@
           # Ignore "possible" leaks for now by default.
           if (self._show_all_leaks or
               getTextOf(raw_error, "kind") != "Leak_PossiblyLost"):
             error = ValgrindError(self._source_dir, raw_error, commandline)
             if error not in cur_report_errors:
               # We haven't seen such errors doing this report yet...
               if error in self._errors:
                 # ... but we saw it in earlier reports, e.g. previous UI test
                 cur_report_errors.add("This error was already printed in "
                                       "some other test, see 'hash=#%016X#'" % \
-                                      (error.__hash__() & 0xffffffffffffffff))
+                                      self.ErrorHash())
               else:
                 # ... and we haven't seen it in other tests as well
                 self._errors.add(error)
                 cur_report_errors.add(error)
 
         suppcountlist = parsed_file.getElementsByTagName("suppcounts")
         if len(suppcountlist) > 0:
           suppcountlist = suppcountlist[0]
           for node in suppcountlist.getElementsByTagName("pair"):
             count = getTextOf(node, "count");
@@ skipping 69 matching lines @@
     parser.error("no filename specified")
   filenames = args
 
   analyzer = MemcheckAnalyzer(options.source_dir, use_gdb=True)
   retcode = analyzer.Report(filenames)
 
   sys.exit(retcode)
 
 if __name__ == "__main__":
   _main()