| |
| import json |
| import os |
| import subprocess |
| |
| DRY_RUN = False |
| |
| |
| def br_call(args): |
| if DRY_RUN: |
| print('DRY RUN: ' + ' '.join(args)) |
| return 0 |
| return subprocess.call(args, stdout=open('/dev/null'), stderr=open('/dev/null')) |
| |
| |
| class SwiftTools(object): |
| """A utility class that enables users to easily find sil-tools without needing |
| to constantly reform paths to the build directory. Also provides safety by |
| asserting if one of the tools does not exist at the specified path""" |
| |
| def __init__(self, swift_build_dir): |
| self.swift_build_dir = swift_build_dir |
| |
| def _get_tool(self, name): |
| path = os.path.join(self.swift_build_dir, 'bin', name) |
| if not os.access(path, os.F_OK): |
| error_msg = "Error! {} does not exist at: {}".format(name, path) |
| raise RuntimeError(error_msg) |
| return path |
| |
| @property |
| def sil_nm(self): |
| """Return the path to sil-nm in the specified swift build directory. Throws a |
| runtime error if the tool does not exist""" |
| return self._get_tool('sil-nm') |
| |
| @property |
| def swiftc(self): |
| """Return the path to swiftc in the specified swift build directory. Throws a |
| runtime error if the tool does not exist""" |
| return self._get_tool('swiftc') |
| |
| @property |
| def sil_opt(self): |
| """Return the path to sil-opt in the specified swift build directory. Throws a |
| runtime error if the tool does not exist""" |
| return self._get_tool('sil-opt') |
| |
| @property |
| 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') |
| |
| @property |
| def sil_passpipeline_dumper(self): |
| """Return the path to sil-passpipeline-dumper in the specified swift build |
| directory. Throws a runtime error if the tool does not exist |
| |
| """ |
| return self._get_tool('sil-passpipeline-dumper') |
| |
| |
| def maybe_abspath(x): |
| if x is None: |
| return x |
| return os.path.abspath(x) |
| |
| class SILOptInvoker(object): |
| |
| def __init__(self, args, tools, early_passes, extra_args): |
| self.tools = tools |
| 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 |
| self.extra_args = extra_args |
| |
| # Start by creating our workdir if necessary |
| subprocess.check_call(["mkdir", "-p", self.work_dir]) |
| |
| # Then copy our input file into the work dir |
| base_input_file = os.path.basename(args.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._invoke(args.input_file, self.get_suffixed_filename('initial'), |
| []) |
| self.input_file = self.get_suffixed_filename('initial+early') |
| |
| # Finally, run the initial sil-opt invocation running the |
| # early-passes. We will not run them again. |
| self._invoke(self.get_suffixed_filename('initial'), |
| self.input_file, |
| early_passes) |
| |
| 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) |
| |
| @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 _invoke(self, input_file, output_file, passes): |
| base_args = self.base_args |
| base_args.extend([ |
| input_file, |
| '-o', output_file]) |
| base_args.extend(self.extra_args) |
| base_args.extend(passes) |
| return br_call(base_args) |
| |
| def invoke_with_passlist(self, output_filename, passes): |
| return self._invoke(self.input_file, output_filename, passes) |
| |
| |
| def get_silopt_invoker(args): |
| tools = SwiftTools(args.swift_build_dir) |
| |
| passes = [] |
| if len(args.pass_list) == 0: |
| json_data = json.loads(subprocess.check_output( |
| [tools.sil_passpipeline_dumper, '-Performance'])) |
| passes = sum((p[2:] for p in json_data if p[0] != 'EarlyModulePasses'), []) |
| passes = ['-' + x[1] for x in passes] |
| else: |
| passes = ['-' + x for x in args.pass_list] |
| |
| # We assume we have an early module passes that runs until fix point and |
| # that is strictly not what is causing the issue. |
| # |
| # Everything else runs one iteration. |
| early_module_passes = [p[2:] for p in json_data |
| if p[0] == 'EarlyModulePasses'][0] |
| early_module_passes = ['-' + x[1] for x in early_module_passes] |
| |
| return SILOptInvoker(args, tools, early_module_passes) |
