make: Reapply r928 and r918.

pylib/gyp/generator/make.py

 #!/usr/bin/python
 
 # Copyright (c) 2011 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.
 
 # Notes:
 #
 # This is all roughly based on the Makefile system used by the Linux
 # kernel, but is a non-recursive make -- we put the entire dependency
@@ skipping 189 matching lines @@
 quiet_cmd_copy = COPY $@
 # send stderr to /dev/null to ignore messages when linking directories.
 cmd_copy = ln -f $< $@ 2>/dev/null || cp -af $< $@
 
 # Due to circular dependencies between libraries :(, we wrap the
 # special "figure out circular dependencies" flags around the entire
 # input list during linking.
 quiet_cmd_link = LINK($(TOOLSET)) $@
 cmd_link = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ -Wl,--start-group $(filter-out FORCE_DO_CMD, $^) -Wl,--end-group $(LIBS)
 
-# Shared-object link (for generating .so).
-# Set SONAME to the library filename so our binaries don't reference the local,
-# absolute paths used on the link command-line.
-# TODO: perhaps this can share with the LINK command above?
+# We support two kinds of shared objects (.so):
+# 1) shared_library, which is just bundling together many dependent libraries
+# into a link line.
+# 2) loadable_module, which is generating a module intended for dlopen().
+#
+# They differ only slightly:
+# In the former case, we want to package all dependent code into the .so.
+# In the latter case, we want to package just the API exposed by the
+# outermost module.
+# This means shared_library uses --whole-archive, while loadable_module doesn't.
+# (Note that --whole-archive is incompatible with the --start-group used in
+# normal linking.)
+
+# Other shared-object link notes:
+# - Set SONAME to the library filename so our binaries don't reference
+# the local, absolute paths used on the link command-line.
 quiet_cmd_solink = SOLINK($(TOOLSET)) $@
-cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--start-group $(filter-out FORCE_DO_CMD, $^) -Wl,--end-group $(LIBS)
+cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--whole-archive $(filter-out FORCE_DO_CMD, $^) -Wl,--no-whole-archive $(LIBS)
+
+quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@
+cmd_solink_module = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--start-group $(filter-out FORCE_DO_CMD, $^) -Wl,--end-group $(LIBS)
 """
+
 r"""
 # Define an escape_quotes function to escape single quotes.
 # This allows us to handle quotes properly as long as we always use
 # use single quotes and escape_quotes.
 escape_quotes = $(subst ','\'',$(1))
 # This comment is here just to include a ' to unconfuse syntax highlighting.
 # Define an escape_vars function to escape '$' variable syntax.
 # This allows us to read/write command lines with shell variables (e.g.
 # $LD_LIBRARY_PATH), without triggering make substitution.
 escape_vars = $(subst $$,$$$$,$(1))
@@ skipping 261 matching lines @@
   """Convert a path to its source directory form."""
   if '$(' in path:
     return path
   if os.path.isabs(path):
     return path
   return srcdir_prefix + path
 
 
 # Map from qualified target to path to output.
 target_outputs = {}
-# Map from qualified target to a list of all linker dependencies,
-# transitively expanded.
-# Used in building shared-library-based executables.
+# Map from qualified target to any linkable output.  A subset
+# of target_outputs.  E.g. when mybinary depends on liba, we want to
+# include liba in the linker line; when otherbinary depends on
+# mybinary, we just want to build mybinary first.
 target_link_deps = {}
 
 
 class MakefileWriter:
   """MakefileWriter packages up the writing of one target-specific foobar.mk.
 
   Its only real entry point is Write(), and is mostly used for namespacing.
   """
 
   def __init__(self, generator_flags):
@@ skipping 84 matching lines @@
         self.WriteLn('# End of this set of suffix rules')
 
 
     self.WriteTarget(spec, configs, deps,
                      extra_link_deps + link_deps, extra_outputs, part_of_all)
 
     # Update global list of target outputs, used in dependency tracking.
     target_outputs[qualified_target] = install_path
 
     # Update global list of link dependencies.
-    if self.type == 'static_library':
-      target_link_deps[qualified_target] = [self.output]
-    elif self.type == 'shared_library':
-      # Anyone that uses us transitively depend on all of our link
-      # dependencies.
-      target_link_deps[qualified_target] = [self.output] + link_deps
+    if self.type in ('static_library', 'shared_library'):
+      target_link_deps[qualified_target] = self.output
 
     # Currently any versions have the same effect, but in future the behavior
     # could be different.
     if self.generator_flags.get('android_ndk_version', None):
       self.WriteAndroidNdkModuleRule(self.target, all_sources, link_deps)
 
     self.fp.close()
 
 
   def WriteSubMake(self, output_filename, makefile_path, targets, build_dir):
@@ skipping 341 matching lines @@
     filenames that will need to be put in front of make for either
     building (deps) or linking (link_deps).
     """
     deps = []
     link_deps = []
     if 'dependencies' in spec:
       deps.extend([target_outputs[dep] for dep in spec['dependencies']
                    if target_outputs[dep]])
       for dep in spec['dependencies']:
         if dep in target_link_deps:
-          link_deps.extend(target_link_deps[dep])
+          link_deps.append(target_link_deps[dep])
       deps.extend(link_deps)
       # TODO: It seems we need to transitively link in libraries (e.g. -lfoo)?
       # This hack makes it work:
       # link_deps.extend(spec.get('libraries', []))
     return (gyp.common.uniquer(deps), gyp.common.uniquer(link_deps))
 
 
   def WriteTarget(self, spec, configs, deps, link_deps, extra_outputs,
                   part_of_all):
     """Write Makefile code to produce the final target of the gyp spec.
@@ skipping 25 matching lines @@
         # Remove duplicate entries
         libraries = gyp.common.uniquer(libraries)
       self.WriteList(libraries, 'LIBS')
       self.WriteLn('%s: GYP_LDFLAGS := $(LDFLAGS_$(BUILDTYPE))' % self.output)
       self.WriteLn('%s: LIBS := $(LIBS)' % self.output)
 
     if self.type == 'executable':
       self.WriteDoCmd([self.output], link_deps, 'link', part_of_all)
     elif self.type == 'static_library':
       self.WriteDoCmd([self.output], link_deps, 'alink', part_of_all)
-    elif self.type in ('loadable_module', 'shared_library'):
+    elif self.type == 'shared_library':
       self.WriteDoCmd([self.output], link_deps, 'solink', part_of_all)
+    elif self.type == 'loadable_module':
+      self.WriteDoCmd([self.output], link_deps, 'solink_module', part_of_all)
     elif self.type == 'none':
       # Write a stamp line.
       self.WriteDoCmd([self.output], deps, 'touch', part_of_all)
     elif self.type == 'settings':
       # Only used for passing flags around.
       pass
     else:
       print "WARNING: no output for", self.type, target
 
     # Add an alias for each target (if there are any outputs).
@@ skipping 488 matching lines @@
   # Add a check to make sure we tried to process all the .d files.
   all_deps += """
   ifneq ($(word %(last)d,$(d_files)),)
     $(error Found unprocessed dependency files (gyp didn't generate enough rules!))
   endif
 """ % { 'last': ((num_outputs / 1000) + 1) * 1000 + 1 }
 
   root_makefile.write(SHARED_FOOTER % { 'generate_all_deps': all_deps })
 
   root_makefile.close()