Quelle  library_sdk_member.go   Sprache: unbekannt

// Copyright 2019 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 (
 "fmt"
 "path/filepath"

 "android/soong/android"

 "github.com/google/blueprint"
 "github.com/google/blueprint/proptools"
)

//go:generate go run ../../blueprint/gobtools/codegen

// This file contains support for using cc library modules within an sdk.

var sharedLibrarySdkMemberType = &librarySdkMemberType{
 SdkMemberTypeBase: android.SdkMemberTypeBase{
  PropertyName:          "native_shared_libs",
  SupportsSdk:           true,
  HostOsDependent:       true,
  SupportedLinkageNames: []string{"shared"},
  StripDisabled:         true,
 },
 prebuiltModuleType: "cc_prebuilt_library_shared",
}

var staticLibrarySdkMemberType = &librarySdkMemberType{
 SdkMemberTypeBase: android.SdkMemberTypeBase{
  PropertyName:          "native_static_libs",
  SupportsSdk:           true,
  HostOsDependent:       true,
  SupportedLinkageNames: []string{"static"},
 },
 prebuiltModuleType: "cc_prebuilt_library_static",
}

var staticAndSharedLibrarySdkMemberType = &librarySdkMemberType{
 SdkMemberTypeBase: android.SdkMemberTypeBase{
  PropertyName:           "native_libs",
  OverridesPropertyNames: map[string]bool{"native_shared_libs": true, "native_static_libs": true},
  SupportsSdk:            true,
  HostOsDependent:        true,
  SupportedLinkageNames:  []string{"static", "shared"},
 },
 prebuiltModuleType: "cc_prebuilt_library",
}

func init() {
 // Register sdk member types.
 android.RegisterSdkMemberType(sharedLibrarySdkMemberType)
 android.RegisterSdkMemberType(staticLibrarySdkMemberType)
 android.RegisterSdkMemberType(staticAndSharedLibrarySdkMemberType)
}

// @auto-generate: gob
type librarySdkMemberType struct {
 android.SdkMemberTypeBase

 prebuiltModuleType string

 noOutputFiles bool // True if there are no srcs files.

}

