Use GNU ar's thin archive if this feature is available....

pylib/gyp/generator/make.py

 #!/usr/bin/python
 
 # Copyright (c) 2009 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 82 matching lines @@
 obj := $(builddir)/obj
 abs_obj := $(abspath $(obj))
 
 # We build up a list of every single one of the targets so we can slurp in the
 # generated dependency rule Makefiles in one pass.
 all_deps :=
 
 # C++ apps need to be linked with g++.  Not sure what's appropriate.
 LINK ?= $(CXX)
 
+# We want to use GNU ar's T option if available because it's much faster.
+# We try to archive and link a file to see ar and ld support this feature.
+define detect_arflags
+$(shell \
+    mkdir -p $(obj).$(1)/arflags;
+    if echo 'int main(){}' > $(obj).$(1)/arflags/artest.c &&
+       $(CXX.$(1)) -c $(obj).$(1)/arflags/artest.c -o $(obj).$(1)/arflags/artest.o> /dev/null 2>&1 &&
+       $(AR.$(1)) crT $(obj).$(1)/arflags/artest.a $(obj).$(1)/arflags/artest.o > /dev/null 2>&1 &&
+       $(LINK.$(1)) $(obj).$(1)/arflags/artest.a -o $(obj).$(1)/arflags/artest > /dev/null 2>&1 ; then
+      arflags=crT;
+    else
+      arflags=cr;
+    fi;
+    echo ARFLAGS.$(1) := $$arflags > $(obj).$(1)/arflags/arflags.mk;
+    echo $$arflags;
+ )
+endef
+
 CC.target ?= $(CC)
 CFLAGS.target ?= $(CFLAGS)
 CXX.target ?= $(CXX)
 CXXFLAGS.target ?= $(CXXFLAGS)
 LINK.target ?= $(LINK)
 LDFLAGS.target ?= $(LDFLAGS)
 AR.target ?= $(AR)
+# We don't want to run the detection multiple times. So, we
+# - use $(obj).target/arflags/arflags.target.mk as the cache of the detection,
+# - use := to avoid the right hand side multiple times, and
+# - use ifeq instead of ?= because ?= is like ifeq and =, not ifeq and := .
+-include $(obj).target/arflags/arflags.mk
+ifeq ($(ARFLAGS.target),)
+  ARFLAGS.target := $(call detect_arflags,target)
+endif
 RANLIB.target ?= ranlib
 
 CC.host ?= gcc
 CFLAGS.host ?=
 CXX.host ?= g++
 CXXFLAGS.host ?=
 LINK.host ?= g++
 LDFLAGS.host ?=
 AR.host ?= ar
+# See the description for ARFLAGS.target.
+-include $(obj).host/arflags/arflags.mk
+ifeq ($(ARFLAGS.host),)
+  ARFLAGS.host := $(call detect_arflags,host)
+endif
 RANLIB.host ?= ranlib
 
 # Flags to make gcc output dependency info.  Note that you need to be
 # careful here to use the flags that ccache and distcc can understand.
 # We write to a dep file on the side first and then rename at the end
 # so we can't end up with a broken dep file.
 depfile = $(depsdir)/$@.d
 DEPFLAGS = -MMD -MF $(depfile).raw
 
 # We have to fixup the deps output in a few ways.
@@ skipping 34 matching lines @@
 # - cmd_foo is the actual command to run;
 # - quiet_cmd_foo is the brief-output summary of the command.
 
 quiet_cmd_cc = CC($(TOOLSET)) $@
 cmd_cc = $(CC.$(TOOLSET)) $(CFLAGS.$(TOOLSET)) $(GYP_CFLAGS) $(DEPFLAGS) -c -o $@ $<
 
 quiet_cmd_cxx = CXX($(TOOLSET)) $@
 cmd_cxx = $(CXX.$(TOOLSET)) $(CXXFLAGS.$(TOOLSET)) $(GYP_CXXFLAGS) $(DEPFLAGS) -c -o $@ $<
 
 quiet_cmd_alink = AR+RANLIB($(TOOLSET)) $@
-cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) rc $@ $(filter %.o,$^) && $(RANLIB.$(TOOLSET)) $@
+cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) $(ARFLAGS.$(TOOLSET)) $@ $(filter %.o,$^) && $(RANLIB.$(TOOLSET)) $@
 
 quiet_cmd_touch = TOUCH $@
 cmd_touch = touch $@
 
 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
@@ skipping 1093 matching lines @@
         makefile_name,
         ' '.join(map(Sourceify, build_files)),
         gyp.common.EncodePOSIXShellList(
             [gyp_binary, '-fmake'] +
             gyp.RegenerateFlags(options) +
             build_files_args)))
 
   root_makefile.write(SHARED_FOOTER)
 
   root_makefile.close()