Merge "split apex.go" (c6e9f92c) · Commits · e / os / android_build_soong

Android.bp

+4 −0

Original line number	Diff line number	Diff line
		@@ -458,8 +458,12 @@ bootstrap_go_package {
		"soong-python",
		],
		srcs: [
		"apex/androidmk.go",
		"apex/apex.go",
		"apex/builder.go",
		"apex/key.go",
		"apex/prebuilt.go",
		"apex/vndk.go",
		],
		testSrcs: [
		"apex/apex_test.go",

apex/androidmk.go

0 → 100644

+205 −0

Original line number	Diff line number	Diff line
		// Copyright (C) 2019 The Android Open Source Project
		//
		// 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 apex

		import (
		"fmt"
		"io"
		"path/filepath"
		"strings"

		"android/soong/android"
		"android/soong/cc"
		"android/soong/java"

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

		func (a *apexBundle) AndroidMk() android.AndroidMkData {
		if a.properties.HideFromMake {
		return android.AndroidMkData{
		Disabled: true,
		}
		}
		writers := []android.AndroidMkData{}
		writers = append(writers, a.androidMkForType())
		return android.AndroidMkData{
		Custom: func(w io.Writer, name, prefix, moduleDir string, data android.AndroidMkData) {
		for _, data := range writers {
		data.Custom(w, name, prefix, moduleDir, data)
		}
		}}
		}

		func (a *apexBundle) androidMkForFiles(w io.Writer, apexName, moduleDir string) []string {
		moduleNames := []string{}
		apexType := a.properties.ApexType
		// To avoid creating duplicate build rules, run this function only when primaryApexType is true
		// to install symbol files in $(PRODUCT_OUT}/apex.
		// And if apexType is flattened, run this function to install files in $(PRODUCT_OUT}/system/apex.
		if !a.primaryApexType && apexType != flattenedApex {
		return moduleNames
		}

		for _, fi := range a.filesInfo {
		if cc, ok := fi.module.(*cc.Module); ok && cc.Properties.HideFromMake {
		continue
		}

		if !android.InList(fi.moduleName, moduleNames) {
		moduleNames = append(moduleNames, fi.moduleName)
		}

		fmt.Fprintln(w, "\ninclude $(CLEAR_VARS)")
		fmt.Fprintln(w, "LOCAL_PATH :=", moduleDir)
		fmt.Fprintln(w, "LOCAL_MODULE :=", fi.moduleName)
		// /apex/<apex_name>/{lib\|framework\|...}
		pathWhenActivated := filepath.Join("$(PRODUCT_OUT)", "apex", apexName, fi.installDir)
		if apexType == flattenedApex {
		// /system/apex/<name>/{lib\|framework\|...}
		fmt.Fprintln(w, "LOCAL_MODULE_PATH :=", filepath.Join(a.installDir.ToMakePath().String(),
		apexName, fi.installDir))
		if a.primaryApexType {
		fmt.Fprintln(w, "LOCAL_SOONG_SYMBOL_PATH :=", pathWhenActivated)
		}
		if len(fi.symlinks) > 0 {
		fmt.Fprintln(w, "LOCAL_MODULE_SYMLINKS :=", strings.Join(fi.symlinks, " "))
		}

		if fi.module != nil && fi.module.NoticeFile().Valid() {
		fmt.Fprintln(w, "LOCAL_NOTICE_FILE :=", fi.module.NoticeFile().Path().String())
		}
		} else {
		fmt.Fprintln(w, "LOCAL_MODULE_PATH :=", pathWhenActivated)
		}
		fmt.Fprintln(w, "LOCAL_PREBUILT_MODULE_FILE :=", fi.builtFile.String())
		fmt.Fprintln(w, "LOCAL_MODULE_CLASS :=", fi.class.NameInMake())
		if fi.module != nil {
		archStr := fi.module.Target().Arch.ArchType.String()
		host := false
		switch fi.module.Target().Os.Class {
		case android.Host:
		if fi.module.Target().Arch.ArchType != android.Common {
		fmt.Fprintln(w, "LOCAL_MODULE_HOST_ARCH :=", archStr)
		}
		host = true
		case android.HostCross:
		if fi.module.Target().Arch.ArchType != android.Common {
		fmt.Fprintln(w, "LOCAL_MODULE_HOST_CROSS_ARCH :=", archStr)
		}
		host = true
		case android.Device:
		if fi.module.Target().Arch.ArchType != android.Common {
		fmt.Fprintln(w, "LOCAL_MODULE_TARGET_ARCH :=", archStr)
		}
		}
		if host {
		makeOs := fi.module.Target().Os.String()
		if fi.module.Target().Os == android.Linux \|\| fi.module.Target().Os == android.LinuxBionic {
		makeOs = "linux"
		}
		fmt.Fprintln(w, "LOCAL_MODULE_HOST_OS :=", makeOs)
		fmt.Fprintln(w, "LOCAL_IS_HOST_MODULE := true")
		}
		}
		if fi.class == javaSharedLib {
		javaModule := fi.module.(*java.Library)
		// soong_java_prebuilt.mk sets LOCAL_MODULE_SUFFIX := .jar Therefore
		// we need to remove the suffix from LOCAL_MODULE_STEM, otherwise
		// we will have foo.jar.jar
		fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", strings.TrimSuffix(fi.builtFile.Base(), ".jar"))
		fmt.Fprintln(w, "LOCAL_SOONG_CLASSES_JAR :=", javaModule.ImplementationAndResourcesJars()[0].String())
		fmt.Fprintln(w, "LOCAL_SOONG_HEADER_JAR :=", javaModule.HeaderJars()[0].String())
		fmt.Fprintln(w, "LOCAL_SOONG_DEX_JAR :=", fi.builtFile.String())
		fmt.Fprintln(w, "LOCAL_DEX_PREOPT := false")
		fmt.Fprintln(w, "include $(BUILD_SYSTEM)/soong_java_prebuilt.mk")
		} else if fi.class == nativeSharedLib \|\| fi.class == nativeExecutable \|\| fi.class == nativeTest {
		fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", fi.builtFile.Base())
		if cc, ok := fi.module.(*cc.Module); ok {
		if cc.UnstrippedOutputFile() != nil {
		fmt.Fprintln(w, "LOCAL_SOONG_UNSTRIPPED_BINARY :=", cc.UnstrippedOutputFile().String())
		}
		cc.AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
		if cc.CoverageOutputFile().Valid() {
		fmt.Fprintln(w, "LOCAL_PREBUILT_COVERAGE_ARCHIVE :=", cc.CoverageOutputFile().String())
		}
		}
		fmt.Fprintln(w, "include $(BUILD_SYSTEM)/soong_cc_prebuilt.mk")
		} else {
		fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", fi.builtFile.Base())
		// For flattened apexes, compat symlinks are attached to apex_manifest.json which is guaranteed for every apex
		if a.primaryApexType && fi.builtFile == a.manifestPbOut && len(a.compatSymlinks) > 0 {
		fmt.Fprintln(w, "LOCAL_POST_INSTALL_CMD :=", strings.Join(a.compatSymlinks, " && "))
		}
		fmt.Fprintln(w, "include $(BUILD_PREBUILT)")
		}
		}
		return moduleNames
		}

		func (a *apexBundle) androidMkForType() android.AndroidMkData {
		return android.AndroidMkData{
		Custom: func(w io.Writer, name, prefix, moduleDir string, data android.AndroidMkData) {
		moduleNames := []string{}
		apexType := a.properties.ApexType
		if a.installable() {
		apexName := proptools.StringDefault(a.properties.Apex_name, name)
		moduleNames = a.androidMkForFiles(w, apexName, moduleDir)
		}

		if apexType == flattenedApex {
		// Only image APEXes can be flattened.
		fmt.Fprintln(w, "\ninclude $(CLEAR_VARS)")
		fmt.Fprintln(w, "LOCAL_PATH :=", moduleDir)
		fmt.Fprintln(w, "LOCAL_MODULE :=", name+a.suffix)
		if len(moduleNames) > 0 {
		fmt.Fprintln(w, "LOCAL_REQUIRED_MODULES :=", strings.Join(moduleNames, " "))
		}
		fmt.Fprintln(w, "include $(BUILD_PHONY_PACKAGE)")
		fmt.Fprintln(w, "$(LOCAL_INSTALLED_MODULE): .KATI_IMPLICIT_OUTPUTS :=", a.outputFile.String())

		} else {
		fmt.Fprintln(w, "\ninclude $(CLEAR_VARS)")
		fmt.Fprintln(w, "LOCAL_PATH :=", moduleDir)
		fmt.Fprintln(w, "LOCAL_MODULE :=", name+a.suffix)
		fmt.Fprintln(w, "LOCAL_MODULE_CLASS := ETC") // do we need a new class?
		fmt.Fprintln(w, "LOCAL_PREBUILT_MODULE_FILE :=", a.outputFile.String())
		fmt.Fprintln(w, "LOCAL_MODULE_PATH :=", a.installDir.ToMakePath().String())
		fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", name+apexType.suffix())
		fmt.Fprintln(w, "LOCAL_UNINSTALLABLE_MODULE :=", !a.installable())
		if len(moduleNames) > 0 {
		fmt.Fprintln(w, "LOCAL_REQUIRED_MODULES +=", strings.Join(moduleNames, " "))
		}
		if len(a.externalDeps) > 0 {
		fmt.Fprintln(w, "LOCAL_REQUIRED_MODULES +=", strings.Join(a.externalDeps, " "))
		}
		var postInstallCommands []string
		if a.prebuiltFileToDelete != "" {
		postInstallCommands = append(postInstallCommands, "rm -rf "+
		filepath.Join(a.installDir.ToMakePath().String(), a.prebuiltFileToDelete))
		}
		// For unflattened apexes, compat symlinks are attached to apex package itself as LOCAL_POST_INSTALL_CMD
		postInstallCommands = append(postInstallCommands, a.compatSymlinks...)
		if len(postInstallCommands) > 0 {
		fmt.Fprintln(w, "LOCAL_POST_INSTALL_CMD :=", strings.Join(postInstallCommands, " && "))
		}
		fmt.Fprintln(w, "include $(BUILD_PREBUILT)")

		if apexType == imageApex {
		fmt.Fprintln(w, "ALL_MODULES.$(LOCAL_MODULE).BUNDLE :=", a.bundleModuleFile.String())
		}
		}
		}}
		}

apex/apex.go

+0 −958

File changed.

Preview size limit exceeded, changes collapsed.

apex/builder.go

0 → 100644

+531 −0

File added.

Preview size limit exceeded, changes collapsed.

apex/prebuilt.go

0 → 100644

+198 −0

Original line number	Diff line number	Diff line
		// Copyright (C) 2019 The Android Open Source Project
		//
		// 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 apex

		import (
		"fmt"
		"strings"

		"android/soong/android"

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

		type Prebuilt struct {
		android.ModuleBase
		prebuilt android.Prebuilt

		properties PrebuiltProperties

		inputApex android.Path
		installDir android.InstallPath
		installFilename string
		outputApex android.WritablePath
		}

		type PrebuiltProperties struct {
		// the path to the prebuilt .apex file to import.
		Source string `blueprint:"mutated"`
		ForceDisable bool `blueprint:"mutated"`

		Src *string
		Arch struct {
		Arm struct {
		Src *string
		}
		Arm64 struct {
		Src *string
		}
		X86 struct {
		Src *string
		}
		X86_64 struct {
		Src *string
		}
		}

		Installable *bool
		// Optional name for the installed apex. If unspecified, name of the
		// module is used as the file name
		Filename *string

		// Names of modules to be overridden. Listed modules can only be other binaries
		// (in Make or Soong).
		// This does not completely prevent installation of the overridden binaries, but if both
		// binaries would be installed by default (in PRODUCT_PACKAGES) the other binary will be removed
		// from PRODUCT_PACKAGES.
		Overrides []string
		}

		func (p *Prebuilt) installable() bool {
		return p.properties.Installable == nil \|\| proptools.Bool(p.properties.Installable)
		}

		func (p *Prebuilt) isForceDisabled() bool {
		return p.properties.ForceDisable
		}

		func (p *Prebuilt) OutputFiles(tag string) (android.Paths, error) {
		switch tag {
		case "":
		return android.Paths{p.outputApex}, nil
		default:
		return nil, fmt.Errorf("unsupported module reference tag %q", tag)
		}
		}

		func (p *Prebuilt) InstallFilename() string {
		return proptools.StringDefault(p.properties.Filename, p.BaseModuleName()+imageApexSuffix)
		}

		func (p Prebuilt) Prebuilt() android.Prebuilt {
		return &p.prebuilt
		}

		func (p *Prebuilt) Name() string {
		return p.prebuilt.Name(p.ModuleBase.Name())
		}

		// prebuilt_apex imports an `.apex` file into the build graph as if it was built with apex.
		func PrebuiltFactory() android.Module {
		module := &Prebuilt{}
		module.AddProperties(&module.properties)
		android.InitSingleSourcePrebuiltModule(module, &module.properties, "Source")
		android.InitAndroidMultiTargetsArchModule(module, android.DeviceSupported, android.MultilibCommon)
		return module
		}

		func (p *Prebuilt) DepsMutator(ctx android.BottomUpMutatorContext) {
		// If the device is configured to use flattened APEX, force disable the prebuilt because
		// the prebuilt is a non-flattened one.
		forceDisable := ctx.Config().FlattenApex()

		// Force disable the prebuilts when we are doing unbundled build. We do unbundled build
		// to build the prebuilts themselves.
		forceDisable = forceDisable \|\| ctx.Config().UnbundledBuild()

		// Force disable the prebuilts when coverage is enabled.
		forceDisable = forceDisable \|\| ctx.DeviceConfig().NativeCoverageEnabled()
		forceDisable = forceDisable \|\| ctx.Config().IsEnvTrue("EMMA_INSTRUMENT")

		// b/137216042 don't use prebuilts when address sanitizer is on
		forceDisable = forceDisable \|\| android.InList("address", ctx.Config().SanitizeDevice()) \|\|
		android.InList("hwaddress", ctx.Config().SanitizeDevice())

		if forceDisable && p.prebuilt.SourceExists() {
		p.properties.ForceDisable = true
		return
		}

		// This is called before prebuilt_select and prebuilt_postdeps mutators
		// The mutators requires that src to be set correctly for each arch so that
		// arch variants are disabled when src is not provided for the arch.
		if len(ctx.MultiTargets()) != 1 {
		ctx.ModuleErrorf("compile_multilib shouldn't be \"both\" for prebuilt_apex")
		return
		}
		var src string
		switch ctx.MultiTargets()[0].Arch.ArchType {
		case android.Arm:
		src = String(p.properties.Arch.Arm.Src)
		case android.Arm64:
		src = String(p.properties.Arch.Arm64.Src)
		case android.X86:
		src = String(p.properties.Arch.X86.Src)
		case android.X86_64:
		src = String(p.properties.Arch.X86_64.Src)
		default:
		ctx.ModuleErrorf("prebuilt_apex does not support %q", ctx.MultiTargets()[0].Arch.String())
		return
		}
		if src == "" {
		src = String(p.properties.Src)
		}
		p.properties.Source = src
		}

		func (p *Prebuilt) GenerateAndroidBuildActions(ctx android.ModuleContext) {
		if p.properties.ForceDisable {
		return
		}

		// TODO(jungjw): Check the key validity.
		p.inputApex = p.Prebuilt().SingleSourcePath(ctx)
		p.installDir = android.PathForModuleInstall(ctx, "apex")
		p.installFilename = p.InstallFilename()
		if !strings.HasSuffix(p.installFilename, imageApexSuffix) {
		ctx.ModuleErrorf("filename should end in %s for prebuilt_apex", imageApexSuffix)
		}
		p.outputApex = android.PathForModuleOut(ctx, p.installFilename)
		ctx.Build(pctx, android.BuildParams{
		Rule: android.Cp,
		Input: p.inputApex,
		Output: p.outputApex,
		})
		if p.installable() {
		ctx.InstallFile(p.installDir, p.installFilename, p.inputApex)
		}

		// TODO(b/143192278): Add compat symlinks for prebuilt_apex
		}

		func (p *Prebuilt) AndroidMkEntries() android.AndroidMkEntries {
		return android.AndroidMkEntries{
		Class: "ETC",
		OutputFile: android.OptionalPathForPath(p.inputApex),
		Include: "$(BUILD_PREBUILT)",
		ExtraEntries: []android.AndroidMkExtraEntriesFunc{
		func(entries *android.AndroidMkEntries) {
		entries.SetString("LOCAL_MODULE_PATH", p.installDir.ToMakePath().String())
		entries.SetString("LOCAL_MODULE_STEM", p.installFilename)
		entries.SetBoolIfTrue("LOCAL_UNINSTALLABLE_MODULE", !p.installable())
		entries.AddStrings("LOCAL_OVERRIDES_MODULES", p.properties.Overrides...)
		},
		},
		}
		}