func (mt *librarySdkMemberType) AddDependencies(ctx android.SdkDependencyContext, dependencyTag blueprint.DependencyTag, names []string) {
 // The base set of targets which does not include native bridge targets.
 defaultTargets := ctx.MultiTargets()

 // The lazily created list of native bridge targets.
 var includeNativeBridgeTargets []android.Target

 for _, lib := range names {
  targets := defaultTargets

  // If native bridge support is required in the sdk snapshot then add native bridge targets to
  // the basic list of targets that are required.
  nativeBridgeSupport := ctx.RequiresTrait(lib, nativeBridgeSdkTrait)
  if nativeBridgeSupport && ctx.Device() {
   // If not already computed then compute the list of native bridge targets.
   if includeNativeBridgeTargets == nil {
    includeNativeBridgeTargets = append([]android.Target{}, defaultTargets...)
    allAndroidTargets := ctx.Config().Targets[android.Android]
    for _, possibleNativeBridgeTarget := range allAndroidTargets {
     if possibleNativeBridgeTarget.NativeBridge == android.NativeBridgeEnabled {
      includeNativeBridgeTargets = append(includeNativeBridgeTargets, possibleNativeBridgeTarget)
     }
    }
   }

   // Include the native bridge targets as well.
   targets = includeNativeBridgeTargets
  }

  // memberDependency encapsulates information about the dependencies to add for this member.
  type memberDependency struct {
   // The targets to depend upon.
   targets []android.Target

   // Additional image variations to depend upon, is either nil for no image variation or
   // contains a single image variation.
   imageVariations []blueprint.Variation
  }

  // Extract the name and version from the module name.
  name, version := StubsLibNameAndVersion(lib)
  if version == "" {
   version = "latest"
  }

  // Compute the set of dependencies to add.
  var memberDependencies []memberDependency
  if ctx.Host() {
   // Host does not support image variations so add a dependency without any.
   memberDependencies = append(memberDependencies, memberDependency{
    targets: targets,
   })
  } else {
   // Otherwise, this is targeting the device so add a dependency on the core image variation
   // (image:"").
   memberDependencies = append(memberDependencies, memberDependency{
    imageVariations: []blueprint.Variation{{Mutator: "image", Variation: android.CoreVariation}},
    targets:         targets,
   })

   // If required add additional dependencies on the image:ramdisk variants.
   if ctx.RequiresTrait(lib, ramdiskImageRequiredSdkTrait) {
    memberDependencies = append(memberDependencies, memberDependency{
     imageVariations: []blueprint.Variation{{Mutator: "image", Variation: android.RamdiskVariation}},
     // Only add a dependency on the first target as that is the only one which will have an
     // image:ramdisk variant.
     targets: targets[:1],
    })
   }

   // If required add additional dependencies on the image:recovery variants.
   if ctx.RequiresTrait(lib, recoveryImageRequiredSdkTrait) {
    memberDependencies = append(memberDependencies, memberDependency{
     imageVariations: []blueprint.Variation{{Mutator: "image", Variation: android.RecoveryVariation}},
     // Only add a dependency on the first target as that is the only one which will have an
     // image:recovery variant.
     targets: targets[:1],
    })
   }
  }

  // For each dependency in the list add dependencies on the targets with the correct variations.
  for _, dependency := range memberDependencies {
   // For each target add a dependency on the target with any additional dependencies.
   for _, target := range dependency.targets {
    // Get the variations for the target.
    variations := target.Variations()

    // Add any additional dependencies needed.
    variations = append(variations, dependency.imageVariations...)

    if mt.SupportedLinkageNames == nil {
     // No link types are supported so add a dependency directly.
     ctx.AddFarVariationDependencies(variations, dependencyTag, name)
    } else {
     // Otherwise, add a dependency on each supported link type in turn.
     for _, linkType := range mt.SupportedLinkageNames {
      libVariations := append(variations,
       blueprint.Variation{Mutator: "link", Variation: linkType})
      // If this is for the device and a shared link type then add a dependency onto the
      // appropriate version specific variant of the module.
      if ctx.Device() && linkType == "shared" {
       libVariations = append(libVariations,
        blueprint.Variation{Mutator: "version", Variation: version})
      }
      ctx.AddFarVariationDependencies(libVariations, dependencyTag, name)
     }
    }
   }
  }
 }
}

func (mt *librarySdkMemberType) IsInstance(ctx android.ModuleContext, module android.ModuleProxy) bool {
 // Check the module to see if it can be used with this module type.
 if m, ok := android.OtherModuleProvider(ctx, module, CcInfoProvider); ok {
  for _, allowableMemberType := range m.SdkMemberTypes {
   if allowableMemberType.SdkPropertyName() == mt.SdkPropertyName() {
    return true
   }
  }
 }

 return false
}

func (mt *librarySdkMemberType) AddPrebuiltModule(ctx android.SdkMemberContext, member android.SdkMember) android.BpModule {
 pbm := ctx.SnapshotBuilder().AddPrebuiltModule(member, mt.prebuiltModuleType)

 ccModule := member.Variants()[0]
 info, ok := android.OtherModuleProvider(ctx.SdkModuleContext(), ccModule, CcInfoProvider)
 if !ok {
  panic(fmt.Errorf("not a cc module: %s", member.Variants()[0]))
 }

 if ctx.RequiresTrait(nativeBridgeSdkTrait) {
  pbm.AddProperty("native_bridge_supported", true)
 }

 if ctx.RequiresTrait(ramdiskImageRequiredSdkTrait) {
  pbm.AddProperty("ramdisk_available", true)
 }

 if ctx.RequiresTrait(recoveryImageRequiredSdkTrait) {
  pbm.AddProperty("recovery_available", true)
 }

 if info.VendorAvailable {
  pbm.AddProperty("vendor_available", true)
 }

 if info.OdmAvailable {
  pbm.AddProperty("odm_available", true)
 }

 if info.ProductAvailable {
  pbm.AddProperty("product_available", true)
 }

 sdkVersion := android.OtherModulePointerProviderOrDefault(ctx.SdkModuleContext(),
  ccModule, android.CommonModuleInfoProvider).SdkVersion
 if sdkVersion != "" {
  pbm.AddProperty("sdk_version", sdkVersion)
 }

 if info.StlInfo != nil && info.StlInfo.Stl != nil {
  pbm.AddProperty("stl", proptools.String(info.StlInfo.Stl))
 }

 if info.LinkerInfo != nil && info.LinkerInfo.LibraryDecoratorInfo != nil {
  uhs := info.LinkerInfo.LibraryDecoratorInfo.UniqueHostSoname
  if uhs != nil {
   pbm.AddProperty("unique_host_soname", proptools.Bool(uhs))
  }
 }

 return pbm
}

