Roll Chrome into Mojo.

tools/valgrind/suppressions.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 # suppressions.py
 
 """Post-process Valgrind suppression matcher.
 
 Suppressions are defined as follows:
@@ skipping 27 matching lines @@
 
 
 def GetSuppressions():
   suppressions_root = path_utils.ScriptDir()
   JOIN = os.path.join
 
   result = {}
 
   supp_filename = JOIN(suppressions_root, "memcheck", "suppressions.txt")
   vg_common = ReadSuppressionsFromFile(supp_filename)
-  supp_filename = JOIN(suppressions_root, "tsan", "suppressions.txt")
-  tsan_common = ReadSuppressionsFromFile(supp_filename)
-  result['common_suppressions'] = vg_common + tsan_common
+  result['common_suppressions'] = vg_common
 
   supp_filename = JOIN(suppressions_root, "memcheck", "suppressions_linux.txt")
   vg_linux = ReadSuppressionsFromFile(supp_filename)
-  supp_filename = JOIN(suppressions_root, "tsan", "suppressions_linux.txt")
-  tsan_linux = ReadSuppressionsFromFile(supp_filename)
-  result['linux_suppressions'] = vg_linux + tsan_linux
+  result['linux_suppressions'] = vg_linux
 
   supp_filename = JOIN(suppressions_root, "memcheck", "suppressions_mac.txt")
   vg_mac = ReadSuppressionsFromFile(supp_filename)
-  supp_filename = JOIN(suppressions_root, "tsan", "suppressions_mac.txt")
-  tsan_mac = ReadSuppressionsFromFile(supp_filename)
-  result['mac_suppressions'] = vg_mac + tsan_mac
-
-  supp_filename = JOIN(suppressions_root, "tsan", "suppressions_win32.txt")
-  tsan_win = ReadSuppressionsFromFile(supp_filename)
-  result['win_suppressions'] = tsan_win
+  result['mac_suppressions'] = vg_mac
 
   supp_filename = JOIN(suppressions_root, "drmemory", "suppressions.txt")
   result['drmem_suppressions'] = ReadSuppressionsFromFile(supp_filename)
   supp_filename = JOIN(suppressions_root, "drmemory", "suppressions_full.txt")
   result['drmem_full_suppressions'] = ReadSuppressionsFromFile(supp_filename)
 
   return result
 
 
 def GlobToRegex(glob_pattern, ignore_case=False):
@@ skipping 63 matching lines @@
     if not self.stack:
       return False
     lines = [f.strip() for f in suppression_from_report]
     return self.regex.match('\n'.join(lines) + '\n') is not None
 
 
 def FilenameToTool(filename):
   """Return the name of the tool that a file is related to, or None.
 
   Example mappings:
-    tools/valgrind/tsan/suppressions.txt -> tsan
     tools/valgrind/drmemory/suppressions.txt -> drmemory
     tools/valgrind/drmemory/suppressions_full.txt -> drmemory
     tools/valgrind/memcheck/suppressions.txt -> memcheck
     tools/valgrind/memcheck/suppressions_mac.txt -> memcheck
   """
   filename = os.path.abspath(filename)
   parts = filename.split(os.sep)
   tool = parts[-2]
-  if tool in ('drmemory', 'memcheck', 'tsan'):
+  if tool in ('drmemory', 'memcheck'):
     return tool
   return None
 
 
 def ReadSuppressionsFromFile(filename):
   """Read suppressions from the given file and return them as a list"""
   tool_to_parser = {
     "drmemory":  ReadDrMemorySuppressions,
     "memcheck":  ReadValgrindStyleSuppressions,
-    "tsan":      ReadValgrindStyleSuppressions,
   }
   tool = FilenameToTool(filename)
   assert tool in tool_to_parser, (
       "unknown tool %s for filename %s" % (tool, filename))
   parse_func = tool_to_parser[tool]
 
   # Consider non-existent files to be empty.
   if not os.path.exists(filename):
     return []
 
   input_file = file(filename, 'r')
   try:
     return parse_func(input_file, filename)
   except SuppressionError:
     input_file.close()
     raise
 
 
 class ValgrindStyleSuppression(Suppression):
   """A suppression using the Valgrind syntax.
 
