respect global strip config

BUILD.bazel

@@ -130,7 +130,11 @@ go_config(
         "//conditions:default": False,
     }),
     static = "//go/config:static",
-    strip = "//go/config:strip",
+    strip = select({
+        "//go/private:is_strip_always": True,
+        "//go/private:is_strip_sometimes_fastbuild": True,
+        "//conditions:default": False,
+    }),
     visibility = ["//visibility:public"],
 )
 

go/config/BUILD.bazel

@@ -1,7 +1,6 @@
 load(
     "@bazel_skylib//rules:common_settings.bzl",
     "bool_flag",
-    "bool_setting",
     "string_flag",
     "string_list_flag",
 )
@@ -34,12 +33,6 @@ bool_flag(
     visibility = ["//visibility:public"],
 )
 
-bool_setting(
-    name = "strip",
-    build_setting_default = False,
-    visibility = ["//visibility:public"],
-)
-
 bool_flag(
     name = "debug",
     build_setting_default = False,

go/modes.rst

@@ -69,12 +69,6 @@ or using `Bazel configuration transitions`_.
 | ``CGO_ENABLED=0``). Packages that contain cgo code may still be built, but   |
 | the cgo code will be filtered out, and the ``cgo`` build tag will be false.  |
 +-------------------+---------------------+------------------------------------+