func (mt *librarySdkMemberType) CreateVariantPropertiesStruct() android.SdkMemberProperties {
 return &nativeLibInfoProperties{memberType: mt}
}

func isGeneratedHeaderDirectory(p android.Path) bool {
 _, gen := p.(android.WritablePath)
 return gen
}

type includeDirsProperty struct {
 // Accessor to retrieve the paths
 pathsGetter func(libInfo *nativeLibInfoProperties) android.Paths

 // The name of the property in the prebuilt library, "" means there is no property.
 propertyName string

 // The directory within the snapshot directory into which items should be copied.
 snapshotDir string

 // True if the items on the path should be copied.
 copy bool

 // True if the paths represent directories, files if they represent files.
 dirs bool
}

var includeDirProperties = []includeDirsProperty{
 {
  // ExportedIncludeDirs lists directories that contains some header files to be
  // copied into a directory in the snapshot. The snapshot directories must be added to
  // the export_include_dirs property in the prebuilt module in the snapshot.
  pathsGetter:  func(libInfo *nativeLibInfoProperties) android.Paths { return libInfo.ExportedIncludeDirs },
  propertyName: "export_include_dirs",
  snapshotDir:  nativeIncludeDir,
  copy:         true,
  dirs:         true,
 },
 {
  // ExportedSystemIncludeDirs lists directories that contains some system header files to
  // be copied into a directory in the snapshot. The snapshot directories must be added to
  // the export_system_include_dirs property in the prebuilt module in the snapshot.
  pathsGetter:  func(libInfo *nativeLibInfoProperties) android.Paths { return libInfo.ExportedSystemIncludeDirs },
  propertyName: "export_system_include_dirs",
  snapshotDir:  nativeIncludeDir,
  copy:         true,
  dirs:         true,
 },
 {
  // ExportedGeneratedIncludeDirs lists directories that contains some header files
  // that are explicitly listed in the ExportedGeneratedHeaders property. So, the contents
  // of these directories do not need to be copied, but these directories do need adding to
  // the export_include_dirs property in the prebuilt module in the snapshot.
  pathsGetter:  func(libInfo *nativeLibInfoProperties) android.Paths { return libInfo.ExportedGeneratedIncludeDirs },
  propertyName: "export_include_dirs",
  snapshotDir:  nativeGeneratedIncludeDir,
  copy:         false,
  dirs:         true,
 },
 {
  // ExportedGeneratedHeaders lists header files that are in one of the directories
  // specified in ExportedGeneratedIncludeDirs must be copied into the snapshot.
  // As they are in a directory in ExportedGeneratedIncludeDirs they do not need adding to a
  // property in the prebuilt module in the snapshot.
  pathsGetter:  func(libInfo *nativeLibInfoProperties) android.Paths { return libInfo.ExportedGeneratedHeaders },
  propertyName: "",
  snapshotDir:  nativeGeneratedIncludeDir,
  copy:         true,
  dirs:         false,
 },
}

