| # 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. |
| |
| """Utility functions for Windows builds. |
| |
| This file is copied to the build directory as part of toolchain setup and |
| is used to set up calls to tools used by the build that need wrappers. |
| """ |
| |
| import os |
| import re |
| import shutil |
| import subprocess |
| import stat |
| import string |
| import sys |
| |
| # tool_wrapper.py doesn't get invoked through python.bat so the Python bin |
| # directory doesn't get added to the path. The Python module search logic |
| # handles this fine and finds win32file.pyd. However the Windows module |
| # search logic then looks for pywintypes27.dll and other DLLs in the path and |
| # if it finds versions with a different bitness first then win32file.pyd will |
| # fail to load with a cryptic error: |
| # ImportError: DLL load failed: %1 is not a valid Win32 application. |
| if sys.platform == 'win32': |
| os.environ['PATH'] = os.path.dirname(sys.executable) + \ |
| os.pathsep + os.environ['PATH'] |
| import win32file # pylint: disable=import-error |
| |
| BASE_DIR = os.path.dirname(os.path.abspath(__file__)) |
| |
| # A regex matching an argument corresponding to the output filename passed to |
| # link.exe. |
| _LINK_EXE_OUT_ARG = re.compile('/OUT:(?P<out>.+)$', re.IGNORECASE) |
| _LINK_PDB_OUT_ARG = re.compile('/PDB:(?P<out>.+)$', re.IGNORECASE) |
| _LINK_ERROR = re.compile('.* error LNK(\d+):') |
| |
| # Retry links when this error is hit, to try to deal with crbug.com/782660 |
| _LINKER_RETRY_ERRORS = 1201 |
| # Maximum number of linker retries. |
| _LINKER_RETRIES = 3 |
| |
| def main(args): |
| exit_code = WinTool().Dispatch(args) |
| if exit_code is not None: |
| sys.exit(exit_code) |
| |
| |
| class WinTool(object): |
| """This class performs all the Windows tooling steps. The methods can either |
| be executed directly, or dispatched from an argument list.""" |
| |
| def _UseSeparateMspdbsrv(self, env, args): |
| """Allows to use a unique instance of mspdbsrv.exe per linker instead of a |
| shared one.""" |
| if len(args) < 1: |
| raise Exception("Not enough arguments") |
| |
| if args[0] != 'link.exe': |
| return |
| |
| # Use the output filename passed to the linker to generate an endpoint name |
| # for mspdbsrv.exe. |
| endpoint_name = None |
| for arg in args: |
| m = _LINK_EXE_OUT_ARG.match(arg) |
| if m: |
| endpoint_name = re.sub(r'\W+', '', |
| '%s_%d' % (m.group('out'), os.getpid())) |
| break |
| |
| if endpoint_name is None: |
| return |
| |
| # Adds the appropriate environment variable. This will be read by link.exe |
| # to know which instance of mspdbsrv.exe it should connect to (if it's |
| # not set then the default endpoint is used). |
| env['_MSPDBSRV_ENDPOINT_'] = endpoint_name |
| |
| def Dispatch(self, args): |
| """Dispatches a string command to a method.""" |
| if len(args) < 1: |
| raise Exception("Not enough arguments") |
| |
| method = "Exec%s" % self._CommandifyName(args[0]) |
| return getattr(self, method)(*args[1:]) |
| |
| def _CommandifyName(self, name_string): |
| """Transforms a tool name like recursive-mirror to RecursiveMirror.""" |
| return name_string.title().replace('-', '') |
| |
| def _GetEnv(self, arch): |
| """Gets the saved environment from a file for a given architecture.""" |
| # The environment is saved as an "environment block" (see CreateProcess |
| # and msvs_emulation for details). We convert to a dict here. |
| # Drop last 2 NULs, one for list terminator, one for trailing vs. separator. |
| pairs = open(arch).read()[:-2].split('\0') |
| kvs = [item.split('=', 1) for item in pairs] |
| return dict(kvs) |
| |
| def ExecDeleteFile(self, path): |
| """Simple file delete command.""" |
| if os.path.exists(path): |
| os.unlink(path) |
| |
| def ExecRecursiveMirror(self, source, dest): |
| """Emulation of rm -rf out && cp -af in out.""" |
| if os.path.exists(dest): |
| if os.path.isdir(dest): |
| def _on_error(fn, path, dummy_excinfo): |
| # The operation failed, possibly because the file is set to |
| # read-only. If that's why, make it writable and try the op again. |
| if not os.access(path, os.W_OK): |
| os.chmod(path, stat.S_IWRITE) |
| fn(path) |
| shutil.rmtree(dest, onerror=_on_error) |
| else: |
| if not os.access(dest, os.W_OK): |
| # Attempt to make the file writable before deleting it. |
| os.chmod(dest, stat.S_IWRITE) |
| os.unlink(dest) |
| |
| if os.path.isdir(source): |
| shutil.copytree(source, dest) |
| else: |
| shutil.copy2(source, dest) |
| # Try to diagnose crbug.com/741603 |
| if not os.path.exists(dest): |
| raise Exception("Copying of %s to %s failed" % (source, dest)) |
| |
| def ExecLinkWrapper(self, arch, use_separate_mspdbsrv, *args): |
| """Filter diagnostic output from link that looks like: |
| ' Creating library ui.dll.lib and object ui.dll.exp' |
| This happens when there are exports from the dll or exe. |
| """ |
| env = self._GetEnv(arch) |
| if use_separate_mspdbsrv == 'True': |
| self._UseSeparateMspdbsrv(env, args) |
| if sys.platform == 'win32': |
| args = list(args) # *args is a tuple by default, which is read-only. |
| args[0] = args[0].replace('/', '\\') |
| # https://docs.python.org/2/library/subprocess.html: |
| # "On Unix with shell=True [...] if args is a sequence, the first item |
| # specifies the command string, and any additional items will be treated as |
| # additional arguments to the shell itself. That is to say, Popen does the |
| # equivalent of: |
| # Popen(['/bin/sh', '-c', args[0], args[1], ...])" |
| # For that reason, since going through the shell doesn't seem necessary on |
| # non-Windows don't do that there. |
| pdb_name = None |
| pe_name = None |
| for arg in args: |
| m = _LINK_PDB_OUT_ARG.match(arg) |
| if m: |
| pdb_name = m.group('out') |
| m = _LINK_EXE_OUT_ARG.match(arg) |
| if m: |
| pe_name = m.group('out') |
| for retry_count in range(_LINKER_RETRIES): |
| retry = False |
| link = subprocess.Popen(args, shell=sys.platform == 'win32', env=env, |
| stdout=subprocess.PIPE, stderr=subprocess.STDOUT) |
| # Read output one line at a time as it shows up to avoid OOM failures when |
| # GBs of output is produced. |
| for line in link.stdout: |
| if (not line.startswith(' Creating library ') and |
| not line.startswith('Generating code') and |
| not line.startswith('Finished generating code')): |
| m = _LINK_ERROR.match(line) |
| if m: |
| error_code = int(m.groups()[0]) |
| if error_code == _LINKER_RETRY_ERRORS: |
| print 'Retrying link due to error %d' % error_code |
| if pdb_name: |
| shutil.copyfile(pdb_name, pdb_name + 'failure_backup') |
| retry = True |
| print line, |
| result = link.wait() |
| if not retry: |
| break |
| if result == 0 and sys.platform == 'win32': |
| # Flush the file buffers to try to work around a Windows 10 kernel bug, |
| # https://crbug.com/644525 |
| output_handle = win32file.CreateFile(pe_name, win32file.GENERIC_WRITE, |
| 0, None, win32file.OPEN_EXISTING, 0, 0) |
| win32file.FlushFileBuffers(output_handle) |
| output_handle.Close() |
| return result |
| |
| def ExecAsmWrapper(self, arch, *args): |
| """Filter logo banner from invocations of asm.exe.""" |
| env = self._GetEnv(arch) |
| popen = subprocess.Popen(args, shell=True, env=env, |
| stdout=subprocess.PIPE, stderr=subprocess.STDOUT) |
| out, _ = popen.communicate() |
| for line in out.splitlines(): |
| # Split to avoid triggering license checks: |
| if (not line.startswith('Copy' + 'right (C' + |
| ') Microsoft Corporation') and |
| not line.startswith('Microsoft (R) Macro Assembler') and |
| not line.startswith(' Assembling: ') and |
| line): |
| print line |
| return popen.returncode |
| |
| def ExecRcWrapper(self, arch, *args): |
| """Converts .rc files to .res files.""" |
| env = self._GetEnv(arch) |
| |
| # We run two resource compilers: |
| # 1. A custom one at build/toolchain/win/rc/rc.py which can run on |
| # non-Windows, and which has /showIncludes support so we can track |
| # dependencies (e.g. on .ico files) of .rc files. |
| # 2. On Windows, regular Microsoft rc.exe, to make sure rc.py produces |
| # bitwise identical output. |
| |
| # 1. Run our rc.py. |
| # Also pass /showIncludes to track dependencies of .rc files. |
| args = list(args) |
| rcpy_args = args[:] |
| rcpy_args[0:1] = [sys.executable, os.path.join(BASE_DIR, 'rc', 'rc.py')] |
| rcpy_res_output = rcpy_args[-2] |
| assert rcpy_res_output.startswith('/fo') |
| assert rcpy_res_output.endswith('.res') |
| rc_res_output = rcpy_res_output + '_ms_rc' |
| args[-2] = rc_res_output |
| rcpy_args.append('/showIncludes') |
| rc_exe_exit_code = subprocess.call(rcpy_args, env=env) |
| if rc_exe_exit_code == 0: |
| # Since tool("rc") can't have deps, add deps on this script and on rc.py |
| # and its deps here, so that rc edges become dirty if rc.py changes. |
| print 'Note: including file: ../../build/toolchain/win/tool_wrapper.py' |
| print 'Note: including file: ../../build/toolchain/win/rc/rc.py' |
| print 'Note: including file: ../../build/toolchain/win/rc/linux64/rc.sha1' |
| print 'Note: including file: ../../build/toolchain/win/rc/mac/rc.sha1' |
| print 'Note: including file: ../../build/toolchain/win/rc/win/rc.exe.sha1' |
| |
| # 2. Run Microsoft rc.exe. |
| if sys.platform == 'win32' and rc_exe_exit_code == 0: |
| popen = subprocess.Popen(args, shell=True, env=env, |
| stdout=subprocess.PIPE, stderr=subprocess.STDOUT) |
| out, _ = popen.communicate() |
| # Filter logo banner from invocations of rc.exe. Older versions of RC |
| # don't support the /nologo flag. |
| for line in out.splitlines(): |
| if (not line.startswith('Microsoft (R) Windows (R) Resource Compiler') |
| and not line.startswith('Copy' + 'right (C' + |
| ') Microsoft Corporation') |
| and line): |
| print line |
| rc_exe_exit_code = popen.returncode |
| # Assert Microsoft rc.exe and rc.py produced identical .res files. |
| if rc_exe_exit_code == 0: |
| import filecmp |
| # Strip "/fo" prefix. |
| assert filecmp.cmp(rc_res_output[3:], rcpy_res_output[3:]) |
| return rc_exe_exit_code |
| |
| def ExecActionWrapper(self, arch, rspfile, *dirname): |
| """Runs an action command line from a response file using the environment |
| for |arch|. If |dirname| is supplied, use that as the working directory.""" |
| env = self._GetEnv(arch) |
| # TODO(scottmg): This is a temporary hack to get some specific variables |
| # through to actions that are set after GN-time. http://crbug.com/333738. |
| for k, v in os.environ.iteritems(): |
| if k not in env: |
| env[k] = v |
| args = open(rspfile).read() |
| dirname = dirname[0] if dirname else None |
| return subprocess.call(args, shell=True, env=env, cwd=dirname) |
| |
| |
| if __name__ == '__main__': |
| sys.exit(main(sys.argv[1:])) |