Merge changes from topics "prebuilt_build_tool", "prebuilt_build_tool_make" (4ec839a2) · Commits · e / os / android_build_soong

android/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -39,6 +39,7 @@ bootstrap_go_package {
		"paths.go",
		"phony.go",
		"prebuilt.go",
		"prebuilt_build_tool.go",
		"proto.go",
		"register.go",
		"rule_builder.go",

android/defs.go

+1 −1

Original line number	Diff line number	Diff line
		@@ -69,7 +69,7 @@ var (
		// A symlink rule.
		Symlink = pctx.AndroidStaticRule("Symlink",
		blueprint.RuleParams{
		Command: "ln -f -s $fromPath $out",
		Command: "rm -f $out && ln -f -s $fromPath $out",
		Description: "symlink $out",
		},
		"fromPath")

android/filegroup.go

+3 −20

Original line number	Diff line number	Diff line
		@@ -15,9 +15,7 @@
		package android

		import (
		"io"
		"strings"
		"text/template"
		)

		func init() {
		@@ -71,23 +69,8 @@ func (fg *fileGroup) Srcs() Paths {
		return append(Paths{}, fg.srcs...)
		}

		var androidMkTemplate = template.Must(template.New("filegroup").Parse(`
		ifdef {{.makeVar}}
		$(error variable {{.makeVar}} set by soong module is already set in make)
		endif
		{{.makeVar}} := {{.value}}
		.KATI_READONLY := {{.makeVar}}
		`))

		func (fg *fileGroup) AndroidMk() AndroidMkData {
		return AndroidMkData{
		Custom: func(w io.Writer, name, prefix, moduleDir string, data AndroidMkData) {
		func (fg *fileGroup) MakeVars(ctx MakeVarsModuleContext) {
		if makeVar := String(fg.properties.Export_to_make_var); makeVar != "" {
		androidMkTemplate.Execute(w, map[string]string{
		"makeVar": makeVar,
		"value": strings.Join(fg.srcs.Strings(), " "),
		})
		}
		},
		ctx.StrictRaw(makeVar, strings.Join(fg.srcs.Strings(), " "))
		}
		}

android/makevars.go

+90 −31

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@ package android
		import (
		"bytes"
		"fmt"
		"sort"
		"strconv"
		"strings"

		@@ -34,43 +35,16 @@ func androidMakeVarsProvider(ctx MakeVarsContext) {
		}

		///////////////////////////////////////////////////////////////////////////////
		// Interface for other packages to use to declare make variables
		type MakeVarsContext interface {

		// BaseMakeVarsContext contains the common functions for other packages to use
		// to declare make variables
		type BaseMakeVarsContext interface {
		Config() Config
		DeviceConfig() DeviceConfig
		AddNinjaFileDeps(deps ...string)

		ModuleName(module blueprint.Module) string
		ModuleDir(module blueprint.Module) string
		ModuleSubDir(module blueprint.Module) string
		ModuleType(module blueprint.Module) string
		BlueprintFile(module blueprint.Module) string

		ModuleErrorf(module blueprint.Module, format string, args ...interface{})
		Errorf(format string, args ...interface{})
		Failed() bool

		VisitAllModules(visit func(Module))
		VisitAllModulesIf(pred func(Module) bool, visit func(Module))

		// Verify the make variable matches the Soong version, fail the build
		// if it does not. If the make variable is empty, just set it.
		Strict(name, ninjaStr string)
		// Check to see if the make variable matches the Soong version, warn if
		// it does not. If the make variable is empty, just set it.
		Check(name, ninjaStr string)

		// These are equivalent to the above, but sort the make and soong
		// variables before comparing them. They also show the unique entries
		// in each list when displaying the difference, instead of the entire
		// string.
		StrictSorted(name, ninjaStr string)
		CheckSorted(name, ninjaStr string)

		// Evaluates a ninja string and returns the result. Used if more
		// complicated modification needs to happen before giving it to Make.
		Eval(ninjaStr string) (string, error)

		// These are equivalent to Strict and Check, but do not attempt to
		// evaluate the values before writing them to the Makefile. They can
		// be used when all ninja variables have already been evaluated through
		@@ -108,6 +82,48 @@ type MakeVarsContext interface {
		DistForGoalsWithFilename(goals []string, path Path, filename string)
		}

		// MakeVarsContext contains the set of functions available for MakeVarsProvider
		// and SingletonMakeVarsProvider implementations.
		type MakeVarsContext interface {
		BaseMakeVarsContext

		ModuleName(module blueprint.Module) string
		ModuleDir(module blueprint.Module) string
		ModuleSubDir(module blueprint.Module) string
		ModuleType(module blueprint.Module) string
		BlueprintFile(module blueprint.Module) string

		ModuleErrorf(module blueprint.Module, format string, args ...interface{})
		Errorf(format string, args ...interface{})

		VisitAllModules(visit func(Module))
		VisitAllModulesIf(pred func(Module) bool, visit func(Module))

		// Verify the make variable matches the Soong version, fail the build
		// if it does not. If the make variable is empty, just set it.
		Strict(name, ninjaStr string)
		// Check to see if the make variable matches the Soong version, warn if
		// it does not. If the make variable is empty, just set it.
		Check(name, ninjaStr string)

		// These are equivalent to the above, but sort the make and soong
		// variables before comparing them. They also show the unique entries
		// in each list when displaying the difference, instead of the entire
		// string.
		StrictSorted(name, ninjaStr string)
		CheckSorted(name, ninjaStr string)

		// Evaluates a ninja string and returns the result. Used if more
		// complicated modification needs to happen before giving it to Make.
		Eval(ninjaStr string) (string, error)
		}

		// MakeVarsModuleContext contains the set of functions available for modules
		// implementing the ModuleMakeVarsProvider interface.
		type MakeVarsModuleContext interface {
		BaseMakeVarsContext
		}

		var _ PathContext = MakeVarsContext(nil)

		type MakeVarsProvider func(ctx MakeVarsContext)
		@@ -135,6 +151,14 @@ func SingletonmakeVarsProviderAdapter(singleton SingletonMakeVarsProvider) MakeV
		return func(ctx MakeVarsContext) { singleton.MakeVars(ctx) }
		}

		// ModuleMakeVarsProvider is a Module with an extra method to provide extra values to be exported to Make.
		type ModuleMakeVarsProvider interface {
		Module

		// MakeVars uses a MakeVarsModuleContext to provide extra values to be exported to Make.
		MakeVars(ctx MakeVarsModuleContext)
		}

		///////////////////////////////////////////////////////////////////////////////

		func makeVarsSingletonFunc() Singleton {
		@@ -209,10 +233,45 @@ func (s *makeVarsSingleton) GenerateBuildActions(ctx SingletonContext) {
		dists = append(dists, mctx.dists...)
		}

		ctx.VisitAllModules(func(m Module) {
		if provider, ok := m.(ModuleMakeVarsProvider); ok {
		mctx := &makeVarsContext{
		SingletonContext: ctx,
		}

		provider.MakeVars(mctx)

		vars = append(vars, mctx.vars...)
		phonies = append(phonies, mctx.phonies...)
		dists = append(dists, mctx.dists...)
		}
		})

		if ctx.Failed() {
		return
		}

		sort.Slice(vars, func(i, j int) bool {
		return vars[i].name < vars[j].name
		})
		sort.Slice(phonies, func(i, j int) bool {
		return phonies[i].name < phonies[j].name
		})
		lessArr := func(a, b []string) bool {
		if len(a) == len(b) {
		for i := range a {
		if a[i] < b[i] {
		return true
		}
		}
		return false
		}
		return len(a) < len(b)
		}
		sort.Slice(dists, func(i, j int) bool {
		return lessArr(dists[i].goals, dists[j].goals) \|\| lessArr(dists[i].paths, dists[j].paths)
		})

		outBytes := s.writeVars(vars)

		if err := pathtools.WriteFileIfChanged(outFile, outBytes, 0666); err != nil {

android/prebuilt_build_tool.go

0 → 100644

+104 −0

Original line number	Diff line number	Diff line
		// Copyright 2020 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 android

		import (
		"path"
		"path/filepath"
		)

		func init() {
		RegisterModuleType("prebuilt_build_tool", prebuiltBuildToolFactory)
		}

		type prebuiltBuildToolProperties struct {
		// Source file to be executed for this build tool
		Src *string `android:"path,arch_variant"`

		// Extra files that should trigger rules using this tool to rebuild
		Deps []string `android:"path,arch_variant"`

		// Create a make variable with the specified name that contains the path to
		// this prebuilt built tool, relative to the root of the source tree.
		Export_to_make_var *string
		}

		type prebuiltBuildTool struct {
		ModuleBase
		prebuilt Prebuilt

		properties prebuiltBuildToolProperties

		toolPath OptionalPath
		}

		func (t *prebuiltBuildTool) Name() string {
		return t.prebuilt.Name(t.ModuleBase.Name())
		}

		func (t prebuiltBuildTool) Prebuilt() Prebuilt {
		return &t.prebuilt
		}

		func (t *prebuiltBuildTool) DepsMutator(ctx BottomUpMutatorContext) {
		if t.properties.Src == nil {
		ctx.PropertyErrorf("src", "missing prebuilt source file")
		}
		}

		func (t *prebuiltBuildTool) GenerateAndroidBuildActions(ctx ModuleContext) {
		sourcePath := t.prebuilt.SingleSourcePath(ctx)
		installedPath := PathForModuleOut(ctx, t.ModuleBase.Name())
		deps := PathsForModuleSrc(ctx, t.properties.Deps)

		relPath, err := filepath.Rel(path.Dir(installedPath.String()), sourcePath.String())
		if err != nil {
		ctx.ModuleErrorf("Unabled to generate symlink between %q and %q: %s", installedPath.String(), sourcePath.String())
		}

		ctx.Build(pctx, BuildParams{
		Rule: Symlink,
		Output: installedPath,
		Input: sourcePath,
		Implicits: deps,
		Args: map[string]string{
		"fromPath": relPath,
		},
		})

		t.toolPath = OptionalPathForPath(installedPath)
		}

		func (t *prebuiltBuildTool) HostToolPath() OptionalPath {
		return t.toolPath
		}

		func (t *prebuiltBuildTool) MakeVars(ctx MakeVarsModuleContext) {
		if makeVar := String(t.properties.Export_to_make_var); makeVar != "" {
		ctx.StrictRaw(makeVar, t.toolPath.String())
		}
		}

		var _ HostToolProvider = &prebuiltBuildTool{}

		// prebuilt_build_tool is to declare prebuilts to be used during the build, particularly for use
		// in genrules with the "tools" property.
		func prebuiltBuildToolFactory() Module {
		module := &prebuiltBuildTool{}
		module.AddProperties(&module.properties)
		InitSingleSourcePrebuiltModule(module, &module.properties, "Src")
		InitAndroidArchModule(module, HostSupportedNoCross, MultilibFirst)
		return module
		}