Merge pull request #6301 from gottesmm/sil-bug-reducer-3

Author: swift-ci

utils/bug_reducer/bug_reducer/bug_reducer.py

@@ -2,27 +2,29 @@
 
 import argparse
 
+import func_bug_reducer
+
 import opt_bug_reducer
 
 import random_bug_finder
 
 
+def add_subparser(subparsers, module, name):
+    sparser = subparsers.add_parser(name)
+    sparser.add_argument('swift_build_dir',
+                         help='Path to the swift build directory '
+                         'containing tools to use')
+    module.add_parser_arguments(sparser)
+
+
 def main():
     parser = argparse.ArgumentParser(description="""\
 A program for reducing sib/sil crashers""")
     subparsers = parser.add_subparsers()
 
-    opt_subparser = subparsers.add_parser("opt")
-    opt_subparser.add_argument('swift_build_dir',
-                               help='Path to the swift build directory '
-                               'containing tools to use')
-    opt_bug_reducer.add_parser_arguments(opt_subparser)
-
-    random_search_subparser = subparsers.add_parser("random-search")
-    random_search_subparser.add_argument('swift_build_dir',
-                                         help='Path to the swift build '
-                                         'directory containing tools to use')
-    random_bug_finder.add_parser_arguments(random_search_subparser)
+    add_subparser(subparsers, opt_bug_reducer, 'opt')
+    add_subparser(subparsers, random_bug_finder, 'random-search')
+    add_subparser(subparsers, func_bug_reducer, 'func')
 
     args = parser.parse_args()
     args.func(args)

utils/bug_reducer/bug_reducer/bug_reducer_utils.py

@@ -1,16 +1,29 @@
 
-import json
 import os
 import subprocess
 
 DRY_RUN = False
+SQUELCH_STDERR = True
+ECHO_CALLS = False
 
 
-def br_call(args):
-    if DRY_RUN:
-        print('DRY RUN: ' + ' '.join(args))
+def br_call(args, dry_run=DRY_RUN, echo=ECHO_CALLS):
+    if dry_run or echo:
+        print('BRCALL: ' + ' '.join(args))
+    if dry_run:
         return 0
-    return subprocess.call(args, stdout=open('/dev/null'), stderr=open('/dev/null'))
+    if SQUELCH_STDERR:
+        return subprocess.call(args, stdout=open('/dev/null'),
+                               stderr=open('/dev/null'))
+    else:
+        # Useful for debugging.
+        return subprocess.call(args, stdout=open('/dev/null'))
+
+
+# We use this since our squelching of stderr can hide missing file errors.
+def sanity_check_file_exists(f):
+    if not os.access(f, os.F_OK):
+        raise RuntimeError('Error! Could not find file: ' + f)
 
 
 class SwiftTools(object):
@@ -50,7 +63,7 @@ def sil_opt(self):
     def sil_func_extractor(self):
         """Return the path to sil-func-extractor in the specified swift build
 directory. Throws a runtime error if the tool does not exist."""
-        return self._get_tool('sil-opt')
+        return self._get_tool('sil-func-extractor')
 
     @property
     def sil_passpipeline_dumper(self):
@@ -67,54 +80,93 @@ def maybe_abspath(x):
     return os.path.abspath(x)
 
 
-class SILOptInvoker(object):
+class SILToolInvokerConfig(object):
 
-    def __init__(self, args, tools, extra_args):
-        self.tools = tools
+    def __init__(self, args):
         self.module_cache = args.module_cache
         self.sdk = args.sdk
         self.target = args.target
         self.resource_dir = maybe_abspath(args.resource_dir)
         self.work_dir = maybe_abspath(args.work_dir)
         self.module_name = args.module_name
+
+
+class SILToolInvoker(object):
+
+    def __init__(self, config, extra_args=None):
+        self.config = config
         self.extra_args = extra_args
 
+    @property
+    def base_args(self):
+        x = [self.tool]
+        if self.config.sdk is not None:
+            x.append("-sdk=%s" % self.config.sdk)
+        if self.config.target is not None:
+            x.append("-target=%s" % self.config.target)
+        if self.config.resource_dir is not None:
+            x.append("-resource-dir=%s" % self.config.resource_dir)
+        if self.config.module_cache is not None:
+            x.append("-module-cache-path=%s" % self.config.module_cache)
+        if self.config.module_name is not None:
+            x.append("-module-name=%s" % self.config.module_name)
+        return x
+
+    @property
+    def tool(self):
+        raise RuntimeError('Abstract Method')
+
+
+class SILConstantInputToolInvoker(SILToolInvoker):
+
+    def __init__(self, config, tools, initial_input_file, extra_args):
+        SILToolInvoker.__init__(self, config, extra_args)
+        self.tools = tools
+
         # Start by creating our workdir if necessary
