Generate, merge, and embed manifest when doing split_link

tools/win/split_link/split_link.py

 # Copyright 2013 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.
 
 """Takes the same arguments as Windows link.exe, and a definition of libraries
 to split into subcomponents. Does multiple passes of link.exe invocation to
 determine exports between parts and generates .def and import libraries to
 cause symbols to be available to other parts."""
 
 import _winreg
@@ skipping 31 matching lines @@
     ref = ctypes.c_wchar_p * size.value
     raw = ref.from_address(ptr)
     args = [arg for arg in raw]
   finally:
     ctypes.windll.kernel32.LocalFree(ptr)
 
   inputs = []
   flags = []
   for arg in args:
     lower_arg = arg.lower()
-    # We'll be replacing this ourselves.
+    # We'll be replacing these ourselves.
     if lower_arg.startswith('/out:'):
       continue
+    if lower_arg.startswith('/manifestfile:'):
+      continue
     if (not lower_arg.startswith('/') and
         lower_arg.endswith(('.obj', '.lib', '.res'))):
       inputs.append(arg)
     else:
       flags.append(arg)
 
   return flags, inputs
 
 
-def GetOriginalLinkerPath():
+def GetRegistryValue(subkey):
   try:
     val = _winreg.QueryValue(_winreg.HKEY_CURRENT_USER,
-                             'Software\\Chromium\\split_link_installed')
+                             'Software\\Chromium\\' + subkey)
     if os.path.exists(val):
       return val
   except WindowsError:
     pass
 
-  raise SystemExit("Couldn't read linker location from registry")
+  raise SystemExit("Couldn't read from registry")
+
+
+def GetOriginalLinkerPath():
+  return GetRegistryValue('split_link_installed')
+
+
+def GetMtPath():
+  return GetRegistryValue('split_link_mt_path')
 
 
 def PartFor(input_file, description_parts, description_all):
   """Determines which part a given link input should be put into (or all)."""
   # Check if it should go in all parts.
   input_file = input_file.lower()
   if any(re.search(spec, input_file) for spec in description_all):
     return -1
   # Or pick which particular one it belongs in.
   for i, spec_list in enumerate(description_parts):
@@ skipping 27 matching lines @@
       mo = regex.search(line)
       if mo:
         if strip_leading_underscore:
           result.add(mo.group(1)[1:])
         else:
           result.add(mo.group(1))
         break
 
   mo = re.search(r'fatal error LNK1120: (\d+) unresolved externals', output)
   # Make sure we have the same number that the linker thinks we have.
-  assert mo or not result
+  if mo is None and result:
+    raise SystemExit(output)
   if len(result) != int(mo.group(1)):
     print output
     print 'Expecting %d, got %d' % (int(mo.group(1)), len(result))
   assert len(result) == int(mo.group(1))
   return sorted(result)
 
 
 def AsCommandLineArgs(items):
   """Intended for output to a response file. Quotes all arguments."""
   return '\n'.join('"' + x + '"' for x in items)
 
 
 def OutputNameForIndex(index):
   """Gets the final output DLL name, given a zero-based index."""
   if index == 0:
     return "chrome.dll"
   else:
     return 'chrome%d.dll' % index
 
 
+def ManifestNameForIndex(index):
+  return OutputNameForIndex(index) + '.intermediate.manifest'
+
+
 def RunLinker(flags, index, inputs, phase):
   """Invokes the linker and returns the stdout, returncode and target name."""
   rspfile = 'part%d_%s.rsp' % (index, phase)
   with open(rspfile, 'w') as f:
     print >> f, AsCommandLineArgs(inputs)
     print >> f, AsCommandLineArgs(flags)
     output_name = OutputNameForIndex(index)
+    manifest_name = ManifestNameForIndex(index)
     print >> f, '/ENTRY:ChromeEmptyEntry@12'
     print >> f, '/OUT:' + output_name
+    print >> f, '/MANIFESTFILE:' + manifest_name
   # Log('[[[\n' + open(rspfile).read() + '\n]]]')
   link_exe = GetOriginalLinkerPath()
   popen = subprocess.Popen([link_exe, '@' + rspfile], stdout=subprocess.PIPE)
   stdout, _ = popen.communicate()
   return stdout, popen.returncode, output_name
 
 
 def GenerateDefFiles(unresolved_by_part):
   """Given a list of unresolved externals, generates a .def file that will
   cause all those symbols to be exported."""
@@ skipping 85 matching lines @@
   for i in range(5):
     Log('--- starting pass %d' % i)
     ok, dlls, unresolved_by_part = AttemptLink(
         flags, inputs_by_part, unresolved_by_part, deffiles, import_libs)
     if ok:
       break
     deffiles = GenerateDefFiles(unresolved_by_part)
     import_libs = BuildImportLibs(flags, inputs_by_part, deffiles)
   else:
     return 1
+
+  mt_exe = GetMtPath()
+  for i, dll in enumerate(dlls):
+    Log('embedding manifest in %s' % dll)
+    args = [mt_exe, '-nologo', '-manifest']
+    args.append(ManifestNameForIndex(i))
+    args.append(description['manifest'])
+    args.append('-outputresource:%s;2' % dll)
+    subprocess.check_call(args)
+
   Log('built %r' % dlls)
 
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main())