GN: Use lib.unstripped rather than lib.stripped. Add a toolchain.gni

build/toolchain/gcc_toolchain.gni

 # Copyright (c) 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.
 
+import("//build/toolchain/toolchain.gni")
+
 # This value will be inherited in the toolchain below.
 concurrent_links = exec_script("get_concurrent_links.py", [], "value")
 
 # This template defines a toolchain for something that works like gcc
 # (including clang).
 #
 # It requires the following variables specifying the executables to run:
 #  - cc
 #  - cxx
 #  - ar
@@ skipping 11 matching lines @@
 #      the libs section of the linker line. It allows one to inject libraries
 #      at the beginning and end for all targets in a toolchain.
 #  - solink_libs_section_prefix
 #  - solink_libs_section_postfix
 #      Same as libs_section_{pre,post}fix except used for solink instead of link.
 #  - post_solink
 #      The content of this string, if specified, will be appended to the solink
 #      command.
 #  - deps
 #      Just forwarded to the toolchain definition.
 #  - is_clang

[brettw, 2015/08/10 20:06:51]

Can you document the new "strip" argument and its behavior here? Should include
what it does and what the default is (seems to be "if it's defined, use the
string to ..., otherwise ...").

[agrieve, 2015/08/10 20:33:47]

Done.

 template("gcc_toolchain") {
   toolchain(target_name) {
     assert(defined(invoker.cc), "gcc_toolchain() must specify a \"cc\" value")
     assert(defined(invoker.cxx), "gcc_toolchain() must specify a \"cxx\" value")
     assert(defined(invoker.ar), "gcc_toolchain() must specify a \"ar\" value")
     assert(defined(invoker.ld), "gcc_toolchain() must specify a \"ld\" value")
     assert(defined(invoker.toolchain_cpu),
            "gcc_toolchain() must specify a \"toolchain_cpu\"")
     assert(defined(invoker.toolchain_os),
            "gcc_toolchain() must specify a \"toolchain_os\"")
@@ skipping 84 matching lines @@
       outputs = [
         "{{target_out_dir}}/{{target_output_name}}{{output_extension}}",
       ]
       default_output_extension = ".a"
       output_prefix = "lib"
     }
 
     tool("solink") {
       soname = "{{target_output_name}}{{output_extension}}"  # e.g. "libfoo.so".
       sofile = "{{root_out_dir}}/$soname"  # Possibly including toolchain dir.
+      if (shlib_subdir != ".") {
+        sofile = "{{root_out_dir}}/$shlib_subdir/$soname"
+      }
       rspfile = sofile + ".rsp"
 
+      unstripped_sofile = sofile
+      if (defined(invoker.strip)) {
+        unstripped_sofile = "{{root_out_dir}}/lib.unstripped/$soname"
+      }
+
       # These variables are not built into GN but are helpers that implement
       # (1) linking to produce a .so, (2) extracting the symbols from that file
       # to a temporary file, (3) if the temporary file has differences from the
       # existing .TOC file, overwrite it, otherwise, don't change it.
       tocfile = sofile + ".TOC"
       temporary_tocname = sofile + ".tmp"
-      link_command =
-          "$ld -shared {{ldflags}} -o $sofile -Wl,-soname=$soname @$rspfile"
+
+      link_command = "$ld -shared {{ldflags}} -o $unstripped_sofile -Wl,-soname=$soname @$rspfile"
       assert(defined(readelf), "to solink you must have a readelf")
       assert(defined(nm), "to solink you must have an nm")
-      toc_command = "{ $readelf -d $sofile | grep SONAME ; $nm -gD -f p $sofile | cut -f1-2 -d' '; } > $temporary_tocname"
+      toc_command = "{ $readelf -d $unstripped_sofile | grep SONAME ; $nm -gD -f p $unstripped_sofile | cut -f1-2 -d' '; } > $temporary_tocname"
       replace_command = "if ! cmp -s $temporary_tocname $tocfile; then mv $temporary_tocname $tocfile; fi"
 
       command = "$link_command && $toc_command && $replace_command"
-      if (defined(invoker.postsolink)) {
-        command += " && " + invoker.postsolink
+      if (defined(invoker.strip)) {
+        strip_command =
+            "${invoker.strip} --strip-unneeded -o $sofile $unstripped_sofile"
+        command += " && " + strip_command
       }
       rspfile_content = "-Wl,--whole-archive {{inputs}} {{solibs}} -Wl,--no-whole-archive $solink_libs_section_prefix {{libs}} $solink_libs_section_postfix"
 
       description = "SOLINK $sofile"
 
       # Use this for {{output_extension}} expansions unless a target manually
       # overrides it (in which case {{output_extension}} will be what the target
       # specifies).
-      default_output_extension = ".so"
+      default_output_extension = shlib_extension
       if (defined(invoker.default_output_extension)) {
         default_output_extension = invoker.default_output_extension
       }
 
       output_prefix = "lib"
 
       # Since the above commands only updates the .TOC file when it changes, ask
       # Ninja to check if the timestamp actually changed to know if downstream
       # dependencies should be recompiled.
       restat = true
 
       # Tell GN about the output files. It will link to the sofile but use the
       # tocfile for dependency management.
       outputs = [
         sofile,
         tocfile,
       ]
-      if (defined(invoker.solink_outputs)) {
-        outputs += invoker.solink_outputs
+      if (sofile != unstripped_sofile) {
+        outputs += [ unstripped_sofile ]
       }
       link_output = sofile
       depend_output = tocfile
     }
 
     tool("link") {
-      outfile = "{{root_out_dir}}/{{target_output_name}}{{output_extension}}"
+      exename = "{{target_output_name}}{{output_extension}}"
+      outfile = "{{root_out_dir}}/$exename"
       rspfile = "$outfile.rsp"
-      command = "$ld {{ldflags}} -o $outfile -Wl,--start-group @$rspfile {{solibs}} -Wl,--end-group $libs_section_prefix {{libs}} $libs_section_postfix"
-      if (defined(invoker.postlink)) {
-        command += " && " + invoker.postlink
+      unstripped_outfile = outfile
+      if (defined(invoker.strip)) {
+        unstripped_outfile = "{{root_out_dir}}/exe.unstripped/$exename"
+      }
+
+      command = "$ld {{ldflags}} -o $unstripped_outfile -Wl,--start-group @$rspfile {{solibs}} -Wl,--end-group $libs_section_prefix {{libs}} $libs_section_postfix"
+      if (defined(invoker.strip)) {
+        strip_command =
+            "${invoker.strip} --strip-unneeded -o $outfile $unstripped_outfile"
+        command += " && " + strip_command
       }
       description = "LINK $outfile"
       rspfile_content = "{{inputs}}"
       outputs = [
         outfile,
       ]
-      if (defined(invoker.link_outputs)) {
-        outputs += invoker.link_outputs
+      if (outfile != unstripped_outfile) {
+        outputs += [ unstripped_outfile ]
       }
     }
 
     tool("stamp") {
       command = "touch {{output}}"
       description = "STAMP {{output}}"
     }
 
     tool("copy") {
       command = "ln -f {{source}} {{output}} 2>/dev/null || (rm -rf {{output}} && cp -af {{source}} {{output}})"
@@ skipping 13 matching lines @@
       if (defined(invoker.is_clang)) {
         is_clang = invoker.is_clang
       }
     }
 
     if (defined(invoker.deps)) {
       deps = invoker.deps
     }
   }
 }