39b6cc5336
Soong does not enforce apex_available on the contents of test apex. To prevent special-casing test apexes in the apex validation aspect in Bazel, drop the test apexes from the tags altogether. ( The core problem I am trying to solve is making sure that stub libraries in Bazel have a single apex available. apex validation happens to be a nice side benefit) Bug: 277651159 Test: go test ./bp2build Change-Id: Ibb3cfedb5c0f2cda0464bf3758c70b67cb5885d1
843 lines
28 KiB
Go
843 lines
28 KiB
Go
// Copyright 2016 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"
|
|
|
|
"android/soong/android"
|
|
"android/soong/bazel"
|
|
"android/soong/bazel/cquery"
|
|
)
|
|
|
|
func init() {
|
|
RegisterPrebuiltBuildComponents(android.InitRegistrationContext)
|
|
}
|
|
|
|
func RegisterPrebuiltBuildComponents(ctx android.RegistrationContext) {
|
|
ctx.RegisterModuleType("cc_prebuilt_library", PrebuiltLibraryFactory)
|
|
ctx.RegisterModuleType("cc_prebuilt_library_shared", PrebuiltSharedLibraryFactory)
|
|
ctx.RegisterModuleType("cc_prebuilt_library_static", PrebuiltStaticLibraryFactory)
|
|
ctx.RegisterModuleType("cc_prebuilt_test_library_shared", PrebuiltSharedTestLibraryFactory)
|
|
ctx.RegisterModuleType("cc_prebuilt_object", PrebuiltObjectFactory)
|
|
ctx.RegisterModuleType("cc_prebuilt_binary", PrebuiltBinaryFactory)
|
|
}
|
|
|
|
type prebuiltLinkerInterface interface {
|
|
Name(string) string
|
|
prebuilt() *android.Prebuilt
|
|
}
|
|
|
|
type prebuiltLinkerProperties struct {
|
|
// a prebuilt library or binary. Can reference a genrule module that generates an executable file.
|
|
Srcs []string `android:"path,arch_variant"`
|
|
|
|
Sanitized Sanitized `android:"arch_variant"`
|
|
|
|
// Check the prebuilt ELF files (e.g. DT_SONAME, DT_NEEDED, resolution of undefined
|
|
// symbols, etc), default true.
|
|
Check_elf_files *bool
|
|
|
|
// if set, add an extra objcopy --prefix-symbols= step
|
|
Prefix_symbols *string
|
|
|
|
// Optionally provide an import library if this is a Windows PE DLL prebuilt.
|
|
// This is needed only if this library is linked by other modules in build time.
|
|
// Only makes sense for the Windows target.
|
|
Windows_import_lib *string `android:"path,arch_variant"`
|
|
|
|
// MixedBuildsDisabled is true if and only if building this prebuilt is explicitly disabled in mixed builds for either
|
|
// its static or shared version on the current build variant. This is to prevent Bazel targets for build variants with
|
|
// which either the static or shared version is incompatible from participating in mixed buiods. Please note that this
|
|
// is an override and does not fully determine whether Bazel or Soong will be used. For the full determination, see
|
|
// cc.ProcessBazelQueryResponse, cc.QueueBazelCall, and cc.MixedBuildsDisabled.
|
|
MixedBuildsDisabled bool `blueprint:"mutated"`
|
|
}
|
|
|
|
type prebuiltLinker struct {
|
|
android.Prebuilt
|
|
|
|
properties prebuiltLinkerProperties
|
|
}
|
|
|
|
func (p *prebuiltLinker) prebuilt() *android.Prebuilt {
|
|
return &p.Prebuilt
|
|
}
|
|
|
|
func (p *prebuiltLinker) PrebuiltSrcs() []string {
|
|
return p.properties.Srcs
|
|
}
|
|
|
|
type prebuiltLibraryInterface interface {
|
|
libraryInterface
|
|
prebuiltLinkerInterface
|
|
disablePrebuilt()
|
|
}
|
|
|
|
type prebuiltLibraryLinker struct {
|
|
*libraryDecorator
|
|
prebuiltLinker
|
|
}
|
|
|
|
var _ prebuiltLinkerInterface = (*prebuiltLibraryLinker)(nil)
|
|
var _ prebuiltLibraryInterface = (*prebuiltLibraryLinker)(nil)
|
|
|
|
func (p *prebuiltLibraryLinker) linkerInit(ctx BaseModuleContext) {}
|
|
|
|
func (p *prebuiltLibraryLinker) linkerDeps(ctx DepsContext, deps Deps) Deps {
|
|
return p.libraryDecorator.linkerDeps(ctx, deps)
|
|
}
|
|
|
|
func (p *prebuiltLibraryLinker) linkerFlags(ctx ModuleContext, flags Flags) Flags {
|
|
return flags
|
|
}
|
|
|
|
func (p *prebuiltLibraryLinker) linkerProps() []interface{} {
|
|
return p.libraryDecorator.linkerProps()
|
|
}
|
|
|
|
func (p *prebuiltLibraryLinker) link(ctx ModuleContext,
|
|
flags Flags, deps PathDeps, objs Objects) android.Path {
|
|
|
|
p.libraryDecorator.flagExporter.exportIncludes(ctx)
|
|
p.libraryDecorator.flagExporter.reexportDirs(deps.ReexportedDirs...)
|
|
p.libraryDecorator.flagExporter.reexportSystemDirs(deps.ReexportedSystemDirs...)
|
|
p.libraryDecorator.flagExporter.reexportFlags(deps.ReexportedFlags...)
|
|
p.libraryDecorator.flagExporter.reexportDeps(deps.ReexportedDeps...)
|
|
p.libraryDecorator.flagExporter.addExportedGeneratedHeaders(deps.ReexportedGeneratedHeaders...)
|
|
|
|
p.libraryDecorator.flagExporter.setProvider(ctx)
|
|
|
|
// TODO(ccross): verify shared library dependencies
|
|
srcs := p.prebuiltSrcs(ctx)
|
|
if len(srcs) > 0 {
|
|
if len(srcs) > 1 {
|
|
ctx.PropertyErrorf("srcs", "multiple prebuilt source files")
|
|
return nil
|
|
}
|
|
|
|
p.libraryDecorator.exportVersioningMacroIfNeeded(ctx)
|
|
|
|
in := android.PathForModuleSrc(ctx, srcs[0])
|
|
|
|
if String(p.prebuiltLinker.properties.Prefix_symbols) != "" {
|
|
prefixed := android.PathForModuleOut(ctx, "prefixed", srcs[0])
|
|
transformBinaryPrefixSymbols(ctx, String(p.prebuiltLinker.properties.Prefix_symbols),
|
|
in, flagsToBuilderFlags(flags), prefixed)
|
|
in = prefixed
|
|
}
|
|
|
|
if p.static() {
|
|
depSet := android.NewDepSetBuilder(android.TOPOLOGICAL).Direct(in).Build()
|
|
ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
|
|
StaticLibrary: in,
|
|
|
|
TransitiveStaticLibrariesForOrdering: depSet,
|
|
})
|
|
return in
|
|
}
|
|
|
|
if p.shared() {
|
|
p.unstrippedOutputFile = in
|
|
libName := p.libraryDecorator.getLibName(ctx) + flags.Toolchain.ShlibSuffix()
|
|
outputFile := android.PathForModuleOut(ctx, libName)
|
|
var implicits android.Paths
|
|
|
|
if p.stripper.NeedsStrip(ctx) {
|
|
stripFlags := flagsToStripFlags(flags)
|
|
stripped := android.PathForModuleOut(ctx, "stripped", libName)
|
|
p.stripper.StripExecutableOrSharedLib(ctx, in, stripped, stripFlags)
|
|
in = stripped
|
|
}
|
|
|
|
// Optimize out relinking against shared libraries whose interface hasn't changed by
|
|
// depending on a table of contents file instead of the library itself.
|
|
tocFile := android.PathForModuleOut(ctx, libName+".toc")
|
|
p.tocFile = android.OptionalPathForPath(tocFile)
|
|
TransformSharedObjectToToc(ctx, outputFile, tocFile)
|
|
|
|
if ctx.Windows() && p.properties.Windows_import_lib != nil {
|
|
// Consumers of this library actually links to the import library in build
|
|
// time and dynamically links to the DLL in run time. i.e.
|
|
// a.exe <-- static link --> foo.lib <-- dynamic link --> foo.dll
|
|
importLibSrc := android.PathForModuleSrc(ctx, String(p.properties.Windows_import_lib))
|
|
importLibName := p.libraryDecorator.getLibName(ctx) + ".lib"
|
|
importLibOutputFile := android.PathForModuleOut(ctx, importLibName)
|
|
implicits = append(implicits, importLibOutputFile)
|
|
|
|
ctx.Build(pctx, android.BuildParams{
|
|
Rule: android.Cp,
|
|
Description: "prebuilt import library",
|
|
Input: importLibSrc,
|
|
Output: importLibOutputFile,
|
|
Args: map[string]string{
|
|
"cpFlags": "-L",
|
|
},
|
|
})
|
|
}
|
|
|
|
ctx.Build(pctx, android.BuildParams{
|
|
Rule: android.Cp,
|
|
Description: "prebuilt shared library",
|
|
Implicits: implicits,
|
|
Input: in,
|
|
Output: outputFile,
|
|
Args: map[string]string{
|
|
"cpFlags": "-L",
|
|
},
|
|
})
|
|
|
|
ctx.SetProvider(SharedLibraryInfoProvider, SharedLibraryInfo{
|
|
SharedLibrary: outputFile,
|
|
Target: ctx.Target(),
|
|
|
|
TableOfContents: p.tocFile,
|
|
})
|
|
|
|
// TODO(b/220898484): Mainline module sdk prebuilts of stub libraries use a stub
|
|
// library as their source and must not be installed, but other prebuilts like
|
|
// libclang_rt.* libraries set `stubs` property because they are LLNDK libraries,
|
|
// but use an implementation library as their source and need to be installed.
|
|
// This discrepancy should be resolved without the prefix hack below.
|
|
isModuleSdkPrebuilts := android.HasAnyPrefix(ctx.ModuleDir(), []string{
|
|
"prebuilts/runtime/mainline/", "prebuilts/module_sdk/"})
|
|
if p.hasStubsVariants() && !p.buildStubs() && !ctx.Host() && isModuleSdkPrebuilts {
|
|
ctx.Module().MakeUninstallable()
|
|
}
|
|
|
|
return outputFile
|
|
}
|
|
}
|
|
|
|
if p.header() {
|
|
ctx.SetProvider(HeaderLibraryInfoProvider, HeaderLibraryInfo{})
|
|
|
|
// Need to return an output path so that the AndroidMk logic doesn't skip
|
|
// the prebuilt header. For compatibility, in case Android.mk files use a
|
|
// header lib in LOCAL_STATIC_LIBRARIES, create an empty ar file as
|
|
// placeholder, just like non-prebuilt header modules do in linkStatic().
|
|
ph := android.PathForModuleOut(ctx, ctx.ModuleName()+staticLibraryExtension)
|
|
transformObjToStaticLib(ctx, nil, nil, builderFlags{}, ph, nil, nil)
|
|
return ph
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (p *prebuiltLibraryLinker) prebuiltSrcs(ctx android.BaseModuleContext) []string {
|
|
sanitize := ctx.Module().(*Module).sanitize
|
|
srcs := p.properties.Srcs
|
|
srcs = append(srcs, srcsForSanitizer(sanitize, p.properties.Sanitized)...)
|
|
if p.static() {
|
|
srcs = append(srcs, p.libraryDecorator.StaticProperties.Static.Srcs...)
|
|
srcs = append(srcs, srcsForSanitizer(sanitize, p.libraryDecorator.StaticProperties.Static.Sanitized)...)
|
|
}
|
|
if p.shared() {
|
|
srcs = append(srcs, p.libraryDecorator.SharedProperties.Shared.Srcs...)
|
|
srcs = append(srcs, srcsForSanitizer(sanitize, p.libraryDecorator.SharedProperties.Shared.Sanitized)...)
|
|
}
|
|
return srcs
|
|
}
|
|
|
|
func (p *prebuiltLibraryLinker) shared() bool {
|
|
return p.libraryDecorator.shared()
|
|
}
|
|
|
|
func (p *prebuiltLibraryLinker) nativeCoverage() bool {
|
|
return false
|
|
}
|
|
|
|
func (p *prebuiltLibraryLinker) disablePrebuilt() {
|
|
p.properties.Srcs = nil
|
|
p.properties.MixedBuildsDisabled = true
|
|
}
|
|
|
|
// Implements versionedInterface
|
|
func (p *prebuiltLibraryLinker) implementationModuleName(name string) string {
|
|
return android.RemoveOptionalPrebuiltPrefix(name)
|
|
}
|
|
|
|
func NewPrebuiltLibrary(hod android.HostOrDeviceSupported, srcsProperty string) (*Module, *libraryDecorator) {
|
|
module, library := NewLibrary(hod)
|
|
module.compiler = nil
|
|
module.bazelable = true
|
|
module.bazelHandler = &prebuiltLibraryBazelHandler{module: module, library: library}
|
|
|
|
prebuilt := &prebuiltLibraryLinker{
|
|
libraryDecorator: library,
|
|
}
|
|
module.linker = prebuilt
|
|
module.library = prebuilt
|
|
|
|
module.AddProperties(&prebuilt.properties)
|
|
|
|
if srcsProperty == "" {
|
|
android.InitPrebuiltModuleWithoutSrcs(module)
|
|
} else {
|
|
srcsSupplier := func(ctx android.BaseModuleContext, _ android.Module) []string {
|
|
return prebuilt.prebuiltSrcs(ctx)
|
|
}
|
|
|
|
android.InitPrebuiltModuleWithSrcSupplier(module, srcsSupplier, srcsProperty)
|
|
}
|
|
|
|
return module, library
|
|
}
|
|
|
|
// cc_prebuilt_library installs a precompiled shared library that are
|
|
// listed in the srcs property in the device's directory.
|
|
func PrebuiltLibraryFactory() android.Module {
|
|
module, _ := NewPrebuiltLibrary(android.HostAndDeviceSupported, "srcs")
|
|
|
|
// Prebuilt shared libraries can be included in APEXes
|
|
android.InitApexModule(module)
|
|
|
|
return module.Init()
|
|
}
|
|
|
|
// cc_prebuilt_library_shared installs a precompiled shared library that are
|
|
// listed in the srcs property in the device's directory.
|
|
func PrebuiltSharedLibraryFactory() android.Module {
|
|
module, _ := NewPrebuiltSharedLibrary(android.HostAndDeviceSupported)
|
|
return module.Init()
|
|
}
|
|
|
|
// cc_prebuilt_test_library_shared installs a precompiled shared library
|
|
// to be used as a data dependency of a test-related module (such as cc_test, or
|
|
// cc_test_library).
|
|
func PrebuiltSharedTestLibraryFactory() android.Module {
|
|
module, library := NewPrebuiltLibrary(android.HostAndDeviceSupported, "srcs")
|
|
library.BuildOnlyShared()
|
|
library.baseInstaller = NewTestInstaller()
|
|
return module.Init()
|
|
}
|
|
|
|
func NewPrebuiltSharedLibrary(hod android.HostOrDeviceSupported) (*Module, *libraryDecorator) {
|
|
module, library := NewPrebuiltLibrary(hod, "srcs")
|
|
library.BuildOnlyShared()
|
|
|
|
// Prebuilt shared libraries can be included in APEXes
|
|
android.InitApexModule(module)
|
|
|
|
return module, library
|
|
}
|
|
|
|
// cc_prebuilt_library_static installs a precompiled static library that are
|
|
// listed in the srcs property in the device's directory.
|
|
func PrebuiltStaticLibraryFactory() android.Module {
|
|
module, _ := NewPrebuiltStaticLibrary(android.HostAndDeviceSupported)
|
|
return module.Init()
|
|
}
|
|
|
|
func NewPrebuiltStaticLibrary(hod android.HostOrDeviceSupported) (*Module, *libraryDecorator) {
|
|
module, library := NewPrebuiltLibrary(hod, "srcs")
|
|
library.BuildOnlyStatic()
|
|
|
|
return module, library
|
|
}
|
|
|
|
type bazelPrebuiltLibraryStaticAttributes struct {
|
|
Static_library bazel.LabelAttribute
|
|
Export_includes bazel.StringListAttribute
|
|
Export_system_includes bazel.StringListAttribute
|
|
Alwayslink bazel.BoolAttribute
|
|
}
|
|
|
|
// TODO(b/228623543): The below is not entirely true until the bug is fixed. For now, both targets are always generated
|
|
// Implements bp2build for cc_prebuilt_library modules. This will generate:
|
|
// - Only a cc_prebuilt_library_static if the shared.enabled property is set to false across all variants.
|
|
// - Only a cc_prebuilt_library_shared if the static.enabled property is set to false across all variants
|
|
// - Both a cc_prebuilt_library_static and cc_prebuilt_library_shared if the aforementioned properties are not false across
|
|
// all variants
|
|
//
|
|
// In all cases, cc_prebuilt_library_static target names will be appended with "_bp2build_cc_library_static".
|
|
func prebuiltLibraryBp2Build(ctx android.TopDownMutatorContext, module *Module) {
|
|
prebuiltLibraryStaticBp2Build(ctx, module, true)
|
|
prebuiltLibrarySharedBp2Build(ctx, module)
|
|
}
|
|
|
|
func prebuiltLibraryStaticBp2Build(ctx android.TopDownMutatorContext, module *Module, fullBuild bool) {
|
|
prebuiltAttrs := Bp2BuildParsePrebuiltLibraryProps(ctx, module, true)
|
|
exportedIncludes := bp2BuildParseExportedIncludes(ctx, module, nil)
|
|
|
|
attrs := &bazelPrebuiltLibraryStaticAttributes{
|
|
Static_library: prebuiltAttrs.Src,
|
|
Export_includes: exportedIncludes.Includes,
|
|
Export_system_includes: exportedIncludes.SystemIncludes,
|
|
// TODO: ¿Alwayslink?
|
|
}
|
|
|
|
props := bazel.BazelTargetModuleProperties{
|
|
Rule_class: "cc_prebuilt_library_static",
|
|
Bzl_load_location: "//build/bazel/rules/cc:cc_prebuilt_library_static.bzl",
|
|
}
|
|
|
|
name := android.RemoveOptionalPrebuiltPrefix(module.Name())
|
|
if fullBuild {
|
|
name += "_bp2build_cc_library_static"
|
|
}
|
|
|
|
tags := android.ApexAvailableTagsWithoutTestApexes(ctx, module)
|
|
ctx.CreateBazelTargetModuleWithRestrictions(props, android.CommonAttributes{Name: name, Tags: tags}, attrs, prebuiltAttrs.Enabled)
|
|
|
|
_true := true
|
|
alwayslinkAttrs := *attrs
|
|
alwayslinkAttrs.Alwayslink.SetValue(&_true)
|
|
ctx.CreateBazelTargetModuleWithRestrictions(props, android.CommonAttributes{Name: name + "_alwayslink", Tags: tags}, &alwayslinkAttrs, prebuiltAttrs.Enabled)
|
|
}
|
|
|
|
type bazelPrebuiltLibrarySharedAttributes struct {
|
|
Shared_library bazel.LabelAttribute
|
|
Export_includes bazel.StringListAttribute
|
|
Export_system_includes bazel.StringListAttribute
|
|
}
|
|
|
|
func prebuiltLibrarySharedBp2Build(ctx android.TopDownMutatorContext, module *Module) {
|
|
prebuiltAttrs := Bp2BuildParsePrebuiltLibraryProps(ctx, module, false)
|
|
exportedIncludes := bp2BuildParseExportedIncludes(ctx, module, nil)
|
|
|
|
attrs := &bazelPrebuiltLibrarySharedAttributes{
|
|
Shared_library: prebuiltAttrs.Src,
|
|
Export_includes: exportedIncludes.Includes,
|
|
Export_system_includes: exportedIncludes.SystemIncludes,
|
|
}
|
|
|
|
props := bazel.BazelTargetModuleProperties{
|
|
Rule_class: "cc_prebuilt_library_shared",
|
|
Bzl_load_location: "//build/bazel/rules/cc:cc_prebuilt_library_shared.bzl",
|
|
}
|
|
|
|
name := android.RemoveOptionalPrebuiltPrefix(module.Name())
|
|
tags := android.ApexAvailableTagsWithoutTestApexes(ctx, module)
|
|
ctx.CreateBazelTargetModuleWithRestrictions(props, android.CommonAttributes{Name: name, Tags: tags}, attrs, prebuiltAttrs.Enabled)
|
|
}
|
|
|
|
type prebuiltObjectProperties struct {
|
|
Srcs []string `android:"path,arch_variant"`
|
|
}
|
|
|
|
type prebuiltObjectLinker struct {
|
|
android.Prebuilt
|
|
objectLinker
|
|
|
|
properties prebuiltObjectProperties
|
|
}
|
|
|
|
type prebuiltLibraryBazelHandler struct {
|
|
module *Module
|
|
library *libraryDecorator
|
|
}
|
|
|
|
var _ BazelHandler = (*prebuiltLibraryBazelHandler)(nil)
|
|
|
|
func (h *prebuiltLibraryBazelHandler) QueueBazelCall(ctx android.BaseModuleContext, label string) {
|
|
if h.module.linker.(*prebuiltLibraryLinker).properties.MixedBuildsDisabled {
|
|
return
|
|
}
|
|
bazelCtx := ctx.Config().BazelContext
|
|
bazelCtx.QueueBazelRequest(label, cquery.GetCcInfo, android.GetConfigKey(ctx))
|
|
}
|
|
|
|
func (h *prebuiltLibraryBazelHandler) ProcessBazelQueryResponse(ctx android.ModuleContext, label string) {
|
|
if h.module.linker.(*prebuiltLibraryLinker).properties.MixedBuildsDisabled {
|
|
return
|
|
}
|
|
bazelCtx := ctx.Config().BazelContext
|
|
ccInfo, err := bazelCtx.GetCcInfo(label, android.GetConfigKey(ctx))
|
|
if err != nil {
|
|
ctx.ModuleErrorf(err.Error())
|
|
return
|
|
}
|
|
|
|
if h.module.static() {
|
|
if ok := h.processStaticBazelQueryResponse(ctx, label, ccInfo); !ok {
|
|
return
|
|
}
|
|
} else if h.module.Shared() {
|
|
if ok := h.processSharedBazelQueryResponse(ctx, label, ccInfo); !ok {
|
|
return
|
|
}
|
|
} else {
|
|
return
|
|
}
|
|
|
|
h.module.maybeUnhideFromMake()
|
|
|
|
h.module.setAndroidMkVariablesFromCquery(ccInfo.CcAndroidMkInfo)
|
|
}
|
|
|
|
func (h *prebuiltLibraryBazelHandler) processStaticBazelQueryResponse(ctx android.ModuleContext, label string, ccInfo cquery.CcInfo) bool {
|
|
staticLibs := ccInfo.CcStaticLibraryFiles
|
|
if len(staticLibs) > 1 {
|
|
ctx.ModuleErrorf("expected 1 static library from bazel target %q, got %s", label, staticLibs)
|
|
return false
|
|
}
|
|
|
|
// TODO(b/184543518): cc_prebuilt_library_static may have properties for re-exporting flags
|
|
|
|
// TODO(eakammer):Add stub-related flags if this library is a stub library.
|
|
// h.library.exportVersioningMacroIfNeeded(ctx)
|
|
|
|
// Dependencies on this library will expect collectedSnapshotHeaders to be set, otherwise
|
|
// validation will fail. For now, set this to an empty list.
|
|
// TODO(cparsons): More closely mirror the collectHeadersForSnapshot implementation.
|
|
h.library.collectedSnapshotHeaders = android.Paths{}
|
|
|
|
if len(staticLibs) == 0 {
|
|
h.module.outputFile = android.OptionalPath{}
|
|
return true
|
|
}
|
|
|
|
var outputPath android.Path = android.PathForBazelOut(ctx, staticLibs[0])
|
|
if len(ccInfo.TidyFiles) > 0 {
|
|
h.module.tidyFiles = android.PathsForBazelOut(ctx, ccInfo.TidyFiles)
|
|
outputPath = android.AttachValidationActions(ctx, outputPath, h.module.tidyFiles)
|
|
}
|
|
|
|
h.module.outputFile = android.OptionalPathForPath(outputPath)
|
|
|
|
depSet := android.NewDepSetBuilder(android.TOPOLOGICAL).Direct(outputPath).Build()
|
|
ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
|
|
StaticLibrary: outputPath,
|
|
TransitiveStaticLibrariesForOrdering: depSet,
|
|
})
|
|
|
|
return true
|
|
}
|
|
|
|
func (h *prebuiltLibraryBazelHandler) processSharedBazelQueryResponse(ctx android.ModuleContext, label string, ccInfo cquery.CcInfo) bool {
|
|
sharedLibs := ccInfo.CcSharedLibraryFiles
|
|
if len(sharedLibs) > 1 {
|
|
ctx.ModuleErrorf("expected 1 shared library from bazel target %s, got %q", label, sharedLibs)
|
|
return false
|
|
}
|
|
|
|
// TODO(b/184543518): cc_prebuilt_library_shared may have properties for re-exporting flags
|
|
|
|
// TODO(eakammer):Add stub-related flags if this library is a stub library.
|
|
// h.library.exportVersioningMacroIfNeeded(ctx)
|
|
|
|
if len(sharedLibs) == 0 {
|
|
h.module.outputFile = android.OptionalPath{}
|
|
return true
|
|
}
|
|
|
|
var outputPath android.Path = android.PathForBazelOut(ctx, sharedLibs[0])
|
|
if len(ccInfo.TidyFiles) > 0 {
|
|
h.module.tidyFiles = android.PathsForBazelOut(ctx, ccInfo.TidyFiles)
|
|
outputPath = android.AttachValidationActions(ctx, outputPath, h.module.tidyFiles)
|
|
}
|
|
|
|
h.module.outputFile = android.OptionalPathForPath(outputPath)
|
|
|
|
// FIXME(b/214600441): We don't yet strip prebuilt shared libraries
|
|
h.library.unstrippedOutputFile = outputPath
|
|
|
|
var toc android.Path
|
|
if len(ccInfo.TocFile) > 0 {
|
|
toc = android.PathForBazelOut(ctx, ccInfo.TocFile)
|
|
} else {
|
|
toc = outputPath // Just reuse `out` so ninja still gets an input but won't matter
|
|
}
|
|
|
|
info := SharedLibraryInfo{
|
|
SharedLibrary: outputPath,
|
|
TableOfContents: android.OptionalPathForPath(toc),
|
|
Target: ctx.Target(),
|
|
}
|
|
ctx.SetProvider(SharedLibraryInfoProvider, info)
|
|
|
|
h.library.setFlagExporterInfoFromCcInfo(ctx, ccInfo)
|
|
h.module.maybeUnhideFromMake()
|
|
return true
|
|
}
|
|
|
|
func (p *prebuiltObjectLinker) prebuilt() *android.Prebuilt {
|
|
return &p.Prebuilt
|
|
}
|
|
|
|
var _ prebuiltLinkerInterface = (*prebuiltObjectLinker)(nil)
|
|
|
|
func (p *prebuiltObjectLinker) link(ctx ModuleContext,
|
|
flags Flags, deps PathDeps, objs Objects) android.Path {
|
|
if len(p.properties.Srcs) > 0 {
|
|
// Copy objects to a name matching the final installed name
|
|
in := p.Prebuilt.SingleSourcePath(ctx)
|
|
outputFile := android.PathForModuleOut(ctx, ctx.ModuleName()+".o")
|
|
ctx.Build(pctx, android.BuildParams{
|
|
Rule: android.CpExecutable,
|
|
Description: "prebuilt",
|
|
Output: outputFile,
|
|
Input: in,
|
|
})
|
|
return outputFile
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *prebuiltObjectLinker) object() bool {
|
|
return true
|
|
}
|
|
|
|
func NewPrebuiltObject(hod android.HostOrDeviceSupported) *Module {
|
|
module := newObject(hod)
|
|
module.bazelHandler = &prebuiltObjectBazelHandler{module: module}
|
|
module.bazelable = true
|
|
prebuilt := &prebuiltObjectLinker{
|
|
objectLinker: objectLinker{
|
|
baseLinker: NewBaseLinker(nil),
|
|
},
|
|
}
|
|
module.linker = prebuilt
|
|
module.AddProperties(&prebuilt.properties)
|
|
android.InitPrebuiltModule(module, &prebuilt.properties.Srcs)
|
|
return module
|
|
}
|
|
|
|
type prebuiltObjectBazelHandler struct {
|
|
module *Module
|
|
}
|
|
|
|
var _ BazelHandler = (*prebuiltObjectBazelHandler)(nil)
|
|
|
|
func (h *prebuiltObjectBazelHandler) QueueBazelCall(ctx android.BaseModuleContext, label string) {
|
|
bazelCtx := ctx.Config().BazelContext
|
|
bazelCtx.QueueBazelRequest(label, cquery.GetOutputFiles, android.GetConfigKey(ctx))
|
|
}
|
|
|
|
func (h *prebuiltObjectBazelHandler) ProcessBazelQueryResponse(ctx android.ModuleContext, label string) {
|
|
bazelCtx := ctx.Config().BazelContext
|
|
outputs, err := bazelCtx.GetOutputFiles(label, android.GetConfigKey(ctx))
|
|
if err != nil {
|
|
ctx.ModuleErrorf(err.Error())
|
|
return
|
|
}
|
|
if len(outputs) != 1 {
|
|
ctx.ModuleErrorf("Expected a single output for `%s`, but got:\n%v", label, outputs)
|
|
return
|
|
}
|
|
out := android.PathForBazelOut(ctx, outputs[0])
|
|
h.module.outputFile = android.OptionalPathForPath(out)
|
|
h.module.maybeUnhideFromMake()
|
|
}
|
|
|
|
type bazelPrebuiltObjectAttributes struct {
|
|
Src bazel.LabelAttribute
|
|
}
|
|
|
|
func prebuiltObjectBp2Build(ctx android.TopDownMutatorContext, module *Module) {
|
|
prebuiltAttrs := bp2BuildParsePrebuiltObjectProps(ctx, module)
|
|
|
|
attrs := &bazelPrebuiltObjectAttributes{
|
|
Src: prebuiltAttrs.Src,
|
|
}
|
|
|
|
props := bazel.BazelTargetModuleProperties{
|
|
Rule_class: "cc_prebuilt_object",
|
|
Bzl_load_location: "//build/bazel/rules/cc:cc_prebuilt_object.bzl",
|
|
}
|
|
|
|
name := android.RemoveOptionalPrebuiltPrefix(module.Name())
|
|
tags := android.ApexAvailableTagsWithoutTestApexes(ctx, module)
|
|
ctx.CreateBazelTargetModule(props, android.CommonAttributes{Name: name, Tags: tags}, attrs)
|
|
}
|
|
|
|
func PrebuiltObjectFactory() android.Module {
|
|
module := NewPrebuiltObject(android.HostAndDeviceSupported)
|
|
return module.Init()
|
|
}
|
|
|
|
type prebuiltBinaryLinker struct {
|
|
*binaryDecorator
|
|
prebuiltLinker
|
|
|
|
toolPath android.OptionalPath
|
|
}
|
|
|
|
var _ prebuiltLinkerInterface = (*prebuiltBinaryLinker)(nil)
|
|
|
|
func (p *prebuiltBinaryLinker) hostToolPath() android.OptionalPath {
|
|
return p.toolPath
|
|
}
|
|
|
|
func (p *prebuiltBinaryLinker) link(ctx ModuleContext,
|
|
flags Flags, deps PathDeps, objs Objects) android.Path {
|
|
// TODO(ccross): verify shared library dependencies
|
|
if len(p.properties.Srcs) > 0 {
|
|
fileName := p.getStem(ctx) + flags.Toolchain.ExecutableSuffix()
|
|
in := p.Prebuilt.SingleSourcePath(ctx)
|
|
outputFile := android.PathForModuleOut(ctx, fileName)
|
|
p.unstrippedOutputFile = in
|
|
|
|
if ctx.Host() {
|
|
// Host binaries are symlinked to their prebuilt source locations. That
|
|
// way they are executed directly from there so the linker resolves their
|
|
// shared library dependencies relative to that location (using
|
|
// $ORIGIN/../lib(64):$ORIGIN/lib(64) as RUNPATH). This way the prebuilt
|
|
// repository can supply the expected versions of the shared libraries
|
|
// without interference from what is in the out tree.
|
|
|
|
// These shared lib paths may point to copies of the libs in
|
|
// .intermediates, which isn't where the binary will load them from, but
|
|
// it's fine for dependency tracking. If a library dependency is updated,
|
|
// the symlink will get a new timestamp, along with any installed symlinks
|
|
// handled in make.
|
|
sharedLibPaths := deps.EarlySharedLibs
|
|
sharedLibPaths = append(sharedLibPaths, deps.SharedLibs...)
|
|
sharedLibPaths = append(sharedLibPaths, deps.LateSharedLibs...)
|
|
|
|
var fromPath = in.String()
|
|
if !filepath.IsAbs(fromPath) {
|
|
fromPath = "$$PWD/" + fromPath
|
|
}
|
|
|
|
ctx.Build(pctx, android.BuildParams{
|
|
Rule: android.Symlink,
|
|
Output: outputFile,
|
|
Input: in,
|
|
Implicits: sharedLibPaths,
|
|
Args: map[string]string{
|
|
"fromPath": fromPath,
|
|
},
|
|
})
|
|
|
|
p.toolPath = android.OptionalPathForPath(outputFile)
|
|
} else {
|
|
if p.stripper.NeedsStrip(ctx) {
|
|
stripped := android.PathForModuleOut(ctx, "stripped", fileName)
|
|
p.stripper.StripExecutableOrSharedLib(ctx, in, stripped, flagsToStripFlags(flags))
|
|
in = stripped
|
|
}
|
|
|
|
// Copy binaries to a name matching the final installed name
|
|
ctx.Build(pctx, android.BuildParams{
|
|
Rule: android.CpExecutable,
|
|
Description: "prebuilt",
|
|
Output: outputFile,
|
|
Input: in,
|
|
})
|
|
}
|
|
|
|
return outputFile
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (p *prebuiltBinaryLinker) binary() bool {
|
|
return true
|
|
}
|
|
|
|
// cc_prebuilt_binary installs a precompiled executable in srcs property in the
|
|
// device's directory, for both the host and device
|
|
func PrebuiltBinaryFactory() android.Module {
|
|
module, _ := NewPrebuiltBinary(android.HostAndDeviceSupported)
|
|
return module.Init()
|
|
}
|
|
|
|
type prebuiltBinaryBazelHandler struct {
|
|
module *Module
|
|
decorator *binaryDecorator
|
|
}
|
|
|
|
func NewPrebuiltBinary(hod android.HostOrDeviceSupported) (*Module, *binaryDecorator) {
|
|
module, binary := newBinary(hod, true)
|
|
module.compiler = nil
|
|
module.bazelHandler = &prebuiltBinaryBazelHandler{module, binary}
|
|
|
|
prebuilt := &prebuiltBinaryLinker{
|
|
binaryDecorator: binary,
|
|
}
|
|
module.linker = prebuilt
|
|
module.installer = prebuilt
|
|
|
|
module.AddProperties(&prebuilt.properties)
|
|
|
|
android.InitPrebuiltModule(module, &prebuilt.properties.Srcs)
|
|
return module, binary
|
|
}
|
|
|
|
var _ BazelHandler = (*prebuiltBinaryBazelHandler)(nil)
|
|
|
|
func (h *prebuiltBinaryBazelHandler) QueueBazelCall(ctx android.BaseModuleContext, label string) {
|
|
bazelCtx := ctx.Config().BazelContext
|
|
bazelCtx.QueueBazelRequest(label, cquery.GetOutputFiles, android.GetConfigKeyApexVariant(ctx, GetApexConfigKey(ctx)))
|
|
}
|
|
|
|
func (h *prebuiltBinaryBazelHandler) ProcessBazelQueryResponse(ctx android.ModuleContext, label string) {
|
|
bazelCtx := ctx.Config().BazelContext
|
|
outputs, err := bazelCtx.GetOutputFiles(label, android.GetConfigKeyApexVariant(ctx, GetApexConfigKey(ctx)))
|
|
if err != nil {
|
|
ctx.ModuleErrorf(err.Error())
|
|
return
|
|
}
|
|
if len(outputs) != 1 {
|
|
ctx.ModuleErrorf("Expected a single output for `%s`, but got:\n%v", label, outputs)
|
|
return
|
|
}
|
|
out := android.PathForBazelOut(ctx, outputs[0])
|
|
h.module.outputFile = android.OptionalPathForPath(out)
|
|
h.module.maybeUnhideFromMake()
|
|
}
|
|
|
|
type bazelPrebuiltBinaryAttributes struct {
|
|
Src bazel.LabelAttribute
|
|
Strip stripAttributes
|
|
}
|
|
|
|
func prebuiltBinaryBp2Build(ctx android.TopDownMutatorContext, module *Module) {
|
|
prebuiltAttrs := bp2BuildParsePrebuiltBinaryProps(ctx, module)
|
|
|
|
var la linkerAttributes
|
|
la.convertStripProps(ctx, module)
|
|
attrs := &bazelPrebuiltBinaryAttributes{
|
|
Src: prebuiltAttrs.Src,
|
|
Strip: stripAttrsFromLinkerAttrs(&la),
|
|
}
|
|
|
|
props := bazel.BazelTargetModuleProperties{
|
|
Rule_class: "cc_prebuilt_binary",
|
|
Bzl_load_location: "//build/bazel/rules/cc:cc_prebuilt_binary.bzl",
|
|
}
|
|
|
|
name := android.RemoveOptionalPrebuiltPrefix(module.Name())
|
|
tags := android.ApexAvailableTagsWithoutTestApexes(ctx, module)
|
|
ctx.CreateBazelTargetModule(props, android.CommonAttributes{Name: name, Tags: tags}, attrs)
|
|
}
|
|
|
|
type Sanitized struct {
|
|
None struct {
|
|
Srcs []string `android:"path,arch_variant"`
|
|
} `android:"arch_variant"`
|
|
Address struct {
|
|
Srcs []string `android:"path,arch_variant"`
|
|
} `android:"arch_variant"`
|
|
Hwaddress struct {
|
|
Srcs []string `android:"path,arch_variant"`
|
|
} `android:"arch_variant"`
|
|
}
|
|
|
|
func srcsForSanitizer(sanitize *sanitize, sanitized Sanitized) []string {
|
|
if sanitize == nil {
|
|
return nil
|
|
}
|
|
if sanitize.isSanitizerEnabled(Asan) && sanitized.Address.Srcs != nil {
|
|
return sanitized.Address.Srcs
|
|
}
|
|
if sanitize.isSanitizerEnabled(Hwasan) && sanitized.Hwaddress.Srcs != nil {
|
|
return sanitized.Hwaddress.Srcs
|
|
}
|
|
return sanitized.None.Srcs
|
|
}
|