Files
build_soong/cc/coverage.go
Pirama Arumuga Nainar 82fe59b656 Refactor libprofile-extras to be added as a whole static library
Bug: http://b/134177005
Bug: http://b/116873221

Previously, the libprofile-extras dependency was added as a
LateStaticLib and the constructor in this library was included during
linking with the '-uinit_profile_extras' linker flag.  This was done
because at the deps() stage, the exact binaries that need coverage are
not known (in fact the coverage-enabled variants are not created yet).

This meant that for a link command, if one of the shared libraries
already exported the constructor, the output of the link command did not
load/link libprofile-extras.

For other reasons, we now want to add more symbols to this library that
need to be linked into all libraries and executables.  To accomplish
that, refactor the dependency handling so libprofile-extras can be added
as a 'WholeStaticLib'.

This is done by creating a new dependency type (with a coverageDepTag
dependency tag) to add libprofile-extras as a dependency for all modules
that can potentially link with coverage.  During the flags() call, this
dependency is moved as a WholeStaticLib dependency iff coverage is
enabled in this link step.

There are a few NFC changes as well:
- deps() takes a DepsContext parameter.
- flags() has an extra PathDeps parameter and return value.
- add useSdk() helper to cc.Module.

Test: Build with coverage and check that we can generate coverage using
SIGUSR1 and the debug.coverage.flush sysprop.

Change-Id: I7e7d8201956a150febbda5bb1794f8ece016db8b
2019-07-03 15:28:50 -07:00

180 lines
5.5 KiB
Go

// Copyright 2017 Google Inc. 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 cc
import (
"strconv"
"github.com/google/blueprint"
"android/soong/android"
)
type CoverageProperties struct {
Native_coverage *bool
NeedCoverageVariant bool `blueprint:"mutated"`
NeedCoverageBuild bool `blueprint:"mutated"`
CoverageEnabled bool `blueprint:"mutated"`
IsCoverageVariant bool `blueprint:"mutated"`
}
type coverage struct {
Properties CoverageProperties
// Whether binaries containing this module need --coverage added to their ldflags
linkCoverage bool
}
func (cov *coverage) props() []interface{} {
return []interface{}{&cov.Properties}
}
func getProfileLibraryName(ctx ModuleContextIntf) string {
// This function should only ever be called for a cc.Module, so the
// following statement should always succeed.
if ctx.useSdk() {
return "libprofile-extras_ndk"
} else {
return "libprofile-extras"
}
}
func (cov *coverage) deps(ctx DepsContext, deps Deps) Deps {
if cov.Properties.NeedCoverageVariant {
ctx.AddVariationDependencies([]blueprint.Variation{
{Mutator: "link", Variation: "static"},
}, coverageDepTag, getProfileLibraryName(ctx))
}
return deps
}
func (cov *coverage) flags(ctx ModuleContext, flags Flags, deps PathDeps) (Flags, PathDeps) {
if !ctx.DeviceConfig().NativeCoverageEnabled() {
return flags, deps
}
if cov.Properties.CoverageEnabled {
flags.Coverage = true
flags.GlobalFlags = append(flags.GlobalFlags, "--coverage", "-O0")
cov.linkCoverage = true
// Override -Wframe-larger-than and non-default optimization
// flags that the module may use.
flags.CFlags = append(flags.CFlags, "-Wno-frame-larger-than=", "-O0")
}
// Even if we don't have coverage enabled, if any of our object files were compiled
// with coverage, then we need to add --coverage to our ldflags.
if !cov.linkCoverage {
if ctx.static() && !ctx.staticBinary() {
// For static libraries, the only thing that changes our object files
// are included whole static libraries, so check to see if any of
// those have coverage enabled.
ctx.VisitDirectDepsWithTag(wholeStaticDepTag, func(m android.Module) {
if cc, ok := m.(*Module); ok && cc.coverage != nil {
if cc.coverage.linkCoverage {
cov.linkCoverage = true
}
}
})
} else {
// For executables and shared libraries, we need to check all of
// our static dependencies.
ctx.VisitDirectDeps(func(m android.Module) {
cc, ok := m.(*Module)
if !ok || cc.coverage == nil {
return
}
if static, ok := cc.linker.(libraryInterface); !ok || !static.static() {
return
}
if cc.coverage.linkCoverage {
cov.linkCoverage = true
}
})
}
}
if cov.linkCoverage {
flags.LdFlags = append(flags.LdFlags, "--coverage")
coverage := ctx.GetDirectDepWithTag(getProfileLibraryName(ctx), coverageDepTag).(*Module)
deps.WholeStaticLibs = append(deps.WholeStaticLibs, coverage.OutputFile().Path())
}
return flags, deps
}
func (cov *coverage) begin(ctx BaseModuleContext) {
// Coverage is disabled globally
if !ctx.DeviceConfig().NativeCoverageEnabled() {
return
}
var needCoverageVariant bool
var needCoverageBuild bool
if ctx.Host() {
// TODO(dwillemsen): because of -nodefaultlibs, we must depend on libclang_rt.profile-*.a
// Just turn off for now.
} else if !ctx.nativeCoverage() {
// Native coverage is not supported for this module type.
} else {
// Check if Native_coverage is set to false. This property defaults to true.
needCoverageVariant = BoolDefault(cov.Properties.Native_coverage, true)
if sdk_version := ctx.sdkVersion(); ctx.useSdk() && sdk_version != "current" {
// Native coverage is not supported for SDK versions < 23
if fromApi, err := strconv.Atoi(sdk_version); err == nil && fromApi < 23 {
needCoverageVariant = false
}
}
if needCoverageVariant {
// Coverage variant is actually built with coverage if enabled for its module path
needCoverageBuild = ctx.DeviceConfig().CoverageEnabledForPath(ctx.ModuleDir())
}
}
cov.Properties.NeedCoverageBuild = needCoverageBuild
cov.Properties.NeedCoverageVariant = needCoverageVariant
}
func coverageMutator(mctx android.BottomUpMutatorContext) {
if c, ok := mctx.Module().(*Module); ok && c.coverage != nil {
needCoverageVariant := c.coverage.Properties.NeedCoverageVariant
needCoverageBuild := c.coverage.Properties.NeedCoverageBuild
if needCoverageVariant {
m := mctx.CreateVariations("", "cov")
// Setup the non-coverage version and set HideFromMake and
// PreventInstall to true.
m[0].(*Module).coverage.Properties.CoverageEnabled = false
m[0].(*Module).coverage.Properties.IsCoverageVariant = false
m[0].(*Module).Properties.HideFromMake = true
m[0].(*Module).Properties.PreventInstall = true
// The coverage-enabled version inherits HideFromMake,
// PreventInstall from the original module.
m[1].(*Module).coverage.Properties.CoverageEnabled = needCoverageBuild
m[1].(*Module).coverage.Properties.IsCoverageVariant = true
}
}
}