Support import libraries for Windows ninja

pylib/gyp/generator/ninja.py

 # Copyright (c) 2012 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import copy
 import gyp
 import gyp.common
 import gyp.msvs_emulation
 import gyp.system_test
 import gyp.xcode_emulation
@@ skipping 100 matching lines @@
     # File representing whether any input dependencies necessary for
     # dependent actions have completed.
     self.preaction_stamp = None
     # File representing whether any input dependencies necessary for
     # dependent compiles have completed.
     self.precompile_stamp = None
     # File representing the completion of actions/rules/copies, if any.
     self.actions_stamp = None
     # Path to the output of the link step, if any.
     self.binary = None
+    # Path to the import library (output by the link step), if any. Used for
+    # Windows DLLs.
+    self.import_library = None
     # Path to the file representing the completion of building the bundle,
     # if any.
     self.bundle = None
 
   def Linkable(self):
     """Return true if this is a target that can be linked against."""
     return self.type in ('static_library', 'shared_library')
 
   def PreActionInput(self):
     """Return the path, if any, that should be used as a dependency of
@@ skipping 525 matching lines @@
         'cc': 'cflags_pch_cc',
         'm': 'cflags_pch_objc',
         'mm': 'cflags_pch_objcc',
       }[lang]
 
       cmd = { 'c': 'cc', 'cc': 'cxx', 'm': 'objc', 'mm': 'objcxx', }.get(lang)
       self.ninja.build(gch, cmd, input, variables=[(var_name, lang_flag)])
 
 
   def WriteLink(self, spec, config_name, config, link_deps):
-    """Write out a link step.  Returns the path to the output."""
+    """Write out a link step.  Returns the path to the output(s)."""
 
     command = {
       'executable':      'link',
       'loadable_module': 'solink_module',
       'shared_library':  'solink',
     }[spec['type']]
 
     implicit_deps = set()
 
     if 'dependencies' in spec:
       # Two kinds of dependencies:
       # - Linkable dependencies (like a .a or a .so): add them to the link line.
       # - Non-linkable dependencies (like a rule that generates a file
       #   and writes a stamp file): add them to implicit_deps
       extra_link_deps = set()
       for dep in spec['dependencies']:
         target = self.target_outputs.get(dep)
         if not target:
           continue
         linkable = target.Linkable()
         if linkable:
-          extra_link_deps.add(target.binary)
+          extra_link_deps.add(target.import_library or target.binary)

[Evan Martin, 2012/02/21 18:10:47]

Would it make more sense for target.Linkable() to just return the correct thing
or None here?

[Nico, 2012/02/21 18:20:54]

Why is this needed? It looks like the build step will create both
target.import_library and target.binary, so the link dep on target.binary should
suffice, right?

[Evan Martin, 2012/02/21 18:23:45]

extra_link_deps are specifically the files that need to be on the command line
to the linker.  So here he's passing foobar.lib instead of foobar.dll because
that's what the linker wants.

[Nico, 2012/02/21 18:27:40]

I see. Is it possible to make target.binary the import library on windows then?

 
         final_output = target.FinalOutput()
         if not linkable or final_output != target.binary:
           implicit_deps.add(final_output)
 
       link_deps.extend(list(extra_link_deps))
 
     extra_bindings = []
     if self.is_mac_bundle:
       output = self.ComputeMacBundleBinaryOutput()
@@ skipping 13 matching lines @@
                                                   ldflags)))
 
     libraries = gyp.common.uniquer(map(self.ExpandSpecial,
                                        spec.get('libraries', [])))
     if self.flavor == 'mac':
       libraries = self.xcode_settings.AdjustLibraries(libraries)
     self.WriteVariableList('libs', libraries)
 
     if command in ('solink', 'solink_module'):
       extra_bindings.append(('soname', os.path.split(output)[1]))
+      if self.flavor == 'win':
+        import_lib = output + '.lib'
+        extra_bindings.append(('dll', output))
+        extra_bindings.append(('implib', import_lib))
+        output = [output, import_lib]
 
     self.ninja.build(output, command, link_deps,
                      implicit=list(implicit_deps),
                      variables=extra_bindings)
     return output
 
   def WriteTarget(self, spec, config_name, config, link_deps, compile_deps):
     if spec['type'] == 'none':
       # TODO(evan): don't call this function for 'none' target types, as
       # it doesn't do anything, and we fake out a 'binary' with a stamp file.
       self.target.binary = compile_deps
     elif spec['type'] == 'static_library':
       self.target.binary = self.ComputeOutput(spec)
       self.ninja.build(self.target.binary, 'alink', link_deps,
                        order_only=compile_deps,
                        variables=[('postbuilds', self.GetPostbuildCommand(
                            spec, self.target.binary, self.target.binary))])
     else:
-      self.target.binary = self.WriteLink(spec, config_name, config, link_deps)
+      output = self.WriteLink(spec, config_name, config, link_deps)
+      if isinstance(output, list):
+        self.target.binary, self.target.import_library = output

[Evan Martin, 2012/02/21 18:10:47]

This makes me feel a little funny. I wonder if it'd be better to just fill in
self.target.import_library inside the WriteLink() function?  (This is fine too
if you prefer it.)

[scottmg, 2012/02/21 18:45:46]

Yeah, that would be a little tidier.

But, I have to modify output in WriteLink anyway so that
self.ninja.build(output, ...) writes both as outputs of the link step. If an exe
depends on the dll target, then it requires the .lib, so there needs to be a
build rule that outputs that.

+      else:
+        self.target.binary = output
     return self.target.binary
 
   def WriteMacBundle(self, spec, mac_bundle_depends):
     assert self.is_mac_bundle
     package_framework = spec['type'] in ('shared_library', 'loadable_module')
     output = self.ComputeMacBundleOutput()
     postbuild = self.GetPostbuildCommand(spec, output, self.target.binary,
                                          is_command_start=not package_framework)
     variables = []
     if postbuild:
@@ skipping 145 matching lines @@
 
     if 'product_dir' in spec:
       path = os.path.join(spec['product_dir'], filename)
       return self.ExpandSpecial(path)
 
     # Some products go into the output root, libraries go into shared library
     # dir, and everything else goes into the normal place.
     type_in_output_root = ['executable', 'loadable_module']
     if self.flavor == 'mac' and self.toolset == 'target':
       type_in_output_root += ['shared_library', 'static_library']
+    elif self.flavor == 'win' and self.toolset == 'target':
+      type_in_output_root += ['shared_library']

[Nico, 2012/02/21 18:20:54]

Is there a test for this?

[scottmg, 2012/02/21 18:45:46]

test/library/gyptest-shared.py

 
     if type in type_in_output_root:
       return filename
     elif type == 'shared_library':
       libdir = 'lib'
       if self.toolset != 'target':
         libdir = os.path.join('lib', '%s' % self.toolset)
       return os.path.join(libdir, filename)
     else:
       return self.GypPathToUniqueOutput(filename, qualified=False)
@@ skipping 195 matching lines @@
       command=('$ld -shared $ldflags -o $out -Wl,-soname=$soname '
                '-Wl,--start-group $in -Wl,--end-group $libs'))
     master_ninja.rule(
       'link',
       description='LINK $out',
       command=('$ld $ldflags -o $out -Wl,-rpath=\$$ORIGIN/lib '
                '-Wl,--start-group $in -Wl,--end-group $libs'))
   elif flavor == 'win':
     master_ninja.rule(
       'alink',
-      description='AR $out',
+      description='LIB $out',
       command='lib /nologo /OUT:$out $in')
     master_ninja.rule(
       'solink',
-      description='SOLINK $out',
-      command=('$ld /nologo /DLL $ldflags /OUT:$out $in $libs'))
+      description='LINK_DLL $dll',

[Evan Martin, 2012/02/21 18:10:47]

FWIW, the description is free text.  So you can use "LINK(DLL) or "LINK DLL" if
you want, underscores aren't necessary.

[scottmg, 2012/02/21 18:45:46]

Done.

+      command=('$ld /nologo /IMPLIB:$implib /DLL $ldflags /OUT:$dll $in $libs'))
     master_ninja.rule(
       'solink_module',
-      description='SOLINK(module) $out',
-      command=('$ld /nologo /DLL $ldflags /OUT:$out $in $libs'))
+      description='LINK_DLL $dll',
+      command=('$ld /nologo /IMPLIB:$implib /DLL $ldflags /OUT:$dll $in $libs'))
     master_ninja.rule(
       'link',
       description='LINK $out',
       command=('$ld /nologo $ldflags /OUT:$out $in $libs'))
   else:
     master_ninja.rule(
       'objc',
       description='OBJC $out',
       command=('$cc -MMD -MF $out.d $defines $includes $cflags $cflags_objc '
                '$cflags_pch_objc -c $in -o $out'),
@@ skipping 111 matching lines @@
 
   user_config = params.get('generator_flags', {}).get('config', None)
   if user_config:
     GenerateOutputForConfig(target_list, target_dicts, data, params,
                             user_config)
   else:
     config_names = target_dicts[target_list[0]]['configurations'].keys()
     for config_name in config_names:
       GenerateOutputForConfig(target_list, target_dicts, data, params,
                               config_name)