StrixOS/build_soong
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Publish Soong configuration to Make variables"

Browse Source
This commit is contained in:
Dan Willemsen
2016-05-13 01:36:28 +00:00
committed by Gerrit Code Review
parent 2522660da7 4b7d5deb84
commit 7f08e21941
3 changed files with 355 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Android.bp
View File

@@ -96,6 +96,7 @@ bootstrap_go_package {
"common/defs.go", "common/defs.go",
"common/env.go", "common/env.go",
"common/glob.go", "common/glob.go",
"common/makevars.go",
"common/module.go", "common/module.go",
"common/mutator.go", "common/mutator.go",
"common/package_ctx.go", "common/package_ctx.go",
@@ -124,6 +125,7 @@ bootstrap_go_package {
"cc/cc.go", "cc/cc.go",
"cc/clang.go", "cc/clang.go",
"cc/gen.go", "cc/gen.go",
"cc/makevars.go",
"cc/sanitize.go", "cc/sanitize.go",
"cc/stl.go", "cc/stl.go",
"cc/toolchain.go", "cc/toolchain.go",

111
cc/makevars.go Normal file
View File

@@ -0,0 +1,111 @@
// 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 cc
import (
"fmt"
"path/filepath"
"strings"
"android/soong/common"
)
func init() {
common.RegisterMakeVarsProvider(pctx, makeVarsProvider)
}
func makeVarsProvider(ctx common.MakeVarsContext) {
ctx.Strict("LLVM_PREBUILTS_VERSION", "${clangVersion}")
ctx.Strict("LLVM_PREBUILTS_BASE", "${clangBase}")
hostType := common.CurrentHostType()
arches := ctx.Config().HostArches[hostType]
makeVarsToolchain(ctx, "", common.Host, hostType, arches[0])
if len(arches) > 1 {
makeVarsToolchain(ctx, "2ND_", common.Host, hostType, arches[1])
}
if winArches, ok := ctx.Config().HostArches[common.Windows]; ok {
makeVarsToolchain(ctx, "", common.Host, common.Windows, winArches[0])
if len(winArches) > 1 {
makeVarsToolchain(ctx, "2ND_", common.Host, common.Windows, winArches[1])
}
}
arches = ctx.Config().DeviceArches
makeVarsToolchain(ctx, "", common.Device, common.NoHostType, arches[0])
if len(arches) > 1 {
makeVarsToolchain(ctx, "2ND_", common.Device, common.NoHostType, arches[1])
}
}
func makeVarsToolchain(ctx common.MakeVarsContext, secondPrefix string,
hod common.HostOrDevice, ht common.HostType, arch common.Arch) {
var typePrefix string
if hod.Host() {
if ht == common.Windows {
typePrefix = "HOST_CROSS_"
} else {
typePrefix = "HOST_"
}
} else {
typePrefix = "TARGET_"
}
makePrefix := secondPrefix + typePrefix
toolchain := toolchainFactories[hod][ht][arch.ArchType](arch)
globalCflags := fmt.Sprintf("${commonGlobalCflags} ${%sGlobalCflags}", hod)
ctx.CheckSorted(makePrefix+"GLOBAL_CFLAGS", strings.Join([]string{
toolchain.ToolchainCflags(),
globalCflags,
toolchain.Cflags(),
}, " "))
ctx.CheckSorted(makePrefix+"GLOBAL_LDFLAGS", strings.Join([]string{
toolchain.ToolchainLdflags(),
toolchain.Ldflags(),
}, " "))
if toolchain.ClangSupported() {
clangPrefix := secondPrefix + "CLANG_" + typePrefix
clangExtras := "-target " + toolchain.ClangTriple() + " -B" + filepath.Join(toolchain.GccRoot(), toolchain.GccTriple(), "bin")
globalClangCflags := fmt.Sprintf("${commonClangGlobalCflags} ${clangExtraCflags} ${%sClangGlobalCflags}", hod)
ctx.CheckSorted(clangPrefix+"GLOBAL_CFLAGS", strings.Join([]string{
toolchain.ToolchainClangCflags(),
globalClangCflags,
toolchain.ClangCflags(),
clangExtras,
}, " "))
ctx.CheckSorted(clangPrefix+"GLOBAL_LDFLAGS", strings.Join([]string{
toolchain.ToolchainClangLdflags(),
toolchain.ClangLdflags(),
clangExtras,
}, " "))
}
ctx.Strict(makePrefix+"CC", gccCmd(toolchain, "gcc"))
ctx.Strict(makePrefix+"CXX", gccCmd(toolchain, "g++"))
if ht == common.Darwin {
ctx.Strict(makePrefix+"AR", "${macArPath}")
} else {
ctx.Strict(makePrefix+"AR", gccCmd(toolchain, "ar"))
ctx.Strict(makePrefix+"READELF", gccCmd(toolchain, "readelf"))
ctx.Strict(makePrefix+"NM", gccCmd(toolchain, "nm"))
}
}

242
common/makevars.go Normal file
View File

@@ -0,0 +1,242 @@
// 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 common
import (
"bytes"
"fmt"
"io/ioutil"
"os"
"android/soong"
"github.com/google/blueprint"
"github.com/google/blueprint/proptools"
)
///////////////////////////////////////////////////////////////////////////////
// Interface for other packages to use to declare make variables
type MakeVarsContext interface {
Config() Config
// 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)
}
type MakeVarsProvider func(ctx MakeVarsContext)
func RegisterMakeVarsProvider(pctx blueprint.PackageContext, provider MakeVarsProvider) {
makeVarsProviders = append(makeVarsProviders, makeVarsProvider{pctx, provider})
}
///////////////////////////////////////////////////////////////////////////////
func init() {
soong.RegisterSingletonType("makevars", makeVarsSingletonFunc)
}
func makeVarsSingletonFunc() blueprint.Singleton {
return &makeVarsSingleton{}
}
type makeVarsSingleton struct{}
type makeVarsProvider struct {
pctx blueprint.PackageContext
call MakeVarsProvider
}
var makeVarsProviders []makeVarsProvider
type makeVarsContext struct {
config Config
ctx blueprint.SingletonContext
pctx blueprint.PackageContext
vars []makeVarsVariable
}
var _ MakeVarsContext = &makeVarsContext{}
type makeVarsVariable struct {
name string
value string
sort bool
strict bool
}
func (s *makeVarsSingleton) GenerateBuildActions(ctx blueprint.SingletonContext) {
config := ctx.Config().(Config)
if !config.EmbeddedInMake() {
return
}
outFile := PathForOutput(ctx, "make_vars"+proptools.String(config.ProductVariables.Make_suffix)+".mk").String()
if ctx.Failed() {
return
}
vars := []makeVarsVariable{}
for _, provider := range makeVarsProviders {
mctx := &makeVarsContext{
config: config,
ctx: ctx,
pctx: provider.pctx,
}
provider.call(mctx)
vars = append(vars, mctx.vars...)
}
if ctx.Failed() {
return
}
outBytes := s.writeVars(vars)
if _, err := os.Stat(outFile); err == nil {
if data, err := ioutil.ReadFile(outFile); err == nil {
if bytes.Equal(data, outBytes) {
return
}
}
}
if err := ioutil.WriteFile(outFile, outBytes, 0666); err != nil {
ctx.Errorf(err.Error())
}
}
func (s *makeVarsSingleton) writeVars(vars []makeVarsVariable) []byte {
buf := &bytes.Buffer{}
fmt.Fprintln(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 := $(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
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.Fprintln(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 :=")
return buf.Bytes()
}
func (c *makeVarsContext) Config() Config {
return c.config
}
func (c *makeVarsContext) addVariable(name, ninjaStr string, strict, sort bool) {
value, err := c.ctx.Eval(c.pctx, ninjaStr)
if err != nil {
c.ctx.Errorf(err.Error())
}
c.vars = append(c.vars, makeVarsVariable{
name: name,
value: value,
strict: strict,
sort: sort,
})
}
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) Check(name, ninjaStr string) {
c.addVariable(name, ninjaStr, false, false)
}
func (c *makeVarsContext) CheckSorted(name, ninjaStr string) {
c.addVariable(name, ninjaStr, false, true)
}