af24cdd99f
This allows removal of almost all current items from the mixed build denylist, which were previously broken due to being unable to separately control flags for compilations of different languages within the same target. Note that this does not appropriately implement asm/c srcs and flags for either the shared variant or the static variant. This will require a followup. Test: bp2build.sh and mixed_libc.sh CI scripts Test: Updated b2build tests Change-Id: I28cf7437ee96cdf2fdbcb1eda2303691cff08ba4
556 lines
22 KiB
Go
556 lines
22 KiB
Go
// Copyright 2021 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 (
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"android/soong/android"
|
|
"android/soong/bazel"
|
|
)
|
|
|
|
// bp2build functions and helpers for converting cc_* modules to Bazel.
|
|
|
|
func init() {
|
|
android.DepsBp2BuildMutators(RegisterDepsBp2Build)
|
|
}
|
|
|
|
func RegisterDepsBp2Build(ctx android.RegisterMutatorsContext) {
|
|
ctx.BottomUp("cc_bp2build_deps", depsBp2BuildMutator)
|
|
}
|
|
|
|
// A naive deps mutator to add deps on all modules across all combinations of
|
|
// target props for cc modules. This is needed to make module -> bazel label
|
|
// resolution work in the bp2build mutator later. This is probably
|
|
// the wrong way to do it, but it works.
|
|
//
|
|
// TODO(jingwen): can we create a custom os mutator in depsBp2BuildMutator to do this?
|
|
func depsBp2BuildMutator(ctx android.BottomUpMutatorContext) {
|
|
module, ok := ctx.Module().(*Module)
|
|
if !ok {
|
|
// Not a cc module
|
|
return
|
|
}
|
|
|
|
if !module.ConvertWithBp2build(ctx) {
|
|
return
|
|
}
|
|
|
|
var allDeps []string
|
|
|
|
for _, p := range module.GetTargetProperties(ctx, &BaseCompilerProperties{}) {
|
|
// base compiler props
|
|
if baseCompilerProps, ok := p.(*BaseCompilerProperties); ok {
|
|
allDeps = append(allDeps, baseCompilerProps.Generated_headers...)
|
|
allDeps = append(allDeps, baseCompilerProps.Generated_sources...)
|
|
}
|
|
}
|
|
|
|
for _, p := range module.GetArchProperties(ctx, &BaseCompilerProperties{}) {
|
|
// arch specific compiler props
|
|
if baseCompilerProps, ok := p.(*BaseCompilerProperties); ok {
|
|
allDeps = append(allDeps, baseCompilerProps.Generated_headers...)
|
|
allDeps = append(allDeps, baseCompilerProps.Generated_sources...)
|
|
}
|
|
}
|
|
|
|
for _, p := range module.GetTargetProperties(ctx, &BaseLinkerProperties{}) {
|
|
// arch specific linker props
|
|
if baseLinkerProps, ok := p.(*BaseLinkerProperties); ok {
|
|
allDeps = append(allDeps, baseLinkerProps.Header_libs...)
|
|
allDeps = append(allDeps, baseLinkerProps.Export_header_lib_headers...)
|
|
allDeps = append(allDeps, baseLinkerProps.Static_libs...)
|
|
allDeps = append(allDeps, baseLinkerProps.Whole_static_libs...)
|
|
}
|
|
}
|
|
|
|
for _, p := range module.GetArchProperties(ctx, &BaseLinkerProperties{}) {
|
|
// arch specific linker props
|
|
if baseLinkerProps, ok := p.(*BaseLinkerProperties); ok {
|
|
allDeps = append(allDeps, baseLinkerProps.Header_libs...)
|
|
allDeps = append(allDeps, baseLinkerProps.Export_header_lib_headers...)
|
|
allDeps = append(allDeps, baseLinkerProps.Static_libs...)
|
|
allDeps = append(allDeps, baseLinkerProps.Whole_static_libs...)
|
|
}
|
|
}
|
|
|
|
// Deps in the static: { .. } and shared: { .. } props of a cc_library.
|
|
if lib, ok := module.compiler.(*libraryDecorator); ok {
|
|
allDeps = append(allDeps, lib.SharedProperties.Shared.Static_libs...)
|
|
allDeps = append(allDeps, lib.SharedProperties.Shared.Whole_static_libs...)
|
|
allDeps = append(allDeps, lib.SharedProperties.Shared.Shared_libs...)
|
|
|
|
allDeps = append(allDeps, lib.StaticProperties.Static.Static_libs...)
|
|
allDeps = append(allDeps, lib.StaticProperties.Static.Whole_static_libs...)
|
|
allDeps = append(allDeps, lib.StaticProperties.Static.Shared_libs...)
|
|
|
|
// TODO(b/186024507, b/186489250): Temporarily exclude adding
|
|
// system_shared_libs deps until libc and libm builds.
|
|
// allDeps = append(allDeps, lib.SharedProperties.Shared.System_shared_libs...)
|
|
// allDeps = append(allDeps, lib.StaticProperties.Static.System_shared_libs...)
|
|
}
|
|
|
|
ctx.AddDependency(module, nil, android.SortedUniqueStrings(allDeps)...)
|
|
}
|
|
|
|
type sharedAttributes struct {
|
|
copts bazel.StringListAttribute
|
|
srcs bazel.LabelListAttribute
|
|
staticDeps bazel.LabelListAttribute
|
|
dynamicDeps bazel.LabelListAttribute
|
|
wholeArchiveDeps bazel.LabelListAttribute
|
|
}
|
|
|
|
// bp2buildParseSharedProps returns the attributes for the shared variant of a cc_library.
|
|
func bp2BuildParseSharedProps(ctx android.TopDownMutatorContext, module *Module) sharedAttributes {
|
|
lib, ok := module.compiler.(*libraryDecorator)
|
|
if !ok {
|
|
return sharedAttributes{}
|
|
}
|
|
|
|
copts := bazel.StringListAttribute{Value: lib.SharedProperties.Shared.Cflags}
|
|
|
|
srcs := bazel.LabelListAttribute{
|
|
Value: android.BazelLabelForModuleSrc(ctx, lib.SharedProperties.Shared.Srcs)}
|
|
|
|
staticDeps := bazel.LabelListAttribute{
|
|
Value: android.BazelLabelForModuleDeps(ctx, lib.SharedProperties.Shared.Static_libs)}
|
|
|
|
dynamicDeps := bazel.LabelListAttribute{
|
|
Value: android.BazelLabelForModuleDeps(ctx, lib.SharedProperties.Shared.Shared_libs)}
|
|
|
|
wholeArchiveDeps := bazel.LabelListAttribute{
|
|
Value: android.BazelLabelForModuleDeps(ctx, lib.SharedProperties.Shared.Whole_static_libs)}
|
|
|
|
return sharedAttributes{
|
|
copts: copts,
|
|
srcs: srcs,
|
|
staticDeps: staticDeps,
|
|
dynamicDeps: dynamicDeps,
|
|
wholeArchiveDeps: wholeArchiveDeps,
|
|
}
|
|
}
|
|
|
|
type staticAttributes struct {
|
|
copts bazel.StringListAttribute
|
|
srcs bazel.LabelListAttribute
|
|
staticDeps bazel.LabelListAttribute
|
|
dynamicDeps bazel.LabelListAttribute
|
|
wholeArchiveDeps bazel.LabelListAttribute
|
|
}
|
|
|
|
// bp2buildParseStaticProps returns the attributes for the static variant of a cc_library.
|
|
func bp2BuildParseStaticProps(ctx android.TopDownMutatorContext, module *Module) staticAttributes {
|
|
lib, ok := module.compiler.(*libraryDecorator)
|
|
if !ok {
|
|
return staticAttributes{}
|
|
}
|
|
|
|
copts := bazel.StringListAttribute{Value: lib.StaticProperties.Static.Cflags}
|
|
|
|
srcs := bazel.LabelListAttribute{
|
|
Value: android.BazelLabelForModuleSrc(ctx, lib.StaticProperties.Static.Srcs)}
|
|
|
|
staticDeps := bazel.LabelListAttribute{
|
|
Value: android.BazelLabelForModuleDeps(ctx, lib.StaticProperties.Static.Static_libs)}
|
|
|
|
dynamicDeps := bazel.LabelListAttribute{
|
|
Value: android.BazelLabelForModuleDeps(ctx, lib.StaticProperties.Static.Shared_libs)}
|
|
|
|
wholeArchiveDeps := bazel.LabelListAttribute{
|
|
Value: android.BazelLabelForModuleDeps(ctx, lib.StaticProperties.Static.Whole_static_libs)}
|
|
|
|
return staticAttributes{
|
|
copts: copts,
|
|
srcs: srcs,
|
|
staticDeps: staticDeps,
|
|
dynamicDeps: dynamicDeps,
|
|
wholeArchiveDeps: wholeArchiveDeps,
|
|
}
|
|
}
|
|
|
|
// Convenience struct to hold all attributes parsed from compiler properties.
|
|
type compilerAttributes struct {
|
|
// Options for all languages
|
|
copts bazel.StringListAttribute
|
|
// Assembly options and sources
|
|
asFlags bazel.StringListAttribute
|
|
asSrcs bazel.LabelListAttribute
|
|
// C options and sources
|
|
conlyFlags bazel.StringListAttribute
|
|
cSrcs bazel.LabelListAttribute
|
|
// C++ options and sources
|
|
cppFlags bazel.StringListAttribute
|
|
srcs bazel.LabelListAttribute
|
|
}
|
|
|
|
// bp2BuildParseCompilerProps returns copts, srcs and hdrs and other attributes.
|
|
func bp2BuildParseCompilerProps(ctx android.TopDownMutatorContext, module *Module) compilerAttributes {
|
|
var srcs bazel.LabelListAttribute
|
|
var copts bazel.StringListAttribute
|
|
var asFlags bazel.StringListAttribute
|
|
var conlyFlags bazel.StringListAttribute
|
|
var cppFlags bazel.StringListAttribute
|
|
|
|
// Creates the -I flags for a directory, while making the directory relative
|
|
// to the exec root for Bazel to work.
|
|
includeFlags := func(dir string) []string {
|
|
// filepath.Join canonicalizes the path, i.e. it takes care of . or .. elements.
|
|
moduleDirRootedPath := filepath.Join(ctx.ModuleDir(), dir)
|
|
return []string{
|
|
"-I" + moduleDirRootedPath,
|
|
// Include the bindir-rooted path (using make variable substitution). This most
|
|
// closely matches Bazel's native include path handling, which allows for dependency
|
|
// on generated headers in these directories.
|
|
// TODO(b/188084383): Handle local include directories in Bazel.
|
|
"-I$(BINDIR)/" + moduleDirRootedPath,
|
|
}
|
|
}
|
|
|
|
// Parse the list of module-relative include directories (-I).
|
|
parseLocalIncludeDirs := func(baseCompilerProps *BaseCompilerProperties) []string {
|
|
// include_dirs are root-relative, not module-relative.
|
|
includeDirs := bp2BuildMakePathsRelativeToModule(ctx, baseCompilerProps.Include_dirs)
|
|
return append(includeDirs, baseCompilerProps.Local_include_dirs...)
|
|
}
|
|
|
|
parseCommandLineFlags := func(soongFlags []string) []string {
|
|
var result []string
|
|
for _, flag := range soongFlags {
|
|
// Soong's cflags can contain spaces, like `-include header.h`. For
|
|
// Bazel's copts, split them up to be compatible with the
|
|
// no_copts_tokenization feature.
|
|
result = append(result, strings.Split(flag, " ")...)
|
|
}
|
|
return result
|
|
}
|
|
|
|
// Parse the list of copts.
|
|
parseCopts := func(baseCompilerProps *BaseCompilerProperties) []string {
|
|
var copts []string
|
|
copts = append(copts, parseCommandLineFlags(baseCompilerProps.Cflags)...)
|
|
for _, dir := range parseLocalIncludeDirs(baseCompilerProps) {
|
|
copts = append(copts, includeFlags(dir)...)
|
|
}
|
|
return copts
|
|
}
|
|
|
|
// baseSrcs contain the list of src files that are used for every configuration.
|
|
var baseSrcs []string
|
|
// baseExcludeSrcs contain the list of src files that are excluded for every configuration.
|
|
var baseExcludeSrcs []string
|
|
// baseSrcsLabelList is a clone of the base srcs LabelList, used for computing the
|
|
// arch or os specific srcs later.
|
|
var baseSrcsLabelList bazel.LabelList
|
|
|
|
// Parse srcs from an arch or OS's props value, taking the base srcs and
|
|
// exclude srcs into account.
|
|
parseSrcs := func(baseCompilerProps *BaseCompilerProperties) bazel.LabelList {
|
|
// Combine the base srcs and arch-specific srcs
|
|
allSrcs := append(baseSrcs, baseCompilerProps.Srcs...)
|
|
// Add srcs-like dependencies such as generated files.
|
|
// First create a LabelList containing these dependencies, then merge the values with srcs.
|
|
generatedHdrsAndSrcs := baseCompilerProps.Generated_headers
|
|
generatedHdrsAndSrcs = append(generatedHdrsAndSrcs, baseCompilerProps.Generated_sources...)
|
|
|
|
generatedHdrsAndSrcsLabelList := android.BazelLabelForModuleDeps(ctx, generatedHdrsAndSrcs)
|
|
|
|
// Combine the base exclude_srcs and configuration-specific exclude_srcs
|
|
allExcludeSrcs := append(baseExcludeSrcs, baseCompilerProps.Exclude_srcs...)
|
|
allSrcsLabelList := android.BazelLabelForModuleSrcExcludes(ctx, allSrcs, allExcludeSrcs)
|
|
return bazel.AppendBazelLabelLists(allSrcsLabelList, generatedHdrsAndSrcsLabelList)
|
|
}
|
|
|
|
for _, props := range module.compiler.compilerProps() {
|
|
if baseCompilerProps, ok := props.(*BaseCompilerProperties); ok {
|
|
srcs.Value = parseSrcs(baseCompilerProps)
|
|
copts.Value = parseCopts(baseCompilerProps)
|
|
asFlags.Value = parseCommandLineFlags(baseCompilerProps.Asflags)
|
|
conlyFlags.Value = parseCommandLineFlags(baseCompilerProps.Conlyflags)
|
|
cppFlags.Value = parseCommandLineFlags(baseCompilerProps.Cppflags)
|
|
|
|
// Used for arch-specific srcs later.
|
|
baseSrcs = baseCompilerProps.Srcs
|
|
baseSrcsLabelList = parseSrcs(baseCompilerProps)
|
|
baseExcludeSrcs = baseCompilerProps.Exclude_srcs
|
|
break
|
|
}
|
|
}
|
|
|
|
// Handle include_build_directory prop. If the property is true, then the
|
|
// target has access to all headers recursively in the package, and has
|
|
// "-I<module-dir>" in its copts.
|
|
if c, ok := module.compiler.(*baseCompiler); ok && c.includeBuildDirectory() {
|
|
copts.Value = append(copts.Value, includeFlags(".")...)
|
|
} else if c, ok := module.compiler.(*libraryDecorator); ok && c.includeBuildDirectory() {
|
|
copts.Value = append(copts.Value, includeFlags(".")...)
|
|
}
|
|
|
|
for arch, props := range module.GetArchProperties(ctx, &BaseCompilerProperties{}) {
|
|
if baseCompilerProps, ok := props.(*BaseCompilerProperties); ok {
|
|
// If there's arch specific srcs or exclude_srcs, generate a select entry for it.
|
|
// TODO(b/186153868): do this for OS specific srcs and exclude_srcs too.
|
|
if len(baseCompilerProps.Srcs) > 0 || len(baseCompilerProps.Exclude_srcs) > 0 {
|
|
srcsList := parseSrcs(baseCompilerProps)
|
|
srcs.SetValueForArch(arch.Name, srcsList)
|
|
// The base srcs value should not contain any arch-specific excludes.
|
|
srcs.Value = bazel.SubtractBazelLabelList(srcs.Value, bazel.LabelList{Includes: srcsList.Excludes})
|
|
}
|
|
|
|
copts.SetValueForArch(arch.Name, parseCopts(baseCompilerProps))
|
|
asFlags.SetValueForArch(arch.Name, parseCommandLineFlags(baseCompilerProps.Asflags))
|
|
conlyFlags.SetValueForArch(arch.Name, parseCommandLineFlags(baseCompilerProps.Conlyflags))
|
|
cppFlags.SetValueForArch(arch.Name, parseCommandLineFlags(baseCompilerProps.Cppflags))
|
|
}
|
|
}
|
|
|
|
// After going through all archs, delete the duplicate files in the arch
|
|
// values that are already in the base srcs.Value.
|
|
for arch, props := range module.GetArchProperties(ctx, &BaseCompilerProperties{}) {
|
|
if _, ok := props.(*BaseCompilerProperties); ok {
|
|
srcs.SetValueForArch(arch.Name, bazel.SubtractBazelLabelList(srcs.GetValueForArch(arch.Name), srcs.Value))
|
|
}
|
|
}
|
|
|
|
// Now that the srcs.Value list is finalized, compare it with the original
|
|
// list, and put the difference into the default condition for the arch
|
|
// select.
|
|
defaultsSrcs := bazel.SubtractBazelLabelList(baseSrcsLabelList, srcs.Value)
|
|
// TODO(b/186153868): handle the case with multiple variant types, e.g. when arch and os are both used.
|
|
srcs.SetValueForArch(bazel.CONDITIONS_DEFAULT, defaultsSrcs)
|
|
|
|
// Handle OS specific props.
|
|
for os, props := range module.GetTargetProperties(ctx, &BaseCompilerProperties{}) {
|
|
if baseCompilerProps, ok := props.(*BaseCompilerProperties); ok {
|
|
srcsList := parseSrcs(baseCompilerProps)
|
|
// TODO(b/186153868): add support for os-specific srcs and exclude_srcs
|
|
srcs.SetValueForOS(os.Name, bazel.SubtractBazelLabelList(srcsList, baseSrcsLabelList))
|
|
copts.SetValueForOS(os.Name, parseCopts(baseCompilerProps))
|
|
asFlags.SetValueForOS(os.Name, parseCommandLineFlags(baseCompilerProps.Asflags))
|
|
conlyFlags.SetValueForOS(os.Name, parseCommandLineFlags(baseCompilerProps.Conlyflags))
|
|
cppFlags.SetValueForOS(os.Name, parseCommandLineFlags(baseCompilerProps.Cppflags))
|
|
}
|
|
}
|
|
|
|
productVariableProps := android.ProductVariableProperties(ctx)
|
|
if props, exists := productVariableProps["Cflags"]; exists {
|
|
for _, prop := range props {
|
|
flags, ok := prop.Property.([]string)
|
|
if !ok {
|
|
ctx.ModuleErrorf("Could not convert product variable cflag property")
|
|
}
|
|
newFlags, _ := bazel.TryVariableSubstitutions(flags, prop.ProductConfigVariable)
|
|
copts.ProductValues = append(copts.ProductValues, bazel.ProductVariableValues{
|
|
ProductVariable: prop.ProductConfigVariable,
|
|
Values: newFlags,
|
|
})
|
|
}
|
|
}
|
|
|
|
// Branch srcs into three language-specific groups.
|
|
// C++ is the "catch-all" group, and comprises generated sources because we don't
|
|
// know the language of these sources until the genrule is executed.
|
|
// TODO(b/): Handle language detection of sources in a Bazel rule.
|
|
isCSrc := func(s string) bool {
|
|
return strings.HasSuffix(s, ".c")
|
|
}
|
|
isAsmSrc := func(s string) bool {
|
|
return strings.HasSuffix(s, ".S") || strings.HasSuffix(s, ".s")
|
|
}
|
|
cSrcs := bazel.FilterLabelListAttribute(srcs, isCSrc)
|
|
asSrcs := bazel.FilterLabelListAttribute(srcs, isAsmSrc)
|
|
srcs = bazel.SubtractBazelLabelListAttribute(srcs, cSrcs)
|
|
srcs = bazel.SubtractBazelLabelListAttribute(srcs, asSrcs)
|
|
return compilerAttributes{
|
|
copts: copts,
|
|
srcs: srcs,
|
|
asFlags: asFlags,
|
|
asSrcs: asSrcs,
|
|
cSrcs: cSrcs,
|
|
conlyFlags: conlyFlags,
|
|
cppFlags: cppFlags,
|
|
}
|
|
}
|
|
|
|
// Convenience struct to hold all attributes parsed from linker properties.
|
|
type linkerAttributes struct {
|
|
deps bazel.LabelListAttribute
|
|
dynamicDeps bazel.LabelListAttribute
|
|
wholeArchiveDeps bazel.LabelListAttribute
|
|
exportedDeps bazel.LabelListAttribute
|
|
linkopts bazel.StringListAttribute
|
|
versionScript bazel.LabelAttribute
|
|
}
|
|
|
|
// FIXME(b/187655838): Use the existing linkerFlags() function instead of duplicating logic here
|
|
func getBp2BuildLinkerFlags(linkerProperties *BaseLinkerProperties) []string {
|
|
flags := linkerProperties.Ldflags
|
|
if !BoolDefault(linkerProperties.Pack_relocations, true) {
|
|
flags = append(flags, "-Wl,--pack-dyn-relocs=none")
|
|
}
|
|
return flags
|
|
}
|
|
|
|
// bp2BuildParseLinkerProps parses the linker properties of a module, including
|
|
// configurable attribute values.
|
|
func bp2BuildParseLinkerProps(ctx android.TopDownMutatorContext, module *Module) linkerAttributes {
|
|
var deps bazel.LabelListAttribute
|
|
var exportedDeps bazel.LabelListAttribute
|
|
var dynamicDeps bazel.LabelListAttribute
|
|
var wholeArchiveDeps bazel.LabelListAttribute
|
|
var linkopts bazel.StringListAttribute
|
|
var versionScript bazel.LabelAttribute
|
|
|
|
for _, linkerProps := range module.linker.linkerProps() {
|
|
if baseLinkerProps, ok := linkerProps.(*BaseLinkerProperties); ok {
|
|
libs := baseLinkerProps.Header_libs
|
|
libs = append(libs, baseLinkerProps.Static_libs...)
|
|
exportedLibs := baseLinkerProps.Export_header_lib_headers
|
|
wholeArchiveLibs := baseLinkerProps.Whole_static_libs
|
|
libs = android.SortedUniqueStrings(libs)
|
|
deps = bazel.MakeLabelListAttribute(android.BazelLabelForModuleDeps(ctx, libs))
|
|
exportedDeps = bazel.MakeLabelListAttribute(android.BazelLabelForModuleDeps(ctx, exportedLibs))
|
|
linkopts.Value = getBp2BuildLinkerFlags(baseLinkerProps)
|
|
wholeArchiveDeps = bazel.MakeLabelListAttribute(android.BazelLabelForModuleDeps(ctx, wholeArchiveLibs))
|
|
|
|
if baseLinkerProps.Version_script != nil {
|
|
versionScript.Value = android.BazelLabelForModuleSrcSingle(ctx, *baseLinkerProps.Version_script)
|
|
}
|
|
|
|
sharedLibs := baseLinkerProps.Shared_libs
|
|
dynamicDeps = bazel.MakeLabelListAttribute(android.BazelLabelForModuleDeps(ctx, sharedLibs))
|
|
|
|
break
|
|
}
|
|
}
|
|
|
|
for arch, p := range module.GetArchProperties(ctx, &BaseLinkerProperties{}) {
|
|
if baseLinkerProps, ok := p.(*BaseLinkerProperties); ok {
|
|
libs := baseLinkerProps.Header_libs
|
|
libs = append(libs, baseLinkerProps.Static_libs...)
|
|
exportedLibs := baseLinkerProps.Export_header_lib_headers
|
|
wholeArchiveLibs := baseLinkerProps.Whole_static_libs
|
|
libs = android.SortedUniqueStrings(libs)
|
|
deps.SetValueForArch(arch.Name, android.BazelLabelForModuleDeps(ctx, libs))
|
|
exportedDeps.SetValueForArch(arch.Name, android.BazelLabelForModuleDeps(ctx, exportedLibs))
|
|
linkopts.SetValueForArch(arch.Name, getBp2BuildLinkerFlags(baseLinkerProps))
|
|
wholeArchiveDeps.SetValueForArch(arch.Name, android.BazelLabelForModuleDeps(ctx, wholeArchiveLibs))
|
|
|
|
if baseLinkerProps.Version_script != nil {
|
|
versionScript.SetValueForArch(arch.Name,
|
|
android.BazelLabelForModuleSrcSingle(ctx, *baseLinkerProps.Version_script))
|
|
}
|
|
|
|
sharedLibs := baseLinkerProps.Shared_libs
|
|
dynamicDeps.SetValueForArch(arch.Name, android.BazelLabelForModuleDeps(ctx, sharedLibs))
|
|
}
|
|
}
|
|
|
|
for os, p := range module.GetTargetProperties(ctx, &BaseLinkerProperties{}) {
|
|
if baseLinkerProps, ok := p.(*BaseLinkerProperties); ok {
|
|
libs := baseLinkerProps.Header_libs
|
|
libs = append(libs, baseLinkerProps.Static_libs...)
|
|
exportedLibs := baseLinkerProps.Export_header_lib_headers
|
|
wholeArchiveLibs := baseLinkerProps.Whole_static_libs
|
|
libs = android.SortedUniqueStrings(libs)
|
|
wholeArchiveDeps.SetValueForOS(os.Name, android.BazelLabelForModuleDeps(ctx, wholeArchiveLibs))
|
|
deps.SetValueForOS(os.Name, android.BazelLabelForModuleDeps(ctx, libs))
|
|
exportedDeps.SetValueForOS(os.Name, android.BazelLabelForModuleDeps(ctx, exportedLibs))
|
|
|
|
linkopts.SetValueForOS(os.Name, getBp2BuildLinkerFlags(baseLinkerProps))
|
|
|
|
sharedLibs := baseLinkerProps.Shared_libs
|
|
dynamicDeps.SetValueForOS(os.Name, android.BazelLabelForModuleDeps(ctx, sharedLibs))
|
|
}
|
|
}
|
|
|
|
return linkerAttributes{
|
|
deps: deps,
|
|
exportedDeps: exportedDeps,
|
|
dynamicDeps: dynamicDeps,
|
|
wholeArchiveDeps: wholeArchiveDeps,
|
|
linkopts: linkopts,
|
|
versionScript: versionScript,
|
|
}
|
|
}
|
|
|
|
// Relativize a list of root-relative paths with respect to the module's
|
|
// directory.
|
|
//
|
|
// include_dirs Soong prop are root-relative (b/183742505), but
|
|
// local_include_dirs, export_include_dirs and export_system_include_dirs are
|
|
// module dir relative. This function makes a list of paths entirely module dir
|
|
// relative.
|
|
//
|
|
// For the `include` attribute, Bazel wants the paths to be relative to the
|
|
// module.
|
|
func bp2BuildMakePathsRelativeToModule(ctx android.BazelConversionPathContext, paths []string) []string {
|
|
var relativePaths []string
|
|
for _, path := range paths {
|
|
// Semantics of filepath.Rel: join(ModuleDir, rel(ModuleDir, path)) == path
|
|
relativePath, err := filepath.Rel(ctx.ModuleDir(), path)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
relativePaths = append(relativePaths, relativePath)
|
|
}
|
|
return relativePaths
|
|
}
|
|
|
|
// bp2BuildParseExportedIncludes creates a string list attribute contains the
|
|
// exported included directories of a module.
|
|
func bp2BuildParseExportedIncludes(ctx android.TopDownMutatorContext, module *Module) bazel.StringListAttribute {
|
|
libraryDecorator := module.linker.(*libraryDecorator)
|
|
|
|
// Export_system_include_dirs and export_include_dirs are already module dir
|
|
// relative, so they don't need to be relativized like include_dirs, which
|
|
// are root-relative.
|
|
includeDirs := libraryDecorator.flagExporter.Properties.Export_system_include_dirs
|
|
includeDirs = append(includeDirs, libraryDecorator.flagExporter.Properties.Export_include_dirs...)
|
|
includeDirsAttribute := bazel.MakeStringListAttribute(includeDirs)
|
|
|
|
for arch, props := range module.GetArchProperties(ctx, &FlagExporterProperties{}) {
|
|
if flagExporterProperties, ok := props.(*FlagExporterProperties); ok {
|
|
archIncludeDirs := flagExporterProperties.Export_system_include_dirs
|
|
archIncludeDirs = append(archIncludeDirs, flagExporterProperties.Export_include_dirs...)
|
|
|
|
// To avoid duplicate includes when base includes + arch includes are combined
|
|
// FIXME: This doesn't take conflicts between arch and os includes into account
|
|
archIncludeDirs = bazel.SubtractStrings(archIncludeDirs, includeDirs)
|
|
|
|
if len(archIncludeDirs) > 0 {
|
|
includeDirsAttribute.SetValueForArch(arch.Name, archIncludeDirs)
|
|
}
|
|
}
|
|
}
|
|
|
|
for os, props := range module.GetTargetProperties(ctx, &FlagExporterProperties{}) {
|
|
if flagExporterProperties, ok := props.(*FlagExporterProperties); ok {
|
|
osIncludeDirs := flagExporterProperties.Export_system_include_dirs
|
|
osIncludeDirs = append(osIncludeDirs, flagExporterProperties.Export_include_dirs...)
|
|
|
|
// To avoid duplicate includes when base includes + os includes are combined
|
|
// FIXME: This doesn't take conflicts between arch and os includes into account
|
|
osIncludeDirs = bazel.SubtractStrings(osIncludeDirs, includeDirs)
|
|
|
|
if len(osIncludeDirs) > 0 {
|
|
includeDirsAttribute.SetValueForOS(os.Name, osIncludeDirs)
|
|
}
|
|
}
|
|
}
|
|
|
|
return includeDirsAttribute
|
|
}
|