android/makevars.go - SHIFTPHONES/android_build_soong - Gitiles

 // 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 android

 import (
 	"bytes"
 	"fmt"
 	"path/filepath"
 	"runtime"
 	"sort"
 	"strings"

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

 func init() {
 	RegisterMakeVarsProvider(pctx, androidMakeVarsProvider)
 }

 func androidMakeVarsProvider(ctx MakeVarsContext) {
 	ctx.Strict("MIN_SUPPORTED_SDK_VERSION", ctx.Config().MinSupportedSdkVersion().String())
 }

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

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

 	Failed() bool

 	// 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
 	// Eval().
 	StrictRaw(name, value string)
 	CheckRaw(name, value string)

 	// GlobWithDeps returns a list of files that match the specified pattern but do not match any
 	// of the patterns in excludes.  It also adds efficient dependencies to rerun the primary
 	// builder whenever a file matching the pattern as added or removed, without rerunning if a
 	// file that does not match the pattern is added to a searched directory.
 	GlobWithDeps(pattern string, excludes []string) ([]string, error)

 	// Phony creates a phony rule in Make, which will allow additional DistForGoal
 	// dependencies to be added to it.  Phony can be called on the same name multiple
 	// times to add additional dependencies.
 	Phony(names string, deps ...Path)

 	// DistForGoal creates a rule to copy one or more Paths to the artifacts
 	// directory on the build server when the specified goal is built.
 	DistForGoal(goal string, paths ...Path)

 	// DistForGoalWithFilename creates a rule to copy a Path to the artifacts
 	// directory on the build server with the given filename when the specified
 	// goal is built.
 	DistForGoalWithFilename(goal string, path Path, filename string)

 	// DistForGoals creates a rule to copy one or more Paths to the artifacts
 	// directory on the build server when any of the specified goals are built.
 	DistForGoals(goals []string, paths ...Path)

 	// DistForGoalsWithFilename creates a rule to copy a Path to the artifacts
 	// directory on the build server with the given filename when any of the
 	// specified goals are built.
 	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
 	ModuleProvider(module blueprint.Module, key blueprint.ProviderKey) interface{}
 	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)

 func RegisterMakeVarsProvider(pctx PackageContext, provider MakeVarsProvider) {
 	makeVarsInitProviders = append(makeVarsInitProviders, makeVarsProvider{pctx, provider})
 }

 // SingletonMakeVarsProvider is a Singleton with an extra method to provide extra values to be exported to Make.
 type SingletonMakeVarsProvider interface {
 	// MakeVars uses a MakeVarsContext to provide extra values to be exported to Make.
 	MakeVars(ctx MakeVarsContext)
 }

 var singletonMakeVarsProvidersKey = NewOnceKey("singletonMakeVarsProvidersKey")

 func getSingletonMakevarsProviders(config Config) *[]makeVarsProvider {
 	return config.Once(singletonMakeVarsProvidersKey, func() interface{} {
 		return &[]makeVarsProvider{}
 	}).(*[]makeVarsProvider)
 }

 // registerSingletonMakeVarsProvider adds a singleton that implements SingletonMakeVarsProvider to
 // the list of MakeVarsProviders to run.
 func registerSingletonMakeVarsProvider(config Config, singleton SingletonMakeVarsProvider) {
 	// Singletons are registered on the Context and may be different between different Contexts,
 	// for example when running multiple tests.  Store the SingletonMakeVarsProviders in the
 	// Config so they are attached to the Context.
 	singletonMakeVarsProviders := getSingletonMakevarsProviders(config)

 	*singletonMakeVarsProviders = append(*singletonMakeVarsProviders,
 		makeVarsProvider{pctx, singletonMakeVarsProviderAdapter(singleton)})
 }

 // singletonMakeVarsProviderAdapter converts a SingletonMakeVarsProvider to a MakeVarsProvider.
 func singletonMakeVarsProviderAdapter(singleton SingletonMakeVarsProvider) MakeVarsProvider {
 	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 {
 	return &makeVarsSingleton{}
 }

 type makeVarsSingleton struct {
 	installsForTesting []byte
 }

 type makeVarsProvider struct {
 	pctx PackageContext
 	call MakeVarsProvider
 }

 // Collection of makevars providers that are registered in init() methods.
 var makeVarsInitProviders []makeVarsProvider

 type makeVarsContext struct {
 	SingletonContext
 	config  Config
 	pctx    PackageContext
 	vars    []makeVarsVariable
 	phonies []phony
 	dists   []dist
 }

 var _ MakeVarsContext = &makeVarsContext{}

 type makeVarsVariable struct {
 	name   string
 	value  string
 	sort   bool
 	strict bool
 }

 type phony struct {
 	name string
 	deps []string
 }

 type dist struct {
 	goals []string
 	paths []string
 }

 func (s *makeVarsSingleton) GenerateBuildActions(ctx SingletonContext) {
 	if !ctx.Config().KatiEnabled() {
 		return
 	}

 	outFile := absolutePath(PathForOutput(ctx,
 		"make_vars"+proptools.String(ctx.Config().productVariables.Make_suffix)+".mk").String())

 	lateOutFile := absolutePath(PathForOutput(ctx,
 		"late"+proptools.String(ctx.Config().productVariables.Make_suffix)+".mk").String())

 	installsFile := absolutePath(PathForOutput(ctx,
 		"installs"+proptools.String(ctx.Config().productVariables.Make_suffix)+".mk").String())

 	if ctx.Failed() {
 		return
 	}

 	var vars []makeVarsVariable
 	var dists []dist
 	var phonies []phony
 	var katiInstalls []katiInstall
 	var katiSymlinks []katiInstall

 	providers := append([]makeVarsProvider(nil), makeVarsInitProviders...)
 	providers = append(providers, *getSingletonMakevarsProviders(ctx.Config())...)

 	for _, provider := range providers {
 		mctx := &makeVarsContext{
 			SingletonContext: ctx,
 			pctx:             provider.pctx,
 		}

 		provider.call(mctx)

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

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

 			provider.MakeVars(mctx)

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

 		if m.ExportedToMake() {
 			katiInstalls = append(katiInstalls, m.base().katiInstalls...)
 			katiSymlinks = append(katiSymlinks, m.base().katiSymlinks...)
 		}
 	})

 	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 {
 		ctx.Errorf(err.Error())
 	}

 	lateOutBytes := s.writeLate(phonies, dists)

 	if err := pathtools.WriteFileIfChanged(lateOutFile, lateOutBytes, 0666); err != nil {
 		ctx.Errorf(err.Error())
 	}

 	installsBytes := s.writeInstalls(katiInstalls, katiSymlinks)
 	if err := pathtools.WriteFileIfChanged(installsFile, installsBytes, 0666); err != nil {
 		ctx.Errorf(err.Error())
 	}

 	s.installsForTesting = installsBytes
 }

 func (s *makeVarsSingleton) writeVars(vars []makeVarsVariable) []byte {
 	buf := &bytes.Buffer{}

 	fmt.Fprint(buf, `# Autogenerated file

 # Compares SOONG_$(1) against $(1), and warns if they are not equal.
 #
 # If the original variable is empty, then just set it to the SOONG_ version.
 #
 # $(1): Name of the variable to check
 # $(2): If not-empty, sort the values before comparing
 # $(3): Extra snippet to run if it does not match
 define soong-compare-var
 ifneq ($$($(1)),)
   my_val_make := $$(strip $(if $(2),$$(sort $$($(1))),$$($(1))))
   my_val_soong := $(if $(2),$$(sort $$(SOONG_$(1))),$$(SOONG_$(1)))
   ifneq ($$(my_val_make),$$(my_val_soong))
     $$(warning $(1) does not match between Make and Soong:)
     $(if $(2),$$(warning Make  adds: $$(filter-out $$(my_val_soong),$$(my_val_make))),$$(warning Make : $$(my_val_make)))
     $(if $(2),$$(warning Soong adds: $$(filter-out $$(my_val_make),$$(my_val_soong))),$$(warning Soong: $$(my_val_soong)))
     $(3)
   endif
   my_val_make :=
   my_val_soong :=
 else
   $(1) := $$(SOONG_$(1))
 endif
 .KATI_READONLY := $(1) SOONG_$(1)
 endef

 my_check_failed := false

 `)

 	// Write all the strict checks out first so that if one of them errors,
 	// we get all of the strict errors printed, but not the non-strict
 	// warnings.
 	for _, v := range vars {
 		if !v.strict {
 			continue
 		}

 		sort := ""
 		if v.sort {
 			sort = "true"
 		}

 		fmt.Fprintf(buf, "SOONG_%s := %s\n", v.name, v.value)
 		fmt.Fprintf(buf, "$(eval $(call soong-compare-var,%s,%s,my_check_failed := true))\n\n", v.name, sort)
 	}

 	fmt.Fprint(buf, `
 ifneq ($(my_check_failed),false)
   $(error Soong variable check failed)
 endif
 my_check_failed :=


 `)

 	for _, v := range vars {
 		if v.strict {
 			continue
 		}

 		sort := ""
 		if v.sort {
 			sort = "true"
 		}

 		fmt.Fprintf(buf, "SOONG_%s := %s\n", v.name, v.value)
 		fmt.Fprintf(buf, "$(eval $(call soong-compare-var,%s,%s))\n\n", v.name, sort)
 	}

 	fmt.Fprintln(buf, "\nsoong-compare-var :=")

 	fmt.Fprintln(buf)

 	return buf.Bytes()
 }

 func (s *makeVarsSingleton) writeLate(phonies []phony, dists []dist) []byte {
 	buf := &bytes.Buffer{}

 	fmt.Fprint(buf, `# Autogenerated file

 # Values written by Soong read after parsing all Android.mk files.


 `)

 	for _, phony := range phonies {
 		fmt.Fprintf(buf, ".PHONY: %s\n", phony.name)
 		fmt.Fprintf(buf, "%s: %s\n", phony.name, strings.Join(phony.deps, "\\\n  "))
 	}

 	fmt.Fprintln(buf)

 	for _, dist := range dists {
 		fmt.Fprintf(buf, ".PHONY: %s\n", strings.Join(dist.goals, " "))
 		fmt.Fprintf(buf, "$(call dist-for-goals,%s,%s)\n",
 			strings.Join(dist.goals, " "), strings.Join(dist.paths, " "))
 	}

 	return buf.Bytes()
 }

 // writeInstalls writes the list of install rules generated by Soong to a makefile.  The rules
 // are exported to Make instead of written directly to the ninja file so that main.mk can add
 // the dependencies from the `required` property that are hard to resolve in Soong.
 func (s *makeVarsSingleton) writeInstalls(installs, symlinks []katiInstall) []byte {
 	buf := &bytes.Buffer{}

 	fmt.Fprint(buf, `# Autogenerated file

 # Values written by Soong to generate install rules that can be amended by Kati.


 `)

 	preserveSymlinksFlag := "-d"
 	if runtime.GOOS == "darwin" {
 		preserveSymlinksFlag = "-R"
 	}

 	for _, install := range installs {
 		// Write a rule for each install request in the form:
 		//  to: from [ deps ] [ | order only deps ]
 		//       cp -f -d $< $@ [ && chmod +x $@ ]
 		fmt.Fprintf(buf, "%s: %s", install.to.String(), install.from.String())
 		for _, dep := range install.implicitDeps {
 			fmt.Fprintf(buf, " %s", dep.String())
 		}
 		if extraFiles := install.extraFiles; extraFiles != nil {
 			fmt.Fprintf(buf, " %s", extraFiles.zip.String())
 		}
 		if len(install.orderOnlyDeps) > 0 {
 			fmt.Fprintf(buf, " |")
 		}
 		for _, dep := range install.orderOnlyDeps {
 			fmt.Fprintf(buf, " %s", dep.String())
 		}
 		fmt.Fprintln(buf)
 		fmt.Fprintln(buf, "\t@echo \"Install: $@\"")
 		fmt.Fprintf(buf, "\trm -f $@ && cp -f %s $< $@\n", preserveSymlinksFlag)
 		if install.executable {
 			fmt.Fprintf(buf, "\tchmod +x $@\n")
 		}
 		if extraFiles := install.extraFiles; extraFiles != nil {
 			fmt.Fprintf(buf, "\t( unzip -qDD -d '%s' '%s' 2>&1 | grep -v \"zipfile is empty\"; exit $${PIPESTATUS[0]} ) || \\\n", extraFiles.dir.String(), extraFiles.zip.String())
 			fmt.Fprintf(buf, "\t  ( code=$$?; if [ $$code -ne 0 -a $$code -ne 1 ]; then exit $$code; fi )\n")
 		}
 		fmt.Fprintln(buf)
 	}

 	for _, symlink := range symlinks {
 		fmt.Fprintf(buf, "%s:", symlink.to.String())
 		if symlink.from != nil {
 			// The symlink doesn't need updating when the target is modified, but we sometimes
 			// have a dependency on a symlink to a binary instead of to the binary directly, and
 			// the mtime of the symlink must be updated when the binary is modified, so use a
 			// normal dependency here instead of an order-only dependency.
 			fmt.Fprintf(buf, " %s", symlink.from.String())
 		}
 		for _, dep := range symlink.implicitDeps {
 			fmt.Fprintf(buf, " %s", dep.String())
 		}
 		if len(symlink.orderOnlyDeps) > 0 {
 			fmt.Fprintf(buf, " |")
 		}
 		for _, dep := range symlink.orderOnlyDeps {
 			fmt.Fprintf(buf, " %s", dep.String())
 		}
 		fmt.Fprintln(buf)

 		fromStr := ""
 		if symlink.from != nil {
 			rel, err := filepath.Rel(filepath.Dir(symlink.to.String()), symlink.from.String())
 			if err != nil {
 				panic(fmt.Errorf("failed to find relative path for symlink from %q to %q: %w",
 					symlink.from.String(), symlink.to.String(), err))
 			}
 			fromStr = rel
 		} else {
 			fromStr = symlink.absFrom
 		}

 		fmt.Fprintln(buf, "\t@echo \"Symlink: $@\"")
 		fmt.Fprintf(buf, "\trm -f $@ && ln -sfn %s $@", fromStr)
 		fmt.Fprintln(buf)
 		fmt.Fprintln(buf)
 	}

 	return buf.Bytes()
 }

 func (c *makeVarsContext) DeviceConfig() DeviceConfig {
 	return DeviceConfig{c.Config().deviceConfig}
 }

 var ninjaDescaper = strings.NewReplacer("$$", "$")

 func (c *makeVarsContext) Eval(ninjaStr string) (string, error) {
 	s, err := c.SingletonContext.Eval(c.pctx, ninjaStr)
 	if err != nil {
 		return "", err
 	}
 	// SingletonContext.Eval returns an exapnded string that is valid for a ninja file, de-escape $$ to $ for use
 	// in a Makefile
 	return ninjaDescaper.Replace(s), nil
 }

 func (c *makeVarsContext) addVariableRaw(name, value string, strict, sort bool) {
 	c.vars = append(c.vars, makeVarsVariable{
 		name:   name,
 		value:  value,
 		strict: strict,
 		sort:   sort,
 	})
 }

 func (c *makeVarsContext) addVariable(name, ninjaStr string, strict, sort bool) {
 	value, err := c.Eval(ninjaStr)
 	if err != nil {
 		c.SingletonContext.Errorf(err.Error())
 	}
 	c.addVariableRaw(name, value, strict, sort)
 }

 func (c *makeVarsContext) addPhony(name string, deps []string) {
 	c.phonies = append(c.phonies, phony{name, deps})
 }

 func (c *makeVarsContext) addDist(goals []string, paths []string) {
 	c.dists = append(c.dists, dist{
 		goals: goals,
 		paths: paths,
 	})
 }

 func (c *makeVarsContext) Strict(name, ninjaStr string) {
 	c.addVariable(name, ninjaStr, true, false)
 }
 func (c *makeVarsContext) StrictSorted(name, ninjaStr string) {
 	c.addVariable(name, ninjaStr, true, true)
 }
 func (c *makeVarsContext) StrictRaw(name, value string) {
 	c.addVariableRaw(name, value, true, false)
 }

 func (c *makeVarsContext) Check(name, ninjaStr string) {
 	c.addVariable(name, ninjaStr, false, false)
 }
 func (c *makeVarsContext) CheckSorted(name, ninjaStr string) {
 	c.addVariable(name, ninjaStr, false, true)
 }
 func (c *makeVarsContext) CheckRaw(name, value string) {
 	c.addVariableRaw(name, value, false, false)
 }

 func (c *makeVarsContext) Phony(name string, deps ...Path) {
 	c.addPhony(name, Paths(deps).Strings())
 }

 func (c *makeVarsContext) DistForGoal(goal string, paths ...Path) {
 	c.DistForGoals([]string{goal}, paths...)
 }

 func (c *makeVarsContext) DistForGoalWithFilename(goal string, path Path, filename string) {
 	c.DistForGoalsWithFilename([]string{goal}, path, filename)
 }

 func (c *makeVarsContext) DistForGoals(goals []string, paths ...Path) {
 	c.addDist(goals, Paths(paths).Strings())
 }

 func (c *makeVarsContext) DistForGoalsWithFilename(goals []string, path Path, filename string) {
 	c.addDist(goals, []string{path.String() + ":" + filename})
 }
	// 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 android

	import (
	"bytes"
	"fmt"
	"path/filepath"
	"runtime"
	"sort"
	"strings"

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

	func init() {
	RegisterMakeVarsProvider(pctx, androidMakeVarsProvider)
	}

	func androidMakeVarsProvider(ctx MakeVarsContext) {
	ctx.Strict("MIN_SUPPORTED_SDK_VERSION", ctx.Config().MinSupportedSdkVersion().String())
	}

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

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

	Failed() bool

	// 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
	// Eval().
	StrictRaw(name, value string)
	CheckRaw(name, value string)

	// GlobWithDeps returns a list of files that match the specified pattern but do not match any
	// of the patterns in excludes. It also adds efficient dependencies to rerun the primary
	// builder whenever a file matching the pattern as added or removed, without rerunning if a
	// file that does not match the pattern is added to a searched directory.
	GlobWithDeps(pattern string, excludes []string) ([]string, error)

	// Phony creates a phony rule in Make, which will allow additional DistForGoal
	// dependencies to be added to it. Phony can be called on the same name multiple
	// times to add additional dependencies.
	Phony(names string, deps ...Path)

	// DistForGoal creates a rule to copy one or more Paths to the artifacts
	// directory on the build server when the specified goal is built.
	DistForGoal(goal string, paths ...Path)

	// DistForGoalWithFilename creates a rule to copy a Path to the artifacts
	// directory on the build server with the given filename when the specified
	// goal is built.
	DistForGoalWithFilename(goal string, path Path, filename string)

	// DistForGoals creates a rule to copy one or more Paths to the artifacts
	// directory on the build server when any of the specified goals are built.
	DistForGoals(goals []string, paths ...Path)

	// DistForGoalsWithFilename creates a rule to copy a Path to the artifacts
	// directory on the build server with the given filename when any of the
	// specified goals are built.
	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
	ModuleProvider(module blueprint.Module, key blueprint.ProviderKey) interface{}
	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)

	func RegisterMakeVarsProvider(pctx PackageContext, provider MakeVarsProvider) {
	makeVarsInitProviders = append(makeVarsInitProviders, makeVarsProvider{pctx, provider})
	}

	// SingletonMakeVarsProvider is a Singleton with an extra method to provide extra values to be exported to Make.
	type SingletonMakeVarsProvider interface {
	// MakeVars uses a MakeVarsContext to provide extra values to be exported to Make.
	MakeVars(ctx MakeVarsContext)
	}

	var singletonMakeVarsProvidersKey = NewOnceKey("singletonMakeVarsProvidersKey")

	func getSingletonMakevarsProviders(config Config) *[]makeVarsProvider {
	return config.Once(singletonMakeVarsProvidersKey, func() interface{} {
	return &[]makeVarsProvider{}
	}).(*[]makeVarsProvider)
	}

	// registerSingletonMakeVarsProvider adds a singleton that implements SingletonMakeVarsProvider to
	// the list of MakeVarsProviders to run.
	func registerSingletonMakeVarsProvider(config Config, singleton SingletonMakeVarsProvider) {
	// Singletons are registered on the Context and may be different between different Contexts,
	// for example when running multiple tests. Store the SingletonMakeVarsProviders in the
	// Config so they are attached to the Context.
	singletonMakeVarsProviders := getSingletonMakevarsProviders(config)

	singletonMakeVarsProviders = append(singletonMakeVarsProviders,
	makeVarsProvider{pctx, singletonMakeVarsProviderAdapter(singleton)})
	}

	// singletonMakeVarsProviderAdapter converts a SingletonMakeVarsProvider to a MakeVarsProvider.
	func singletonMakeVarsProviderAdapter(singleton SingletonMakeVarsProvider) MakeVarsProvider {
	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 {
	return &makeVarsSingleton{}
	}

	type makeVarsSingleton struct {
	installsForTesting []byte
	}

	type makeVarsProvider struct {
	pctx PackageContext
	call MakeVarsProvider
	}

	// Collection of makevars providers that are registered in init() methods.
	var makeVarsInitProviders []makeVarsProvider

	type makeVarsContext struct {
	SingletonContext
	config Config
	pctx PackageContext
	vars []makeVarsVariable
	phonies []phony
	dists []dist
	}

	var _ MakeVarsContext = &makeVarsContext{}

	type makeVarsVariable struct {
	name string
	value string
	sort bool
	strict bool
	}

	type phony struct {
	name string
	deps []string
	}

	type dist struct {
	goals []string
	paths []string
	}

	func (s *makeVarsSingleton) GenerateBuildActions(ctx SingletonContext) {
	if !ctx.Config().KatiEnabled() {
	return
	}

	outFile := absolutePath(PathForOutput(ctx,
	"make_vars"+proptools.String(ctx.Config().productVariables.Make_suffix)+".mk").String())

	lateOutFile := absolutePath(PathForOutput(ctx,
	"late"+proptools.String(ctx.Config().productVariables.Make_suffix)+".mk").String())

	installsFile := absolutePath(PathForOutput(ctx,
	"installs"+proptools.String(ctx.Config().productVariables.Make_suffix)+".mk").String())

	if ctx.Failed() {
	return
	}

	var vars []makeVarsVariable
	var dists []dist
	var phonies []phony
	var katiInstalls []katiInstall
	var katiSymlinks []katiInstall

	providers := append([]makeVarsProvider(nil), makeVarsInitProviders...)
	providers = append(providers, *getSingletonMakevarsProviders(ctx.Config())...)

	for _, provider := range providers {
	mctx := &makeVarsContext{
	SingletonContext: ctx,
	pctx: provider.pctx,
	}

	provider.call(mctx)

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

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

	provider.MakeVars(mctx)

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

	if m.ExportedToMake() {
	katiInstalls = append(katiInstalls, m.base().katiInstalls...)
	katiSymlinks = append(katiSymlinks, m.base().katiSymlinks...)
	}
	})

	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 {
	ctx.Errorf(err.Error())
	}

	lateOutBytes := s.writeLate(phonies, dists)

	if err := pathtools.WriteFileIfChanged(lateOutFile, lateOutBytes, 0666); err != nil {
	ctx.Errorf(err.Error())
	}

	installsBytes := s.writeInstalls(katiInstalls, katiSymlinks)
	if err := pathtools.WriteFileIfChanged(installsFile, installsBytes, 0666); err != nil {
	ctx.Errorf(err.Error())
	}

	s.installsForTesting = installsBytes
	}

	func (s *makeVarsSingleton) writeVars(vars []makeVarsVariable) []byte {
	buf := &bytes.Buffer{}

	fmt.Fprint(buf, `# Autogenerated file

	# Compares SOONG_$(1) against $(1), and warns if they are not equal.
	#
	# If the original variable is empty, then just set it to the SOONG_ version.
	#
	# $(1): Name of the variable to check
	# $(2): If not-empty, sort the values before comparing
	# $(3): Extra snippet to run if it does not match
	define soong-compare-var
	ifneq ($$($(1)),)
	my_val_make := $$(strip $(if $(2),$$(sort $$($(1))),$$($(1))))
	my_val_soong := $(if $(2),$$(sort $$(SOONG_$(1))),$$(SOONG_$(1)))
	ifneq ($$(my_val_make),$$(my_val_soong))
	$$(warning $(1) does not match between Make and Soong:)
	$(if $(2),$$(warning Make adds: $$(filter-out $$(my_val_soong),$$(my_val_make))),$$(warning Make : $$(my_val_make)))
	$(if $(2),$$(warning Soong adds: $$(filter-out $$(my_val_make),$$(my_val_soong))),$$(warning Soong: $$(my_val_soong)))
	$(3)
	endif
	my_val_make :=
	my_val_soong :=
	else
	$(1) := $$(SOONG_$(1))
	endif
	.KATI_READONLY := $(1) SOONG_$(1)
	endef

	my_check_failed := false

	`)

	// Write all the strict checks out first so that if one of them errors,
	// we get all of the strict errors printed, but not the non-strict
	// warnings.
	for _, v := range vars {
	if !v.strict {
	continue
	}

	sort := ""
	if v.sort {
	sort = "true"
	}

	fmt.Fprintf(buf, "SOONG_%s := %s\n", v.name, v.value)
	fmt.Fprintf(buf, "$(eval $(call soong-compare-var,%s,%s,my_check_failed := true))\n\n", v.name, sort)
	}

	fmt.Fprint(buf, `
	ifneq ($(my_check_failed),false)
	$(error Soong variable check failed)
	endif
	my_check_failed :=


	`)

	for _, v := range vars {
	if v.strict {
	continue
	}

	sort := ""
	if v.sort {
	sort = "true"
	}

	fmt.Fprintf(buf, "SOONG_%s := %s\n", v.name, v.value)
	fmt.Fprintf(buf, "$(eval $(call soong-compare-var,%s,%s))\n\n", v.name, sort)
	}

	fmt.Fprintln(buf, "\nsoong-compare-var :=")

	fmt.Fprintln(buf)

	return buf.Bytes()
	}

	func (s *makeVarsSingleton) writeLate(phonies []phony, dists []dist) []byte {
	buf := &bytes.Buffer{}

	fmt.Fprint(buf, `# Autogenerated file

	# Values written by Soong read after parsing all Android.mk files.


	`)

	for _, phony := range phonies {
	fmt.Fprintf(buf, ".PHONY: %s\n", phony.name)
	fmt.Fprintf(buf, "%s: %s\n", phony.name, strings.Join(phony.deps, "\\\n "))
	}

	fmt.Fprintln(buf)

	for _, dist := range dists {
	fmt.Fprintf(buf, ".PHONY: %s\n", strings.Join(dist.goals, " "))
	fmt.Fprintf(buf, "$(call dist-for-goals,%s,%s)\n",
	strings.Join(dist.goals, " "), strings.Join(dist.paths, " "))
	}

	return buf.Bytes()
	}

	// writeInstalls writes the list of install rules generated by Soong to a makefile. The rules
	// are exported to Make instead of written directly to the ninja file so that main.mk can add
	// the dependencies from the `required` property that are hard to resolve in Soong.
	func (s *makeVarsSingleton) writeInstalls(installs, symlinks []katiInstall) []byte {
	buf := &bytes.Buffer{}

	fmt.Fprint(buf, `# Autogenerated file

	# Values written by Soong to generate install rules that can be amended by Kati.


	`)

	preserveSymlinksFlag := "-d"
	if runtime.GOOS == "darwin" {
	preserveSymlinksFlag = "-R"
	}

	for _, install := range installs {
	// Write a rule for each install request in the form:
	// to: from [ deps ] [ \| order only deps ]
	// cp -f -d $< $@ [ && chmod +x $@ ]
	fmt.Fprintf(buf, "%s: %s", install.to.String(), install.from.String())
	for _, dep := range install.implicitDeps {
	fmt.Fprintf(buf, " %s", dep.String())
	}
	if extraFiles := install.extraFiles; extraFiles != nil {
	fmt.Fprintf(buf, " %s", extraFiles.zip.String())
	}
	if len(install.orderOnlyDeps) > 0 {
	fmt.Fprintf(buf, " \|")
	}
	for _, dep := range install.orderOnlyDeps {
	fmt.Fprintf(buf, " %s", dep.String())
	}
	fmt.Fprintln(buf)
	fmt.Fprintln(buf, "\t@echo \"Install: $@\"")
	fmt.Fprintf(buf, "\trm -f $@ && cp -f %s $< $@\n", preserveSymlinksFlag)
	if install.executable {
	fmt.Fprintf(buf, "\tchmod +x $@\n")
	}
	if extraFiles := install.extraFiles; extraFiles != nil {
	fmt.Fprintf(buf, "\t( unzip -qDD -d '%s' '%s' 2>&1 \| grep -v \"zipfile is empty\"; exit $${PIPESTATUS[0]} ) \|\| \\\n", extraFiles.dir.String(), extraFiles.zip.String())
	fmt.Fprintf(buf, "\t ( code=$$?; if [ $$code -ne 0 -a $$code -ne 1 ]; then exit $$code; fi )\n")
	}
	fmt.Fprintln(buf)
	}

	for _, symlink := range symlinks {
	fmt.Fprintf(buf, "%s:", symlink.to.String())
	if symlink.from != nil {
	// The symlink doesn't need updating when the target is modified, but we sometimes
	// have a dependency on a symlink to a binary instead of to the binary directly, and
	// the mtime of the symlink must be updated when the binary is modified, so use a
	// normal dependency here instead of an order-only dependency.
	fmt.Fprintf(buf, " %s", symlink.from.String())
	}
	for _, dep := range symlink.implicitDeps {
	fmt.Fprintf(buf, " %s", dep.String())
	}
	if len(symlink.orderOnlyDeps) > 0 {
	fmt.Fprintf(buf, " \|")
	}
	for _, dep := range symlink.orderOnlyDeps {
	fmt.Fprintf(buf, " %s", dep.String())
	}
	fmt.Fprintln(buf)

	fromStr := ""
	if symlink.from != nil {
	rel, err := filepath.Rel(filepath.Dir(symlink.to.String()), symlink.from.String())
	if err != nil {
	panic(fmt.Errorf("failed to find relative path for symlink from %q to %q: %w",
	symlink.from.String(), symlink.to.String(), err))
	}
	fromStr = rel
	} else {
	fromStr = symlink.absFrom
	}

	fmt.Fprintln(buf, "\t@echo \"Symlink: $@\"")
	fmt.Fprintf(buf, "\trm -f $@ && ln -sfn %s $@", fromStr)
	fmt.Fprintln(buf)
	fmt.Fprintln(buf)
	}

	return buf.Bytes()
	}

	func (c *makeVarsContext) DeviceConfig() DeviceConfig {
	return DeviceConfig{c.Config().deviceConfig}
	}

	var ninjaDescaper = strings.NewReplacer("$$", "$")

	func (c *makeVarsContext) Eval(ninjaStr string) (string, error) {
	s, err := c.SingletonContext.Eval(c.pctx, ninjaStr)
	if err != nil {
	return "", err
	}
	// SingletonContext.Eval returns an exapnded string that is valid for a ninja file, de-escape $$ to $ for use
	// in a Makefile
	return ninjaDescaper.Replace(s), nil
	}

	func (c *makeVarsContext) addVariableRaw(name, value string, strict, sort bool) {
	c.vars = append(c.vars, makeVarsVariable{
	name: name,
	value: value,
	strict: strict,
	sort: sort,
	})
	}

	func (c *makeVarsContext) addVariable(name, ninjaStr string, strict, sort bool) {
	value, err := c.Eval(ninjaStr)
	if err != nil {
	c.SingletonContext.Errorf(err.Error())
	}
	c.addVariableRaw(name, value, strict, sort)
	}

	func (c *makeVarsContext) addPhony(name string, deps []string) {
	c.phonies = append(c.phonies, phony{name, deps})
	}

	func (c *makeVarsContext) addDist(goals []string, paths []string) {
	c.dists = append(c.dists, dist{
	goals: goals,
	paths: paths,
	})
	}

	func (c *makeVarsContext) Strict(name, ninjaStr string) {
	c.addVariable(name, ninjaStr, true, false)
	}
	func (c *makeVarsContext) StrictSorted(name, ninjaStr string) {
	c.addVariable(name, ninjaStr, true, true)
	}
	func (c *makeVarsContext) StrictRaw(name, value string) {
	c.addVariableRaw(name, value, true, false)
	}

	func (c *makeVarsContext) Check(name, ninjaStr string) {
	c.addVariable(name, ninjaStr, false, false)
	}
	func (c *makeVarsContext) CheckSorted(name, ninjaStr string) {
	c.addVariable(name, ninjaStr, false, true)
	}
	func (c *makeVarsContext) CheckRaw(name, value string) {
	c.addVariableRaw(name, value, false, false)
	}

	func (c *makeVarsContext) Phony(name string, deps ...Path) {
	c.addPhony(name, Paths(deps).Strings())
	}

	func (c *makeVarsContext) DistForGoal(goal string, paths ...Path) {
	c.DistForGoals([]string{goal}, paths...)
	}

	func (c *makeVarsContext) DistForGoalWithFilename(goal string, path Path, filename string) {
	c.DistForGoalsWithFilename([]string{goal}, path, filename)
	}

	func (c *makeVarsContext) DistForGoals(goals []string, paths ...Path) {
	c.addDist(goals, Paths(paths).Strings())
	}

	func (c *makeVarsContext) DistForGoalsWithFilename(goals []string, path Path, filename string) {
	c.addDist(goals, []string{path.String() + ":" + filename})
	}