blob: 2805e56c602e7b81025d2c84fb2098dfa13fa889 [file] [log] [blame]
// 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 (
"encoding/json"
"errors"
"path/filepath"
"sort"
"strings"
"sync"
"android/soong/android"
"android/soong/cc/config"
)
type VndkProperties struct {
Vndk struct {
// declared as a VNDK or VNDK-SP module. The vendor variant
// will be installed in /system instead of /vendor partition.
//
// `vendor_available` must be explicitly set to either true or
// false together with `vndk: {enabled: true}`.
Enabled *bool
// declared as a VNDK-SP module, which is a subset of VNDK.
//
// `vndk: { enabled: true }` must set together.
//
// All these modules are allowed to link to VNDK-SP or LL-NDK
// modules only. Other dependency will cause link-type errors.
//
// If `support_system_process` is not set or set to false,
// the module is VNDK-core and can link to other VNDK-core,
// VNDK-SP or LL-NDK modules only.
Support_system_process *bool
// Extending another module
Extends *string
}
}
type vndkdep struct {
Properties VndkProperties
}
func (vndk *vndkdep) props() []interface{} {
return []interface{}{&vndk.Properties}
}
func (vndk *vndkdep) begin(ctx BaseModuleContext) {}
func (vndk *vndkdep) deps(ctx BaseModuleContext, deps Deps) Deps {
return deps
}
func (vndk *vndkdep) isVndk() bool {
return Bool(vndk.Properties.Vndk.Enabled)
}
func (vndk *vndkdep) isVndkSp() bool {
return Bool(vndk.Properties.Vndk.Support_system_process)
}
func (vndk *vndkdep) isVndkExt() bool {
return vndk.Properties.Vndk.Extends != nil
}
func (vndk *vndkdep) getVndkExtendsModuleName() string {
return String(vndk.Properties.Vndk.Extends)
}
func (vndk *vndkdep) typeName() string {
if !vndk.isVndk() {
return "native:vendor"
}
if !vndk.isVndkExt() {
if !vndk.isVndkSp() {
return "native:vendor:vndk"
}
return "native:vendor:vndksp"
}
if !vndk.isVndkSp() {
return "native:vendor:vndkext"
}
return "native:vendor:vndkspext"
}
func (vndk *vndkdep) vndkCheckLinkType(ctx android.ModuleContext, to *Module, tag DependencyTag) {
if to.linker == nil {
return
}
if !vndk.isVndk() {
// Non-VNDK modules (those installed to /vendor) can't depend on modules marked with
// vendor_available: false.
violation := false
if lib, ok := to.linker.(*llndkStubDecorator); ok && !Bool(lib.Properties.Vendor_available) {
violation = true
} else {
if _, ok := to.linker.(libraryInterface); ok && to.VendorProperties.Vendor_available != nil && !Bool(to.VendorProperties.Vendor_available) {
// Vendor_available == nil && !Bool(Vendor_available) should be okay since
// it means a vendor-only library which is a valid dependency for non-VNDK
// modules.
violation = true
}
}
if violation {
ctx.ModuleErrorf("Vendor module that is not VNDK should not link to %q which is marked as `vendor_available: false`", to.Name())
}
}
if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
// Check only shared libraries.
// Other (static and LL-NDK) libraries are allowed to link.
return
}
if !to.UseVndk() {
ctx.ModuleErrorf("(%s) should not link to %q which is not a vendor-available library",
vndk.typeName(), to.Name())
return
}
if tag == vndkExtDepTag {
// Ensure `extends: "name"` property refers a vndk module that has vendor_available
// and has identical vndk properties.
if to.vndkdep == nil || !to.vndkdep.isVndk() {
ctx.ModuleErrorf("`extends` refers a non-vndk module %q", to.Name())
return
}
if vndk.isVndkSp() != to.vndkdep.isVndkSp() {
ctx.ModuleErrorf(
"`extends` refers a module %q with mismatched support_system_process",
to.Name())
return
}
if !Bool(to.VendorProperties.Vendor_available) {
ctx.ModuleErrorf(
"`extends` refers module %q which does not have `vendor_available: true`",
to.Name())
return
}
}
if to.vndkdep == nil {
return
}
// Check the dependencies of VNDK shared libraries.
if err := vndkIsVndkDepAllowed(vndk, to.vndkdep); err != nil {
ctx.ModuleErrorf("(%s) should not link to %q (%s): %v",
vndk.typeName(), to.Name(), to.vndkdep.typeName(), err)
return
}
}
func vndkIsVndkDepAllowed(from *vndkdep, to *vndkdep) error {
// Check the dependencies of VNDK, VNDK-Ext, VNDK-SP, VNDK-SP-Ext and vendor modules.
if from.isVndkExt() {
if from.isVndkSp() {
if to.isVndk() && !to.isVndkSp() {
return errors.New("VNDK-SP extensions must not depend on VNDK or VNDK extensions")
}
return nil
}
// VNDK-Ext may depend on VNDK, VNDK-Ext, VNDK-SP, VNDK-SP-Ext, or vendor libs.
return nil
}
if from.isVndk() {
if to.isVndkExt() {
return errors.New("VNDK-core and VNDK-SP must not depend on VNDK extensions")
}
if from.isVndkSp() {
if !to.isVndkSp() {
return errors.New("VNDK-SP must only depend on VNDK-SP")
}
return nil
}
if !to.isVndk() {
return errors.New("VNDK-core must only depend on VNDK-core or VNDK-SP")
}
return nil
}
// Vendor modules may depend on VNDK, VNDK-Ext, VNDK-SP, VNDK-SP-Ext, or vendor libs.
return nil
}
var (
vndkCoreLibrariesKey = android.NewOnceKey("vndkCoreLibrarires")
vndkSpLibrariesKey = android.NewOnceKey("vndkSpLibrarires")
llndkLibrariesKey = android.NewOnceKey("llndkLibrarires")
vndkPrivateLibrariesKey = android.NewOnceKey("vndkPrivateLibrarires")
vndkUsingCoreVariantLibrariesKey = android.NewOnceKey("vndkUsingCoreVariantLibrarires")
modulePathsKey = android.NewOnceKey("modulePaths")
vndkSnapshotOutputsKey = android.NewOnceKey("vndkSnapshotOutputs")
vndkMustUseVendorVariantListKey = android.NewOnceKey("vndkMustUseVendorVariantListKey")
testVndkMustUseVendorVariantListKey = android.NewOnceKey("testVndkMustUseVendorVariantListKey")
vndkLibrariesLock sync.Mutex
headerExts = []string{".h", ".hh", ".hpp", ".hxx", ".h++", ".inl", ".inc", ".ipp", ".h.generic"}
)
func vndkCoreLibraries(config android.Config) *[]string {
return config.Once(vndkCoreLibrariesKey, func() interface{} {
return &[]string{}
}).(*[]string)
}
func vndkSpLibraries(config android.Config) *[]string {
return config.Once(vndkSpLibrariesKey, func() interface{} {
return &[]string{}
}).(*[]string)
}
func llndkLibraries(config android.Config) *[]string {
return config.Once(llndkLibrariesKey, func() interface{} {
return &[]string{}
}).(*[]string)
}
func vndkPrivateLibraries(config android.Config) *[]string {
return config.Once(vndkPrivateLibrariesKey, func() interface{} {
return &[]string{}
}).(*[]string)
}
func vndkUsingCoreVariantLibraries(config android.Config) *[]string {
return config.Once(vndkUsingCoreVariantLibrariesKey, func() interface{} {
return &[]string{}
}).(*[]string)
}
func modulePaths(config android.Config) map[string]string {
return config.Once(modulePathsKey, func() interface{} {
return make(map[string]string)
}).(map[string]string)
}
func vndkSnapshotOutputs(config android.Config) *android.RuleBuilderInstalls {
return config.Once(vndkSnapshotOutputsKey, func() interface{} {
return &android.RuleBuilderInstalls{}
}).(*android.RuleBuilderInstalls)
}
func vndkMustUseVendorVariantList(cfg android.Config) []string {
return cfg.Once(vndkMustUseVendorVariantListKey, func() interface{} {
override := cfg.Once(testVndkMustUseVendorVariantListKey, func() interface{} {
return []string(nil)
}).([]string)
if override != nil {
return override
}
return config.VndkMustUseVendorVariantList
}).([]string)
}
// test may call this to override global configuration(config.VndkMustUseVendorVariantList)
// when it is called, it must be before the first call to vndkMustUseVendorVariantList()
func setVndkMustUseVendorVariantListForTest(config android.Config, mustUseVendorVariantList []string) {
config.Once(testVndkMustUseVendorVariantListKey, func() interface{} {
return mustUseVendorVariantList
})
}
func processLlndkLibrary(mctx android.BottomUpMutatorContext, m *Module) {
lib := m.linker.(*llndkStubDecorator)
name := strings.TrimSuffix(m.Name(), llndkLibrarySuffix)
vndkLibrariesLock.Lock()
defer vndkLibrariesLock.Unlock()
llndkLibraries := llndkLibraries(mctx.Config())
if !inList(name, *llndkLibraries) {
*llndkLibraries = append(*llndkLibraries, name)
sort.Strings(*llndkLibraries)
}
if !Bool(lib.Properties.Vendor_available) {
vndkPrivateLibraries := vndkPrivateLibraries(mctx.Config())
if !inList(name, *vndkPrivateLibraries) {
*vndkPrivateLibraries = append(*vndkPrivateLibraries, name)
sort.Strings(*vndkPrivateLibraries)
}
}
}
func processVndkLibrary(mctx android.BottomUpMutatorContext, m *Module) {
name := strings.TrimPrefix(m.Name(), "prebuilt_")
vndkLibrariesLock.Lock()
defer vndkLibrariesLock.Unlock()
modulePaths := modulePaths(mctx.Config())
if inList(name, vndkMustUseVendorVariantList(mctx.Config())) {
m.Properties.MustUseVendorVariant = true
}
if mctx.DeviceConfig().VndkUseCoreVariant() && !inList(name, vndkMustUseVendorVariantList(mctx.Config())) {
vndkUsingCoreVariantLibraries := vndkUsingCoreVariantLibraries(mctx.Config())
if !inList(name, *vndkUsingCoreVariantLibraries) {
*vndkUsingCoreVariantLibraries = append(*vndkUsingCoreVariantLibraries, name)
sort.Strings(*vndkUsingCoreVariantLibraries)
}
}
if m.vndkdep.isVndkSp() {
vndkSpLibraries := vndkSpLibraries(mctx.Config())
if !inList(name, *vndkSpLibraries) {
*vndkSpLibraries = append(*vndkSpLibraries, name)
sort.Strings(*vndkSpLibraries)
modulePaths[name] = mctx.ModuleDir()
}
} else {
vndkCoreLibraries := vndkCoreLibraries(mctx.Config())
if !inList(name, *vndkCoreLibraries) {
*vndkCoreLibraries = append(*vndkCoreLibraries, name)
sort.Strings(*vndkCoreLibraries)
modulePaths[name] = mctx.ModuleDir()
}
}
if !Bool(m.VendorProperties.Vendor_available) {
vndkPrivateLibraries := vndkPrivateLibraries(mctx.Config())
if !inList(name, *vndkPrivateLibraries) {
*vndkPrivateLibraries = append(*vndkPrivateLibraries, name)
sort.Strings(*vndkPrivateLibraries)
}
}
}
func IsForVndkApex(mctx android.BottomUpMutatorContext, m *Module) bool {
if !m.Enabled() {
return false
}
if !mctx.Device() {
return false
}
if m.Target().NativeBridge == android.NativeBridgeEnabled {
return false
}
// prebuilt vndk modules should match with device
// TODO(b/142675459): Use enabled: to select target device in vndk_prebuilt_shared
// When b/142675459 is landed, remove following check
if p, ok := m.linker.(*vndkPrebuiltLibraryDecorator); ok && !p.matchesWithDevice(mctx.DeviceConfig()) {
return false
}
if lib, ok := m.linker.(libraryInterface); ok {
useCoreVariant := m.vndkVersion() == mctx.DeviceConfig().PlatformVndkVersion() &&
mctx.DeviceConfig().VndkUseCoreVariant() && !m.MustUseVendorVariant()
return lib.shared() && m.UseVndk() && m.IsVndk() && !m.isVndkExt() && !useCoreVariant
}
return false
}
// gather list of vndk-core, vndk-sp, and ll-ndk libs
func VndkMutator(mctx android.BottomUpMutatorContext) {
m, ok := mctx.Module().(*Module)
if !ok {
return
}
if !m.Enabled() {
return
}
if m.Target().NativeBridge == android.NativeBridgeEnabled {
// Skip native_bridge modules
return
}
if _, ok := m.linker.(*llndkStubDecorator); ok {
processLlndkLibrary(mctx, m)
return
}
lib, is_lib := m.linker.(*libraryDecorator)
prebuilt_lib, is_prebuilt_lib := m.linker.(*prebuiltLibraryLinker)
if (is_lib && lib.buildShared()) || (is_prebuilt_lib && prebuilt_lib.buildShared()) {
if m.vndkdep != nil && m.vndkdep.isVndk() && !m.vndkdep.isVndkExt() {
processVndkLibrary(mctx, m)
return
}
}
}
func init() {
android.RegisterSingletonType("vndk-snapshot", VndkSnapshotSingleton)
android.RegisterMakeVarsProvider(pctx, func(ctx android.MakeVarsContext) {
outputs := vndkSnapshotOutputs(ctx.Config())
ctx.Strict("SOONG_VNDK_SNAPSHOT_FILES", outputs.String())
})
}
func VndkSnapshotSingleton() android.Singleton {
return &vndkSnapshotSingleton{}
}
type vndkSnapshotSingleton struct{}
func (c *vndkSnapshotSingleton) GenerateBuildActions(ctx android.SingletonContext) {
// BOARD_VNDK_VERSION must be set to 'current' in order to generate a VNDK snapshot.
if ctx.DeviceConfig().VndkVersion() != "current" {
return
}
if ctx.DeviceConfig().PlatformVndkVersion() == "" {
return
}
if ctx.DeviceConfig().BoardVndkRuntimeDisable() {
return
}
c.buildVndkLibrariesTxtFiles(ctx)
outputs := vndkSnapshotOutputs(ctx.Config())
snapshotDir := "vndk-snapshot"
vndkLibDir := make(map[android.ArchType]string)
snapshotVariantDir := ctx.DeviceConfig().DeviceArch()
for _, target := range ctx.Config().Targets[android.Android] {
dir := snapshotVariantDir
if ctx.DeviceConfig().BinderBitness() == "32" {
dir = filepath.Join(dir, "binder32")
}
arch := "arch-" + target.Arch.ArchType.String()
if target.Arch.ArchVariant != "" {
arch += "-" + target.Arch.ArchVariant
}
dir = filepath.Join(dir, arch)
vndkLibDir[target.Arch.ArchType] = dir
}
configsDir := filepath.Join(snapshotVariantDir, "configs")
noticeDir := filepath.Join(snapshotVariantDir, "NOTICE_FILES")
includeDir := filepath.Join(snapshotVariantDir, "include")
noticeBuilt := make(map[string]bool)
installSnapshotFileFromPath := func(path android.Path, out string) {
ctx.Build(pctx, android.BuildParams{
Rule: android.Cp,
Input: path,
Output: android.PathForOutput(ctx, snapshotDir, out),
Description: "vndk snapshot " + out,
Args: map[string]string{
"cpFlags": "-f -L",
},
})
*outputs = append(*outputs, android.RuleBuilderInstall{
From: android.PathForOutput(ctx, snapshotDir, out),
To: out,
})
}
installSnapshotFileFromContent := func(content, out string) {
ctx.Build(pctx, android.BuildParams{
Rule: android.WriteFile,
Output: android.PathForOutput(ctx, snapshotDir, out),
Description: "vndk snapshot " + out,
Args: map[string]string{
"content": content,
},
})
*outputs = append(*outputs, android.RuleBuilderInstall{
From: android.PathForOutput(ctx, snapshotDir, out),
To: out,
})
}
tryBuildNotice := func(m *Module) {
name := ctx.ModuleName(m) + ".so.txt"
if _, ok := noticeBuilt[name]; ok {
return
}
noticeBuilt[name] = true
if m.NoticeFile().Valid() {
installSnapshotFileFromPath(m.NoticeFile().Path(), filepath.Join(noticeDir, name))
}
}
vndkCoreLibraries := vndkCoreLibraries(ctx.Config())
vndkSpLibraries := vndkSpLibraries(ctx.Config())
vndkPrivateLibraries := vndkPrivateLibraries(ctx.Config())
var generatedHeaders android.Paths
includeDirs := make(map[string]bool)
type vndkSnapshotLibraryInterface interface {
exportedFlagsProducer
libraryInterface
}
var _ vndkSnapshotLibraryInterface = (*prebuiltLibraryLinker)(nil)
var _ vndkSnapshotLibraryInterface = (*libraryDecorator)(nil)
installVndkSnapshotLib := func(m *Module, l vndkSnapshotLibraryInterface, dir string) bool {
name := ctx.ModuleName(m)
libOut := filepath.Join(dir, name+".so")
installSnapshotFileFromPath(m.outputFile.Path(), libOut)
tryBuildNotice(m)
if ctx.Config().VndkSnapshotBuildArtifacts() {
prop := struct {
ExportedDirs []string `json:",omitempty"`
ExportedSystemDirs []string `json:",omitempty"`
ExportedFlags []string `json:",omitempty"`
RelativeInstallPath string `json:",omitempty"`
}{}
prop.ExportedFlags = l.exportedFlags()
prop.ExportedDirs = l.exportedDirs().Strings()
prop.ExportedSystemDirs = l.exportedSystemDirs().Strings()
prop.RelativeInstallPath = m.RelativeInstallPath()
propOut := libOut + ".json"
j, err := json.Marshal(prop)
if err != nil {
ctx.Errorf("json marshal to %q failed: %#v", propOut, err)
return false
}
installSnapshotFileFromContent(string(j), propOut)
}
return true
}
isVndkSnapshotLibrary := func(m *Module) (i vndkSnapshotLibraryInterface, libDir string, isVndkSnapshotLib bool) {
if m.Target().NativeBridge == android.NativeBridgeEnabled {
return nil, "", false
}
if !m.UseVndk() || !m.IsForPlatform() || !m.installable() {
return nil, "", false
}
l, ok := m.linker.(vndkSnapshotLibraryInterface)
if !ok || !l.shared() {
return nil, "", false
}
name := ctx.ModuleName(m)
if inList(name, *vndkCoreLibraries) {
return l, filepath.Join("shared", "vndk-core"), true
} else if inList(name, *vndkSpLibraries) {
return l, filepath.Join("shared", "vndk-sp"), true
} else {
return nil, "", false
}
}
ctx.VisitAllModules(func(module android.Module) {
m, ok := module.(*Module)
if !ok || !m.Enabled() {
return
}
baseDir, ok := vndkLibDir[m.Target().Arch.ArchType]
if !ok {
return
}
l, libDir, ok := isVndkSnapshotLibrary(m)
if !ok {
return
}
if !installVndkSnapshotLib(m, l, filepath.Join(baseDir, libDir)) {
return
}
generatedHeaders = append(generatedHeaders, l.exportedDeps()...)
for _, dir := range append(l.exportedDirs(), l.exportedSystemDirs()...) {
includeDirs[dir.String()] = true
}
})
if ctx.Config().VndkSnapshotBuildArtifacts() {
headers := make(map[string]bool)
for _, dir := range android.SortedStringKeys(includeDirs) {
// workaround to determine if dir is under output directory
if strings.HasPrefix(dir, android.PathForOutput(ctx).String()) {
continue
}
exts := headerExts
// Glob all files under this special directory, because of C++ headers.
if strings.HasPrefix(dir, "external/libcxx/include") {
exts = []string{""}
}
for _, ext := range exts {
glob, err := ctx.GlobWithDeps(dir+"/**/*"+ext, nil)
if err != nil {
ctx.Errorf("%#v\n", err)
return
}
for _, header := range glob {
if strings.HasSuffix(header, "/") {
continue
}
headers[header] = true
}
}
}
for _, header := range android.SortedStringKeys(headers) {
installSnapshotFileFromPath(android.PathForSource(ctx, header),
filepath.Join(includeDir, header))
}
isHeader := func(path string) bool {
for _, ext := range headerExts {
if strings.HasSuffix(path, ext) {
return true
}
}
return false
}
for _, path := range android.PathsToDirectorySortedPaths(android.FirstUniquePaths(generatedHeaders)) {
header := path.String()
if !isHeader(header) {
continue
}
installSnapshotFileFromPath(path, filepath.Join(includeDir, header))
}
}
installSnapshotFileFromContent(android.JoinWithSuffix(*vndkCoreLibraries, ".so", "\\n"),
filepath.Join(configsDir, "vndkcore.libraries.txt"))
installSnapshotFileFromContent(android.JoinWithSuffix(*vndkPrivateLibraries, ".so", "\\n"),
filepath.Join(configsDir, "vndkprivate.libraries.txt"))
var modulePathTxtBuilder strings.Builder
modulePaths := modulePaths(ctx.Config())
first := true
for _, lib := range android.SortedStringKeys(modulePaths) {
if first {
first = false
} else {
modulePathTxtBuilder.WriteString("\\n")
}
modulePathTxtBuilder.WriteString(lib)
modulePathTxtBuilder.WriteString(".so ")
modulePathTxtBuilder.WriteString(modulePaths[lib])
}
installSnapshotFileFromContent(modulePathTxtBuilder.String(),
filepath.Join(configsDir, "module_paths.txt"))
}
func installListFile(ctx android.SingletonContext, list []string, pathComponents ...string) android.OutputPath {
out := android.PathForOutput(ctx, pathComponents...)
ctx.Build(pctx, android.BuildParams{
Rule: android.WriteFile,
Output: out,
Description: "Writing " + out.String(),
Args: map[string]string{
"content": strings.Join(list, "\\n"),
},
})
return out
}
func (c *vndkSnapshotSingleton) buildVndkLibrariesTxtFiles(ctx android.SingletonContext) {
var (
llndk, vndkcore, vndksp, vndkprivate, vndkcorevariant, merged []string
)
vndkVersion := ctx.DeviceConfig().PlatformVndkVersion()
config := ctx.Config()
ctx.VisitAllModules(func(m android.Module) {
if !m.Enabled() {
return
}
c, ok := m.(*Module)
if !ok || c.Os().Class != android.Device {
return
}
lib, ok := c.linker.(interface{ shared() bool })
if !ok || !lib.shared() {
return
}
if !c.OutputFile().Valid() {
return
}
filename := c.OutputFile().Path().Base()
if c.isLlndk(config) {
llndk = append(llndk, filename)
if c.isVndkPrivate(config) {
vndkprivate = append(vndkprivate, filename)
}
} else if c.vndkVersion() == vndkVersion && c.IsVndk() && !c.isVndkExt() {
if c.isVndkSp() {
vndksp = append(vndksp, filename)
} else {
vndkcore = append(vndkcore, filename)
}
if c.isVndkPrivate(config) {
vndkprivate = append(vndkprivate, filename)
}
if ctx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
vndkcorevariant = append(vndkcorevariant, filename)
}
}
})
llndk = android.SortedUniqueStrings(llndk)
vndkcore = android.SortedUniqueStrings(vndkcore)
vndksp = android.SortedUniqueStrings(vndksp)
vndkprivate = android.SortedUniqueStrings(vndkprivate)
vndkcorevariant = android.SortedUniqueStrings(vndkcorevariant)
installListFile(ctx, llndk, "vndk", "llndk.libraries.txt")
installListFile(ctx, vndkcore, "vndk", "vndkcore.libraries.txt")
installListFile(ctx, vndksp, "vndk", "vndksp.libraries.txt")
installListFile(ctx, vndkprivate, "vndk", "vndkprivate.libraries.txt")
installListFile(ctx, vndkcorevariant, "vndk", "vndkcorevariant.libraries.txt")
// merged & tagged & filtered-out(libclang_rt)
filterOutLibClangRt := func(libList []string) (filtered []string) {
for _, lib := range libList {
if !strings.HasPrefix(lib, "libclang_rt.") {
filtered = append(filtered, lib)
}
}
return
}
merged = append(merged, addPrefix(filterOutLibClangRt(llndk), "LLNDK: ")...)
merged = append(merged, addPrefix(vndksp, "VNDK-SP: ")...)
merged = append(merged, addPrefix(filterOutLibClangRt(vndkcore), "VNDK-core: ")...)
merged = append(merged, addPrefix(vndkprivate, "VNDK-private: ")...)
installListFile(ctx, merged, "vndk", "vndk.libraries.txt")
}