-  Most tools, even ones that are not Valgrind-based, use this syntax, ie
-  TSan, etc.
+  Most tools, even ones that are not Valgrind-based, use this syntax.
 
   Attributes:
     Same as Suppression.
   """
 
   def __init__(self, description, type, stack, defined_at):
-    """Creates a suppression using the Memcheck and TSan, syntax."""
+    """Creates a suppression using the Memcheck syntax."""
     regex = '{\n.*\n%s\n' % type
     for line in stack:
       if line == ELLIPSIS:
         regex += '(.*\n)*'
       else:
         regex += GlobToRegex(line)
         regex += '\n'
     regex += '(.*\n)*'
     regex += '}'
 
@@ skipping 79 matching lines @@
           ValgrindStyleSuppression(cur_descr, cur_type, cur_stack,
                                    "%s:%d" % (supp_descriptor, nline)))
       cur_descr = ''
       cur_type = ''
       cur_stack = []
       in_suppression = False
     elif not cur_descr:
       cur_descr = line
       continue
     elif not cur_type:
-      if (not line.startswith("Memcheck:") and
-          not line.startswith("ThreadSanitizer:")):
+      if not line.startswith("Memcheck:"):
         raise SuppressionError(
-            'Expected "Memcheck:TYPE" or "ThreadSanitizer:TYPE", '
-            'got "%s"' % line,
+            'Expected "Memcheck:TYPE", got "%s"' % line,
             "%s:%d" % (supp_descriptor, nline))
       supp_type = line.split(':')[1]
       if not supp_type in ["Addr1", "Addr2", "Addr4", "Addr8",
                            "Cond", "Free", "Jump", "Leak", "Overlap", "Param",
                            "Value1", "Value2", "Value4", "Value8",
-                           "Race", "UnlockNonLocked", "InvalidLock",
                            "Unaddressable", "Uninitialized"]:
         raise SuppressionError('Unknown suppression type "%s"' % supp_type,
                                "%s:%d" % (supp_descriptor, nline))
       cur_type = line
       continue
     elif re.match("^fun:.*|^obj:.*|^\.\.\.$", line):
       cur_stack.append(line.strip())
     elif len(cur_stack) == 0 and cur_type == "Memcheck:Param":
       cur_stack.append(line.strip())
     else:
       raise SuppressionError(
           '"fun:function_name" or "obj:object_file" or "..." expected',
           "%s:%d" % (supp_descriptor, nline))
   return result
 
 
 def PresubmitCheckSuppressions(supps):
   """Check a list of suppressions and return a list of SuppressionErrors.
 
   Mostly useful for separating the checking logic from the Presubmit API for
   testing.
   """
   known_supp_names = {}  # Key: name, Value: suppression.
   errors = []
   for s in supps:
     if re.search("<.*suppression.name.here>", s.description):
       # Suppression name line is
       # <insert_a_suppression_name_here> for Memcheck,
-      # <Put your suppression name here> for TSan,
       # name=<insert_a_suppression_name_here> for DrMemory
       errors.append(
           SuppressionError(
               "You've forgotten to put a suppression name like bug_XXX",
               s.defined_at))
       continue
 
     if s.description in known_supp_names:
       errors.append(
           SuppressionError(
               'Suppression named "%s" is defined more than once, '
               'see %s' % (s.description,
                           known_supp_names[s.description].defined_at),
               s.defined_at))
     else:
       known_supp_names[s.description] = s
   return errors
 
 
 def PresubmitCheck(input_api, output_api):
   """A helper function useful in PRESUBMIT.py
      Returns a list of errors or [].
   """
   sup_regex = re.compile('suppressions.*\.txt$')
   filenames = [f.AbsoluteLocalPath() for f in input_api.AffectedFiles()
                    if sup_regex.search(f.LocalPath())]
 
   errors = []
 
-  # TODO(timurrrr): warn on putting suppressions into a wrong file,
-  # e.g. TSan suppression in a memcheck file.
-
   for f in filenames:
     try:
       supps = ReadSuppressionsFromFile(f)
       errors.extend(PresubmitCheckSuppressions(supps))
     except SuppressionError as e:
       errors.append(e)
 
   return [output_api.PresubmitError(str(e)) for e in errors]
 
 
@@ skipping 241 matching lines @@
   test_memcheck_stack_4 = """{
     test
     Memcheck:Addr4
     fun:absolutly
     fun:brilliant
     obj:condition
     fun:detection
     fun:expression
   }"""
 
-  test_tsan_stack = """{
-    test
-    ThreadSanitizer:Race
-    fun:absolutly
-    fun:brilliant
-    obj:condition
-    fun:detection
-    fun:expression
-  }"""
-
-
   positive_memcheck_suppressions_1 = [
     "{\nzzz\nMemcheck:Leak\nfun:absolutly\n}",
     "{\nzzz\nMemcheck:Leak\nfun:ab*ly\n}",
     "{\nzzz\nMemcheck:Leak\nfun:absolutly\nfun:brilliant\n}",
     "{\nzzz\nMemcheck:Leak\n...\nfun:brilliant\n}",
     "{\nzzz\nMemcheck:Leak\n...\nfun:detection\n}",
     "{\nzzz\nMemcheck:Leak\nfun:absolutly\n...\nfun:detection\n}",
     "{\nzzz\nMemcheck:Leak\nfun:ab*ly\n...\nfun:detection\n}",
     "{\nzzz\nMemcheck:Leak\n...\nobj:condition\n}",
     "{\nzzz\nMemcheck:Leak\n...\nobj:condition\nfun:detection\n}",
@@ skipping 20 matching lines @@
   ]
 
   positive_memcheck_suppressions_4 = [
     "{\nzzz\nMemcheck:Addr4\nfun:absolutly\n}",
     "{\nzzz\nMemcheck:Unaddressable\nfun:absolutly\n}",
     "{\nzzz\nMemcheck:Addr4\nfun:absolutly\nfun:brilliant\n}",
     "{\nzzz\nMemcheck:Unaddressable\n...\nfun:brilliant\n}",
     "{\nzzz\nMemcheck:Addr4\n...\nfun:detection\n}",
   ]
 
-  positive_tsan_suppressions = [
-    "{\nzzz\nThreadSanitizer:Race\n...\nobj:condition\n}",
-    "{\nzzz\nThreadSanitizer:Race\nfun:absolutly\n}",
-  ]
-
   negative_memcheck_suppressions_1 = [
     "{\nzzz\nMemcheck:Leak\nfun:abnormal\n}",
     "{\nzzz\nMemcheck:Leak\nfun:ab*liant\n}",
     "{\nzzz\nMemcheck:Leak\nfun:brilliant\n}",
     "{\nzzz\nMemcheck:Leak\nobj:condition\n}",
     "{\nzzz\nMemcheck:Addr8\nfun:brilliant\n}",
   ]
 
   negative_memcheck_suppressions_2 = [
     "{\nzzz\nMemcheck:Cond\nfun:abnormal\n}",
@@ skipping 18 matching lines @@
     "{\nzzz\nMemcheck:Addr1\nfun:abnormal\n}",
     "{\nzzz\nMemcheck:Addr4\nfun:abnormal\n}",
     "{\nzzz\nMemcheck:Unaddressable\nfun:abnormal\n}",
     "{\nzzz\nMemcheck:Addr1\nfun:absolutly\n}",
     "{\nzzz\nMemcheck:Addr2\nfun:ab*liant\n}",
     "{\nzzz\nMemcheck:Value4\nfun:brilliant\n}",
     "{\nzzz\nMemcheck:Leak\nobj:condition\n}",
     "{\nzzz\nMemcheck:Addr8\nfun:brilliant\n}",
   ]
 
-  negative_tsan_suppressions = [
-    "{\nzzz\nThreadSanitizer:Leak\nfun:absolutly\n}",
-    "{\nzzz\nThreadSanitizer:Race\nfun:brilliant\n}",
-  ]
-
   TestStack(test_memcheck_stack_1,
             positive_memcheck_suppressions_1,
             negative_memcheck_suppressions_1)
   TestStack(test_memcheck_stack_2,
             positive_memcheck_suppressions_2,
             negative_memcheck_suppressions_2)
   TestStack(test_memcheck_stack_3,
             positive_memcheck_suppressions_3,
             negative_memcheck_suppressions_3)
   TestStack(test_memcheck_stack_4,
             positive_memcheck_suppressions_4,
             negative_memcheck_suppressions_4)
-  TestStack(test_tsan_stack, positive_tsan_suppressions,
-            negative_tsan_suppressions)
 
   # TODO(timurrrr): add TestFailPresubmit tests.
 
   ### DrMemory self tests.
 
   # http://crbug.com/96010 suppression.
   stack_96010 = """{
     UNADDRESSABLE ACCESS
     name=<insert_a_suppression_name_here>
     *!TestingProfile::FinishInit
@@ skipping 170 matching lines @@
   bad_stack_frame = """
     UNADDRESSABLE ACCESS
     name=http://crbug.com/1234
     fun:memcheck_style_frame
   """
   TestFailPresubmit(bad_stack_frame, 'Unexpected stack frame pattern',
                     suppression_parser=ReadDrMemorySuppressions)
 
   # Test FilenameToTool.
   filenames_to_tools = {
-    "tools/valgrind/tsan/suppressions.txt": "tsan",
     "tools/valgrind/drmemory/suppressions.txt": "drmemory",
     "tools/valgrind/drmemory/suppressions_full.txt": "drmemory",
     "tools/valgrind/memcheck/suppressions.txt": "memcheck",
     "tools/valgrind/memcheck/suppressions_mac.txt": "memcheck",
     "asdf/tools/valgrind/memcheck/suppressions_mac.txt": "memcheck",
     "foo/bar/baz/tools/valgrind/memcheck/suppressions_mac.txt": "memcheck",
     "foo/bar/baz/tools/valgrind/suppressions.txt": None,
     "tools/valgrind/suppressions.txt": None,
   }
   for (filename, expected_tool) in filenames_to_tools.items():
@@ skipping 34 matching lines @@
               "instruction=test 0x08(%eax) $0x01\n"
               "ntdll.dll!*\n"
               "*!foo\n")
   assert str(supp) == supp_str, (
       "str(supp) != supp_str:\nleft: %s\nright: %s" % (str(supp), supp_str))
 
 
 if __name__ == '__main__':
   SelfTest()
   print 'PASS'