3 # Copyright (c) 2012 Google Inc. All rights reserved.
4 # Use of this source code is governed by a BSD-style license that can be
5 # found in the LICENSE file.
7 """Utility functions for Windows builds.
9 These functions are executed via gyp-win-tool when using the ninja generator.
20 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
22 # A regex matching an argument corresponding to the output filename passed to
24 _LINK_EXE_OUT_ARG = re.compile('/OUT:(?P<out>.+)$', re.IGNORECASE)
28 exit_code = executor.Dispatch(args)
29 if exit_code is not None:
33 class WinTool(object):
34 """This class performs all the Windows tooling steps. The methods can either
35 be executed directly, or dispatched from an argument list."""
37 def _UseSeparateMspdbsrv(self, env, args):
38 """Allows to use a unique instance of mspdbsrv.exe per linker instead of a
41 raise Exception("Not enough arguments")
43 if args[0] != 'link.exe':
46 # Use the output filename passed to the linker to generate an endpoint name
50 m = _LINK_EXE_OUT_ARG.match(arg)
52 endpoint_name = re.sub(r'\W+', '',
53 '%s_%d' % (m.group('out'), os.getpid()))
56 if endpoint_name is None:
59 # Adds the appropriate environment variable. This will be read by link.exe
60 # to know which instance of mspdbsrv.exe it should connect to (if it's
61 # not set then the default endpoint is used).
62 env['_MSPDBSRV_ENDPOINT_'] = endpoint_name
64 def Dispatch(self, args):
65 """Dispatches a string command to a method."""
67 raise Exception("Not enough arguments")
69 method = "Exec%s" % self._CommandifyName(args[0])
70 return getattr(self, method)(*args[1:])
72 def _CommandifyName(self, name_string):
73 """Transforms a tool name like recursive-mirror to RecursiveMirror."""
74 return name_string.title().replace('-', '')
76 def _GetEnv(self, arch):
77 """Gets the saved environment from a file for a given architecture."""
78 # The environment is saved as an "environment block" (see CreateProcess
79 # and msvs_emulation for details). We convert to a dict here.
80 # Drop last 2 NULs, one for list terminator, one for trailing vs. separator.
81 pairs = open(arch).read()[:-2].split('\0')
82 kvs = [item.split('=', 1) for item in pairs]
85 def ExecStamp(self, path):
86 """Simple stamp command."""
87 open(path, 'w').close()
89 def ExecRecursiveMirror(self, source, dest):
90 """Emulation of rm -rf out && cp -af in out."""
91 if os.path.exists(dest):
92 if os.path.isdir(dest):
93 def _on_error(fn, path, excinfo):
94 # The operation failed, possibly because the file is set to
95 # read-only. If that's why, make it writable and try the op again.
96 if not os.access(path, os.W_OK):
97 os.chmod(path, stat.S_IWRITE)
99 shutil.rmtree(dest, onerror=_on_error)
101 if not os.access(dest, os.W_OK):
102 # Attempt to make the file writable before deleting it.
103 os.chmod(dest, stat.S_IWRITE)
106 if os.path.isdir(source):
107 shutil.copytree(source, dest)
109 shutil.copy2(source, dest)
111 def ExecLinkWrapper(self, arch, use_separate_mspdbsrv, *args):
112 """Filter diagnostic output from link that looks like:
113 ' Creating library ui.dll.lib and object ui.dll.exp'
114 This happens when there are exports from the dll or exe.
116 env = self._GetEnv(arch)
117 if use_separate_mspdbsrv == 'True':
118 self._UseSeparateMspdbsrv(env, args)
119 link = subprocess.Popen([args[0].replace('/', '\\')] + list(args[1:]),
122 stdout=subprocess.PIPE,
123 stderr=subprocess.STDOUT)
124 out, _ = link.communicate()
125 for line in out.splitlines():
126 if (not line.startswith(' Creating library ') and
127 not line.startswith('Generating code') and
128 not line.startswith('Finished generating code')):
130 return link.returncode
132 def ExecLinkWithManifests(self, arch, embed_manifest, out, ldcmd, resname,
133 mt, rc, intermediate_manifest, *manifests):
134 """A wrapper for handling creating a manifest resource and then executing
136 # The 'normal' way to do manifests is to have link generate a manifest
137 # based on gathering dependencies from the object files, then merge that
138 # manifest with other manifests supplied as sources, convert the merged
139 # manifest to a resource, and then *relink*, including the compiled
140 # version of the manifest resource. This breaks incremental linking, and
141 # is generally overly complicated. Instead, we merge all the manifests
142 # provided (along with one that includes what would normally be in the
143 # linker-generated one, see msvs_emulation.py), and include that into the
144 # first and only link. We still tell link to generate a manifest, but we
145 # only use that to assert that our simpler process did not miss anything.
147 'python': sys.executable,
154 'intermediate_manifest': intermediate_manifest,
155 'manifests': ' '.join(manifests),
159 subprocess.check_call(
160 '%(python)s gyp-win-tool manifest-wrapper %(arch)s %(mt)s -nologo '
161 '-manifest %(manifests)s -out:%(out)s.manifest' % variables)
162 if embed_manifest == 'True':
163 subprocess.check_call(
164 '%(python)s gyp-win-tool manifest-to-rc %(arch)s %(out)s.manifest'
165 ' %(out)s.manifest.rc %(resname)s' % variables)
166 subprocess.check_call(
167 '%(python)s gyp-win-tool rc-wrapper %(arch)s %(rc)s '
168 '%(out)s.manifest.rc' % variables)
169 add_to_ld = ' %(out)s.manifest.res' % variables
170 subprocess.check_call(ldcmd + add_to_ld)
172 # Run mt.exe on the theoretically complete manifest we generated, merging
173 # it with the one the linker generated to confirm that the linker
174 # generated one does not add anything. This is strictly unnecessary for
175 # correctness, it's only to verify that e.g. /MANIFESTDEPENDENCY was not
176 # used in a #pragma comment.
178 # Merge the intermediate one with ours to .assert.manifest, then check
179 # that .assert.manifest is identical to ours.
180 subprocess.check_call(
181 '%(python)s gyp-win-tool manifest-wrapper %(arch)s %(mt)s -nologo '
182 '-manifest %(out)s.manifest %(intermediate_manifest)s '
183 '-out:%(out)s.assert.manifest' % variables)
184 assert_manifest = '%(out)s.assert.manifest' % variables
185 our_manifest = '%(out)s.manifest' % variables
186 # Load and normalize the manifests. mt.exe sometimes removes whitespace,
187 # and sometimes doesn't unfortunately.
188 with open(our_manifest, 'rb') as our_f:
189 with open(assert_manifest, 'rb') as assert_f:
190 our_data = our_f.read().translate(None, string.whitespace)
191 assert_data = assert_f.read().translate(None, string.whitespace)
192 if our_data != assert_data:
195 sys.stderr.write('%s\n-----\n' % filename)
196 with open(filename, 'rb') as f:
197 sys.stderr.write(f.read() + '\n-----\n')
198 dump(intermediate_manifest)
200 dump(assert_manifest)
202 'Linker generated manifest "%s" added to final manifest "%s" '
204 'Were /MANIFEST switches used in #pragma statements? ' % (
205 intermediate_manifest, our_manifest, assert_manifest))
208 def ExecManifestWrapper(self, arch, *args):
209 """Run manifest tool with environment set. Strip out undesirable warning
210 (some XML blocks are recognized by the OS loader, but not the manifest
212 env = self._GetEnv(arch)
213 popen = subprocess.Popen(args, shell=True, env=env,
214 stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
215 out, _ = popen.communicate()
216 for line in out.splitlines():
217 if line and 'manifest authoring warning 81010002' not in line:
219 return popen.returncode
221 def ExecManifestToRc(self, arch, *args):
222 """Creates a resource file pointing a SxS assembly manifest.
223 |args| is tuple containing path to resource file, path to manifest file
224 and resource name which can be "1" (for executables) or "2" (for DLLs)."""
225 manifest_path, resource_path, resource_name = args
226 with open(resource_path, 'wb') as output:
227 output.write('#include <windows.h>\n%s RT_MANIFEST "%s"' % (
229 os.path.abspath(manifest_path).replace('\\', '/')))
231 def ExecMidlWrapper(self, arch, outdir, tlb, h, dlldata, iid, proxy, idl,
233 """Filter noisy filenames output from MIDL compile step that isn't
234 quietable via command line flags.
236 args = ['midl', '/nologo'] + list(flags) + [
244 env = self._GetEnv(arch)
245 popen = subprocess.Popen(args, shell=True, env=env,
246 stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
247 out, _ = popen.communicate()
248 # Filter junk out of stdout, and write filtered versions. Output we want
249 # to filter is pairs of lines that look like this:
250 # Processing C:\Program Files (x86)\Microsoft SDKs\...\include\objidl.idl
252 lines = out.splitlines()
253 prefixes = ('Processing ', '64 bit Processing ')
254 processing = set(os.path.basename(x)
255 for x in lines if x.startswith(prefixes))
257 if not line.startswith(prefixes) and line not in processing:
259 return popen.returncode
261 def ExecAsmWrapper(self, arch, *args):
262 """Filter logo banner from invocations of asm.exe."""
263 env = self._GetEnv(arch)
264 popen = subprocess.Popen(args, shell=True, env=env,
265 stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
266 out, _ = popen.communicate()
267 for line in out.splitlines():
268 if (not line.startswith('Copyright (C) Microsoft Corporation') and
269 not line.startswith('Microsoft (R) Macro Assembler') and
270 not line.startswith(' Assembling: ') and
273 return popen.returncode
275 def ExecRcWrapper(self, arch, *args):
276 """Filter logo banner from invocations of rc.exe. Older versions of RC
277 don't support the /nologo flag."""
278 env = self._GetEnv(arch)
279 popen = subprocess.Popen(args, shell=True, env=env,
280 stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
281 out, _ = popen.communicate()
282 for line in out.splitlines():
283 if (not line.startswith('Microsoft (R) Windows (R) Resource Compiler') and
284 not line.startswith('Copyright (C) Microsoft Corporation') and
287 return popen.returncode
289 def ExecActionWrapper(self, arch, rspfile, *dir):
290 """Runs an action command line from a response file using the environment
291 for |arch|. If |dir| is supplied, use that as the working directory."""
292 env = self._GetEnv(arch)
293 # TODO(scottmg): This is a temporary hack to get some specific variables
294 # through to actions that are set after gyp-time. http://crbug.com/333738.
295 for k, v in os.environ.iteritems():
298 args = open(rspfile).read()
299 dir = dir[0] if dir else None
300 return subprocess.call(args, shell=True, env=env, cwd=dir)
302 def ExecClCompile(self, project_dir, selected_files):
303 """Executed by msvs-ninja projects when the 'ClCompile' target is used to
304 build selected C/C++ files."""
305 project_dir = os.path.relpath(project_dir, BASE_DIR)
306 selected_files = selected_files.split(';')
307 ninja_targets = [os.path.join(project_dir, filename) + '^^'
308 for filename in selected_files]
310 cmd.extend(ninja_targets)
311 return subprocess.call(cmd, shell=True, cwd=BASE_DIR)
313 if __name__ == '__main__':
314 sys.exit(main(sys.argv[1:]))