diff options
-rw-r--r-- | Android.bp | 2 | ||||
-rw-r--r-- | cc/makevars.go | 111 | ||||
-rw-r--r-- | common/makevars.go | 242 |
3 files changed, 355 insertions, 0 deletions
@@ -96,6 +96,7 @@ bootstrap_go_package { "common/defs.go", "common/env.go", "common/glob.go", + "common/makevars.go", "common/module.go", "common/mutator.go", "common/package_ctx.go", @@ -124,6 +125,7 @@ bootstrap_go_package { "cc/cc.go", "cc/clang.go", "cc/gen.go", + "cc/makevars.go", "cc/sanitize.go", "cc/stl.go", "cc/toolchain.go", diff --git a/cc/makevars.go b/cc/makevars.go new file mode 100644 index 00000000..00a4f712 --- /dev/null +++ b/cc/makevars.go @@ -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")) + } +} diff --git a/common/makevars.go b/common/makevars.go new file mode 100644 index 00000000..ad4f6d46 --- /dev/null +++ b/common/makevars.go @@ -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) +} |