-| :param:`strip`    | :type:`bool`        | :value:`false`                     |
-+-------------------+---------------------+------------------------------------+
-| Strips symbols from compiled packages and linked binaries (using the ``-w``  |
-| flag). May also be set with the ``--strip`` command line option, which       |
-| affects C/C++ targets, too.                                                  |
-+-------------------+---------------------+------------------------------------+
 | :param:`debug`    | :type:`bool`        | :value:`false`                     |
 +-------------------+---------------------+------------------------------------+
 | Includes debugging information in compiled packages (using the ``-N`` and    |

go/private/BUILD.bazel

@@ -30,6 +30,21 @@ config_setting(
     visibility = ["//:__pkg__"],
 )
 
+config_setting(
+    name = "is_strip_always",
+    values = {"strip": "always"},
+    visibility = ["//:__pkg__"],
+)
+
+config_setting(
+    name = "is_strip_sometimes_fastbuild",
+    values = {
+        "strip": "sometimes",
+        "compilation_mode": "fastbuild",
+    },
+    visibility = ["//:__pkg__"],
+)
+
 bzl_library(
     name = "context",
     srcs = ["context.bzl"],

go/private/actions/link.bzl

@@ -181,7 +181,7 @@ def emit_link(
     # Do not remove, somehow this is needed when building for darwin/arm only.
     tool_args.add("-buildid=redacted")
     if go.mode.strip:
-        tool_args.add("-w")
+        tool_args.add("-s", "-w")
     tool_args.add_joined("-extldflags", extldflags, join_with = " ")
 
     conflict_err = _check_conflicts(arcs)

go/private/context.bzl

@@ -830,7 +830,7 @@ def _go_config_impl(ctx):
         race = ctx.attr.race[BuildSettingInfo].value,
         msan = ctx.attr.msan[BuildSettingInfo].value,
         pure = ctx.attr.pure[BuildSettingInfo].value,
-        strip = ctx.attr.strip[BuildSettingInfo].value,
+        strip = ctx.attr.strip,
         debug = ctx.attr.debug[BuildSettingInfo].value,
         linkmode = ctx.attr.linkmode[BuildSettingInfo].value,
         gc_linkopts = ctx.attr.gc_linkopts[BuildSettingInfo].value,
@@ -860,10 +860,7 @@ go_config = rule(
             mandatory = True,
             providers = [BuildSettingInfo],
         ),
-        "strip": attr.label(
-            mandatory = True,
-            providers = [BuildSettingInfo],
-        ),
+        "strip": attr.bool(mandatory = True),
         "debug": attr.label(
             mandatory = True,
             providers = [BuildSettingInfo],

go/private/rules/transition.bzl

@@ -174,7 +174,6 @@ _common_reset_transition_dict = dict({
     "//go/config:msan": False,
     "//go/config:race": False,
     "//go/config:pure": False,
-    "//go/config:strip": False,
     "//go/config:debug": False,
     "//go/config:linkmode": LINKMODE_NORMAL,
     "//go/config:tags": [],

tests/core/strip/BUILD.bazel

@@ -0,0 +1,6 @@
+load("@io_bazel_rules_go//go/tools/bazel_testing:def.bzl", "go_bazel_test")
+
+go_bazel_test(
+    name = "strip_test",
+    srcs = ["strip_test.go"],
+)

tests/core/strip/README.rst

@@ -0,0 +1,13 @@
+symbol stripping
+====================
+
+strip_test
+---------
+
+Tests that the global Bazel configuration for stripping are applied to go_binary
+targets.
+In particular, it tests that stripping is performed iff the bazel flag ``--strip``
+is set to ``always`` or ``--strip`` is set to ``sometimes`` and ``--compilation_mode``
+is ``fastbuild``.
+Additionally, it tests that stack traces still contain the same information when stripping
+is enabled.

tests/core/strip/strip_test.go

@@ -0,0 +1,270 @@
+// Copyright 2019 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package strip_test
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+
+	"github.com/bazelbuild/rules_go/go/tools/bazel_testing"
+)
+
+func TestMain(m *testing.M) {
+	bazel_testing.TestMain(m, bazel_testing.Args{
+		Main: `
+-- BUILD.bazel --
+load("@io_bazel_rules_go//go:def.bzl", "go_binary")
+
+go_binary(
+    name = "strip",
+    srcs = ["strip.go"],
+)
+-- strip.go --
+package main
+
+import (
+	"debug/elf"
+	"debug/macho"
+	"debug/pe"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"regexp"
+	"runtime"
+	"runtime/debug"
+	"strings"
+)
+
+var wantStrip = flag.Bool("wantstrip", false, "")
+
+func main() {
+	flag.Parse()
+	stackTrace, err := panicAndRecover()
+	if err != nil {
+		panic(err)
+	}
+	gotStackTrace := strings.Split(stackTrace, "\n")
+	if len(gotStackTrace) != len(wantStackTrace) {
+		panic(fmt.Sprintf("got %d lines of stack trace, want %d", len(gotStackTrace), len(wantStackTrace)))
+	}
+	for i := range gotStackTrace {
+		expectedLine := regexp.MustCompile(wantStackTrace[i])
+		if !expectedLine.MatchString(gotStackTrace[i]) {
+			panic(fmt.Sprintf("got unexpected stack trace line %q at index %d", gotStackTrace[i], i))
+		}
+	}
+	stripped, err := isStripped()
+	if err != nil {
+		panic(err)
+	}
+	if stripped != *wantStrip {
+		panic(fmt.Sprintf("got stripped=%t, want stripped=%t", stripped, *wantStrip))
+	}
+}
+
+func panicAndRecover() (stackTrace string, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			stackTrace = string(debug.Stack())
+		}
+	}()
+	panic("test")
+	return "", errors.New("should not reach here")
+}
+
+func isStripped() (bool, error) {
+	ownLocation, err := os.Executable()
+	if err != nil {
+		return false, err
+	}
+	ownBinary, err := os.Open(ownLocation)
+	if err != nil {
+		return false, err
+	}
+	defer ownBinary.Close()
+	switch runtime.GOOS {
+	case "darwin":
+		return isStrippedMachO(ownBinary)
+	case "linux":
+		return isStrippedElf(ownBinary)
+	case "windows":
+		return isStrippedPE(ownBinary)
+	default:
+		return false, fmt.Errorf("unsupported OS: %s", runtime.GOOS)
+	}
+}
+
+func isStrippedMachO(f io.ReaderAt) (bool, error) {
+	macho, err := macho.NewFile(f)
+	if err != nil {
+		return false, err
+	}
+	gotDwarf := macho.Segment("__DWARF") != nil
+	gotDebugInfo := macho.Section("__zdebug_info") != nil
+	if gotDwarf != gotDebugInfo {
+		return false, fmt.Errorf("inconsistent stripping: gotDwarf=%v, gotDebugInfo=%v", gotDwarf, gotDebugInfo)
+	}
+	return !gotDwarf, nil
+}
+
+func isStrippedElf(f io.ReaderAt) (bool, error) {
+	elf, err := elf.NewFile(f)
+	if err != nil {
+		return false, err
+	}
+	var gotSymtab bool
+	for _, section := range elf.Sections {
+		if section.Name == ".symtab" {
+			gotSymtab = true
+			break
+		}
+	}
+	return !gotSymtab, nil
+}
+
+
+func isStrippedPE(f io.ReaderAt) (bool, error) {
+	pe, err := pe.NewFile(f)
+	if err != nil {
+		return false, err
+	}
+	symtab := pe.Section(".symtab")
+	if symtab == nil {
+		return false, fmt.Errorf("no .symtab section")
+	}
+	emptySymtab := (symtab.VirtualSize <= 4) && (symtab.Size <= 512)
+	return emptySymtab, nil
+}
+
+
+` + embedWantedStackTraces(),
+	})
+}
+
+func Test(t *testing.T) {
+	for _, test := range []struct {
+		desc, stripFlag, compilationMode string
+		wantStrip                        bool
+	}{
+		{
+			desc:      "run_auto",
+			wantStrip: true,
+		},
+		{
+			desc:            "run_fastbuild",
+			compilationMode: "fastbuild",
+			wantStrip:       true,
+		},
+		{
+			desc:            "run_dbg",
+			compilationMode: "dbg",
+		},
+		{
+			desc:            "run_opt",
+			compilationMode: "opt",
+		},
+		{
+			desc:      "run_always",
+			stripFlag: "always",
+			wantStrip: true,
+		},
+		{
+			desc:            "run_always_opt",
+			stripFlag:       "always",
+			compilationMode: "opt",
+			wantStrip:       true,
+		},
+		{
+			desc:      "run_never",
+			stripFlag: "never",
+		},
+		{
+			desc:            "run_sometimes_fastbuild",
+			stripFlag:       "sometimes",
+			compilationMode: "fastbuild",
+			wantStrip:       true,
+		},
+		{
+			desc:            "run_sometimes_dbg",
+			stripFlag:       "sometimes",
+			compilationMode: "dbg",
+		},
+		{
+			desc:            "run_sometimes_opt",
+			stripFlag:       "sometimes",
+			compilationMode: "opt",
+		},
+	} {
+		t.Run(test.desc, func(t *testing.T) {
+			args := []string{"run"}
+			if len(test.stripFlag) > 0 {
+				args = append(args, "--strip", test.stripFlag)
+			}
+			if len(test.compilationMode) > 0 {
+				args = append(args, "--compilation_mode", test.compilationMode)
+			}
+			args = append(args, "//:strip", "--", fmt.Sprintf("-wantstrip=%v", test.wantStrip))
+			cmd := bazel_testing.BazelCmd(args...)
+			stderr := &bytes.Buffer{}
+			cmd.Stderr = stderr
+			t.Logf("running: bazel %s", strings.Join(args, " "))
+			if err := cmd.Run(); err != nil {
+				var xerr *exec.ExitError
+				if !errors.As(err, &xerr) {
+					t.Fatalf("unexpected error: %v", err)
+				}
+				if xerr.ExitCode() == bazel_testing.BUILD_FAILURE {
+					t.Fatalf("unexpected build failure: %v\nstderr:\n%s", err, stderr.Bytes())
+					return
+				} else if xerr.ExitCode() == bazel_testing.TESTS_FAILED {
+					t.Fatalf("error running %s:\n%s", strings.Join(cmd.Args, " "), stderr.Bytes())
+				} else {
+					t.Fatalf("unexpected error: %v\nstderr:\n%s", err, stderr.Bytes())
+				}
+			}
+		})
+	}
+}
+
+var wantStackTrace = []string{
+	`^goroutine \d+ \[running\]:$`,
+	`^runtime/debug\.Stack\(\)$`,
+	`^	GOROOT/src/runtime/debug/stack\.go:\d+ \+0x[0-9a-f]+$`,
+	`^main\.panicAndRecover\.func1\(\)$`,
+	`^	strip\.go:\d+ \+0x[0-9a-f]+$`,
+	`^panic\({0x[0-9a-f]+, 0x[0-9a-f]+}\)$`,
+	`^	GOROOT/src/runtime/panic\.go:\d+ \+0x[0-9a-f]+$`,
+	`^main\.panicAndRecover\(\)$`,
+	`^	strip\.go:\d+ \+0x[0-9a-f]+$`,
+	`^main\.main\(\)$`,
+	`^	strip\.go:\d+ \+0x[0-9a-f]+$`,
+	`^$`,
+}
+
+func embedWantedStackTraces() string {
+	buf := &bytes.Buffer{}
+	fmt.Fprintln(buf, "var wantStackTrace = []string{")
+	for _, s := range wantStackTrace {
+		fmt.Fprintf(buf, "`%s`,\n", s)
+	}
+	fmt.Fprintln(buf, "}")
+	return buf.String()
+}