// Add properties that may, or may not, be arch specific.
func addPossiblyArchSpecificProperties(sdkModuleContext android.ModuleContext, builder android.SnapshotBuilder, libInfo *nativeLibInfoProperties, outputProperties android.BpPropertySet) {

 outputProperties.AddProperty("sanitize", &libInfo.Sanitize)

 // Copy the generated library to the snapshot and add a reference to it in the .bp module.
 if libInfo.outputFile != nil {
  nativeLibraryPath := nativeLibraryPathFor(libInfo)
  builder.CopyToSnapshot(libInfo.outputFile, nativeLibraryPath)
  outputProperties.AddProperty("srcs", []string{nativeLibraryPath})
 }

 if len(libInfo.SharedLibs) > 0 {
  outputProperties.AddPropertyWithTag("shared_libs", libInfo.SharedLibs, builder.SdkMemberReferencePropertyTag(false))
 }

 // SystemSharedLibs needs to be propagated if it's a list, even if it's empty,
 // so check for non-nil instead of nonzero length.
 if libInfo.SystemSharedLibs != nil {
  outputProperties.AddPropertyWithTag("system_shared_libs", libInfo.SystemSharedLibs, builder.SdkMemberReferencePropertyTag(false))
 }

 // Map from property name to the include dirs to add to the prebuilt module in the snapshot.
 includeDirs := make(map[string][]string)

 // Iterate over each include directory property, copying files and collating property
 // values where necessary.
 for _, propertyInfo := range includeDirProperties {
  // Calculate the base directory in the snapshot into which the files will be copied.
  // lib.archSubDir is "" for common properties.
  targetDir := filepath.Join(libInfo.OsPrefix(), libInfo.archSubDir, propertyInfo.snapshotDir)

  propertyName := propertyInfo.propertyName

  // Iterate over each path in one of the include directory properties.
  for _, path := range propertyInfo.pathsGetter(libInfo) {
   inputPath := path.String()

   // Map the input path to a snapshot relative path. The mapping is independent of the module
   // that references them so that if multiple modules within the same snapshot export the same
   // header files they end up in the same place in the snapshot and so do not get duplicated.
   targetRelativePath := inputPath
   if isGeneratedHeaderDirectory(path) {
    // Remove everything up to the .intermediates/ from the generated output directory to
    // leave a module relative path.
    base := android.PathForIntermediates(sdkModuleContext, "")
    targetRelativePath = android.Rel(sdkModuleContext, base.String(), inputPath)
   }

   snapshotRelativePath := filepath.Join(targetDir, targetRelativePath)

   // Copy the files/directories when necessary.
   if propertyInfo.copy {
    if propertyInfo.dirs {
     // When copying a directory glob and copy all the headers within it.
     headers, _ := sdkModuleContext.GlobWithDeps(inputPath+"/**/*.h", nil)
     additionalHeaders, _ := sdkModuleContext.GlobWithDeps(inputPath+"/**/*.hpp", nil)
     for _, file := range append(headers, additionalHeaders...) {
      src := android.PathForSource(sdkModuleContext, file)

      // The destination path in the snapshot is constructed from the snapshot relative path
      // of the input directory and the input directory relative path of the header file.
      inputRelativePath := android.Rel(sdkModuleContext, inputPath, file)
      dest := filepath.Join(snapshotRelativePath, inputRelativePath)
      builder.CopyToSnapshot(src, dest)
     }
    } else {
     // Otherwise, just copy the file to its snapshot relative path.
     builder.CopyToSnapshot(path, snapshotRelativePath)
    }
   }

   // Only directories are added to a property.
   if propertyInfo.dirs {
    includeDirs[propertyName] = append(includeDirs[propertyName], snapshotRelativePath)
   }
  }
 }

 // Add the collated include dir properties to the output.
 for _, property := range android.SortedKeys(includeDirs) {
  outputProperties.AddProperty(property, includeDirs[property])
 }

 if len(libInfo.StubsVersions) > 0 {
  stubsSet := outputProperties.AddPropertySet("stubs")
  stubsSet.AddProperty("versions", libInfo.StubsVersions)
  // The symbol file will be copied next to the Android.bp file
  stubsSet.AddProperty("symbol_file", libInfo.StubsSymbolFilePath.Base())
  builder.CopyToSnapshot(libInfo.StubsSymbolFilePath, libInfo.StubsSymbolFilePath.Base())
 }
}