-        subprocess.check_call(["mkdir", "-p", self.work_dir])
+        subprocess.check_call(["mkdir", "-p", self.config.work_dir])
 
         # Then copy our input file into the work dir
-        base_input_file = os.path.basename(args.input_file)
+        base_input_file = os.path.basename(initial_input_file)
         (base, ext) = os.path.splitext(base_input_file)
         self.base_input_file_stem = base
         self.base_input_file_ext = ".sib"
 
         # First emit an initial *.sib file. This ensures no matter if we have a
         # *.swiftmodule, *.sil, or *.sib file, we are always using *.sib.
-        self.input_file = self.get_suffixed_filename('initial')
-        self._invoke(args.input_file, [], self.input_file)
+        self.input_file = initial_input_file
+        sanity_check_file_exists(initial_input_file)
+
+    def _invoke(self, input_file, passes, output_filename):
+        raise RuntimeError('Abstract method')
+
+    @property
+    def base_args(self):
+        base_args = SILToolInvoker.base_args.fget(self)
+        base_args.append('-emit-sib')
+        return base_args
 
     def get_suffixed_filename(self, suffix):
         basename = self.base_input_file_stem + '_' + suffix
         basename += self.base_input_file_ext
-        return os.path.join(self.work_dir, basename)
+        return os.path.join(self.config.work_dir, basename)
+
+
+class SILOptInvoker(SILConstantInputToolInvoker):
+
+    def __init__(self, config, tools, input_file, extra_args):
+        SILConstantInputToolInvoker.__init__(self, config, tools, input_file,
+                                             extra_args)
+        self.input_file = self.get_suffixed_filename('initial')
+        self._invoke(input_file, [], self.input_file)
 
     @property
-    def base_args(self):
-        x = [self.tools.sil_opt, "-emit-sib"]
-        if self.sdk is not None:
-            x.append("-sdk=%s" % self.sdk)
-        if self.target is not None:
-            x.append("-target=%s" % self.target)
-        if self.resource_dir is not None:
-            x.append("-resource-dir=%s" % self.resource_dir)
-        if self.module_cache is not None:
-            x.append("-module-cache-path=%s" % self.module_cache)
-        if self.module_name is not None:
-            x.append("-module-name=%s" % self.module_name)
-        return x
+    def tool(self):
+        return self.tools.sil_opt
 
     def _cmdline(self, input_file, passes, output_file='-'):
         base_args = self.base_args
+        sanity_check_file_exists(input_file)
         base_args.extend([input_file, '-o', output_file])
         base_args.extend(self.extra_args)
         base_args.extend(passes)
@@ -129,3 +181,61 @@ def invoke_with_passlist(self, passes, output_filename):
 
     def cmdline_with_passlist(self, passes):
         return self._cmdline(self.input_file, passes)
+
+
+class SILFuncExtractorInvoker(SILConstantInputToolInvoker):
+
+    def __init__(self, config, tools, input_file):
+        SILConstantInputToolInvoker.__init__(self, config, tools, input_file,
+                                             [])
+
+    @property
+    def tool(self):
+        return self.tools.sil_func_extractor
+
+    def _cmdline(self, input_file, funclist_path, output_file='-', invert=False):
+        sanity_check_file_exists(input_file)
+        sanity_check_file_exists(funclist_path)
+        assert(isinstance(funclist_path, str))
+        base_args = self.base_args
+        base_args.extend([input_file, '-o', output_file,
+                          '-func-file=%s' % funclist_path])
+        if invert:
+            base_args.append('-invert')
+        return base_args
+
+    def _invoke(self, input_file, funclist_path, output_filename, invert=False):
+        assert(isinstance(funclist_path, str))
+        cmdline = self._cmdline(input_file, funclist_path, output_filename,
+                                invert)
+        return br_call(cmdline)
+
+    def invoke_with_functions(self, funclist_path, output_filename, invert=False):
+        assert(isinstance(funclist_path, str))
+        return self._invoke(self.input_file, funclist_path, output_filename,
+                            invert)
+
+    def cmdline_with_functions(self, funclist_path, invert=False):
+        assert(isinstance(funclist_path, str))
+        return self._cmdline(self.input_file, funclist_path, invert)
+
+
+class SILNMInvoker(SILToolInvoker):
+
+    def __init__(self, config, tools):
+        self.tools = tools
+        SILToolInvoker.__init__(self, config)
+
+    @property
+    def tool(self):
+        return self.tools.sil_nm
+
+    def get_symbols(self, input_file):
+        sanity_check_file_exists(input_file)
+        cmdline = self.base_args
+        cmdline.append(input_file)
+        output = subprocess.check_output(cmdline)
+        for l in output.split("\n")[:-1]:
+            t = tuple(l.split(" "))
+            assert(len(t) == 2)
+            yield t