const (
 nativeIncludeDir          = "include"
 nativeGeneratedIncludeDir = "include_gen"
 nativeStubDir             = "lib"
)

// path to the native library. Relative to <sdk_root>/<api_dir>
func nativeLibraryPathFor(lib *nativeLibInfoProperties) string {
 return filepath.Join(lib.OsPrefix(), lib.archSubDir,
  nativeStubDir, lib.outputFile.Base())
}

// nativeLibInfoProperties represents properties of a native lib
//
// The exported (capitalized) fields will be examined and may be changed during common value extraction.
// The unexported fields will be left untouched.
type nativeLibInfoProperties struct {
 android.SdkMemberPropertiesBase

 memberType *librarySdkMemberType

 // archSubDir is the subdirectory within the OS directory in the sdk snapshot into which arch
 // specific files will be copied.
 //
 // It is not exported since any value other than "" is always going to be arch specific.
 // This is "" for non-arch specific common properties.
 archSubDir string

 // The list of possibly common exported include dirs.
 //
 // This field is exported as its contents may not be arch specific.
 ExportedIncludeDirs android.Paths `android:"arch_variant"`

 // The list of arch specific exported generated include dirs.
 //
 // This field is exported as its contents may not be arch specific, e.g. protos.
 ExportedGeneratedIncludeDirs android.Paths `android:"arch_variant"`

 // The list of arch specific exported generated header files.
 //
 // This field is exported as its contents may not be arch specific, e.g. protos.
 ExportedGeneratedHeaders android.Paths `android:"arch_variant"`

 // The list of possibly common exported system include dirs.
 //
 // This field is exported as its contents may not be arch specific.
 ExportedSystemIncludeDirs android.Paths `android:"arch_variant"`

 // The list of possibly common exported flags.
 //
 // This field is exported as its contents may not be arch specific.
 ExportedFlags []string `android:"arch_variant"`

 // The set of shared libraries
 //
 // This field is exported as its contents may not be arch specific.
 SharedLibs []string `android:"arch_variant"`

 // The set of system shared libraries. Note nil and [] are semantically
 // distinct - see BaseLinkerProperties.System_shared_libs.
 //
 // This field is exported as its contents may not be arch specific.
 SystemSharedLibs []string `android:"arch_variant"`

 // The specific stubs version for the lib variant, or empty string if stubs
 // are not in use.
 //
 // Marked 'ignored-on-host' as the AllStubsVersions() from which this is
 // initialized is not set on host and the stubs.versions property which this
 // is written to does not vary by arch so cannot be android specific.
 StubsVersions []string `sdk:"ignored-on-host"`

 // The symbol file containing the APIs exported by this library.
 StubsSymbolFilePath android.Path `sdk:"ignored-on-host"`

 // Value of SanitizeProperties.Sanitize. Several - but not all - of these
 // affect the expanded variants. All are propagated to avoid entangling the
 // sanitizer logic with the snapshot generation.
 Sanitize SanitizeUserProps `android:"arch_variant"`

 // outputFile is not exported as it is always arch specific.
 outputFile android.Path
}

func (p *nativeLibInfoProperties) PopulateFromVariant(ctx android.SdkMemberContext, variant android.ModuleProxy) {
 addOutputFile := true
 ccInfo := android.OtherModulePointerProviderOrDefault(ctx.SdkModuleContext(), variant, CcInfoProvider)

 if s := ccInfo.SanitizeInfo; s != nil {
  // We currently do not capture sanitizer flags for libs with sanitizers
  // enabled, because they may vary among variants that cannot be represented
  // in the input blueprint files. In particular, sanitizerDepsMutator enables
  // various sanitizers on dependencies, but in many cases only on static
  // ones, and we cannot specify sanitizer flags at the link type level (i.e.
  // in StaticOrSharedProperties).
  if s.IsUnsanitizedVariant {
   // This still captures explicitly disabled sanitizers, which may be
   // necessary to avoid cyclic dependencies.
   p.Sanitize = s.Sanitize
  } else {
   // Do not add the output file to the snapshot if we don't represent it
   // properly.
   addOutputFile = false
  }
 }

 exportedInfo, _ := android.OtherModuleProvider(ctx.SdkModuleContext(), variant, FlagExporterInfoProvider)

 // Separate out the generated include dirs (which are arch specific) from the
 // include dirs (which may not be).
 exportedIncludeDirs, exportedGeneratedIncludeDirs := android.FilterPathListPredicate(
  exportedInfo.IncludeDirs, isGeneratedHeaderDirectory)

 target := android.OtherModulePointerProviderOrDefault(ctx.SdkModuleContext(), variant, android.CommonModuleInfoProvider).Target
 p.archSubDir = target.Arch.ArchType.String()
 if target.NativeBridge == android.NativeBridgeEnabled {
  p.archSubDir += "_native_bridge"
 }

 // Make sure that the include directories are unique.
 p.ExportedIncludeDirs = android.FirstUniquePaths(exportedIncludeDirs)
 p.ExportedGeneratedIncludeDirs = android.FirstUniquePaths(exportedGeneratedIncludeDirs)

 // Take a copy before filtering out duplicates to avoid changing the slice owned by the
 // ccModule.
 dirs := append(android.Paths(nil), exportedInfo.SystemIncludeDirs...)
 p.ExportedSystemIncludeDirs = android.FirstUniquePaths(dirs)

 p.ExportedFlags = exportedInfo.Flags
 if linker := ccInfo.LinkerInfo; linker != nil {
  specifiedDeps := specifiedDeps{}
  setLinkerSpecifiedDeps(linker, &specifiedDeps)

  if lib := ccInfo.LibraryInfo; lib != nil {
   linkableInfo := android.OtherModulePointerProviderOrDefault(ctx.SdkModuleContext(), variant, LinkableInfoProvider)
   if !linkableInfo.HasStubsVariants {
    // Propagate dynamic dependencies for implementation libs, but not stubs.
    p.SharedLibs = specifiedDeps.sharedLibs
   } else {
    // TODO(b/169373910): 1. Only output the specific version (from
    // ccModule.StubsVersion()) if the module is versioned. 2. Ensure that all
    // the versioned stub libs are retained in the prebuilt tree; currently only
    // the stub corresponding to ccModule.StubsVersion() is.
    p.StubsVersions = lib.AllStubsVersions
    if lib.BuildStubs && linker.LibraryDecoratorInfo.StubsSymbolFilePath == nil {
     ctx.ModuleErrorf("Could not determine symbol_file")
    } else {
     p.StubsSymbolFilePath = linker.LibraryDecoratorInfo.StubsSymbolFilePath
    }
   }
  }
  p.SystemSharedLibs = specifiedDeps.systemSharedLibs
 }
 p.ExportedGeneratedHeaders = exportedInfo.GeneratedHeaders

 if !p.memberType.noOutputFiles && addOutputFile {
  p.outputFile = getRequiredMemberOutputFile(ctx, variant)
 }
}

func getRequiredMemberOutputFile(ctx android.SdkMemberContext, module android.ModuleProxy) android.Path {
 var path android.Path
 if info, ok := android.OtherModuleProvider(ctx.SdkModuleContext(), module, LinkableInfoProvider); ok && info.OutputFile.Valid() {
  path = info.OutputFile.Path()
 } else {
  ctx.SdkModuleContext().ModuleErrorf("member variant %s does not have a valid output file", module)
 }
 return path
}

func (p *nativeLibInfoProperties) AddToPropertySet(ctx android.SdkMemberContext, propertySet android.BpPropertySet) {
 addPossiblyArchSpecificProperties(ctx.SdkModuleContext(), ctx.SnapshotBuilder(), p, propertySet)
}